Revize 4e05470f

added Spade plugin sources

plugins/imigerSpadeConverter/pom.xml

@@ +1 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>cz.zcu.kiv</groupId>
+    <artifactId>imiger-spade-converter</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <packaging>jar</packaging>
+
+    <properties>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-assembly-plugin</artifactId>
+                <configuration>
+                    <archive>
+                        <manifestFile>${project.build.outputDirectory}/META-INF/MANIFEST.MF</manifestFile>
+                    </archive>
+                    <descriptorRefs>
+                        <descriptorRef>jar-with-dependencies</descriptorRef>
+                    </descriptorRefs>
+                </configuration>
+                <executions>
+                    <execution>
+                        <id>make-assembly</id> <!-- this is used for inheritance merges -->
+                        <phase>package</phase> <!-- bind to the packaging phase -->
+                        <goals>
+                            <goal>single</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+
+    <dependencies>
+        <!-- Libs for JSON handling -->
+        <dependency>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+            <version>2.8.5</version>
+        </dependency>
+        <dependency>
+            <groupId>net.sf.json-lib</groupId>
+            <artifactId>json-lib</artifactId>
+            <version>2.4</version>
+            <classifier>jdk15</classifier>
+        </dependency>
+
+        <!-- Lib for loading file -->
+        <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+            <version>2.6</version>
+        </dependency>
+
+        <!-- Libs for Logging -->
+        <dependency>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-api</artifactId>
+            <version>2.11.1</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-core</artifactId>
+            <version>2.11.1</version>
+        </dependency>
+
+        <!-- Libs for Unit testing -->
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <version>5.3.2</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+
+</project>

plugins/imigerSpadeConverter/src/main/java/cz/zcu/kiv/imiger/plugin/spade/Spade.java

@@ +1 @@
+package cz.zcu.kiv.imiger.plugin.spade;
+
+import cz.zcu.kiv.imiger.plugin.spade.api.Graph;
+import cz.zcu.kiv.imiger.plugin.spade.graph.GraphManager;
+import cz.zcu.kiv.imiger.plugin.spade.graph.loader.GraphJSONDataLoader;
+import cz.zcu.kiv.imiger.plugin.spade.graph.loader.JSONConfigLoader;
+import net.sf.json.JSONObject;
+
+public class Spade {
+
+    /**
+     * Convert input spade JSON to RAW JSON and return it.
+     */
+    public String getRawJson(String file) {
+        GraphManager graphManager = new GraphJSONDataLoader(file).loadData();
+        JSONConfigLoader configLoader = new JSONConfigLoader(graphManager);
+
+        Graph graph = graphManager.createGraph(configLoader);
+        JSONObject json = JSONObject.fromObject(graph);
+
+        throw new NullPointerException();
+        //return json.toString();
+    }
+}

plugins/imigerSpadeConverter/src/main/java/cz/zcu/kiv/imiger/plugin/spade/api/AttributeDataType.java

@@ +1 @@
+package cz.zcu.kiv.imiger.plugin.spade.api;
+
+public enum AttributeDataType {
+    NUMBER {
+        @Override
+        public String toString() {
+            return "number";
+        }
+    },
+    DATE {
+        @Override
+        public String toString() {
+            return "date";
+        }
+    },
+    ENUM {
+        @Override
+        public String toString() {
+            return "enum";
+        }
+    },
+    STRING {
+        @Override
+        public String toString() {
+            return "string";
+        }
+    };
+
+    public static AttributeDataType getEnum(String value){
+        switch (value) {
+            case "number": return AttributeDataType.NUMBER;
+            case "date": return AttributeDataType.DATE;
+            case "enum": return AttributeDataType.ENUM;
+            default: return AttributeDataType.STRING;
+        }
+    }
+}

plugins/imigerSpadeConverter/src/main/java/cz/zcu/kiv/imiger/plugin/spade/api/AttributeType.java

