Custom Actions Follow UP

[glsp-bot]

So I have questions to the server client communication, the 'Custom Actions in GLSP' already helped a lot but my problem is that I don't have any predefined actions or handlers I can reuse.

My task is basically to retrieve a list of strings (attribute types) from the server to the client.

Client

I injected the action dispatcher into my class:

```constructor(@inject(TYPES.IActionDispatcher) protected actionDispatcher: GLSPActionDispatcher) {
super();
}```

Then I defined 2 actions as required for the actionDispatcher.requestUntil call

```export class AttributeTypesAction  implements RequestAction<ReturnAttributeTypesAction> {
    static KIND = 'getAttributeTypes';
    kind: string = AttributeTypesAction.KIND;
    requestId: string;
    constructor() {
        this.requestId = generateRequestId();
    }
}

export class ReturnAttributeTypesAction implements ResponseAction {
    responseId: string;
    static KIND = 'returnAttributeTypes';
    kind = ReturnAttributeTypesAction.KIND;
    constructor() { }
}```

And I'm sending the action to the server and want to process the response in the .then and not in a specific handler

```this.actionDispatcher.requestUntil(new AttributeTypesAction()).then(response => {
            alert(response);
        });```

Server

I defined the action in the server

```public class AttributeTypesAction extends Action {

    public static String KIND = 'getAttributeTypes';

    public AttributeTypesAction() {
        super(KIND);
    }
}```

And the action handler

```public class EcoreGetAttributeTypesActionHandler extends AbstractActionHandler {

    @Override
    public boolean handles(Action action) {
        return action instanceof AttributeTypesAction;
    }

    @Override
    protected Optional<Action> execute(Action action, GraphicalModelState modelState) {
        // ...
    }
}```

I added my action handler to the defaultActionHandlers of the DefaultGLSPModule class

```bindActionHandlers().add(EcoreGetAttributeTypesActionHandler.class);```

And because it still did not work I changed the action provider to include my class

```@Override
    protected Class<? extends ActionProvider> bindActionProvider() {
        return EcoreActionProvider.class; // includes AttributeTypesAction & DefaultActionProvider
    }```

As the error messages show I get a timeout and it says the handler is not found

 q5.PNG

What is missing so that the server will process my request?

original thread by Leo Knoll

[planger]

It looks like you haven't registered the server on the client-side to handle the action with the KIND getAttributeTypes. In order to control which actions are supposed to be handled in the client locally or which should be sent to the server, the diagram server proxy on the client (GLSPWebsocketDiagramServer) registers itself as action handler for specific actions and relays them to the server. See
https://github.com/eclipsesource/graphical-lsp/blob/648cd1a21f056aa693e4575433203d1b4b9c9f53/client/packages/sprotty-client/src/model-source/websocket-diagram-server.ts#L79

You'll have to add your custom actions here in order to make sure they are sent and handled by the server.

[planger]

(well not 'here', but you can register the diagram server as a handler for actions also in any other place where you have access to the di container or can inject things)

[glsp-bot]

[Leo Knoll]

Thank you that and some other stuff made it finally work, I'll share my solution tomorrow for documentation :-)

[glsp-bot]

[Leo Knoll]

Example how to add customs actions based on my changes:
Client
Inject ActionDispenser

```constructor(@inject(TYPES.IActionDispatcher) protected actionDispatcher: GLSPActionDispatcher) {
super();
}```

Define Actions:

```export class AttributeTypesAction  implements RequestAction<ReturnAttributeTypesAction> {
    static readonly KIND = 'getAttributeTypes';
    kind = AttributeTypesAction.KIND;
    constructor(public readonly requestId: string = generateRequestId()) { }
}

export class ReturnAttributeTypesAction implements ResponseAction {
    static readonly KIND = 'returnAttributeTypes';
    kind = ReturnAttributeTypesAction.KIND;
    types: string[];
    constructor(public readonly actions: string[], public readonly responseId: string = '') {
        this.types = actions;
    }
}```

Change EcoreGLSPTheiaDiagramServer to contain you actions in initialize

```initialize(registry: ActionHandlerRegistry): void {
        super.initialize(registry);

       //...
        registry.register(AttributeTypesAction.KIND, this);
        registry.register(ReturnAttributeTypesAction.KIND, this);
    }```

Dispatch action

```// request possible element types
        this.actionDispatcher.requestUntil(new AttributeTypesAction()).then(response => {
            if (response) {
                const action: ReturnAttributeTypesAction = <ReturnAttributeTypesAction> response;
                this.types = action.types;
            }
        });```

Server
Add Actions on server

```public class AttributeTypesAction extends RequestAction<ReturnAttributeTypesAction> {
    public static String KIND = 'getAttributeTypes';
    public AttributeTypesAction() {
        super(KIND);
    }
}
public class ReturnAttributeTypesAction extends ResponseAction {
    public static String KIND = 'returnAttributeTypes';
    private List<String> types;
    public ReturnAttributeTypesAction() {
        super(KIND);
    }
    public ReturnAttributeTypesAction(List<String> types) {
        super(KIND);
        this.types = types;
    }
    public List<String> getTypes() {
        return types;
    }
    public void setTypes(List<String> types) {
        this.types = types;
    }
}```

Change EcoreActionProvider to contain your incoming action in private void addEcoreActions

```private void addEcoreActions() {
       // ...
        ecoreActions.add(new AttributeTypesAction());
}```

Add action handler to handle your action and return action

```public class EcoreGetAttributeTypesActionHandler extends AbstractActionHandler {

    @Override
    public boolean handles(Action action) {
        return action instanceof AttributeTypesAction;
    }

    @Override
    protected Optional<Action> execute(Action action, GraphicalModelState modelState) {
        List<String> types = getEAttributeTypeList(EcoreModelState.getResourceManager(modelState));
        Collections.sort(types);

        return Optional.of(new ReturnAttributeTypesAction(types));
    }

    private List<String> getEAttributeTypeList(ResourceManager resManager) {
        List<String> list = new ArrayList<>();
        for (EObject obj : EcoreLabelEditOperationHandler.getAllEAttributeTypes(resManager)) {
            list.add(((ENamedElement) obj).getName());
        }
        return list;
    }
}```

Change EcoreGLSPModule and add your action handler in the constructor

```public EcoreGLSPModule() {
        // ...
        bindActionHandlers().add(EcoreGetAttributeTypesActionHandler.class);
    }```