CollectionRepositoryDefault.java

package org.linkedopenactors.rdfpub.adapter.driven;

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

import org.apache.commons.rdf.api.RDF;
import org.linkedopenactors.rdfpub.domain.commonsrdf.ActivityPubObject;
import org.linkedopenactors.rdfpub.domain.commonsrdf.ActivityPubObjectConvertable;
import org.linkedopenactors.rdfpub.domain.commonsrdf.ActivityPubObjectFactory;
import org.linkedopenactors.rdfpub.domain.commonsrdf.ActorsStore;
import org.linkedopenactors.rdfpub.domain.commonsrdf.ActorsStoreRepository;
import org.linkedopenactors.rdfpub.domain.commonsrdf.CollectionRepository;
import org.linkedopenactors.rdfpub.domain.commonsrdf.OrderedCollectionPage;
import org.linkedopenactors.rdfpub.domain.commonsrdf.vocab.Vocabularies;

public class CollectionRepositoryDefault implements CollectionRepository {
	
//	private final RdfTypeRepository rdfTypeRepository;
//	private final Repository repository;
//	private final ResourceFactory resourceFactory;
//	private org.linkedopenactors.rdfpub.domain.commonsrdf.Actor actor;
//	private org.linkedopenactors.rdfpub.domain.ObjectFactory objectFactory;
	private ActivityPubObjectFactory activityPubObjectFactory;
	private RDF rdf;
//	private ActorsStoreRepository actorsStoreRepository;
	private ActorsStore actorsStore;
	private org.linkedopenactors.rdfpub.domain.commonsrdf.vocab.AS as;

	public CollectionRepositoryDefault(org.linkedopenactors.rdfpub.domain.commonsrdf.Actor actor, 
//			Repository repository,
//			ResourceFactory resourceFactory, RdfTypeRepository rdfTypeRepository,
//			org.linkedopenactors.rdfpub.domain.ObjectFactory objectFactory,
			ActivityPubObjectFactory activityPubObjectFactory, RDF rdf, ActorsStoreRepository actorsStoreRepository, Vocabularies vocabularies) {
//		this.actor = actor;
		as = vocabularies.getActivityStreams();
		actorsStore = actorsStoreRepository.find(actor.getSubject()).orElseThrow();
//		this.repository = repository;
//		this.resourceFactory = resourceFactory;
//		this.rdfTypeRepository = rdfTypeRepository;
//		this.objectFactory = objectFactory;
		this.activityPubObjectFactory = activityPubObjectFactory;
		this.rdf = rdf;
//		this.actorsStoreRepository = actorsStoreRepository;
	}
	
	@Override
	public OrderedCollectionPage getInbox(Integer startIndex, Integer pageSize) {
		return getCollection(actorsStore.getInbox(), as.outbox(), pageSize, startIndex);
	}

	@Override
	public OrderedCollectionPage getPublic(Integer startIndex, Integer pageSize) {
		throw new UnsupportedOperationException();
		// TODO
//		return getCollection(Values.iri(AS.Public().toString()), pageSize, startIndex);
	}

