@eclipse-glsp-examples/workflow-server 0.9.0-next.0193b16.17

package/src/provider/workflow-command-palette-action-provider.ts

@@ -0,0 +1,142 @@
+/********************************************************************************
+ * Copyright (c) 2022 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import {
+    Args,
+    CommandPaletteActionProvider,
+    CreateEdgeOperation,
+    CreateNodeOperation,
+    DefaultTypes,
+    DeleteElementOperation,
+    GModelElement,
+    GNode,
+    LabeledAction,
+    ModelState,
+    Point
+} from '@eclipse-glsp/server-node';
+import { inject, injectable } from 'inversify';
+import { TaskNode } from '../graph-extension';
+import { ModelTypes } from '../util/model-types';
+
+@injectable()
+export class WorkflowCommandPaletteActionProvider extends CommandPaletteActionProvider {
+    @inject(ModelState)
+    protected override modelState: ModelState;
+
+    getPaletteActions(selectedElementIds: string[], selectedElements: GModelElement[], position: Point, args?: Args): LabeledAction[] {
+        const actions: LabeledAction[] = [];
+        if (this.modelState.isReadonly) {
+            return actions;
+        }
+        const index = this.modelState.index;
+        // Create actions
+        const location = position ?? Point.ORIGIN;
+        actions.push(
+            {
+                label: 'Create Automated Task',
+                actions: [CreateNodeOperation.create(ModelTypes.AUTOMATED_TASK, { location })],
+                icon: 'fa-plus-square'
+            },
+            {
+                label: 'Create Manual Task',
+                actions: [CreateNodeOperation.create(ModelTypes.MANUAL_TASK, { location })],
+                icon: 'fa-plus-square'
+            },
+            {
+                label: 'Create Merge Node',
+                actions: [CreateNodeOperation.create(ModelTypes.MERGE_NODE, { location })],
+                icon: 'fa-plus-square'
+            },
+            {
+                label: 'Create Decision Node',
+                actions: [CreateNodeOperation.create(ModelTypes.DECISION_NODE, { location })],
+                icon: 'fa-plus-square'
+            },
+            {
+                label: 'Create Category',
+                actions: [CreateNodeOperation.create(ModelTypes.CATEGORY, { location })],
+                icon: 'fa-plus-square'
+            }
+        );
+        // Create edge action between two nodes
+        if (selectedElements.length === 1) {
+            const element = selectedElements[0];
+            if (element instanceof GNode) {
+                actions.push(...this.createEdgeActions(element, index.getAllByClass(TaskNode)));
+            }
+        } else if (selectedElements.length === 2) {
+            const source = selectedElements[0];
+            const target = selectedElements[1];
+            if (source instanceof TaskNode && target instanceof TaskNode) {
+                actions.push(
+                    this.createEdgeAction(`Create Edge from ${this.getLabel(source)} to ${this.getLabel(target)}`, source, target)
+                );
+                actions.push(
+                    this.createWeightedEdgeAction(
+                        `Create Weighted Edge from ${this.getLabel(source)} to ${this.getLabel(target)}`,
+                        source,
+                        target
+                    )
+                );
+            }
+        }
+        // Delete action
+
+        const label = selectedElementIds.length === 1 ? 'Delete' : 'Delete All';
+        actions.push({ label, actions: [DeleteElementOperation.create(selectedElementIds)], icon: 'fa-minus-square' });
+
+        return actions;
+    }
+
+    protected createEdgeActions(source: GNode, targets: GNode[]): LabeledAction[] {
+        const actions: LabeledAction[] = [];
+        targets.forEach(node => actions.push(this.createEdgeAction(`Create Edge to ${this.getLabel(node)}`, source, node)));
+        targets.forEach(node =>
+            actions.push(this.createWeightedEdgeAction(`Create Weighted Edge to ${this.getLabel(node)}`, source, node))
+        );
+        return actions;
+    }
+
+    protected createWeightedEdgeAction(label: string, source: GNode, node: GNode): LabeledAction {
+        return {
+            label,
+            actions: [
+                CreateEdgeOperation.create({
+                    elementTypeId: ModelTypes.WEIGHTED_EDGE,
+                    sourceElementId: source.id,
+                    targetElementId: node.id
+                })
+            ],
+            icon: 'fa-plus-square'
+        };
+    }
+
+    protected createEdgeAction(label: string, source: GNode, node: GNode): LabeledAction {
+        return {
+            label,
+            actions: [
+                CreateEdgeOperation.create({ elementTypeId: DefaultTypes.EDGE, sourceElementId: source.id, targetElementId: node.id })
+            ],
+            icon: 'fa-plus-square'
+        };
+    }
+
+    protected getLabel(node: GNode): string {
+        if (node instanceof TaskNode) {
+            return node.name;
+        }
+        return node.id;
+    }
+}

package/src/provider/workflow-context-menu-item-provider.ts

@@ -0,0 +1,51 @@
+/********************************************************************************
+ * Copyright (c) 2022 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { Args, ContextMenuItemProvider, CreateNodeOperation, MenuItem, ModelState, Point } from '@eclipse-glsp/server-node';
+import { inject, injectable } from 'inversify';
+import { GridSnapper } from '../handler/grid-snapper';
+import { ModelTypes } from '../util/model-types';
+
+@injectable()
+export class WorkflowContextMenuItemProvider extends ContextMenuItemProvider {
+    @inject(ModelState)
+    protected modelState: ModelState;
+
+    getItems(selectedElementIds: string[], position: Point, args?: Args): MenuItem[] {
+        if (this.modelState.isReadonly || selectedElementIds.length !== 0) {
+            return [];
+        }
+        const snappedPosition = GridSnapper.snap(position);
+        const newAutTask: MenuItem = {
+            id: 'newAutoTask',
+            label: 'Automated Task',
+            actions: [CreateNodeOperation.create(ModelTypes.AUTOMATED_TASK, { location: snappedPosition })]
+        };
+        const newManTask: MenuItem = {
+            id: 'newManualTask',
+            label: 'Manual Task',
+            actions: [CreateNodeOperation.create(ModelTypes.MANUAL_TASK, { location: snappedPosition })]
+        };
+        const newChildMenu: MenuItem = {
+            id: 'new',
+            label: 'New',
+            actions: [],
+            children: [newAutTask, newManTask],
+            icon: 'add',
+            group: '0_new'
+        };
+        return [newChildMenu];
+    }
+}

package/src/util/model-types.ts

@@ -0,0 +1,55 @@
+/********************************************************************************
+ * Copyright (c) 2022 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+/* eslint-disable @typescript-eslint/padding-line-between-statements */
+export namespace ModelTypes {
+    export const LABEL_HEADING = 'label:heading';
+    export const LABEL_TEXT = 'label:text';
+    export const COMP_HEADER = 'comp:header';
+    export const LABEL_ICON = 'label:icon';
+    export const WEIGHTED_EDGE = 'edge:weighted';
+    export const ICON = 'icon';
+    export const ACTIVITY_NODE = 'activityNode';
+    export const DECISION_NODE = `${ACTIVITY_NODE}:decision`;
+    export const MERGE_NODE = `${ACTIVITY_NODE}:merge`;
+    export const FORK_NODE = `${ACTIVITY_NODE}:fork`;
+    export const JOIN_NODE = `${ACTIVITY_NODE}:join`;
+    export const TASK = 'task';
+    export const MANUAL_TASK = `${TASK}:manual`;
+    export const AUTOMATED_TASK = `${TASK}:automated`;
+    export const CATEGORY = 'category';
+    export const STRUCTURE = 'struct';
+
+    export function toNodeType(type: string): string {
+        switch (type) {
+            case DECISION_NODE:
+                return 'decisionNode';
+            case MERGE_NODE:
+                return 'mergeNode';
+            case FORK_NODE:
+                return 'forkNode';
+            case JOIN_NODE:
+                return 'joinNode';
+            case MANUAL_TASK:
+                return 'manual';
+            case AUTOMATED_TASK:
+                return 'automated';
+            case CATEGORY:
+                return 'category';
+            default:
+                return 'unknown';
+        }
+    }
+}

