BPMN redactor

db-services/db-diagram-service/src/main/java/com/qreal/wmp/db/diagram/model/DefaultDiagramNode.java

@@ -30,6 +30,9 @@ public class DefaultDiagramNode implements Serializable {
     @Column(name = "type")
     private String type;
 
+    @Column(name = "parent_id")
+    private String parentId;
+
     @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER, orphanRemoval = true)
     @JoinColumn(name = "node_id", referencedColumnName = "id")
     private Set<Property> properties = new HashSet<>();
@@ -55,6 +58,10 @@ public DefaultDiagramNode(TDefaultDiagramNode tDefaultDiagramNode) {
             type = tDefaultDiagramNode.getType();
         }
 
+        if (tDefaultDiagramNode.isSetParentId()) {
+            parentId = tDefaultDiagramNode.getParentId();
+        }
+
         if (tDefaultDiagramNode.isSetProperties()) {
             properties = tDefaultDiagramNode.getProperties().stream().map(Property::new).
                     collect(Collectors.toSet());
@@ -81,6 +88,10 @@ public TDefaultDiagramNode toTDefaultDiagramNode() {
             tDefaultDiagramNode.setType(type);
         }
 
+        if (parentId != null) {
+            tDefaultDiagramNode.setParentId(parentId);
+        }
+
         if (properties != null && !properties.isEmpty()) {
             tDefaultDiagramNode.setProperties(properties.stream().map(Property::toTProperty).
                     collect(Collectors.toSet()));

editor-core/src/main/webapp/app/core/editorCore/controller/DiagramEditorController.ts

@@ -13,27 +13,32 @@ import {SceneController} from "./SceneController";
 import {DiagramEditor} from "../model/DiagramEditor";
 import {DiagramElementListener} from "./DiagramElementListener";
 import {PaletteController} from "./PaletteController";
+import {ElementConstructor} from "../model/ElementConstructor"
+import {MapUtils} from "../../../utils/MapUtils";
+import {DiagramScene} from "../model/DiagramScene";
 export class DiagramEditorController {
 
     protected diagramEditor: DiagramEditor;
     protected sceneController: SceneController;
     protected propertyEditorController: PropertyEditorController;
     protected elementsTypeLoader: ElementsTypeLoader;
     protected paletteController: PaletteController;
-    protected nodeTypesMap: Map<String, NodeType>;
-    protected linkPatternsMap: Map<String, joint.dia.Link>;
+    protected nodeTypesMap: Map<string, NodeType>;
+    protected linkPatternsMap: Map<string, joint.dia.Link>;
     protected undoRedoController: UndoRedoController;
     protected elementTypes: ElementTypes;
+    protected elementConstructor: ElementConstructor;
 
     constructor($scope, $attrs) {
         this.undoRedoController = new UndoRedoController();
-        this.nodeTypesMap = new Map<String, NodeType>();
-        this.linkPatternsMap = new Map<String, joint.dia.Link>();
+        this.nodeTypesMap = new Map<string, NodeType>();
+        this.linkPatternsMap = new Map<string, joint.dia.Link>();
         this.paletteController = new PaletteController();
         DiagramElementListener.getNodeType = (type: string): NodeType => {
             return this.getNodeType(type);
         };
         this.diagramEditor = new DiagramEditor();
+        this.elementConstructor = new ElementConstructor(this);
         this.sceneController = new SceneController(this, this.diagramEditor.getScene());
         this.elementsTypeLoader = new ElementsTypeLoader();
 
@@ -56,12 +61,12 @@ export class DiagramEditorController {
         return this.diagramEditor.getGraph();
     }
 
-    public getNodesMap(): Map<String, DiagramNode> {
+    public getNodesMap(): Map<string, DiagramNode> {
         var paper = this.diagramEditor.getScene();
         return paper.getNodesMap();
     }
 
-    public getLinksMap(): Map<String, Link> {
+    public getLinksMap(): Map<string, Link> {
         var paper = this.diagramEditor.getScene();
         return paper.getLinksMap();
     }
@@ -75,11 +80,15 @@ export class DiagramEditorController {
     }
 
     public getNodeType(type: string): NodeType {
-        return this.nodeTypesMap[type];
+        return this.nodeTypesMap.get(type);
     }
 
-    public getNodeProperties(type: string): Map<String, Property> {
-        return this.nodeTypesMap[type].getPropertiesMap();
+    public getNodeProperties(type: string): Map<string, Property> {
+        return this.nodeTypesMap.get(type).getPropertiesMap();
+    }
+
+    public getElementConstructor(): ElementConstructor {
+        return this.elementConstructor;
     }
 
     public getUndoRedoController(): UndoRedoController {
@@ -97,11 +106,11 @@ export class DiagramEditorController {
         return new DiagramParts(this.getNodesMap(), this.getLinksMap());
     }
 
-    public getNodeTypes(): Map<String, NodeType> {
+    public getNodeTypes(): Map<string, NodeType> {
         return this.nodeTypesMap;
     }
 
-    public getLinkPatterns(): Map<String, joint.dia.Link> {
+    public getLinkPatterns(): Map<string, joint.dia.Link> {
         return this.linkPatternsMap;
     }
 
@@ -111,19 +120,19 @@ export class DiagramEditorController {
         scene.addLinksFromMap(diagramParts.linksMap);
     }
 
+    public getScene(): DiagramScene {
+        return this.diagramEditor.getScene();
+    }
+
     protected handleLoadedTypes(elementTypes: ElementTypes): void {
         this.propertyEditorController = new PropertyEditorController(this.sceneController, this.undoRedoController);
 
         this.elementTypes = elementTypes;
 
-        $.extend(this.linkPatternsMap, elementTypes.linkPatterns);
-        $.extend(this.nodeTypesMap, elementTypes.blockTypes.convertToMap(), elementTypes.flowTypes.convertToMap(),
-            elementTypes.uncategorisedTypes);
+        MapUtils.extend(this.linkPatternsMap, this.elementTypes.linkPatterns);
+        MapUtils.extend(this.nodeTypesMap, elementTypes.blockTypes.convertToMap(), elementTypes.flowTypes.convertToMap());
 
         this.diagramEditor.getScene().setLinkPatterns(this.linkPatternsMap);
-        this.paletteController.appendBlocksPalette(elementTypes.blockTypes);
-        this.paletteController.appendFlowsPalette(elementTypes.flowTypes);
-        this.paletteController.initClick(this.diagramEditor.getScene());
-        this.paletteController.initDraggable();
+        this.paletteController.init(this.diagramEditor.getScene(), elementTypes, this.nodeTypesMap);
     }
 }

editor-core/src/main/webapp/app/core/editorCore/controller/DiagramElementListener.ts

@@ -30,16 +30,13 @@ export class DiagramElementListener {
             }
 
             var nodeType: NodeType = DiagramElementListener.getNodeType(this.paper.getCurrentLinkTypeName());
-            var typeProperties: Map<String, Property> = nodeType.getPropertiesMap();
+            var typeProperties: Map<string, Property> = nodeType.getPropertiesMap();
 
-            var nodeProperties: Map<String, Property> = new Map<String, Property>();
-            for (var property in typeProperties) {
-                nodeProperties[property] = new Property(typeProperties[property].name,
-                    typeProperties[property].type, typeProperties[property].value);
+            var nodeProperties: Map<string, Property> = new Map<string, Property>();
+            for (var [propertyName, property] of typeProperties) {
+                nodeProperties.set(propertyName, new Property(property.name, property.type, property.value));
             }
-
-            var linkObject: Link = new Link(link, nodeType.getShownName(), nodeType.getName(), nodeProperties);
-            DiagramElementListener.makeAndExecuteCreateLinkCommand(linkObject);
+            DiagramElementListener.makeAndExecuteCreateLinkCommand(link, nodeType.getShownName(), nodeType.getName(), nodeProperties);
 
             this.paper.model.addCell(link);
 
@@ -60,7 +57,8 @@ export class DiagramElementListener {
         return null;
     };
 
-    static makeAndExecuteCreateLinkCommand: (linkObject: Link) => void = function(linkObject: Link): void {
+    static makeAndExecuteCreateLinkCommand: (jointObject: joint.dia.Link, name: string, type: string,
+                                             properties: Map<string, Property>) => void = function(): void {
         console.error("DiagramElementListener makeAndExecuteCreateLinkCommand method is empty")
     }
 }

editor-core/src/main/webapp/app/core/editorCore/controller/PaletteController.ts

@@ -10,8 +10,43 @@ export class PaletteController {
     private subprogramsSelector: string = "#subprograms-navigation";
     private blocksSelector: string = "#blocks-navigation";
     private flowsSelector: string = "#flows-navigation";
+    private paper: DiagramScene;
+    private elementTypes: ElementTypes;
+    private nodesTypesMap: Map<string, NodeType>;
 
-    public initDraggable(): void {
+    public init(paper: DiagramScene, elementTypes: ElementTypes, nodesTypesMap: Map<string, NodeType>) {
+        this.paper = paper;
+        this.elementTypes = elementTypes;
+        this.nodesTypesMap = nodesTypesMap;
+        this.reload();
+    }
+
+    public reload() {
+        this.clearPaletteContent(this.blocksSelector);
+        this.clearPaletteContent(this.flowsSelector);
+
+        this.appendBlocksPalette(this.elementTypes.blockTypes);
+        this.appendFlowsPalette(this.elementTypes.flowTypes);
+        this.initClick();
+        this.initDraggable();
+    }
+
+    public searchPaletteReload(event: Event) {
+        var searchPatterns: string[] = (<any> event.target).value.split(" ").map((str) => str.toLowerCase());
+
+        for (var [name, nodeType] of this.nodesTypesMap) {
+            var notFound: boolean;
+            for (var i in searchPatterns) {
+                notFound = name.indexOf(searchPatterns[i]) == -1;
+                if (notFound)
+                    break;
+            }
+            nodeType.setSearchVisibility(!notFound);
+        }
+        this.reload();
+    }
+
+    private initDraggable(): void {
         $(".tree-element").draggable({
             helper: function () {
                 var clone =  $(this).find('.element-img').clone();
@@ -27,8 +62,9 @@ export class PaletteController {
         });
     }
 
-    public initClick(paper: DiagramScene): void {
-        $("[data-type='" + paper.getCurrentLinkTypeName() + "']").css("border", "2px solid #00ff00");
+    private initClick(): void {
+        $("[data-type='" + this.paper.getCurrentLinkTypeName() + "']").css("border", "2px solid #00ff00");
+        var paper: DiagramScene = this.paper;
         $(".flow-element").mousedown(function () {
             paper.setCurrentLinkType($(this).attr("data-type"));
             $(".flow-element").css("border", "");
@@ -37,42 +73,23 @@ export class PaletteController {
     }
 
     public appendSubprogramsPalette(subprogramDiagramNodes: SubprogramDiagramNode[],
-                                    nodeTypesMap: Map<String, NodeType>): void {
+                                    nodeTypesMap: Map<string, NodeType>): void {
         var typeName: string = "Subprogram";
         var paletteView: SubprogramPaletteView = new SubprogramPaletteView(subprogramDiagramNodes,
-            nodeTypesMap[typeName].getImage());
+            nodeTypesMap.get(typeName).getImage());
         this.appendPaletteContent(this.subprogramsSelector, paletteView.getContent());
     }
 
-    public appendBlocksPalette(paletteTypes: PaletteTree): void {
+    private appendBlocksPalette(paletteTypes: PaletteTree): void {
         var paletteView: BlocksPaletteView = new BlocksPaletteView(paletteTypes, "tree-element");
         this.appendPaletteContent(this.blocksSelector, paletteView.getContent());
     }
 
-    public appendFlowsPalette(paletteTypes: PaletteTree): void {
+    private appendFlowsPalette(paletteTypes: PaletteTree): void {
         var paletteView: BlocksPaletteView = new BlocksPaletteView(paletteTypes, "tree-element flow-element");
         this.appendPaletteContent(this.flowsSelector, paletteView.getContent());
     }
 
-    public searchPaletteReload(event: Event, elementTypes: ElementTypes, nodesTypesMap: Map<String, NodeType>) {
-        var searchPatterns: string[] = (<any> event.target).value.split(" ").map((str) => str.toLowerCase());
-
-        for (var name in nodesTypesMap) {
-            var notFound: Boolean = false;
-            for (var i in searchPatterns) {
-                notFound = name.indexOf(searchPatterns[i]) == -1;
-                if (notFound)
-                    break;
-            }
-            nodesTypesMap[name].setVisibility(!notFound);
-        }
-        this.clearPaletteContent(this.blocksSelector);
-        this.clearPaletteContent(this.flowsSelector);
-
-        this.appendBlocksPalette(elementTypes.blockTypes);
-        this.appendFlowsPalette(elementTypes.flowTypes);
-    }
-
     private appendPaletteContent(selector: string, content: string): void {
         $(selector).append(content);
 
@@ -84,5 +101,4 @@ export class PaletteController {
     private clearPaletteContent(selector: string): void {
         $(selector).empty();
     }
-
 }

editor-core/src/main/webapp/app/core/editorCore/controller/PropertyEditorController.ts

@@ -7,6 +7,7 @@ import {HtmlView} from "../view/HtmlView";
 import {PropertyViewFactory} from "./PropertyViewFactory";
 import {UndoRedoController} from "./UndoRedoController";
 import {SceneController} from "./SceneController";
+import {DiagramNode} from "../model/DiagramNode";
 export class PropertyEditorController {
 
     private propertyViewFactory: PropertyViewFactory;
@@ -18,12 +19,22 @@ export class PropertyEditorController {
         this.sceneController = sceneController;
         this.undoRedoController = undoRedoController;
         this.initInputStringListener();
+        this.initInputTextListener();
         this.initCheckboxListener();
         this.initDropdownListener();
         this.initSpinnerListener();
 
+        var controller: PropertyEditorController = this;
+
         document.addEventListener('property-changed', function(e: any) {
-            $("." + e.detail.key + "-" + e.detail.nodeId).each(function(index) {
+            var currentElement: DiagramElement = controller.sceneController.getCurrentElement();
+            if (e.detail.key === "InnerText") {
+                currentElement.getJointObject().attr("text", {
+                    text: e.detail.value
+                });
+            } else if (e.detail.key === "ChangeType") {
+                controller.sceneController.changeElementType(currentElement, e.detail.value);
+            } else $("." + e.detail.key + "-" + e.detail.nodeId).each(function(index) {
                 if ($(this).val() !== e.detail.value) {
                     $(this).val(e.detail.value);
                     $(this).trigger('autosize');
@@ -34,22 +45,22 @@ export class PropertyEditorController {
 
     public setNodeProperties(element: DiagramElement): void {
         $('#property_table tbody').empty();
-        var properties: Map<String, Property> = element.getChangeableProperties();
-        for (var property in properties) {
+        var properties: Map<string, Property> = element.getChangeableProperties();
+        for (var [propertyName, property] of properties) {
             var propertyView: HtmlView = this.propertyViewFactory.createView(element.getLogicalId(), element.getType(),
-                property, properties[property]);
+                propertyName, property);
             var htmlElement = $(propertyView.getContent());
             $('#property_table tbody').append(htmlElement);
 
-            if (properties[property].type === "combobox") {
-                this.initCombobox(element.getType(), property, htmlElement);
+            if (property.type === "combobox") {
+                this.initCombobox(element.getType(), propertyName, htmlElement);
             }
         }
     }
 
     public addChangePropertyCommand(key: string, value: string, changeHtmlFunction: () => void): void {
         var currentElement: DiagramElement = this.sceneController.getCurrentElement();
-        var property: Property = currentElement.getChangeableProperties()[key];
+        var property: Property = currentElement.getChangeableProperties().get(key);
         var changePropertyCommand: Command = new ChangePropertyCommand(key, value, property.value,
             this.setProperty.bind(this), changeHtmlFunction);
         this.undoRedoController.addCommand(changePropertyCommand);
@@ -61,7 +72,7 @@ export class PropertyEditorController {
 
     public setProperty(key: string, value: string): void {
         var currentElement: DiagramElement = this.sceneController.getCurrentElement();
-        var property: Property = currentElement.getChangeableProperties()[key];
+        var property: Property = currentElement.getChangeableProperties().get(key);
         property.value = value;
         currentElement.setProperty(key, property);
     }
@@ -116,7 +127,7 @@ export class PropertyEditorController {
         $(document).on('change', '.checkbox', function () {
             var currentElement: DiagramElement = controller.sceneController.getCurrentElement();
             var key = $(this).data('type');
-            var property: Property = currentElement.getChangeableProperties()[key];
+            var property: Property = currentElement.getChangeableProperties().get(key);
             var currentValue = property.value;
             var newValue = controller.changeCheckboxValue(currentValue);
             controller.addChangePropertyCommand(key, newValue, controller.changeCheckboxHtml.bind(
@@ -126,6 +137,16 @@ export class PropertyEditorController {
         });
     }
 
+    private initInputTextListener(): void {
+        var controller: PropertyEditorController = this;
+        $(document).on('input', '.property-edit-text', function () {
+            var key = $(this).data('type');
+            var value = $(this).val();
+            controller.addChangePropertyCommand(key, value, () => {});
+            controller.setProperty(key, value);
+        });
+    }
+
     private initDropdownListener(): void {
         var controller: PropertyEditorController = this;
         $(document).on('change', '.mydropdown', function () {