ActivityPubStoreDefault.java

package org.linkedopenactors.rdfpub.store.rdf4j;

import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

import org.apache.commons.rdf.api.BlankNodeOrIRI;
import org.apache.commons.rdf.api.Graph;
import org.apache.commons.rdf.api.IRI;
import org.apache.commons.rdf.api.RDF;
import org.apache.commons.rdf.api.RDFTerm;
import org.apache.commons.rdf.api.Triple;
import org.linkedopenactors.rdfpub.domain.commonsrdf.ActivityPubObject;
import org.linkedopenactors.rdfpub.domain.commonsrdf.ActivityPubObjectFactory;
import org.linkedopenactors.rdfpub.domain.commonsrdf.ActivityPubStore;
import org.linkedopenactors.rdfpub.store.Store;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class ActivityPubStoreDefault implements ActivityPubStore {

	private Store store;
	private ActivityPubObjectFactory activityPubObjectFactory;
	private IRI storeOwner;

	public ActivityPubStoreDefault(RDF rdf, IRI storeOwner, Store store, ActivityPubObjectFactory activityPubObjectFactory) {
		this.storeOwner = storeOwner;
		this.store = store;
		this.activityPubObjectFactory = activityPubObjectFactory;
	}
	
	@Override
	public void add(ActivityPubObject ao1, String logMsg) {
		store.add(storeOwner, ao1.asGraph(), logMsg);
	}
	@Override
	public void add(Set<Triple> newTriples, String logMsg) {
		store.add(storeOwner, newTriples, logMsg);
	}

	@Override
	public void update(ActivityPubObject ao1, String logMsg) {
		Set<BlankNodeOrIRI> subjects = ao1.asGraph().stream().map(Triple::getSubject).collect(Collectors.toSet());
		store.remove(storeOwner, subjects, logMsg);
		store.add(storeOwner, ao1.asGraph(), logMsg);
	}

	@Override
	public void addCollectionItem(/**BlankNodeOrIRI graphName,**/ IRI collection, IRI item, String logMsg) {
		store.addItem(storeOwner, collection, item, logMsg);
	}

	@Override
	public List<IRI> getCollection(BlankNodeOrIRI graphName, IRI collection) {
		return store.getCollection(graphName, collection);
	}

	@Override
	public Set<IRI> findCollection(IRI member) {
		return store.findCollection(storeOwner, member);
	}

	@Override
	public Optional<ActivityPubObject> find(IRI subject) {
		return find(subject, 0);
	}
		
	@Override
	public Optional<ActivityPubObject> find(IRI subject, int deep) {
		log.debug("find(graphName:"+storeOwner+", subject:"+subject+")");
		return store.find(storeOwner, subject, deep)
				.map(graph->activityPubObjectFactory.create(subject, graph));
	}

	@Override
	public Optional<ActivityPubObject> find(IRI subject, IRI predicate,RDFTerm object) {
		log.debug("find(graphName:"+storeOwner+", subject:"+subject+", predicate:"+predicate+",RDFTerm:"+object+")");
		Optional<Graph> find = store.find(storeOwner, subject, predicate, object);
		if(find.isEmpty()) {
			return Optional.empty();
		} else {
			return find
				.map(graph->activityPubObjectFactory.create(subject, graph));
		}
	}

	@Override
	public Set<ActivityPubObject> findAll(Set<IRI> subjectsParam) {
		log.debug("find(graphName:"+storeOwner+", subject:"+subjectsParam+")");
		List<BlankNodeOrIRI> subjects = subjectsParam.stream()
				.map(IRI.class::cast)
				.collect(Collectors.toList());
		
		return store.findAll(storeOwner, subjects).entrySet().stream()
			.filter(e->e.getKey() instanceof IRI)
			.map(e->activityPubObjectFactory.create((IRI)e.getKey(), e.getValue()))
			.collect(Collectors.toSet());
	}

//	@Override
//	public Optional<ActivityPubObject> findLatestRevision(BlankNodeOrIRI graphName, IRI pointerSubject) {
//		return store.findLatestRevisionSubject(graphName, pointerSubject).flatMap(latestSubject->{
//			return store.find(graphName, latestSubject)
//				.map(graph->activityPubObjectFactory.create(latestSubject, graph));
//		});
//	}

	@Override
	public Optional<ActivityPubObject> findLatestRevision(IRI pointerSubject) {
		return store.findLatestRevisionSubject(storeOwner, pointerSubject).flatMap(latestSubject->{
			return store.find(storeOwner, latestSubject)
				.map(graph->activityPubObjectFactory.create(latestSubject, graph));
		});
	}

	@Override
	public Optional<ActivityPubObject> findWholeGraph(IRI subject) {
		return store.find(storeOwner)
				.map(graph->activityPubObjectFactory.create(subject, graph));
	}

	@Override
	public IRI getOwner() {
		return storeOwner;
	}

	@Override
	public Graph dump(IRI graphName) {
		Graph graph = store.find(graphName).orElseThrow();
		return graph;
	}
}