ActorDefault.java

package org.linkedopenactors.rdfpub.domain.commonsrdf;

import java.util.Optional;
import java.util.Set;

import org.apache.commons.rdf.api.Graph;
import org.apache.commons.rdf.api.IRI;
import org.apache.commons.rdf.api.Literal;
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.vocab.AS;
import org.linkedopenactors.rdfpub.domain.commonsrdf.vocab.LDP;
import org.linkedopenactors.rdfpub.domain.commonsrdf.vocab.RDFPUB;
import org.linkedopenactors.rdfpub.domain.commonsrdf.vocab.Security;
import org.linkedopenactors.rdfpub.domain.commonsrdf.vocab.Vocabularies;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class ActorDefault extends ActivityPubObjectDefault implements Actor {

	private RDFPUB rdfpub;
	private AS as;
	private Security security;

	public ActorDefault(RDF rdf, IRI subject, Graph graph, GraphToStringConverter graphToStringConverter, SubjectProvider subjectProvider, Vocabularies vocabularies, InstanceProperties instanceProperties) {
		super(rdf, subject, graph, graphToStringConverter, subjectProvider, vocabularies, instanceProperties);
		rdfpub = vocabularies.getRdfPub();
		as = vocabularies.getActivityStreams();
		security = vocabularies.getSecurity();
	}

	@Override
	public IRI getOutbox() {
		return getIris(rdf.createIRI(AS.outbox)).stream().findFirst().orElseThrow();
	}

	@Override
	public void setOutbox(IRI outboxIri) {
		set(rdf.createIRI(AS.outbox), Set.of(outboxIri));
	}

	@Override
	public IRI getInbox() {
		return getIris(rdf.createIRI(LDP.inbox)).stream().findFirst().orElseThrow();
	}
	
	@Override
	public void setInbox(IRI inboxIri) {
		set(rdf.createIRI(LDP.inbox), Set.of(inboxIri));		
	}

	@Override
	public IRI getFollowing() {
		return getIris(rdf.createIRI(AS.following)).stream().findFirst().orElseThrow();
	}

	@Override
	public IRI getFollowers() {
		return getIris(rdf.createIRI(AS.followers)).stream().findFirst().orElseThrow();
	}

	@Override
	public IRI getLiked() {
		return getIris(rdf.createIRI(AS.liked)).stream().findFirst().orElseThrow();
	}

	@Override
	public Optional<String> getOauth2IssuerUserId() {
		return asGraph().stream(getSubject(), rdfpub.oauth2IssuerUserId(), null).findFirst()
				.map(Triple::getObject)
				.map(Literal.class::cast)
				.map(Literal::getLexicalForm);
	}

	@Override
	public void setOauth2IssuerUserId(String userId) {
		set(rdfpub.oauth2IssuerUserId(), rdf.createLiteral(userId));		
	}

	@Override
	public void setPreferredUsername(String preferredUsername) {
		set(as.preferredUsername(), rdf.createLiteral(preferredUsername));
	}

	@Override
	public Optional<String> getPreferredUsername() {
		return asGraph().stream(getSubject(), as.preferredUsername(), null).findFirst().map(Triple::getObject).map(RDFTerm::toString);
	}

	@Override
	public Optional<IRI> getEndpoints() {
		return getIri(as.endpoints());
	}

	@Override
	public void setEndpoints(Endpoints endpoints) {		
		log.debug("endpoints.getSubject(): " + endpoints.getSubject());
		log.debug("actor subject(): " + getSubject());
		set(as.endpoints(), endpoints.getSubject());		
		getEndpoints().ifPresent(this::remove);
		add(endpoints.asGraph());
	}

	@Override
	public Optional<IRI> getPublicKey() {
		return getIri(security.publicKey());
	}

	@Override
	public Optional<Endpoints> resolveEndpoints() {
		return getEndpoints()
			.flatMap(i->asConvertable().resolve(i))
			.map(ActivityPubObject::asConvertable)
			.map(ActivityPubObjectConvertable::asEndpoints);
	}

	@Override
	public void setPublicKey(PublicKey publicKey) {
		log.debug("publicKey.getSubject(): " + publicKey.getSubject());
		log.debug("actor subject(): " + getSubject());
		set(security.publicKey(), publicKey.getSubject());		
		getPublicKey().ifPresent(this::remove);
		add(publicKey.asGraph());
	}
}