private Map<String, SemanticTypeNode> createDomainNodeMap() {
   Map<String, SemanticTypeNode> hNodeIdToDomainNodeMap = new HashMap<>();
   Set<Node> alignmentColumnNodes = alignment.getNodesByType(NodeType.ColumnNode);
   if (alignmentColumnNodes == null) return hNodeIdToDomainNodeMap;
   for (Node cNode : alignmentColumnNodes) {
     Set<LabeledLink> incomingLinks = alignment.getCurrentIncomingLinksToNode(cNode.getId());
     if (incomingLinks != null && !incomingLinks.isEmpty()) {
       LabeledLink incomingLink =
           alignment.getCurrentIncomingLinksToNode(cNode.getId()).iterator().next();
       if (incomingLink != null && incomingLink.getSource() instanceof InternalNode) {
         String hNodeId = ((ColumnNode) cNode).getHNodeId();
         if (incomingLink instanceof DataPropertyOfColumnLink
             || incomingLink instanceof ObjectPropertySpecializationLink) {
           String id;
           if (incomingLink instanceof DataPropertyOfColumnLink)
             id = ((DataPropertyOfColumnLink) incomingLink).getSpecializedLinkId();
           else id = ((ObjectPropertySpecializationLink) incomingLink).getSpecializedLinkId();
           hNodeIdToDomainNodeMap.put(
               hNodeId,
               new SemanticTypeNode(
                   id,
                   id,
                   id,
                   incomingLink.getLabel().getRdfsLabel(),
                   incomingLink.getLabel().getRdfsComment()));
         } else {
           InternalNode source = (InternalNode) incomingLink.getSource();
           hNodeIdToDomainNodeMap.put(
               hNodeId,
               new SemanticTypeNode(
                   source.getId(),
                   source.getUri(),
                   source.getDisplayId(),
                   source.getLabel().getRdfsLabel(),
                   source.getLabel().getRdfsComment()));
         }
       }
     }
   }
   return hNodeIdToDomainNodeMap;
 }
  private Set<SemanticTypeMapping> findSemanticTypeInGraph(
      ColumnNode sourceColumn,
      SemanticType semanticType,
      HashMap<String, Integer> semanticTypesCount,
      Set<Node> addedNodes) {

    logger.debug("finding matches for semantic type in the graph ... ");

    if (addedNodes == null) addedNodes = new HashSet<Node>();

    Set<SemanticTypeMapping> mappings = new HashSet<SemanticTypeMapping>();

    if (semanticType == null) {
      logger.error("semantic type is null.");
      return mappings;
    }
    if (semanticType.getDomain() == null) {
      logger.error("semantic type does not have any domain");
      return mappings;
    }

    if (semanticType.getType() == null) {
      logger.error("semantic type does not have any link");
      return mappings;
    }

    String domainUri = semanticType.getDomain().getUri();
    String propertyUri = semanticType.getType().getUri();
    Double confidence = semanticType.getConfidenceScore();
    Origin origin = semanticType.getOrigin();

    Integer countOfSemanticType = semanticTypesCount.get(domainUri + propertyUri);
    if (countOfSemanticType == null) {
      logger.error("count of semantic type should not be null or zero");
      return mappings;
    }

    if (domainUri == null || domainUri.isEmpty()) {
      logger.error("semantic type does not have any domain");
      return mappings;
    }

    if (propertyUri == null || propertyUri.isEmpty()) {
      logger.error("semantic type does not have any link");
      return mappings;
    }

    logger.debug(
        "semantic type: " + domainUri + "|" + propertyUri + "|" + confidence + "|" + origin);

    // add dataproperty to existing classes if sl is a data node mapping
    //		Set<Node> foundInternalNodes = new HashSet<Node>();
    Set<SemanticTypeMapping> semanticTypeMatches =
        this.graphBuilder.getSemanticTypeMatches().get(domainUri + propertyUri);
    if (semanticTypeMatches != null) {
      for (SemanticTypeMapping stm : semanticTypeMatches) {

        SemanticTypeMapping mp =
            new SemanticTypeMapping(
                sourceColumn, semanticType, stm.getSource(), stm.getLink(), stm.getTarget());
        mappings.add(mp);
        //				foundInternalNodes.add(stm.getSource());
      }
    }

    logger.debug("adding data property to the found internal nodes ...");

    Integer count;
    boolean allowMultipleSamePropertiesPerNode =
        ModelingConfigurationRegistry.getInstance()
            .getModelingConfiguration(
                ContextParametersRegistry.getInstance()
                    .getContextParameters(ontologyManager.getContextId())
                    .getKarmaHome())
            .isMultipleSamePropertyPerNode();
    Set<Node> nodesWithSameUriOfDomain = this.graphBuilder.getUriToNodesMap().get(domainUri);
    if (nodesWithSameUriOfDomain != null) {
      for (Node source : nodesWithSameUriOfDomain) {
        count = this.graphBuilder.getNodeDataPropertyCount().get(source.getId() + propertyUri);

        if (count != null) {
          if (allowMultipleSamePropertiesPerNode) {
            if (count >= countOfSemanticType.intValue()) continue;
          } else {
            if (count >= 1) continue;
          }
        }

        String nodeId = new RandomGUID().toString();
        ColumnNode target = new ColumnNode(nodeId, nodeId, sourceColumn.getColumnName(), null);
        if (!this.graphBuilder.addNode(target)) continue;
        ;
        addedNodes.add(target);

        String linkId = LinkIdFactory.getLinkId(propertyUri, source.getId(), target.getId());
        LabeledLink link = new DataPropertyLink(linkId, new Label(propertyUri));
        if (!this.graphBuilder.addLink(source, target, link)) continue;
        ;

        SemanticTypeMapping mp =
            new SemanticTypeMapping(
                sourceColumn, semanticType, (InternalNode) source, link, target);
        mappings.add(mp);
      }
    }

    return mappings;
  }
  @Override
  public void generateJson(String prefix, PrintWriter pw, VWorkspace vWorkspace) {
    VWorksheet vWorksheet = vWorkspace.getViewFactory().getVWorksheetByWorksheetId(worksheetId);
    List<String> hNodeIdList = new ArrayList<String>();
    List<HNodePath> columns = vWorksheet.getColumns();
    for (HNodePath path : columns) hNodeIdList.add(path.getLeaf().getId());
    String alignmentId =
        AlignmentManager.Instance()
            .constructAlignmentId(vWorkspace.getWorkspace().getId(), vWorksheet.getWorksheetId());

    JSONObject topObj = new JSONObject();
    try {
      topObj.put(
          GenericJsonKeys.updateType.name(), AlignmentSVGVisualizationUpdate.class.getSimpleName());
      topObj.put(JsonKeys.alignmentId.name(), alignmentId);
      topObj.put(JsonKeys.worksheetId.name(), worksheetId);

      // Using Mohsen's GraphUtils method for graph traversal
      HashMap<Node, Integer> nodeHeightsMap = GraphUtil.levelingCyclicGraph(alignmentGraph);
      HashMap<Node, Set<ColumnNode>> nodeCoverage =
          GraphUtil.getNodesCoverage(alignmentGraph, nodeHeightsMap);
      /** Identify the max height * */
      int maxTreeHeight = 0;
      for (Node node : nodeHeightsMap.keySet()) {
        if (nodeHeightsMap.get(node) >= maxTreeHeight) {
          maxTreeHeight = nodeHeightsMap.get(node);
        }
      }

      /** * Add the nodes and the links from the Steiner tree ** */
      List<String> hNodeIdsAdded = new ArrayList<String>();
      JSONArray nodesArr = new JSONArray();
      JSONArray linksArr = new JSONArray();

      if (alignmentGraph != null && alignmentGraph.vertexSet().size() != 0) {
        /** Add the nodes * */
        Set<Node> nodes = alignmentGraph.vertexSet();
        HashMap<Node, Integer> verticesIndex = new HashMap<Node, Integer>();
        int nodesIndexcounter = 0;
        for (Node node : nodes) {
          /** Get info about the nodes that this node covers or sits above * */
          int height = maxTreeHeight - nodeHeightsMap.get(node);

          /** Add the hnode ids of the columns that this vertex covers * */
          JSONArray hNodeIdsCoveredByVertex = new JSONArray();
          for (Node v : nodeCoverage.get(node)) {
            if (v instanceof ColumnNode) {
              ColumnNode cNode = (ColumnNode) v;
              hNodeIdsCoveredByVertex.put(cNode.getHNodeId());
            }
          }

          String hNodeId = "";

          /** Add the semantic type information * */
          if (node instanceof ColumnNode) {
            ColumnNode cNode = (ColumnNode) node;
            hNodeId = cNode.getHNodeId();
            hNodeIdsAdded.add(cNode.getHNodeId());
          }
          JSONObject nodeObj =
              getNodeJsonObject(
                  node.getLocalId(),
                  node.getId(),
                  node.getType().name(),
                  height,
                  hNodeIdsCoveredByVertex,
                  hNodeId);
          nodesArr.put(nodeObj);
          verticesIndex.put(node, nodesIndexcounter++);
        }

        /** * Add the links ** */
        Set<Link> links = alignmentGraph.edgeSet();
        for (Link link : links) {
          Node source = link.getSource();
          Integer sourceIndex = verticesIndex.get(source);
          Node target = link.getTarget();
          Integer targetIndex = verticesIndex.get(target);
          Set<Link> outEdges = alignmentGraph.outgoingEdgesOf(target);

          if (sourceIndex == null || targetIndex == null) {
            logger.error("Edge vertex index not found!");
            continue;
          }

          JSONObject linkObj = new JSONObject();
          linkObj.put(JsonKeys.source.name(), sourceIndex);
          linkObj.put(JsonKeys.target.name(), targetIndex);
          linkObj.put(JsonKeys.sourceNodeId.name(), source.getId());
          linkObj.put(JsonKeys.targetNodeId.name(), target.getId());

          linkObj.put(JsonKeys.label.name(), link.getLabel().getLocalName());
          linkObj.put(JsonKeys.id.name(), link.getId() + "");
          linkObj.put(JsonKeys.linkStatus.name(), link.getStatus().name());
          linkObj.put(JsonKeys.linkUri.name(), link.getLabel().getUri());

          if (target.getType() == NodeType.ColumnNode && outEdges.isEmpty()) {
            linkObj.put(JsonKeys.linkType.name(), JsonValues.holderLink.name());
            if (link.getKeyType() == LinkKeyInfo.PartOfKey)
              linkObj.put(JsonKeys.label.name(), link.getLabel().getLocalName() + "*");
          }

          linksArr.put(linkObj);

          if (link.getType() == LinkType.ClassInstanceLink
              && link.getKeyType() == LinkKeyInfo.PartOfKey
              && target instanceof ColumnNode) {
            ColumnNode cNode = (ColumnNode) target;
            // Add the holder vertex object and the link that attaches nodes to the columns
            JSONArray hNodeIdsCoveredByVertex_holder = new JSONArray();
            hNodeIdsCoveredByVertex_holder.put(cNode.getHNodeId());

            JSONObject vertObj_holder =
                getNodeJsonObject(
                    JsonValues.key.name(),
                    source.getId() + "_holder",
                    NodeType.ColumnNode.name(),
                    0,
                    hNodeIdsCoveredByVertex_holder,
                    cNode.getHNodeId());
            nodesArr.put(vertObj_holder);
            nodesIndexcounter++;

            // Add the holder link
            JSONObject linkObj_holder =
                getLinkJsonObject(
                    JsonValues.key.name(),
                    "",
                    nodesIndexcounter,
                    nodesIndexcounter - 1,
                    "",
                    "",
                    "",
                    "");
            linksArr.put(linkObj_holder);
          }

          if (link.getType() == LinkType.DataPropertyOfColumnLink) {
            DataPropertyOfColumnLink dpLink = (DataPropertyOfColumnLink) link;
            String startHNodeId = dpLink.getSpecializedColumnHNodeId();

            // Get height of the class instance node
            int height = maxTreeHeight - nodeHeightsMap.get(link.getSource());

            // Add 2 more holder nodes
            // Start node
            JSONArray hNodeIdsCoveredByVertex_holder = new JSONArray();
            hNodeIdsCoveredByVertex_holder.put(startHNodeId);
            JSONObject startNode =
                getNodeJsonObject(
                    "",
                    source.getId() + "_holder",
                    JsonValues.DataPropertyOfColumnHolder.name(),
                    height - 0.35,
                    hNodeIdsCoveredByVertex_holder,
                    startHNodeId);
            nodesArr.put(startNode);

            nodesIndexcounter++;

            // End node
            String endHNodeId = ((ColumnNode) link.getTarget()).getHNodeId();
            JSONArray hNodeIdsCoveredByVertex_holder_2 = new JSONArray();
            hNodeIdsCoveredByVertex_holder_2.put(endHNodeId);
            JSONObject endNode =
                getNodeJsonObject(
                    "",
                    target.getId() + "_holder",
                    JsonValues.DataPropertyOfColumnHolder.name(),
                    height - 0.35,
                    hNodeIdsCoveredByVertex_holder_2,
                    endHNodeId);
            nodesArr.put(endNode);

            nodesIndexcounter++;

            // Add the horizontal link
            JSONObject linkObj_holder =
                getLinkJsonObject(
                    "",
                    "",
                    nodesIndexcounter - 2,
                    nodesIndexcounter - 1,
                    JsonValues.horizontalDataPropertyLink.name(),
                    "",
                    "",
                    "");
            linksArr.put(linkObj_holder);
          } else if (link.getType() == LinkType.ObjectPropertySpecializationLink) {
            ObjectPropertySpecializationLink opLink = (ObjectPropertySpecializationLink) link;
            Link specializedLink = opLink.getSpecializedLink();

            // Get height of the class instance node
            int height = nodeHeightsMap.get(specializedLink.getTarget());

            // Add 2 more holder nodes
            // Start node
            JSONArray hNodeIdsCoveredByVertex_holder = new JSONArray();
            for (Node v : nodeCoverage.get(specializedLink.getTarget())) {
              if (v instanceof ColumnNode) {
                ColumnNode cNode = (ColumnNode) v;
                hNodeIdsCoveredByVertex_holder.put(cNode.getHNodeId());
              }
            }
            JSONObject startNode =
                getNodeJsonObject(
                    "",
                    source.getId() + "_holder",
                    JsonValues.DataPropertyOfColumnHolder.name(),
                    height + 0.65,
                    hNodeIdsCoveredByVertex_holder,
                    "");
            nodesArr.put(startNode);

            nodesIndexcounter++;

            // End node
            String endHNodeId = ((ColumnNode) link.getTarget()).getHNodeId();
            JSONArray hNodeIdsCoveredByVertex_holder_2 = new JSONArray();
            hNodeIdsCoveredByVertex_holder_2.put(endHNodeId);
            JSONObject endNode =
                getNodeJsonObject(
                    "",
                    target.getId() + "_holder",
                    JsonValues.DataPropertyOfColumnHolder.name(),
                    height + 0.65,
                    hNodeIdsCoveredByVertex_holder_2,
                    endHNodeId);
            nodesArr.put(endNode);

            nodesIndexcounter++;

            // Add the horizontal link
            JSONObject linkObj_holder =
                getLinkJsonObject(
                    "",
                    "",
                    nodesIndexcounter - 2,
                    nodesIndexcounter - 1,
                    JsonValues.horizontalDataPropertyLink.name(),
                    "",
                    "",
                    "");
            linksArr.put(linkObj_holder);
          }

          linkObj.put(JsonKeys.linkType.name(), link.getType());
        }
      }

      // Add the vertices for the columns that were not in Steiner tree
      hNodeIdList.removeAll(hNodeIdsAdded);
      for (String hNodeId : hNodeIdList) {
        JSONArray hNodeIdsCoveredByVertex = new JSONArray();
        hNodeIdsCoveredByVertex.put(hNodeId);
        JSONObject vertObj =
            getNodeJsonObject(
                "", hNodeId, JsonValues.Unassigned.name(), 0, hNodeIdsCoveredByVertex, hNodeId);
        nodesArr.put(vertObj);
      }

      topObj.put(JsonKeys.maxTreeHeight.name(), maxTreeHeight);
      topObj.put(JsonKeys.nodes.name(), nodesArr);
      topObj.put(JsonKeys.links.name(), linksArr);

      pw.write(topObj.toString());
    } catch (JSONException e) {
      logger.error("Error occured while writing JSON!", e);
    }
  }
