Java Code Examples for org.neo4j.graphdb.Node#setProperty()

public AnswerInfo(Node node, int id, int parentId, String creationDate, int score, String body, int ownerUserId) {
    this.node = node;
    this.answerId = id;
    this.parentQuestionId = parentId;
    this.ownerUserId = ownerUserId;

    node.addLabel(Label.label(StackOverflowExtractor.ANSWER));

    node.setProperty(StackOverflowExtractor.ANSWER_ID, id);
    node.setProperty(StackOverflowExtractor.ANSWER_PARENT_QUESTION_ID, parentId);
    node.setProperty(StackOverflowExtractor.ANSWER_CREATION_DATE, creationDate);
    node.setProperty(StackOverflowExtractor.ANSWER_SCORE, score);
    node.setProperty(StackOverflowExtractor.ANSWER_BODY, body);
    node.setProperty(StackOverflowExtractor.ANSWER_OWNER_USER_ID, ownerUserId);
    node.setProperty(StackOverflowExtractor.ANSWER_ACCEPTED, false);

}
 

public void run(GraphDatabaseService db) {
    this.db = db;
    MboxHandler myHandler = new MboxHandler();
    myHandler.setDb(db);
    MimeConfig config=new MimeConfig();
    config.setMaxLineLen(-1);
    parser = new MimeStreamParser(config);
    parser.setContentHandler(myHandler);
    parse(new File(mboxPath));
    try (Transaction tx = db.beginTx()) {
        for (String address : myHandler.getMailUserNameMap().keySet()) {
            Node node = myHandler.getMailUserMap().get(address);
            node.setProperty(MAILUSER_NAMES, String.join(", ", myHandler.getMailUserNameMap().get(address)));
        }
        tx.success();
    }
    try (Transaction tx = db.beginTx()) {
        for (String mailId : myHandler.getMailReplyMap().keySet()) {
            Node mailNode = myHandler.getMailMap().get(mailId);
            Node replyNode = myHandler.getMailMap().get(myHandler.getMailReplyMap().get(mailId));
            if (mailNode != null & replyNode != null)
                mailNode.createRelationshipTo(replyNode, RelationshipType.withName(MailListExtractor.MAIL_IN_REPLY_TO));
        }
        tx.success();
    }
}
 

public static void createMethodNode(MethodInfo methodInfo, Node node) {
    node.addLabel(Label.label(JavaCodeExtractor.METHOD));
    node.setProperty(JavaCodeExtractor.METHOD_NAME, methodInfo.name);
    node.setProperty(JavaCodeExtractor.METHOD_RETURN, methodInfo.returnString);
    node.setProperty(JavaCodeExtractor.METHOD_ACCESS, methodInfo.visibility);
    node.setProperty(JavaCodeExtractor.METHOD_IS_CONSTRUCTOR, methodInfo.isConstruct);
    node.setProperty(JavaCodeExtractor.METHOD_IS_ABSTRACT, methodInfo.isAbstract);
    node.setProperty(JavaCodeExtractor.METHOD_IS_FINAL, methodInfo.isFinal);
    node.setProperty(JavaCodeExtractor.METHOD_IS_STATIC, methodInfo.isStatic);
    node.setProperty(JavaCodeExtractor.METHOD_IS_SYNCHRONIZED, methodInfo.isSynchronized);
    node.setProperty(JavaCodeExtractor.METHOD_CONTENT, methodInfo.content);
    node.setProperty(JavaCodeExtractor.METHOD_COMMENT, methodInfo.comment);
    node.setProperty(JavaCodeExtractor.METHOD_BELONGTO, methodInfo.belongTo);
    node.setProperty(JavaCodeExtractor.METHOD_PARAMS, methodInfo.paramString);
    node.setProperty(JavaCodeExtractor.METHOD_THROWS, String.join(", ", methodInfo.throwSet));
    node.setProperty(JavaCodeExtractor.SIGNATURE, methodInfo.belongTo+"."+methodInfo.name+"("+methodInfo.paramString+")");
}
 

@Override
public void createStatusUpdate(final long timestamp, final Node user,
		final StatusUpdate content) {
	// get last recent status update
	final Node lastUpdate = NeoUtils.getNextSingleNode(user,
			SocialGraphRelationshipType.UPDATE);

	// create new status update node
	final Node crrUpdate = NeoUtils.createStatusUpdateNode(content.getId());

	// prepare status update for JSON parsing
	content.setTimestamp(timestamp);
	content.setCreator(new User(user));

	// fill status update node
	crrUpdate.setProperty(Properties.StatusUpdate.TIMESTAMP, timestamp);
	crrUpdate.setProperty(Properties.StatusUpdate.CONTENT_TYPE,
			content.getType());
	crrUpdate.setProperty(Properties.StatusUpdate.CONTENT, content
			.toJSONObject().toJSONString());

	// update references to previous status update (if existing)
	if (lastUpdate != null) {
		user.getSingleRelationship(SocialGraphRelationshipType.UPDATE,
				Direction.OUTGOING).delete();
		crrUpdate.createRelationshipTo(lastUpdate,
				SocialGraphRelationshipType.UPDATE);
	}

	// add reference from user to current update node
	user.createRelationshipTo(crrUpdate, SocialGraphRelationshipType.UPDATE);
	user.setProperty(Properties.User.LAST_UPDATE, timestamp);

	// update ego network for this user
	this.updateEgoNetwork(user);
}
 