	@Override
	public OrderedCollectionPage getOutbox(Integer startIndex, Integer pageSize) {
		return getCollection(actorsStore.getOutbox(), as.outbox(), pageSize, startIndex);
	}

	
	private OrderedCollectionPage getCollection(List<org.apache.commons.rdf.api.IRI> outboxActivityIris,
			org.apache.commons.rdf.api.IRI namedGraphOfCollectionToUse, Integer pageSize, Integer startIndex) {
		Set<org.apache.commons.rdf.api.IRI> outboxActivityIrisPaged = new HashSet<>();
		
		int max = startIndex+pageSize > outboxActivityIris.size() ? outboxActivityIris.size() : startIndex+pageSize;
		
		for (int i = startIndex; i < max; i++) {
			outboxActivityIrisPaged.add(outboxActivityIris.get(i));
		}
		Set<org.linkedopenactors.rdfpub.domain.commonsrdf.Activity> activities = actorsStore.findAll(outboxActivityIrisPaged).stream()
				.map(ActivityPubObject::asConvertable)
				.map(ActivityPubObjectConvertable::asActivity)
				.collect(Collectors.toSet());

		String subjectOfOrderedCollection = String.format("%s?pageSize=%s&startIndex=%s", namedGraphOfCollectionToUse.toString(), pageSize, startIndex);
		ActivityPubObject activityPubObject = activityPubObjectFactory.create(rdf.createIRI(subjectOfOrderedCollection));
		OrderedCollectionPage orderedCollectionPage = activityPubObject.asConvertable().asOrderedCollectionPage();
		
		orderedCollectionPage.setSummary("collection: " +namedGraphOfCollectionToUse.toString() + "; pageSize: " + pageSize + "; startIndex: " + startIndex);
		orderedCollectionPage.setPartOf(namedGraphOfCollectionToUse);
		orderedCollectionPage.setTotalItems(activities.size());
		activities.forEach(orderedCollectionPage::addActivity);
		
		return orderedCollectionPage;
	}
	
	
//	private OrderedCollectionPageWithActivities getCollection(org.apache.commons.rdf.api.IRI namedGraphOfCollectionToUse, Integer pageSize, Integer startIndex) {
//
//		
//		
//		List<org.linkedopenactors.rdfpub.domain.commonsrdf.Activity> activities  = getActivities(namedGraphOfCollectionToUse, pageSize, startIndex);
//
//		String subjectOfOrderedCollection = String.format("%s?pageSize=%s&startIndex=%s", namedGraphOfCollectionToUse.toString(), pageSize, startIndex);
//		ActivityPubObject activityPubObject = activityPubObjectFactory.create(rdf.createIRI(subjectOfOrderedCollection));
//		OrderedCollectionPage orderedCollectionPage = activityPubObject.asConvertable().asOrderedCollectionPage();
//		
////		OrderedCollectionPage orderedCollectionPage = objectFactory.createOrderedCollectionPage(resourceFactory.iri(subjectOfOrderedCollection));
//		orderedCollectionPage.setSummary("collection: " +namedGraphOfCollectionToUse.toString() + "; pageSize: " + pageSize + "; startIndex: " + startIndex);
//		orderedCollectionPage.setPartOf(namedGraphOfCollectionToUse);
//		orderedCollectionPage.setTotalItems(activities.size());
//		orderedCollectionPage.setItems( activities.stream().map(org.linkedopenactors.rdfpub.domain.commonsrdf.Activity::getSubject).collect(Collectors.toSet()) );
//		
//		OrderedCollectionPageWithActivities pageWithActivities = new OrderedCollectionPageWithActivitiesDefault(activities, orderedCollectionPage);
//		
//		return pageWithActivities;
//	}

//	private List<org.linkedopenactors.rdfpub.domain.commonsrdf.Activity> getActivities(org.apache.commons.rdf.api.IRI namedGraphToUse, int pageSize, int startIndex) {
//		
//		
//		
//		String select = ("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n"
//				+ "SELECT DISTINCT ?entity ?published ?type ?actor ?name ?summary ?object\n");
//				
//		if(namedGraphToUse!=null) {
//			select = select + String.format("FROM <%s> \n", namedGraphToUse.toString());  
//		}
//
//		String typeDefFroms = "FROM " + rdfTypeRepository.getContextsOfAddedTypeDefinitions().stream()
//				.map(IRI::stringValue)
//				.map(iri->"<"+iri+">")
//				.collect(Collectors.joining("\nFROM "));
//			
//		String queryString = String.format(select 
//				+ typeDefFroms
//				+ "\nWHERE\n"
//				+ "{\n"
//				+ "  ?entity rdf:type ?type.\n"
//				+ "  OPTIONAL {?entity <https://www.w3.org/ns/activitystreams#published> ?published .}\n"
//				+ "  OPTIONAL {?entity <https://www.w3.org/ns/activitystreams#actor> ?actor .}\n"
//				+ "  OPTIONAL {?entity <https://www.w3.org/ns/activitystreams#name> ?name .}\n"
//				+ "  OPTIONAL {?entity <https://www.w3.org/ns/activitystreams#summary> ?summary .}\n"
//				+ "  OPTIONAL {?entity <https://www.w3.org/ns/activitystreams#object> ?object .}\n"
//				+ "  ?type rdfs:subClassOf* <https://www.w3.org/ns/activitystreams#Activity> .\n"
//				+ "}\n"
//				+ "ORDER BY desc(?published)\n"
//				+ "LIMIT %s\n"
//				+ "OFFSET %s", pageSize, startIndex)
//				;
//		
//		log.trace("queryString: \n" + queryString);
//		
//		try (RepositoryConnection conn = repository.getConnection()) {
//			TupleQuery tupleQuery = conn.prepareTupleQuery(queryString);
//			TupleQueryResult result = tupleQuery.evaluate();
//			log.trace(namedGraphToUse + " -> result.hasNext(): " + result.hasNext());
//			
//			Model pureStatements = QueryResults.asModel(conn.getStatements(null, null, null, namedGraphToUse));
//			ModelLogger.trace(log, pureStatements, "pureStatements of '"+namedGraphToUse+"'");
//			
//			List<Activity> activities = new ArrayList<>();
//			while (result.hasNext()) {
//				BindingSet bindingSet = result.next();
//				log.trace("bindingSet: " + bindingSet);
//				
//				String subject = bindingSet.getBinding("entity").getValue().stringValue();
//				org.linkedopenactors.rdfpub.domain.IRI type = toIRI(bindingSet, "type").orElseThrow(()->new IllegalStateException("type is mandatory!"));
//				
//				Activity activity = objectFactory.createActivity(resourceFactory.iri(subject));
//				activity.setType(getActivityType(type));
//				toString(bindingSet, "published").map(this::toInstant).ifPresent(activity::setPublished);
//				toString(bindingSet, "name").ifPresent(activity::setName);
//				toString(bindingSet, "summary").ifPresent(activity::setSummary);
//				toIRI(bindingSet, "actor").ifPresent(activity::setActor);
//				toIRI(bindingSet, "object").ifPresent(activity::setObject);
//				
//				activities.add(activity);
//			}
//			return activities;			
//		}
//	}
	
//	private org.linkedopenactors.rdfpub.domain.ActivityType getActivityType(org.linkedopenactors.rdfpub.domain.IRI type) {
//		if(org.linkedopenactors.rdfpub.domain.AS.Create().equals(type)) {
//			return org.linkedopenactors.rdfpub.domain.ActivityType.CREATE;			
//		} else if(org.linkedopenactors.rdfpub.domain.AS.Create().equals(type)) {
//			return org.linkedopenactors.rdfpub.domain.ActivityType.UPDATE;			
//		} else {
//			throw new IllegalStateException(" unsupported activity type: " + type);
//		}
//	}
//	
//	private Optional<org.linkedopenactors.rdfpub.domain.IRI> toIRI(BindingSet bindingSet, String bindingName) {		
//				return toString(bindingSet, bindingName)
//				.map(resourceFactory::iri);
//	}
//
//	private Optional<String> toString(BindingSet bindingSet, String bindingName) {		
//		return Optional.ofNullable(
//				bindingSet.getBinding(bindingName))
//				.map(Binding::getValue)
//				.map(Value::stringValue);
//	}
//
//	private Instant toInstant(String stringDate) {
//		LocalDateTime localDateTime = LocalDateTime.parse(stringDate, DateTimeFormatter.ISO_OFFSET_DATE_TIME); 
//		ZoneId zoneId = ZoneOffset.systemDefault(); 
//		ZonedDateTime zonedDateTime = localDateTime.atZone(zoneId); 
//		return zonedDateTime.toInstant();
//	}
}