import org.neo4j.procedure.Procedure; //导入依赖的package包/类
@Procedure(name = "com.maxdemarzi.schema.generate", mode = Mode.SCHEMA)
@Description("CALL com.maxdemarzi.schema.generate() - generate schema")

public Stream<StringResult> generate() throws IOException {
    org.neo4j.graphdb.schema.Schema schema = db.schema();
    if (!schema.getIndexes(Labels.Provider).iterator().hasNext()) {
        schema.constraintFor(Labels.Provider)
                .assertPropertyIsUnique("name")
                .create();
    }
    if (!schema.getIndexes(Labels.Order).iterator().hasNext()) {
        schema.constraintFor(Labels.Order)
                .assertPropertyIsUnique("id")
                .create();
    }
    return Stream.of(new StringResult("Schema Generated"));
}
 

import org.neo4j.procedure.Procedure; //导入依赖的package包/类
@Procedure(value = "graph.versioner.diff.from.current", mode = DEFAULT)
@Description("graph.versioner.diff.from.current(state) - Get a list of differences that must be applied to the given state in order to become the current entity state")
public Stream<DiffOutput> diffFromCurrent(
		@Name("state") Node state) {

	Optional<Node> currentState = Optional.ofNullable(state.getSingleRelationship(RelationshipType.withName(Utility.HAS_STATE_TYPE), Direction.INCOMING))
			.map(Relationship::getStartNode).map(entity -> entity.getSingleRelationship(RelationshipType.withName(Utility.CURRENT_TYPE), Direction.OUTGOING))
			.map(Relationship::getEndNode);

	Stream<DiffOutput> result = Stream.empty();

	if(currentState.isPresent() && !currentState.equals(Optional.of(state))){
		result = diffBetweenStates(Optional.of(state), currentState);
	}

	return result;
}
 

import org.neo4j.procedure.Procedure; //导入依赖的package包/类
/**
 * this procedure takes a list of node-id's and clones them with their labels and properties
 */
@Procedure
@PerformsWrites
public Stream<Result> cloneNodes(@Name("nodeIds") List<Long> nodeIds, @Name("withRelationships") boolean withRelationships) {
    return nodeIds.stream().map((nodeId) -> {
        Result result = new Result(nodeId);
        try {
            Node node = db.getNodeById(nodeId);
            Node copy = copyProperties(node, copyLabels(node, db.createNode()));
            if (withRelationships) {
                copyRelationships(node, copy,false);
            }
            return result.withOther(copy.getId());
        } catch (Exception e) {
            return result.withError(e);
        }
    });
}
 

import org.neo4j.procedure.Procedure; //导入依赖的package包/类
/**
 * Merges the nodes with the same label, property and value onto the first found node.
 * The other nodes and relationships are deleted.
 */
@Procedure
@PerformsWrites
public Stream<Result> mergeNodes(@Name("label") String label, @Name("property") String property, @Name("value") Object value) {
    ResourceIterator<Node> nodes = db.findNodes(Label.label(label), property, value);
    if (!nodes.hasNext()) return Stream.empty();
    Node first = nodes.next();
    if (!nodes.hasNext()) {
        return Stream.of(new Result(first.getId()));
    }
    return nodes.stream().map( (other) -> {
        Result result = new Result(first.getId());
        try {
            mergeNodes(other, first, true);
            return result.withOther(other.getId());
        } catch (Exception e) {
            return result.withError(e);
        }
    });
}
 

import org.neo4j.procedure.Procedure; //导入依赖的package包/类
/**
 * Redirects a relationships to a new target node.
 */
@Procedure
@PerformsWrites
public Stream<Result> redirectRelationship(@Name("relationshipId") long relId, @Name("newNodeId") long newNodeId, @Name("isEndNode") boolean isEndNode) {
    Relationship rel = db.getRelationshipById(relId);
    Node newNode = db.getNodeById(newNodeId);
    Result result = new Result(rel.getId());
    try {
        Relationship newRel = isEndNode ?
                rel.getStartNode().createRelationshipTo(newNode, rel.getType()) :
                rel.getEndNode().createRelationshipTo(newNode, rel.getType());
        copyProperties(rel,newRel);
        rel.delete();
        return Stream.of(result.withOther(newRel.getId()));
    } catch (Exception e) {
        return Stream.of(result.withError(e));
    }
}
 