@Before
public void setup() {
  n1 = createNode("http://x.org/a");
  n2 = createNode("http://x.org/b");
  Node rel = createNode(relationshipType1);
  rel.setProperty(NodeProperties.LABEL, relationshipType1Label);
  createNode(relationshipType2);

  n1.createRelationshipTo(n2, RelationshipType.withName(relationshipType1));
  n1.createRelationshipTo(n2, RelationshipType.withName(relationshipType2));
  n1.createRelationshipTo(n2, RelationshipType.withName(relationshipType3));

  edgeLabeler = new EdgeLabeler(graphDb);
  edgeLabeler.run();
}
 

@Override
public void activate(final Collection<Neo4jPosLengthMatch> matches) {
	for (final Neo4jPosLengthMatch match : matches) {
		final Node segment = match.getSegment();
		try {
			final Number lengthNumber = (Number) segment.getProperty(ModelConstants.LENGTH);
			final int length = Neo4jHelper.numberToInt(lengthNumber);

			segment.setProperty(ModelConstants.LENGTH, -length + 1);
		} catch (final NotFoundException e) {
			// do nothing (node has been removed)
		}
	}
}
 

/**
 * Gets a Neo4j node entity that contains the root pattern for performing hierarchical pattern recognition from.
 * @param db The Neo4j graph database service.
 * @return Returns a Neo4j node entity that contains the root pattern for performing hierarchical pattern recognition from.
 */
private static Node getRootPatternNode(GraphDatabaseService db) {
    Node patternNode;
    patternNode = new NodeManager().getOrCreateNode(GRAPH_MANAGER, GraphManager.ROOT_TEMPLATE, db);
    try(Transaction tx = db.beginTx()) {
        if (!patternNode.hasProperty("matches")) {
            patternNode.setProperty("matches", 0);
            patternNode.setProperty("threshold", GraphManager.MIN_THRESHOLD);
            patternNode.setProperty("root", 1);
            patternNode.setProperty("phrase", "{0} {1}");
        }
        tx.success();
    }
    return patternNode;
}
 

@Override
public void activate(final Collection<Neo4jSwitchMonitoredMatch> matches) {
	for (final Neo4jSwitchMonitoredMatch match : matches) {
		final Node sw = match.getSw();
		final Node sensor = driver.getGraphDb().createNode(Neo4jConstants.labelSensor);
		sensor.setProperty(ModelConstants.ID, driver.generateNewVertexId());
		sw.createRelationshipTo(sensor, Neo4jConstants.relationshipTypeMonitoredBy);
	}
}
 

public static void createPlainTextNode(PlainTextInfo plainText, Node node) {
    node.addLabel(Label.label(WordKnowledgeExtractor.DOCX_PLAIN_TEXT));
    if(plainText.getText() != null)
        node.setProperty(WordKnowledgeExtractor.PLAIN_TEXT_CONTENT, plainText.toHtml(false));
    /*
    if(plainText.getEnglishText() != null)
        node.setProperty(WordKnowledgeExtractor.PLAIN_TEXT_ENGLISH_CONTENT, plainText.toHtml(true));
        */
    else node.setProperty(WordKnowledgeExtractor.PLAIN_TEXT_CONTENT, "");
}
 

/**
 * create a user node in the active database
 * 
 * @param userId
 *            user identifier
 * @return user node having its identifier stored
 * @throws IllegalArgumentException
 *             if the identifier is already in use
 */
public static Node createUserNode(final String userId) {
	if (INDEX_USERS.get(IDENTIFIER, userId).getSingle() == null) {
		final Node user = DATABASE.createNode();
		user.setProperty(Properties.User.IDENTIFIER, userId);
		INDEX_USERS.add(user, IDENTIFIER, userId);
		return user;
	}

	throw new IllegalArgumentException("user node with identifier \""
			+ userId + "\" already existing!");
}
 

@Override
public void activate(final Collection<Neo4jSwitchSetInjectMatch> matches) {
	for (final Neo4jSwitchSetInjectMatch match : matches) {
		final Node sw = match.getSw();
		final String currentPositionString = (String) sw.getProperty(ModelConstants.CURRENTPOSITION);
		final Position currentPosition = Position.valueOf(currentPositionString);
		final Position newCurrentPosition = Position.values()[(currentPosition.ordinal() + 1) % Position.values().length];
		sw.setProperty(ModelConstants.CURRENTPOSITION, newCurrentPosition.toString());
	}
}
 