package/src/workflow-diagram-configuration.ts

@@ -0,0 +1,122 @@
+/********************************************************************************
+ * Copyright (c) 2022 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { DefaultTypes, EdgeTypeHint, ShapeTypeHint } from '@eclipse-glsp/protocol';
+import {
+    DiagramConfiguration,
+    GCompartment,
+    GEdge,
+    getDefaultMapping,
+    GLabel,
+    GModelElementConstructor,
+    ServerLayoutKind
+} from '@eclipse-glsp/server-node';
+import { injectable } from 'inversify';
+import { ActivityNode, Category, TaskNode } from './graph-extension';
+import { ModelTypes as types } from './util/model-types';
+
+@injectable()
+export class WorkflowDiagramConfiguration implements DiagramConfiguration {
+    get typeMapping(): Map<string, GModelElementConstructor> {
+        const mapping = getDefaultMapping();
+        mapping.set(types.LABEL_HEADING, GLabel);
+        mapping.set(types.LABEL_TEXT, GLabel);
+        mapping.set(types.COMP_HEADER, GCompartment);
+        mapping.set(types.LABEL_ICON, GLabel);
+        mapping.set(types.WEIGHTED_EDGE, GEdge);
+        mapping.set(types.ICON, GCompartment);
+        mapping.set(types.ACTIVITY_NODE, ActivityNode);
+        mapping.set(types.TASK, TaskNode);
+        mapping.set(types.CATEGORY, Category);
+        mapping.set(types.STRUCTURE, GCompartment);
+        return mapping;
+    }
+
+    get shapeTypeHints(): ShapeTypeHint[] {
+        return [
+            createDefaultShapeTypeHint(types.MANUAL_TASK),
+            createDefaultShapeTypeHint(types.AUTOMATED_TASK),
+            createDefaultShapeTypeHint(types.FORK_NODE),
+            createDefaultShapeTypeHint(types.JOIN_NODE),
+            createDefaultShapeTypeHint(types.DECISION_NODE),
+            createDefaultShapeTypeHint(types.MERGE_NODE),
+            {
+                elementTypeId: types.CATEGORY,
+                repositionable: true,
+                deletable: true,
+                resizable: true,
+                reparentable: true,
+                containableElementTypeIds: [
+                    types.DECISION_NODE,
+                    types.MERGE_NODE,
+                    types.FORK_NODE,
+                    types.JOIN_NODE,
+                    types.AUTOMATED_TASK,
+                    types.MANUAL_TASK,
+                    types.CATEGORY
+                ]
+            }
+        ];
+    }
+
+    get edgeTypeHints(): EdgeTypeHint[] {
+        return [
+            createDefaultEdgeTypeHint(DefaultTypes.EDGE),
+            {
+                elementTypeId: types.WEIGHTED_EDGE,
+                repositionable: true,
+                deletable: true,
+                routable: true,
+                sourceElementTypeIds: [types.DECISION_NODE],
+                targetElementTypeIds: [types.MANUAL_TASK, types.AUTOMATED_TASK, types.FORK_NODE, types.JOIN_NODE]
+            }
+        ];
+    }
+
+    layoutKind = ServerLayoutKind.MANUAL;
+    needsClientLayout = true;
+    animatedUpdate = true;
+}
+
+export function createDefaultShapeTypeHint(elementId: string): ShapeTypeHint {
+    return { elementTypeId: elementId, repositionable: true, deletable: true, resizable: true, reparentable: true };
+}
+
+export function createDefaultEdgeTypeHint(elementId: string): EdgeTypeHint {
+    return {
+        elementTypeId: elementId,
+        repositionable: true,
+        deletable: true,
+        routable: true,
+        sourceElementTypeIds: [
+            types.MANUAL_TASK,
+            types.AUTOMATED_TASK,
+            types.DECISION_NODE,
+            types.MERGE_NODE,
+            types.FORK_NODE,
+            types.JOIN_NODE,
+            types.CATEGORY
+        ],
+        targetElementTypeIds: [
+            types.MANUAL_TASK,
+            types.AUTOMATED_TASK,
+            types.DECISION_NODE,
+            types.MERGE_NODE,
+            types.FORK_NODE,
+            types.JOIN_NODE,
+            types.CATEGORY
+        ]
+    };
+}

package/src/workflow-diagram-module.ts

@@ -0,0 +1,115 @@
+/********************************************************************************
+ * Copyright (c) 2022 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import {
+    CommandPaletteActionProvider,
+    ContextMenuItemProvider,
+    DiagramConfiguration,
+    GLSPServer,
+    GModelDiagramModule,
+    InstanceMultiBinding,
+    LabelEditValidator,
+    ModelValidator,
+    MultiBinding,
+    NavigationTargetProvider,
+    NavigationTargetResolver,
+    OperationHandlerConstructor,
+    PopupModelFactory,
+    ServerModule
+} from '@eclipse-glsp/server-node';
+import { BindingTarget } from '@eclipse-glsp/server-node/lib/di/binding-target';
+import { injectable } from 'inversify';
+import { CreateAutomatedTaskHandler } from './handler/create-automated-task-handler';
+import { CreateCategoryHandler } from './handler/create-category-handler';
+import { CreateDecisionNodeHandler } from './handler/create-decision-node-handler';
+import { CreateEdgeHandler } from './handler/create-edge-handler';
+import { CreateForkNodeHandler } from './handler/create-fork-node-handler';
+import { CreateJoinNodeHandler } from './handler/create-join-node-handler';
+import { CreateManualTaskHandler } from './handler/create-manual-task-handler';
+import { CreateMergeNodeHandler } from './handler/create-merge-node-handler';
+import { CreateWeightedEdgeHandler } from './handler/create-weighted-edge-handler';
+import { WorkflowLabelEditValidator } from './labeledit/workflow-label-edit-validator';
+import { WorkflowModelValidator } from './marker/workflow-model-validator';
+import { WorkflowNavigationTargetResolver } from './model/workflow-navigation-target-resolver';
+import { NextNodeNavigationTargetProvider } from './provider/next-node-navigation-target-provider';
+import { NodeDocumentationNavigationTargetProvider } from './provider/node-documentation-navigation-target-provider';
+import { PreviousNodeNavigationTargetProvider } from './provider/previous-node-navigation-target-provider';
+import { WorkflowCommandPaletteActionProvider } from './provider/workflow-command-palette-action-provider';
+import { WorkflowContextMenuItemProvider } from './provider/workflow-context-menu-item-provider';
+import { WorkflowDiagramConfiguration } from './workflow-diagram-configuration';
+import { WorkflowGLSPServer } from './workflow-glsp-server';
+import { WorkflowPopupFactory } from './workflow-popup-factory';
+
+@injectable()
+export class WorkflowServerModule extends ServerModule {
+    protected override bindGLSPServer(): BindingTarget<GLSPServer> {
+        return WorkflowGLSPServer;
+    }
+}
+
+@injectable()
+export class WorkflowDiagramModule extends GModelDiagramModule {
+    get diagramType(): string {
+        return 'workflow-diagram';
+    }
+
+    protected override configureOperationHandlers(binding: InstanceMultiBinding<OperationHandlerConstructor>): void {
+        super.configureOperationHandlers(binding);
+        binding.add(CreateAutomatedTaskHandler);
+        binding.add(CreateManualTaskHandler);
+        binding.add(CreateJoinNodeHandler);
+        binding.add(CreateForkNodeHandler);
+        binding.add(CreateEdgeHandler);
+        binding.add(CreateWeightedEdgeHandler);
+        binding.add(CreateMergeNodeHandler);
+        binding.add(CreateDecisionNodeHandler);
+        binding.add(CreateCategoryHandler);
+    }
+
+    protected bindDiagramConfiguration(): BindingTarget<DiagramConfiguration> {
+        return WorkflowDiagramConfiguration;
+    }
+
+    protected override bindNavigationTargetResolver(): BindingTarget<NavigationTargetResolver> | undefined {
+        return WorkflowNavigationTargetResolver;
+    }
+
+    protected override bindContextMenuItemProvider(): BindingTarget<ContextMenuItemProvider> | undefined {
+        return WorkflowContextMenuItemProvider;
+    }
+
+    protected override bindCommandPaletteActionProvider(): BindingTarget<CommandPaletteActionProvider> | undefined {
+        return WorkflowCommandPaletteActionProvider;
+    }
+
+    protected override bindLabelEditValidator(): BindingTarget<LabelEditValidator> | undefined {
+        return WorkflowLabelEditValidator;
+    }
+
+    protected override bindPopupModelFactory(): BindingTarget<PopupModelFactory> | undefined {
+        return WorkflowPopupFactory;
+    }
+
+    protected override bindModelValidator(): BindingTarget<ModelValidator> | undefined {
+        return WorkflowModelValidator;
+    }
+
+    protected override configureNavigationTargetProviders(binding: MultiBinding<NavigationTargetProvider>): void {
+        super.configureNavigationTargetProviders(binding);
+        binding.add(NextNodeNavigationTargetProvider);
+        binding.add(PreviousNodeNavigationTargetProvider);
+        binding.add(NodeDocumentationNavigationTargetProvider);
+    }
+}

package/src/workflow-glsp-server.ts

@@ -0,0 +1,37 @@
+/********************************************************************************
+ * Copyright (c) 2022 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { Args, ArgsUtil, DefaultGLSPServer, InitializeResult, Logger, MaybePromise } from '@eclipse-glsp/server-node';
+import { inject, injectable } from 'inversify';
+
+@injectable()
+export class WorkflowGLSPServer extends DefaultGLSPServer {
+    MESSAGE_KEY = 'message';
+    TIMESTAMP_KEY = 'timestamp';
+
+    @inject(Logger)
+    protected override logger: Logger;
+
+    protected override handleInitializeArgs(result: InitializeResult, args: Args | undefined): MaybePromise<InitializeResult> {
+        if (!args) {
+            return result;
+        }
+        const timestamp = ArgsUtil.get(args, this.TIMESTAMP_KEY);
+        const message = ArgsUtil.get(args, this.MESSAGE_KEY);
+
+        this.logger.debug(`${timestamp}: ${message}`);
+        return result;
+    }
+}

package/src/workflow-popup-factory.ts

@@ -0,0 +1,46 @@
+/********************************************************************************
+ * Copyright (c) 2022 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { GModelElement, GModelRoot, GPreRenderedElement, PopupModelFactory, RequestPopupModelAction } from '@eclipse-glsp/server-node';
+import { TaskNode } from './graph-extension';
+import { injectable } from 'inversify';
+
+const NL = '<br/>';
+
+@injectable()
+export class WorkflowPopupFactory implements PopupModelFactory {
+    createPopupModel(element: GModelElement, action: RequestPopupModelAction): GModelRoot | undefined {
+        if (element && element instanceof TaskNode) {
+            const popupTitle = GPreRenderedElement.builder()
+                .id('popup-title')
+                .code(`<div class="sprotty-popup-title">${element.name}</div>`)
+                .build();
+
+            const popupBody = GPreRenderedElement.builder()
+                .id('popup-body')
+                .code(`<div class="sprotty-popup-body">${this.generateBody(element)}</div>`)
+                .build();
+
+            return GModelRoot.builder().type('html').canvasBounds(action.bounds).id('sprotty-popup').add(popupTitle).add(popupBody).build();
+        }
+        return undefined;
+    }
+
+    private generateBody(task: TaskNode): string {
+        return `Type: ${task.taskType} ${NL}
+            Duration: ${task.duration} ${NL}
+            Reference: ${task.references} ${NL}`;
+    }
+}