import org.neo4j.procedure.Procedure; //导入依赖的package包/类
@Procedure
public void createQueryField(
        @Name( "name" ) String name,
        @Name( "cypherQuery" ) String cypherQuery )
{
    synchronized ( fields )
    {
        String old = fields.putIfAbsent( name, cypherQuery );
        if( old != null )
        {
            throw new IllegalStateException( "`" + name + "` is already in use." );
        }

        rebuildSchema();
    }
}
 

import org.neo4j.procedure.Procedure; //导入依赖的package包/类
@Override
public Stream<CompilationMessage> visitExecutable( ExecutableElement method, Void ignored )
{
    Procedure procedure = method.getAnnotation( Procedure.class );
    if ( procedure == null )
    {
        return Stream.of( new PerformsWriteMisuseError( method, "@%s usage error: missing @%s annotation on method",
                PerformsWrites.class.getSimpleName(), Procedure.class.getSimpleName() ) );
    }

    if ( procedure.mode() != Mode.DEFAULT )
    {
        return Stream.of( new PerformsWriteMisuseError( method,
                "@%s usage error: cannot use mode other than Mode.DEFAULT",
                PerformsWrites.class.getSimpleName() ) );
    }
    return Stream.empty();
}
 

import org.neo4j.procedure.Procedure; //导入依赖的package包/类
@Procedure
public Stream<PredictionResult> predict(@Name("model") String model, @Name("inputs") Map<String,Object> inputs) {
    MLModel mlModel = MLModel.from(model);
    Object value = mlModel.predict(inputs);
    double confidence = 0.0d;
    return Stream.of(new PredictionResult(value, confidence));
}
 

import org.neo4j.procedure.Procedure; //导入依赖的package包/类
@Procedure(value = "graph.versioner.rollback.nth", mode = WRITE)
@Description("graph.versioner.rollback.nth(entity, nth-state, date) - Rollback the given Entity to the nth previous State")
public Stream<NodeOutput> rollbackNth(
        @Name("entity") Node entity,
        @Name("state") long nthState,
        @Name(value = "date", defaultValue = "0") long date) {

    long instantDate = (date == 0) ? Calendar.getInstance().getTimeInMillis() : date;

    return new GetBuilder().build()
            .flatMap(get -> get.getNthState(entity, nthState).findFirst())
            .map(state -> rollbackTo(entity, state.node, instantDate))
            .orElse(Stream.empty());
}
 

import org.neo4j.procedure.Procedure; //导入依赖的package包/类
@Procedure(value = "graph.versioner.patch.from", mode = Mode.WRITE)
@Description("graph.versioner.patch.from(entity, state, date) - Add a new State to the given Entity, starting from the given one. It will update all the properties, not labels.")
public Stream<NodeOutput> patchFrom(
        @Name("entity") Node entity,
        @Name("state") Node state,
        @Name(value = "date", defaultValue = "0") long date) {

    long instantDate = (date == 0) ? Calendar.getInstance().getTimeInMillis() : date;

    Utility.checkRelationship(entity, state);

    // Getting the CURRENT rel if it exist
    Spliterator<Relationship> currentRelIterator = entity.getRelationships(RelationshipType.withName(Utility.CURRENT_TYPE), Direction.OUTGOING).spliterator();
    Node newState = StreamSupport.stream(currentRelIterator, false).map(currentRel -> {
        Node currentState = currentRel.getEndNode();
        Long currentDate = (Long) currentRel.getProperty("date");
        // Creating the new node
        Map<String, Object> patchedProps = currentState.getAllProperties();
        patchedProps.putAll(state.getAllProperties());
        Node result = Utility.setProperties(db.createNode(Utility.labels(state.getLabels())), patchedProps);

        // Updating CURRENT state
        result = Utility.currentStateUpdate(entity, instantDate, currentRel, currentState, currentDate, result);

        return result;
    }).findFirst().orElseGet(() -> {
        throw new VersionerCoreException("Can't find any current State node for the given entity.");
    });

    log.info(Utility.LOGGER_TAG + "Patched Entity with id {}, adding a State with id {}", entity.getId(), newState.getId());
    return Stream.of(new NodeOutput(newState));
}
 