@Override
public int reInitializeCommunities()
{
    Map<Integer, Integer> initCommunities = new HashMap<Integer, Integer>();
    int communityCounter = 0;

    try (final Transaction tx = beginUnforcedTransaction())
    {
        try
        {
            for (Node n : GlobalGraphOperations.at(neo4jGraph).getAllNodes())
            {
                Integer communityId = (Integer) (n.getProperty(COMMUNITY));
                if (!initCommunities.containsKey(communityId))
                {
                    initCommunities.put(communityId, communityCounter);
                    communityCounter++;
                }
                int newCommunityId = initCommunities.get(communityId);
                n.setProperty(COMMUNITY, newCommunityId);
                n.setProperty(NODE_COMMUNITY, newCommunityId);
            }
            tx.success();
        }
        catch (Exception e)
        {
            tx.failure();
            throw new BenchmarkingException("unable to reinitialize communities", e);
        }
    }

    return communityCounter;
}
 

public Node createNode(GraphDatabaseService db){
    Node node=db.createNode();
    node.addLabel(Label.label(GitExtractor.COMMIT));
    node.setProperty(GitExtractor.COMMIT_ID,commitId);
    node.setProperty(GitExtractor.COMMIT_DATE,createDate);
    node.setProperty(GitExtractor.COMMIT_LOGMESSAGE,logMessage);
    node.setProperty(GitExtractor.COMMIT_CONTENT,content);
    return node;
}
 

public static void createIssueUserNode(IssueUserInfo issueUserInfo, Node node) {
    node.addLabel(Label.label(JiraExtractor.ISSUEUSER));
    node.setProperty(JiraExtractor.ISSUEUSER_NAME, issueUserInfo.getName());
    node.setProperty(JiraExtractor.ISSUEUSER_EMAIL_ADDRESS, issueUserInfo.getName());
    node.setProperty(JiraExtractor.ISSUEUSER_DISPLAY_NAME, issueUserInfo.getName());
    node.setProperty(JiraExtractor.ISSUEUSER_ACTIVE, issueUserInfo.getName());
}
 

@Override
public void apply(Node node) {
	double secondMember = 0.0;
	for( Relationship rin : node.getRelationships() ) {
		Node neigh = rin.getOtherNode(node);
		
		double neighRank = (double) neigh.getProperty(attName);
		secondMember += neighRank / neigh.getDegree();
	}
	
	secondMember *= this.dampingFactor;
	node.setProperty(attName, firstMember + secondMember);
}
 

public static void createPatchNode(PatchInfo patchInfo, Node node) {
    node.addLabel(Label.label(JiraExtractor.PATCH));
    node.setProperty(JiraExtractor.PATCH_ISSUE_ID, patchInfo.getIssueId());
    node.setProperty(JiraExtractor.PATCH_ID, patchInfo.getPatchId());
    node.setProperty(JiraExtractor.PATCH_NAME, patchInfo.getPatchName());
    node.setProperty(JiraExtractor.PATCH_CONTENT, patchInfo.getContent());
    node.setProperty(JiraExtractor.PATCH_CREATOR_NAME, patchInfo.getCreatorName());
    node.setProperty(JiraExtractor.PATCH_CREATED_DATE, patchInfo.getCreatedDate());
}
 

@Override
    List<Node> show() {
        if ( state != State.ready ) throw new IllegalStateException("Model not trained yet");
        List<Node> result = new ArrayList<>();
        int layerCount = model.getnLayers();
        for (Layer layer : model.getLayers()) {
            Node node = node("Layer",
                    "type", layer.type().name(), "index", layer.getIndex(),
                    "pretrainLayer", layer.isPretrainLayer(), "miniBatchSize", layer.getInputMiniBatchSize(),
                    "numParams", layer.numParams());
            if (layer instanceof DenseLayer) {
                DenseLayer dl = (DenseLayer) layer;
                node.addLabel(Label.label("DenseLayer"));
                node.setProperty("activation",dl.getActivationFn().toString()); // todo parameters
                node.setProperty("biasInit",dl.getBiasInit());
                node.setProperty("biasLearningRate",dl.getBiasLearningRate());
                node.setProperty("l1",dl.getL1());
                node.setProperty("l1Bias",dl.getL1Bias());
                node.setProperty("l2",dl.getL2());
                node.setProperty("l2Bias",dl.getL2Bias());
                node.setProperty("distribution",dl.getDist().toString());
                node.setProperty("in",dl.getNIn());
                node.setProperty("out",dl.getNOut());
            }
            result.add(node);
//            layer.preOutput(allOne, Layer.TrainingMode.TEST);
//            layer.p(allOne, Layer.TrainingMode.TEST);
//            layer.activate(allOne, Layer.TrainingMode.TEST);
        }
        return result;
    }
 

@Override
public void apply(Node node) {
	long newComponent = this.getLowestComponent(node);
	node.setProperty(attName, newComponent);
}
 

@Override
public void init(Node node) {
	node.setProperty(attName, node.getId());
}
 

/**
 * create a new user
 * 
 * @param userId
 *            user identifier
 * @param displayName
 *            user display name
 * @param profilePicturePath
 *            path to the profile picture of the user
 */
public void createUser(final String userId, final String displayName,
		final String profilePicturePath) {
	final Node user = NeoUtils.createUserNode(userId);
	user.setProperty(Properties.User.DISPLAY_NAME, displayName);
	user.setProperty(Properties.User.PROFILE_PICTURE_PATH,
			profilePicturePath);
}