@@ +1 @@
+package cz.zcu.kiv.imiger.plugin.spade.api;
+
+/**
+ * Class represents one attribute type which is used in input JSON file and in output JSON file (file between frontend
+ * and backend).
+ */
+public class AttributeType {
+    /** name of attribute */
+    public String name;
+    /** data type of attribute */
+    public AttributeDataType dataType;
+    /** additional info */
+    public String text;
+
+    public AttributeType(String name, AttributeDataType dataType, String text) {
+        this.name = name;
+        this.dataType = dataType;
+        this.text = text;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public AttributeDataType getDataType() {
+        return dataType;
+    }
+
+    public String getText() {
+        return text;
+    }
+}

plugins/imigerSpadeConverter/src/main/java/cz/zcu/kiv/imiger/plugin/spade/api/BaseEdge.java

@@ +1 @@
+package cz.zcu.kiv.imiger.plugin.spade.api;
+
+/**
+ * Class represents edge. Class contains attributes which are common for input JSON format and for
+ * output JSON format (JSON between frontend and backend)
+ */
+public class BaseEdge {
+    /** identification number of edge */
+    private int id;
+    /** original ID of vertex from edge leads */
+    private int from;
+    /** original ID of vertex where edge leads */
+    private int to;
+    /** additional info */
+    private String text;
+
+    public BaseEdge(int id, int from, int to, String text) {
+        this.id = id;
+        this.from = from;
+        this.to = to;
+        this.text = text;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public int getFrom() {
+        return from;
+    }
+
+    public void setFrom(int from) {
+        this.from = from;
+    }
+
+    public int getTo() {
+        return to;
+    }
+
+    public void setTo(int to) {
+        this.to = to;
+    }
+
+    public String getText() {
+        return text;
+    }
+
+    public void setText(String text) {
+        this.text = text;
+    }
+
+    /**
+     * Generate hash code based on attributes {@code from} and {@code to}.
+     * @return generated hash code.
+     */
+    @Override
+    public int hashCode() {
+        return from * 100000 + to;
+    }
+
+    /**
+     * Two edges are equals where their {@code from} and {@code to} are equals.
+     *
+     * @param edge which will be compared with this instance
+     * @return tru if edges are equal, false otherwise
+     */
+    @Override
+    public boolean equals(Object edge) {
+        if (!(edge instanceof BaseEdge)) return false;
+
+        BaseEdge cmpEdge = (BaseEdge) edge;
+        return from == cmpEdge.from && to == cmpEdge.to;
+    }
+}

plugins/imigerSpadeConverter/src/main/java/cz/zcu/kiv/imiger/plugin/spade/api/BaseVertex.java

@@ +1 @@
+package cz.zcu.kiv.imiger.plugin.spade.api;
+
+/**
+ * Class represents vertex. Class contains attributes which are common for input JSON format and for
+ * output JSON format (JSON between frontend and backend)
+ */
+public class BaseVertex {
+
+    /** New generated identification number. */
+    private int id;
+    /** Name of vertex. */
+    private String name;
+    /** Index of vertex archetype. */
+    private int archetypeIndex;
+    /** Additional info. */
+    private String text;
+
+    public BaseVertex(int id, String name, int archetypeIndex, String text) {
+        this.id = id;
+        this.name = name;
+        this.archetypeIndex = archetypeIndex;
+        this.text = text;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public int getArchetype() {
+        return archetypeIndex;
+    }
+
+    public void setArchetype(int archetypeIndex) {
+        this.archetypeIndex = archetypeIndex;
+    }
+
+    public String getText() {
+        return text;
+    }
+
+    public void setText(String text) {
+        this.text = text;
+    }
+
+    /**
+     * Generate hash code which is based on {@code originalId}.
+     * @return generated has code
+     */
+    @Override
+    public int hashCode() {
+        return id;
+    }
+
+    /**
+     * Two vertices are equals when their {@code originalId} is equals.
+     * @param vertex which will be compared with this instance
+     * @return true if vertices are equal, false otherwise
+     */
+    @Override
+    public boolean equals(Object vertex) {
+        if (!(vertex instanceof BaseVertex)) return false;
+        return id == ((BaseVertex) vertex).id;
+    }
+}

plugins/imigerSpadeConverter/src/main/java/cz/zcu/kiv/imiger/plugin/spade/api/Edge.java

@@ +1 @@
+package cz.zcu.kiv.imiger.plugin.spade.api;
+
+import java.util.List;
+
+/**
+ * Class represents edge which is used for output JSON format (JSON between frontend and backend).
+ */
+public class Edge extends BaseEdge {
+
+    /**
+     * List of subedgeInfo.
+     * When two input edges are equals, in output their are in one record and their differences are in subedgeInfo.
+     */
+    private List<SubedgeInfo> subedgeInfo;
+
+    /**
+     * Create new edge.
+     * @param id new generated identification number
+     * @param from original ID of vertex from edge leads
+     * @param to original ID of vertex where edge leads
+     * @param text additional info
+     * @param subedgeInfo list which contains differences between equals edges
+     */
+    public Edge(int id, int from, int to, String text, List<SubedgeInfo> subedgeInfo) {
+        super(id, from, to, text);
+        this.subedgeInfo = subedgeInfo;
+    }
+
+    public List<SubedgeInfo> getSubedgeInfo(){
+        return subedgeInfo;
+    }
+
+    public void setSubedgeInfo(List<SubedgeInfo> subedgeInfo) {
+        this.subedgeInfo = subedgeInfo;
+    }
+}

plugins/imigerSpadeConverter/src/main/java/cz/zcu/kiv/imiger/plugin/spade/api/EdgeArchetype.java

@@ +1 @@
+package cz.zcu.kiv.imiger.plugin.spade.api;
+
+public class EdgeArchetype {
+    public String name;
+    public String text;
+
+    public EdgeArchetype(String name, String text) {
+        this.name = name;
+        this.text = text;
+    }
+
+    public String getName() {
+        return  name;
+    }
+
+    public String getText() {
+        return text;
+    }
+}

plugins/imigerSpadeConverter/src/main/java/cz/zcu/kiv/imiger/plugin/spade/api/Graph.java

@@ +1 @@
+package cz.zcu.kiv.imiger.plugin.spade.api;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.*;
+
+/**
+ * Class represents graph with all information about graph plus information about state in which used store graph.
+ * Class is used for creating of JSON which is send to frontend.
+ */
+public class Graph {
+
+    private Set<Vertex> vertices;
+    private List<Edge> edges;
+    private List<VertexArchetype> vertexArchetypes;
+    private List<EdgeArchetype> edgeArchetypes;
+    private List<AttributeType> attributeTypes;
+    private Map<String, List<String>> possibleEnumValues;
+
+    private List<Group> groups;
+    private List<SideBar> sideBar;
+    private String highlightedVertex; // group-ID, vertex-ID
+    private String highlightedEdge;
+
+    private static final Logger logger = LogManager.getLogger();
+
+    public Graph() {
+        vertices = new HashSet<>();
+        edges = new LinkedList<>();
+    }
+
+    public List<Edge> getEdges() {
+        logger.trace("ENTRY");
+        logger.trace("EXIT");
+        return edges;
+    }
+
+    public Set<Vertex> getVertices() {
+        logger.trace("ENTRY");
+        logger.trace("EXIT");
+        return vertices;
+    }
+
+    public List<VertexArchetype> getVertexArchetypes() {
+        return vertexArchetypes;
+    }
+
+    public List<EdgeArchetype> getEdgeArchetypes() {
+        return edgeArchetypes;
+    }
+
+    public List<AttributeType> getAttributeTypes() {
+        return attributeTypes;
+    }
+
+    public Map<String, List<String>> getPossibleEnumValues() {
+        return possibleEnumValues;
+    }
+
+    public List<Group> getGroups() {
+        return groups;
+    }
+
+    public List<SideBar> getSideBar() {
+        return sideBar;
+    }
+
+    public String getHighlightedVertex() {
+        return highlightedVertex;
+    }
+
+    public String getHighlightedEdge() {
+        return highlightedEdge;
+    }
+
+    public void setVertexArchetypes(List<VertexArchetype> vertexArchetypes) {
+        this.vertexArchetypes = vertexArchetypes;
+    }
+
+    public void setEdgeArchetypes(List<EdgeArchetype> edgeArchetypes) {
+        this.edgeArchetypes = edgeArchetypes;
+    }
+
+    public void setAttributeTypes(List<AttributeType> attributeTypes) {
+        this.attributeTypes = attributeTypes;
+    }
+
+    public void setPossibleEnumValues(Map<Integer, List<String>> possibleEnumValues) {
+        this.possibleEnumValues = new HashMap<>();
+        for (Map.Entry<Integer, List<String>> entry : possibleEnumValues.entrySet()) {
+            this.possibleEnumValues.put("" + entry.getKey(), entry.getValue());
+        }
+    }
+
+    public void setGroups(List<Group> groups) {
+        this.groups = groups;
+    }
+
+    public void setSideBar(List<SideBar> sideBar) {
+        this.sideBar = sideBar;
+    }
+
+    public void setHighlightedVertex(String highlightedVertex) {
+        this.highlightedVertex = highlightedVertex;
+    }
+
+    public void setHighlightedEdge(String highlightedEdge) {
+        this.highlightedEdge = highlightedEdge;
+    }
+}

plugins/imigerSpadeConverter/src/main/java/cz/zcu/kiv/imiger/plugin/spade/api/Group.java

@@ +1 @@
+package cz.zcu.kiv.imiger.plugin.spade.api;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Class represents group of edges and their settings. Used in JSON between frontend and backend.
+ */
+public class Group {
+
+    /** Generated id of group. */
+    private int id;
+    /** Name of group */
+    private String name;
+    /** List of vertices id which belongs to this group */
+    private List<Integer> verticesId;
+    /** List of vertices id whose outgoing edges are visible. */
+    private List<Integer> verticesEdgeFromId;
+    /** List of vertices id whose incoming edges are visible. */
+    private List<Integer> verticesEdgeToId;
+    /** Relative position in graph */
+    private Position position;
+
+    public Group(int id, String name){
+        this.id = id;
+        this.name = name;
+        this.verticesId = new ArrayList<>();
+        this.verticesEdgeFromId = new ArrayList<>();
+        this.verticesEdgeToId = new ArrayList<>();
+        this.position = null;
+    }
+
+    public Group(int id, String name, List<Integer> verticesId, List<Integer> verticesEdgeFromId, List<Integer> verticesEdgeToId) {
+        this.id = id;
+        this.name = name;
+        this.verticesId = verticesId;
+        this.verticesEdgeFromId = verticesEdgeFromId;
+        this.verticesEdgeToId = verticesEdgeToId;
+        this.position = null;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public List<Integer> getVerticesId() {
+        return verticesId;
+    }
+
+    public void setVerticesId(List<Integer> verticesId) {
+        this.verticesId = verticesId;
+    }
+
+    public List<Integer> getVerticesEdgeFromId() {
+        return verticesEdgeFromId;
+    }
+
+    public void setVerticesEdgeFromId(List<Integer> verticesEdgeFromId) {
+        this.verticesEdgeFromId = verticesEdgeFromId;
+    }
+
+    public List<Integer> getVerticesEdgeToId() {
+        return verticesEdgeToId;
+    }
+
+    public void setVerticesEdgeToId(List<Integer> verticesEdgeToId) {
+        this.verticesEdgeToId = verticesEdgeToId;
+    }
+
+    public void addVertexId(int vertexId){
+        this.verticesId.add(vertexId);
+    }
+
+    public void addVetexEdgeToId(int vertexId){
+        this.verticesEdgeToId.add(vertexId);
+    }
+
+    public void addVetexEdgeFromId(int vertexId){
+        this.verticesEdgeFromId.add(vertexId);
+    }
+
+    public Position getPosition() {
+        return position;
+    }
+
+    public void setPosition(Position position) {
+        this.position = position;
+    }
+}

plugins/imigerSpadeConverter/src/main/java/cz/zcu/kiv/imiger/plugin/spade/api/Position.java

@@ +1 @@
+package cz.zcu.kiv.imiger.plugin.spade.api;
+
+/**
+ * Class is used for storing information about vertex/group relative position.
+ */
+public class Position {
+
+    /** Relative X position. */
+    private float x;
+    /** Relative Y position */
+    private float y;
+
+    public Position(float x, float y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public float getX() {
+        return x;
+    }
+
+    public void setX(float x) {
+        this.x = x;
+    }
+
+    public float getY() {
+        return y;
+    }
+
+    public void setY(float y) {
+        this.y = y;
+    }
+}

plugins/imigerSpadeConverter/src/main/java/cz/zcu/kiv/imiger/plugin/spade/api/SideBar.java

@@ +1 @@
+package cz.zcu.kiv.imiger.plugin.spade.api;
+
+/**
+ * Class store information about item in side bar.
+ */
+public class SideBar {
+
+    /** Identification number of vertex or group which was generated in application. */
+    private int vertexId;
+    /** Indicates if related vertexes of this item have visible icon which shows relation with this item. */
+    private boolean isIconsDisplayed;
+
+    public SideBar(int vertexId, boolean isIconsDisplayed) {
+        this.vertexId = vertexId;
+        this.isIconsDisplayed = isIconsDisplayed;
+    }
+
+    public int getVertexId() {
+        return vertexId;
+    }
+
+    public void setVertexId(int vertexId) {
+        this.vertexId = vertexId;
+    }
+
+    public boolean isIconsDisplayed() {
+        return isIconsDisplayed;
+    }
+
+    public void setIconsDisplayed(boolean iconsDisplayed) {
+        this.isIconsDisplayed = iconsDisplayed;
+    }
+}

plugins/imigerSpadeConverter/src/main/java/cz/zcu/kiv/imiger/plugin/spade/api/SubedgeInfo.java

@@ +1 @@
+package cz.zcu.kiv.imiger.plugin.spade.api;
+
+import java.util.List;
+
+public class SubedgeInfo {
+
+    /** Edge archetype index. */
+    private int archetype;
+    /** Original id of edge which is taken from input JSON file. */
+    private int id;
+    /** List of all tributes. Every attribute is stored in String array in pair as {attribute name, attribute value}. */
+    private List<String[]> attributes;
+
+    /**
+     * Create new subedgeInfo
+     * @param id Original id of edge which is taken from input JSON file.
+     * @param archetype Edge archetype index.
+     * @param attributes  List of all tributes. Every attribute is stored in String array in pair as {attribute name, attribute value}.
+     */
+    public SubedgeInfo(int id, int archetype, List<String[]> attributes) {
+        this.id = id;
+        this.archetype = archetype;
+        this.attributes = attributes;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public int getArchetype() {
+        return archetype;
+    }
+
+    public List<String[]> getAttributes() {
+        return attributes;
+    }
+}

plugins/imigerSpadeConverter/src/main/java/cz/zcu/kiv/imiger/plugin/spade/api/Vertex.java

@@ +1 @@
+package cz.zcu.kiv.imiger.plugin.spade.api;
+
+import cz.zcu.kiv.imiger.plugin.spade.graph.VertexImpl;
+
+import java.util.List;
+
+/**
+ * Class represents vertex which is used for output JSON format (JSON between frontend and backend)
+ */
+public class Vertex extends BaseVertex {
+
+    /** List of all tributes. Every attribute is stored in String array in pair as {attribute name, attribute value}. */
+    private List<String[]> attributes;
+    /** Relative position in graph */
+    private Position position;
+
+    /**
+     * Create new vertex.
+     * @param id original identification number from input file
+     * @param name of vertex
+     * @param archetypeIndex index of vertex archetype
+     * @param text additional info
+     * @param attributes List of all attributes. Every attribute is stored in String array in pair as {attribute name, attribute value}.
+     */
+    public Vertex(int id, String name, int archetypeIndex, String text, List<String[]> attributes) {
+        super(id, name, archetypeIndex, text);
+        this.attributes = attributes;
+        this.position = null;
+    }
+
+    /**
+     * Create new vertex.
+     * @param vertex instance of VertexImpl with set all parameters
+     * @param attributes ist of all attributes. Every attribute is stored in String array in pair as {attribute name, attribute value}.
+     */
+    public Vertex(VertexImpl vertex, List<String[]> attributes){
+        this(vertex.getId(), vertex.getName(), vertex.getArchetype(), vertex.getText(), attributes);
+    }
+
+    public List<String[]> getAttributes() {
+        return attributes;
+    }
+
+    public void setAttributes(List<String[]> attributes) {
+        this.attributes = attributes;
+    }
+
+    public Position getPosition() {
+        return position;
+    }
+
+    public void setPosition(Position position) {
+        this.position = position;
+    }
+}

plugins/imigerSpadeConverter/src/main/java/cz/zcu/kiv/imiger/plugin/spade/api/VertexArchetype.java

@@ +1 @@
+package cz.zcu.kiv.imiger.plugin.spade.api;
+
+public class VertexArchetype {
+    public String name;
+    public String text;
+    public String icon;
+
+    public VertexArchetype(String name, String text, String icon) {
+        this.name = name;
+        this.text = text;
+        this.icon = icon;
+    }
+
+    public VertexArchetype(String name, String text) {
+        this(name, text, "");
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getText() {
+        return text;
+    }
+
+    public String getIcon() {
+        return icon;
+    }
+}

plugins/imigerSpadeConverter/src/main/java/cz/zcu/kiv/imiger/plugin/spade/graph/Attribute.java

@@ +1 @@
+package cz.zcu.kiv.imiger.plugin.spade.graph;
+
+/**
+ * This class represents attribute of edge or vertex.
+ */
+public class Attribute {
+    /** Index to array of attribute types which is defined in input JSON file */
+    private int typeIndex;
+    /** Value of attribute */
+    private Object value;
+
+    public Attribute(int typeIndex, Object value) {
+        this.typeIndex = typeIndex;
+        this.value = value;
+    }
+
+    public int getTypeIndex() {
+        return typeIndex;
+    }
+
+    public void setTypeIndex(int typeIndex) {
+        this.typeIndex = typeIndex;
+    }
+
+    public Object getValue() {
+        return value;
+    }
+
+    public void setValue(Object value) {
+        this.value = value;
+    }
+}

plugins/imigerSpadeConverter/src/main/java/cz/zcu/kiv/imiger/plugin/spade/graph/EdgeArchetypeInfo.java

@@ +1 @@
+package cz.zcu.kiv.imiger.plugin.spade.graph;
+
+public class EdgeArchetypeInfo {
+    /**
+     * index of the archetype of the vertex the edge leads to
+     */
+    public int fromArchetypeIndex;
+
+    /**
+     * index of the archetype of the edge
+     */
+    public int edgeArchetypeIndex;
+
+    /**
+     * index of the archetype of the vertex the edge leads from
+     */
+    public int toArchetypeIndex;
+
+    public EdgeArchetypeInfo(int fromArchetypeIndex, int edgeArchetypeIndex, int toArchetypeIndex) {
+        this.fromArchetypeIndex = fromArchetypeIndex;
+        this.edgeArchetypeIndex = edgeArchetypeIndex;
+        this.toArchetypeIndex = toArchetypeIndex;
+    }
+
+    @Override
+    public int hashCode() {
+        return fromArchetypeIndex * 10000 + edgeArchetypeIndex * 100 + fromArchetypeIndex;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if(!(obj instanceof EdgeArchetypeInfo)) return false;
+        
+        EdgeArchetypeInfo info = (EdgeArchetypeInfo)obj;
+        return (info.fromArchetypeIndex == fromArchetypeIndex) &&
+                (info.edgeArchetypeIndex == edgeArchetypeIndex) &&
+                (info.toArchetypeIndex == toArchetypeIndex);
+    }
+}

plugins/imigerSpadeConverter/src/main/java/cz/zcu/kiv/imiger/plugin/spade/graph/EdgeImpl.java

@@ +1 @@
+package cz.zcu.kiv.imiger.plugin.spade.graph;
+
+import cz.zcu.kiv.imiger.plugin.spade.api.BaseEdge;
+
+import java.util.*;
+
+/**
+ * Class represents edge which is used for input JSON format.
+ */
+public class EdgeImpl extends BaseEdge {
+
+    /** original identification number which is defined in input file */
+    private int originalId;
+    /** index of edge archetype */
+    private int archetypeIndex;
+    /** Map contains attributes stored in key value format. Key is index to array of attribute types defined in input file */
+    private Map<Integer, Attribute> attributesMap;
+
+    /**
+     * Create new edge.
+     * @param id new generated identification number
+     * @param from original ID of vertex from edge leads
+     * @param to original ID of vertex where edge leads
+     * @param text additional info
+     * @param originalId original identification number which is defined in input file
+     * @param archetypeIndex index of edge archetype
+     */
+    public EdgeImpl(int id, int from, int to, String text, int originalId, int archetypeIndex) {
+        super(id, from, to, text);
+        this.originalId = originalId;
+        this.archetypeIndex = archetypeIndex;
+        this.attributesMap = new HashMap<>();
+    }
+
+    public Attribute getAttribute(int attrTypeIndex) {
+        return attributesMap.get(attrTypeIndex);
+    }
+
+    public Map<Integer, Attribute> getAttributesMap() {
+        return attributesMap;
+    }
+
+
+    public int getOriginalId() {
+        return originalId;
+    }
+
+
+    public int getArchetype() {
+        return archetypeIndex;
+    }
+
+
+    public void addAttribute(int attrTypeIndex, Object value) {
+        Attribute attr = new Attribute(attrTypeIndex, value);
+        attributesMap.put(attrTypeIndex, attr);
+    }
+
+    public void addAttributes(Map<Integer, Attribute> attributes) {
+        this.attributesMap.putAll(attributes);
+    }
+
+    public void setOriginalId(int originalId) {
+        this.originalId = originalId;
+    }
+
+    public void setArchetypeIndex(int archetypeIndex) {
+        this.archetypeIndex = archetypeIndex;
+    }
+
+    /**
+     * Return list of attributes sorted by their key value in {@code attributeMap}
+     * @return sorted list
+     */
+    public List<Attribute> getSortedAttributes() {
+        List<Attribute> list = new ArrayList<>();
+        ArrayList<Integer> indices = new ArrayList<>(attributesMap.keySet());
+        //indices.sort(Integer::compareTo);
+        Collections.sort(indices);
+        for (Integer index : indices) {
+            list.add(attributesMap.get(index));
+        }
+        return list;
+    }
+}

plugins/imigerSpadeConverter/src/main/java/cz/zcu/kiv/imiger/plugin/spade/graph/GraphManager.java

@@ +1 @@
+package cz.zcu.kiv.imiger.plugin.spade.graph;
+
+import cz.zcu.kiv.imiger.plugin.spade.api.*;
+import cz.zcu.kiv.imiger.plugin.spade.graph.filter.*;
+import cz.zcu.kiv.imiger.plugin.spade.graph.loader.JSONConfigLoader;
+
+import java.util.*;
+
+public class GraphManager {
+
+    public List<VertexArchetype> vertexArchetypes = new ArrayList<>();
+    public List<EdgeArchetype> edgeArchetypes = new ArrayList<>();
+    public List<AttributeType> attributeTypes = new ArrayList<>();
+
+    /**
+     * the key is the attributeType index, the value is the list of possible values
+     */
+    private Map<Integer, List<String>> possibleEnumValues = new HashMap<>();
+
+    /**
+     * key is the archetype index, value is the set of vertices of the given archetype
+     */
+    public Map<Integer, HashSet<VertexImpl>> vertices = new HashMap<>();
+
+    /**
+     * key is the triplet of archetypes {fromVertex, edge, toVertex}, value is the list of edges for the given archetype triplet
+     */
+    public Map<EdgeArchetypeInfo, List<EdgeImpl>> edges = new HashMap<>();
+
+    public void addVertexArchetype(String name, String text) {
+        vertexArchetypes.add(new VertexArchetype(name, text));
+    }
+
+    public void addEdgeArchetype(String name, String text) {
+        edgeArchetypes.add(new EdgeArchetype(name, text));
+    }
+
+
+    public void addAttributeType(String name, AttributeDataType dataType, String text) {
+        attributeTypes.add(new AttributeType(name, dataType, text));
+    }
+
+    /**
+     * Adds a list of values to the possible values hashmap. All duplicated are
+     * removed.
+     *
+     * @param attributeTypeId - Id of attribute type
+     * @param values          - List of values of the corresponding attribute type
+     */
+    public void addUniquePossibleAttributeValues(int attributeTypeId, List<String> values) {
+        if (possibleEnumValues.containsKey(attributeTypeId)) {
+            List<String> attrValues = possibleEnumValues.get(attributeTypeId);
+            List<String> valuesWithoutDuplicates = new ArrayList<>(new HashSet<>(values)); // Converting to hashset removes duplicates
+            valuesWithoutDuplicates.removeAll(attrValues);   // Values to add without values already present in the hashmap
+            attrValues.addAll(valuesWithoutDuplicates);
+        } else {
+            possibleEnumValues.put(attributeTypeId, values);
+        }
+    }
+
+    public List<Integer> getEnumPositionsForAttrIndex(int attributeTypeId, List<String> enumValues) {
+        List<Integer> positions = new ArrayList<>();
+        if (!possibleEnumValues.containsKey(attributeTypeId)) {
+            return positions;
+        }
+
+        List<String> possibleValues = possibleEnumValues.get(attributeTypeId);
+        for (int i = 0; i < possibleValues.size(); i++) {
+            String possibleValue = possibleValues.get(i);
+            if (enumValues.contains(possibleValue)) {
+                positions.add(i);
+            }
+        }
+
+        return positions;
+    }
+
+    /**
+     * Gets string values from possible enums for attribute type id.
+     *
+     * @param attributeTypeId - Id of the attribute type
+     * @param valuePositions  - List of positions in the possible enums hashmap for which to find the enum values.
+     * @return - List of string values of enums.
+     */
+    private List<String> getEnumStringsForAttrIndex(int attributeTypeId, List<Integer> valuePositions) {
+        List<String> values = new ArrayList<>();
+
+        List<String> possibleValues = possibleEnumValues.get(attributeTypeId);
+        for (int i = 0; i < possibleValues.size(); i++) {
+            if (valuePositions.contains(i)) {
+                values.add(possibleValues.get(i));
+            }
+        }
+
+        return values;
+    }
+
+    public AttributeType getAttributeDataTypeByName(String attributeName) {
+        return attributeTypes.get(getAttributeIndex(attributeName));
+    }
+
+    /**
+     * Adds a record to the possibleEnumValues hashset of the attributes possible values.
+     *
+     * @param attributeIndex - Index of the attribute for which to add the possible values
+     * @param possibleValues - All the possible values of the attribute
+     */
+    public void addEnumValues(int attributeIndex, List<String> possibleValues) {
+        possibleEnumValues.put(attributeIndex, possibleValues);
+    }
+
+    /**
+     * Creates a new vertex from input parameters and adds it to the map of
+     * vertices with the archetypeIndex as the key.
+     *
+     * @param id             - ID of the vertex to add
+     * @param name           - Name of the vertex
+     * @param text           - Text of the vertex
+     * @param archetypeIndex - Type of archetype associated with this vertex
+     * @param attributes     - Map of attributes associated with the vertex
+     */
+    public void addVertex(int id, String name, String text, int archetypeIndex, Map<Integer, Attribute> attributes) {
+        VertexImpl vertexToAdd = new VertexImpl(id, name, archetypeIndex, text);
+        if (vertices.containsKey(archetypeIndex)) {
+            vertices.get(archetypeIndex).add(vertexToAdd);
+        } else {
+            HashSet<VertexImpl> vertexSet = new HashSet<>();
+            vertexSet.add(vertexToAdd);
+            vertices.put(archetypeIndex, vertexSet);
+        }
+
+        vertexToAdd.addAttributes(attributes);
+    }
+
+    /**
+     * Creates a new edge from input parameters and adds it to the map of
+     * edges with the archetypeIndex as the key.
+     *
+     * @param id            - ID of the edge to add
+     * @param from          - ID of the vertex the edge comes from
+     * @param to            - ID of the vertex the edge points to
+     * @param text          - Text of edge
+     * @param archetypeInfo - The archetype information associated with this edge
+     * @param attributes    - Map of attributes associated with the edge
+     */
+    public void addEdge(int id, int from, int to, String text, EdgeArchetypeInfo archetypeInfo, Map<Integer, Attribute> attributes) {
+        EdgeImpl edgeToAdd = new EdgeImpl(id, from, to, text, id, archetypeInfo.edgeArchetypeIndex);
+        edgeToAdd.addAttributes(attributes);
+
+        if (edges.containsKey(archetypeInfo)) {
+            edges.get(archetypeInfo).add(edgeToAdd);
+        } else {
+            List<EdgeImpl> edgesList = new ArrayList<>();
+            edgesList.add(edgeToAdd);
+            edges.put(archetypeInfo, edgesList);
+        }
+    }
+
+    /**
+     * returns the index of a given enum value in the list of the possible enum values
+     *
+     * @param value the enum value
+     * @return index in the list of possible enum values or -1 if the value is not in the list
+     */
+    public int getEnumValueIndex(int attributeTypeIndex, String value) {
+        int index = -1;
+        List<String> values = possibleEnumValues.get(attributeTypeIndex);
+        for (int i = 0; i < values.size(); i++) {
+            if (values.get(i).equals(value)) {
+                index = i;
+                break;
+            }
+        }
+        return index;
+    }
+
+    /**
+     * returns the index of an attribute with a given name in the attributeTypes list
+     *
+     * @param name the name of the attribute
+     * @return the attribute index or -1 if there is no attribute with such a name
+     */
+    public int getAttributeIndex(String name) {
+        int index = -1;
+        for (int i = 0; i < attributeTypes.size(); i++) {
+            if (attributeTypes.get(i).name.equals(name)) {
+                index = i;
+                break;
+            }
+        }
+        return index;
+    }
+
+    /**
+     * returns the index of an archetype with a given name in the vertexArchetypes list
+     *
+     * @param archetypeName name of the archetype
+     * @return the index or -1 if there is no archetype with the given name in the list
+     */
+    public int getVertexArchetypeIndex(String archetypeName) {
+        int index = -1;
+        for (int i = 0; i < vertexArchetypes.size(); i++) {
+            if (vertexArchetypes.get(i).name.equals(archetypeName)) {
+                index = i;
+                break;
+            }
+        }
+        return index;
+    }
+
+    /**
+     * returns the index of an archetype with a given name in the edgeArchetypes list
+     *
+     * @param archetypeName name of the archetype
+     * @return the index or -1 if there is no archetype with the given name in the list
+     */
+    public int getEdgeArchetypeIndex(String archetypeName) {
+        int index = -1;
+        for (int i = 0; i < edgeArchetypes.size(); i++) {
+            if (edgeArchetypes.get(i).name.equals(archetypeName)) {
+                index = i;
+                break;
+            }
+        }
+        return index;
+    }
+
+    /**
+     * Filters the edges and vertices according to the default filter loaded from the configuration file
+     * and constructs the {@code Graph} object.
+     *
+     * @param configLoader - The object that loads the configuration file.
+     * @return - Constructed {@code Graph} object.
+     */
+    public Graph createGraph(JSONConfigLoader configLoader) {
+        Graph graph = new Graph();
+
+        // To use default filter from a configuration file
+        GraphFilter filter = configLoader.loadDefaultFilter();
+        if (filter == null) {
+            // To Enable Everything
+            filter = new GraphFilter();
+            filter.setVertexArchetypeFilter(new ArrayList<>(), GraphFilter.ArchetypeMatchType.NON_MATCHING);
+            filter.setEdgeArchetypeFilter(new ArrayList<>(), GraphFilter.ArchetypeMatchType.NON_MATCHING);
+        }
+
+
+        Set<VertexImpl> resultVertices = getVerticesByArchetypeFilter(filter);
+        resultVertices = getVerticesByAttributeFilter(filter, resultVertices);
+        List<EdgeImpl> resultEdges = getEdgesByArchetypeFilter(filter, resultVertices);
+        resultEdges = getEdgesByAttributeFilter(filter, resultEdges);
+
+        addVerticesToGraph(graph, resultVertices);
+        addEdgesToGraph(graph, resultEdges);
+
+        Map<String, String> archetypeIcons = configLoader.loadArchetypeIcons();
+        addVertexArchetypes(graph, archetypeIcons);
+        graph.setEdgeArchetypes(edgeArchetypes);
+
+        graph.setAttributeTypes(attributeTypes);
+        graph.setPossibleEnumValues(possibleEnumValues);
+
+        List<String> defaultGroupArchetypes = configLoader.loadGroupArchetypesStrings();
+        addDefaultGroups(graph, defaultGroupArchetypes);
+
+        return graph;
+    }
+
+    /**
+     * Gets filtered vertices by attributes.
+     *
+     * @param filter   - Filter object.
+     * @param vertices - List of vertices for filtration.
+     * @return - List of vertices filtered by attribute.
+     */
+    private Set<VertexImpl> getVerticesByAttributeFilter(GraphFilter filter, Set<VertexImpl> vertices) {
+        Set<VertexImpl> resultVertices = new HashSet<>();
+        for (VertexImpl vertex : vertices) {
+            boolean filterPassed = true;
+            AttributeFilter attributeFilter = filter.getVertexAttributeFilter(vertex.getArchetype());
+            if (attributeFilter != null) {
+                // Iterate through all attributes of the vertex
+                for (int attributeIndex : vertex.getAttributesMap().keySet()) {
+                    Attribute vertexAttribute = vertex.getAttributesMap().get(attributeIndex);
+
+                    filterPassed = (filterPassed && checkAttributeFiltersPassed(vertexAttribute, attributeFilter, attributeIndex));
+                    if (!filterPassed) break;   // filter did not pass
+                }
+            }
+            if (filterPassed)
+                resultVertices.add(vertex);
+        }
+        return resultVertices;
+    }
+
+    /**
+     * Gets filtered edges by attribute.
+     *
+     * @param filter - Filter object.
+     * @param edges  - List of edges for filtration.
+     * @return - List of edges filtered by attribute.
+     */
+    private List<EdgeImpl> getEdgesByAttributeFilter(GraphFilter filter, List<EdgeImpl> edges) {
+        List<EdgeImpl> resultEdges = new ArrayList<>();
+        for (EdgeImpl edge : edges) {
+            boolean filterPassed = true;
+            AttributeFilter attributeFilter = filter.getEdgeAttributeFilter(edge.getArchetype());
+            if (attributeFilter != null) {
+                // Iterate through all attributes of the edge
+                for (int attributeIndex : edge.getAttributesMap().keySet()) {
+                    Attribute edgeAttribute = edge.getAttributesMap().get(attributeIndex);
+
+                    filterPassed = (filterPassed && checkAttributeFiltersPassed(edgeAttribute, attributeFilter, attributeIndex));
+                    if (!filterPassed) break;   // filter did not pass
+                }
+            }
+            if (filterPassed)
+                resultEdges.add(edge);
+        }
+
+        return resultEdges;
+    }
+
+    /**
+     * Filters the attribute by its attribute filters and checks if it passed.
+     *
+     * @param vertexAttribute - Attribute object to filter.
+     * @param attributeFilter - Attribute filter of the attribute.
+     * @param attributeIndex  - Index of the attribute.
+     * @return - true if passed the filter, else false.
+     */
+    private boolean checkAttributeFiltersPassed(Attribute vertexAttribute, AttributeFilter attributeFilter, int attributeIndex) {
+        AttributeDataType attributeType = attributeTypes.get(vertexAttribute.getTypeIndex()).dataType;
+
+        boolean filterPassed;
+        ITypeAttributeFilter typeFilter = null;
+        switch (attributeType) {
+            case NUMBER:
+                typeFilter = attributeFilter.getNumberFilter(attributeIndex);
+                break;
+            case DATE:
+                typeFilter = attributeFilter.getDateFilter(attributeIndex);
+                break;
+            case ENUM:
+                typeFilter = attributeFilter.getEnumFilter(attributeIndex);
+                break;
+            case STRING:
+                typeFilter = attributeFilter.getStringFilter(attributeIndex);
+                break;
+        }
+        if (typeFilter == null) { // No filters mean pass
+            return true;
+        }
+
+        filterPassed = typeFilter.filter(vertexAttribute.getValue());
+
+        return filterPassed;
+    }
+
+    /**
+     * Filters vertices by archetype from the specified filter object.
+     *
+     * @param filter - Filter to be applied to the vertices.
+     * @return A list of vertices filtered by the specified filter object.
+     */
+    private HashSet<VertexImpl> getVerticesByArchetypeFilter(GraphFilter filter) {
+        HashSet<VertexImpl> resultVertices = new HashSet<>();
+
+        VertexArchetypeFilter vertexArchetypeFilter = filter.getVertexArchetypeFilter();
+        List<Integer> archetypesFiltered = vertexArchetypeFilter.archetypeIndeces;
+        switch (vertexArchetypeFilter.matchType) {
+            case MATCHING:
+                for (Map.Entry<Integer, HashSet<VertexImpl>> vertexArchetypeEntry : vertices.entrySet()) {
+                    if (archetypesFiltered.contains(vertexArchetypeEntry.getKey())) {
+                        resultVertices.addAll(vertexArchetypeEntry.getValue());
+                    }
+                }
+                break;
+            case NON_MATCHING:
+                for (Map.Entry<Integer, HashSet<VertexImpl>> vertexArchetypeEntry : vertices.entrySet()) {
+                    if (!archetypesFiltered.contains(vertexArchetypeEntry.getKey())) {
+                        resultVertices.addAll(vertexArchetypeEntry.getValue());
+                    }
+                }
+                break;
+        }
+
+        return resultVertices;
+    }
+
+    /**
+     * Filters edges by archetype from the specified filter object. Also removes all edges that contain either a vertex
+     * from which the edge originates or to which the edge leads.
+     *
+     * @param filter         - Filter to be applied to the edges list.
+     * @param resultVertices - List of vertices which should be present in the result graph.
+     * @return A list of edges filtered by the specified filter object
+     */
+    private List<EdgeImpl> getEdgesByArchetypeFilter(GraphFilter filter, Set<VertexImpl> resultVertices) {
+        List<EdgeImpl> resultEdges = new ArrayList<>();
+
+        EdgeArchetypeFilter edgeArchetypeFilter = filter.getEdgeArchetypeFilter();
+        List<EdgeArchetypeInfo> edgeInfosFiltered = edgeArchetypeFilter.archetypeIndeces;
+        switch (edgeArchetypeFilter.matchType) {
+            case MATCHING:
+                for (Map.Entry<EdgeArchetypeInfo, List<EdgeImpl>> edgeEntry : edges.entrySet()) {
+                    if (edgeInfosFiltered.contains(edgeEntry.getKey())) {
+                        resultEdges.addAll(edgeEntry.getValue());
+                    }
+                }
+                break;
+            case NON_MATCHING:
+                for (Map.Entry<EdgeArchetypeInfo, List<EdgeImpl>> edgeEntry : edges.entrySet()) {
+                    if (!edgeInfosFiltered.contains(edgeEntry.getKey())) {
+                        resultEdges.addAll(edgeEntry.getValue());
+                    }
+                }
+                break;
+        }
+
+        Iterator<EdgeImpl> i = resultEdges.iterator();
+        while (i.hasNext()) {
+            EdgeImpl edge = i.next();
+
+            VertexImpl toDummy = new VertexImpl(edge.getTo(), null, -1, null);
+            VertexImpl fromDummy = new VertexImpl(edge.getFrom(), null, -1, null);
+
+            if (!resultVertices.contains(toDummy) || !resultVertices.contains(fromDummy)) {
+                i.remove();
+            }
+        }
+
+        return resultEdges;
+    }
+