Example #4
0
  private static DirectedWeightedMultigraph<Node, LabeledLink> buildGraphsFromStatements2(
      List<Statement> statements) {

    if (statements == null || statements.size() == 0) return null;

    DirectedWeightedMultigraph<Node, LabeledLink> graph =
        new DirectedWeightedMultigraph<Node, LabeledLink>(LabeledLink.class);

    // Assumption: there is only one rdf:type for each URI
    HashMap<String, Node> uri2Classes = new HashMap<String, Node>();
    for (Statement st : statements) {

      String subjStr = st.getSubject();
      String predicateStr = st.getPredicate();
      String objStr = st.getObject();

      subjStr = getUri(subjStr);
      predicateStr = getUri(predicateStr);
      objStr = getUri(objStr);

      if (predicateStr.equalsIgnoreCase(typePredicate)) {

        Node classNode = new InternalNode(objStr, new Label(objStr));
        uri2Classes.put(subjStr, classNode);
        graph.addVertex(classNode);
      }
    }

    //		int countOfLiterals = 0;
    String id;
    for (Statement st : statements) {

      String subjStr = st.getSubject();
      String predicateStr = st.getPredicate();
      String objStr = st.getObject();

      subjStr = getUri(subjStr);
      predicateStr = getUri(predicateStr);
      objStr = getUri(objStr);

      if (predicateStr.equalsIgnoreCase(typePredicate)) continue;

      Node subj = uri2Classes.get(subjStr);
      if (subj == null) {
        subj = new InternalNode(subjStr, new Label(subjStr));
        graph.addVertex(subj);
      }

      Node obj = uri2Classes.get(objStr);
      if (obj == null) {
        if (objStr.startsWith(attPrefix)) {
          id = new RandomGUID().toString();
          obj = new ColumnNode(id, objStr, objStr, null, null);
          SemanticType semanticType =
              new SemanticType(
                  ((ColumnNode) obj).getHNodeId(),
                  new Label(predicateStr),
                  subj.getLabel(),
                  Origin.User,
                  1.0,
                  false);
          ((ColumnNode) obj).setUserSelectedSemanticType(semanticType);

        } else if (objStr.indexOf(":") == -1 && objStr.indexOf("\"") != -1) {
          //					String literalId = "lit:" + serviceId + "_l" + String.valueOf(countOfLiterals);
          obj = new LiteralNode(objStr, objStr, null);
          //					countOfLiterals ++;
        } else obj = new InternalNode(objStr, new Label(objStr));

        graph.addVertex(obj);
      }

      LabeledLink e;
      if (obj instanceof InternalNode)
        e =
            new ObjectPropertyLink(
                LinkIdFactory.getLinkId(predicateStr, subj.getId(), obj.getId()),
                new Label(predicateStr),
                ObjectPropertyType.None);
      else
        e =
            new DataPropertyLink(
                LinkIdFactory.getLinkId(predicateStr, subj.getId(), obj.getId()),
                new Label(predicateStr));
      graph.addEdge(subj, obj, e);
    }

    return graph;
  }
  @Override
  public UpdateContainer doIt(Workspace workspace) throws CommandException {
    final OntologyManager ontMgr = workspace.getOntologyManager();
    Set<LabeledLink> properties = new HashSet<>();

    logger.debug(
        "GetPropertiesCommand:"
            + propertiesRange
            + ":"
            + classURI
            + ","
            + domainURI
            + ", "
            + rangeURI);

    if (propertiesRange == INTERNAL_PROP_RANGE.allObjectProperties) {
      HashMap<String, Label> linkList = ontMgr.getObjectProperties();
      if (linkList != null) {
        for (Label label : linkList.values()) {
          properties.add(new DataPropertyLink(label.getUri(), label));
        }
      }
    } else if (propertiesRange == INTERNAL_PROP_RANGE.allDataProperties) {
      HashMap<String, Label> linkList = ontMgr.getDataProperties();
      for (Label label : linkList.values()) {
        properties.add(new DataPropertyLink(label.getUri(), label));
      }
    } else if (propertiesRange == INTERNAL_PROP_RANGE.propertiesWithDomainRange) {
      Map<String, Label> linkList =
          ontMgr.getObjectPropertiesByDomainRange(domainURI, rangeURI, true);
      for (Label label : linkList.values()) {
        properties.add(new DataPropertyLink(label.getUri(), label));
      }
    } else if (propertiesRange == INTERNAL_PROP_RANGE.dataPropertiesForClass) {
      Map<String, Label> linkList = ontMgr.getDataPropertiesByDomain(classURI, true);
      for (Label label : linkList.values()) {
        properties.add(new DataPropertyLink(label.getUri(), label));
      }
    } else if (propertiesRange == INTERNAL_PROP_RANGE.existingProperties) {
      Alignment alignment =
          AlignmentManager.Instance()
              .getAlignmentOrCreateIt(workspace.getId(), worksheetId, ontMgr);
      Set<String> steinerTreeNodeIds = new HashSet<String>();
      if (alignment != null && !alignment.isEmpty()) {
        DirectedWeightedMultigraph<Node, LabeledLink> steinerTree = alignment.getSteinerTree();
        for (Node node : steinerTree.vertexSet()) {
          if (node.getType() == NodeType.InternalNode) {
            steinerTreeNodeIds.add(node.getId());
          }
        }

        List<LabeledLink> specializedLinks = new ArrayList<LabeledLink>();
        Set<LabeledLink> temp = null;
        temp = alignment.getLinksByType(LinkType.DataPropertyLink);
        if (temp != null) specializedLinks.addAll(temp);
        for (LabeledLink link : steinerTree.edgeSet())
          if (link instanceof ObjectPropertyLink) specializedLinks.add(link);

        // Store the data property links for specialized edge link options
        properties.addAll(specializedLinks);
      }
    }

    logger.debug("Got back " + properties.size() + " results");
    final Set<LabeledLink> finalProperties = properties;

    UpdateContainer upd =
        new UpdateContainer(
            new AbstractUpdate() {
              @Override
              public void generateJson(String prefix, PrintWriter pw, VWorkspace vWorkspace) {
                JSONObject obj = new JSONObject();
                JSONArray resultArray = new JSONArray();

                try {
                  obj.put(JsonKeys.updateType.name(), "PropertyList");

                  for (LabeledLink link : finalProperties) {
                    Label linkLabel = link.getLabel();
                    String edgeLabelStr = linkLabel.getDisplayName();
                    JSONObject edgeObj = new JSONObject();
                    if (linkLabel.getUri() != null
                        && linkLabel.getNs() != null
                        && linkLabel.getUri().equalsIgnoreCase(linkLabel.getNs())) {
                      edgeLabelStr = linkLabel.getUri();
                    }

                    edgeObj.put(JsonKeys.label.name(), edgeLabelStr);
                    edgeObj.put(JsonKeys.uri.name(), linkLabel.getUri());
                    edgeObj.put(JsonKeys.id.name(), link.getId());
                    resultArray.put(edgeObj);
                  }

                  obj.put(JsonKeys.properties.name(), resultArray);
                  pw.println(obj.toString());
                } catch (Exception e) {
                  logger.error("Exception:", e);
                  e.printStackTrace();
                }
              }
            });
    return upd;
  }