import org.neo4j.procedure.Procedure; //导入依赖的package包/类
@Procedure(value = "graph.versioner.diff", mode = DEFAULT)
@Description("graph.versioner.diff(stateFrom, stateTo) - Get a list of differences that must be applied to stateFrom in order to convert it into stateTo")
public Stream<DiffOutput> diff(
        @Name("stateFrom") Node stateFrom,
        @Name("stateTo") Node stateTo) {
    return diffBetweenStates(Optional.of(stateFrom), Optional.of(stateTo));
}
 

import org.neo4j.procedure.Procedure; //导入依赖的package包/类
@Procedure(value = "graph.versioner.diff.from.previous", mode = DEFAULT)
  @Description("graph.versioner.diff.from.previous(state) - Get a list of differences that must be applied to the previous statusof the given one in order to become the given state")
  public Stream<DiffOutput> diffFromPrevious(
          @Name("state") Node state) {

Optional<Node> stateFrom = Optional.ofNullable(state.getSingleRelationship(RelationshipType.withName(Utility.PREVIOUS_TYPE), Direction.OUTGOING)).map(Relationship::getEndNode);

Stream<DiffOutput> result = Stream.empty();

if(stateFrom.isPresent()){
	result = diffBetweenStates(stateFrom, Optional.of(state));
}

return result;
  }
 

import org.neo4j.procedure.Procedure; //导入依赖的package包/类
@Procedure(value = "graph.versioner.init", mode = Mode.WRITE)
@Description("graph.versioner.init(entityLabel, {key:value,...}, {key:value,...}, additionalLabel, date) - Create an Entity node with an optional initial State.")
public Stream<NodeOutput> init(
        @Name("entityLabel") String entityLabel,
        @Name(value = "entityProps", defaultValue = "{}") Map<String, Object> entityProps,
        @Name(value = "stateProps", defaultValue = "{}") Map<String, Object> stateProps,
        @Name(value = "additionalLabel", defaultValue = "") String additionalLabel,
        @Name(value = "date", defaultValue = "0") long date) {

    List<String> labelNames = new ArrayList<>(singletonList(entityLabel));

    Node entity = Utility.setProperties(db.createNode(Utility.labels(labelNames)), entityProps);

    labelNames = new ArrayList<>(singletonList(Utility.STATE_LABEL));
    if (!additionalLabel.isEmpty()) {
        labelNames.add(additionalLabel);
    }
    Node state = Utility.setProperties(db.createNode(Utility.labels(labelNames)), stateProps);

    long instantDate = (date == 0) ? Calendar.getInstance().getTimeInMillis() : date;

    // Connecting the new current state to the Entity
        Utility.addCurrentState(state, entity, instantDate);

    log.info(Utility.LOGGER_TAG + "Created a new Entity with label {} and id {}", entityLabel, entity.getId());

    return Stream.of(new NodeOutput(entity));
}
 

import org.neo4j.procedure.Procedure; //导入依赖的package包/类
@Procedure(value = "graph.versioner.get.current.path", mode = DEFAULT)
  @Description("graph.versioner.get.current.path(entity) - Get the current Path (Entity, State and rels) for the given Entity.")
  public Stream<PathOutput> getCurrentPath(
          @Name("entity") Node entity) {

PathValueBuilder builder = new PathValueBuilder().addNode(entity);

Optional.ofNullable(entity.getSingleRelationship(RelationshipType.withName(Utility.CURRENT_TYPE), Direction.OUTGOING)).map(builder::addOutgoingRelationship);

      return Stream.of(builder.result()).map(PathOutput::new);
  }
 

import org.neo4j.procedure.Procedure; //导入依赖的package包/类
@Procedure(value = "graph.versioner.get.current.state", mode = DEFAULT)
@Description("graph.versioner.get.current.state(entity) - Get the current State node for the given Entity.")
public Stream<NodeOutput> getCurrentState(
        @Name("entity") Node entity) {

    return Stream.of(Optional.ofNullable(entity.getSingleRelationship(RelationshipType.withName(Utility.CURRENT_TYPE), Direction.OUTGOING))
.map(Relationship::getEndNode).map(NodeOutput::new).orElse(null));
}
 

import org.neo4j.procedure.Procedure; //导入依赖的package包/类
@Procedure(value = "graph.versioner.get.all", mode = DEFAULT)
  @Description("graph.versioner.get.all(entity) - Get all the State nodes for the given Entity.")
  public Stream<PathOutput> getAllState(
          @Name("entity") Node entity) {

PathValueBuilder builder = new PathValueBuilder();
builder.addNode(entity);
builder.addOutgoingRelationship(entity.getSingleRelationship(RelationshipType.withName(Utility.CURRENT_TYPE), Direction.OUTGOING));
StreamSupport.stream(entity.getRelationships(RelationshipType.withName(Utility.HAS_STATE_TYPE), Direction.OUTGOING).spliterator(), false)
		//.sorted((a, b) -> -1 * Long.compare((long)a.getProperty(START_DATE_PROP), (long)b.getProperty(START_DATE_PROP)))
		.forEach(rel ->
			Optional.ofNullable(rel.getEndNode().getSingleRelationship(RelationshipType.withName(Utility.PREVIOUS_TYPE), Direction.OUTGOING))
					.map(builder::addOutgoingRelationship)
);

return Stream.of(new PathOutput(builder.result()));
  }
 

import org.neo4j.procedure.Procedure; //导入依赖的package包/类
@Procedure(value = "graph.versioner.get.by.label", mode = DEFAULT)
  @Description("graph.versioner.get.by.label(entity, label) - Get State nodes with the given label, by the given Entity node")
  public Stream<NodeOutput> getAllStateByLabel(
          @Name("entity") Node entity,
          @Name("label") String label) {

return StreamSupport.stream(entity.getRelationships(RelationshipType.withName(Utility.HAS_STATE_TYPE), Direction.OUTGOING).spliterator(), false)
		.map(Relationship::getEndNode)
		.filter(node -> node.hasLabel(Label.label(label)))
		.map(NodeOutput::new);
  }
 

import org.neo4j.procedure.Procedure; //导入依赖的package包/类
@Procedure(value = "graph.versioner.get.by.date", mode = DEFAULT)
  @Description("graph.versioner.get.by.date(entity, date) - Get State node by the given Entity node, created at the given date")
  public Stream<NodeOutput> getStateByDate(
          @Name("entity") Node entity,
          @Name("date") long date) {

return StreamSupport.stream(entity.getRelationships(RelationshipType.withName(Utility.HAS_STATE_TYPE), Direction.OUTGOING).spliterator(), false)
		.filter(relationship -> relationship.getProperty(Utility.START_DATE_PROP).equals(date))
		.map(Relationship::getEndNode)
		.map(NodeOutput::new);
  }
 

import org.neo4j.procedure.Procedure; //导入依赖的package包/类
@Procedure(value = "graph.versioner.get.nth.state", mode = DEFAULT)
@Description("graph.versioner.get.nth.state(entity, nth) - Get the nth State node for the given Entity.")
public Stream<NodeOutput> getNthState(
		@Name("entity") Node entity,
		@Name("nth") long nth) {

	Optional<Node> currentState = getCurrentState(entity).findFirst().map(c -> c.node);
	return Stream
			.iterate(currentState, s -> s.flatMap(this::jumpToPreviousState))
			.limit(nth + 1)
			.map(NodeOutput::new)
			.reduce((a, b) -> b) //get only the last value (apply jumpToPreviousState n times
			.map(Stream::of)
			.orElse(Stream.empty());
}
 

import org.neo4j.procedure.Procedure; //导入依赖的package包/类
@Procedure(name = "com.maxdemarzi.schema.generate", mode = Mode.SCHEMA)
@Description("CALL com.maxdemarzi.schema.generate() - generate schema")

public Stream<StringResult> generate() throws IOException {
    org.neo4j.graphdb.schema.Schema schema = db.schema();
    if (!schema.getIndexes(Labels.Attribute).iterator().hasNext()) {
        schema.constraintFor(Labels.Attribute)
                .assertPropertyIsUnique("name")
                .create();
    }
    if (!schema.getIndexes(Labels.Path).iterator().hasNext()) {
        schema.constraintFor(Labels.Path)
                .assertPropertyIsUnique("id")
                .create();
    }
    if (!schema.getIndexes(Labels.Rule).iterator().hasNext()) {
        schema.constraintFor(Labels.Rule)
                .assertPropertyIsUnique("id")
                .create();
    }
    if (!schema.getIndexes(Labels.User).iterator().hasNext()) {
        schema.constraintFor(Labels.User)
                .assertPropertyIsUnique("username")
                .create();
    }
    return Stream.of(new StringResult("Schema Generated"));
}