/*
* Copyright (C) 2003-2011 eXo Platform SAS.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.exoplatform.social.core.storage.impl;
import org.chromattic.api.query.QueryBuilder;
import org.chromattic.api.query.QueryResult;
import org.exoplatform.services.log.ExoLogger;
import org.exoplatform.services.log.Log;
import org.exoplatform.social.core.chromattic.entity.IdentityEntity;
import org.exoplatform.social.core.chromattic.entity.ProfileEntity;
import org.exoplatform.social.core.chromattic.entity.RelationshipEntity;
import org.exoplatform.social.core.chromattic.entity.RelationshipListEntity;
import org.exoplatform.social.core.identity.model.Identity;
import org.exoplatform.social.core.identity.model.Profile;
import org.exoplatform.social.core.profile.ProfileFilter;
import org.exoplatform.social.core.relationship.model.Relationship;
import org.exoplatform.social.core.storage.RelationshipStorageException;
import org.exoplatform.social.core.storage.api.IdentityStorage;
import org.exoplatform.social.core.storage.api.RelationshipStorage;
import org.exoplatform.social.core.storage.exception.NodeNotFoundException;
import org.exoplatform.social.core.storage.query.JCRProperties;
import org.exoplatform.social.core.storage.query.Order;
import org.exoplatform.social.core.storage.query.WhereExpression;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
* @author <a href="mailto:alain.defrance@exoplatform.com">Alain Defrance</a>
* @version $Revision$
*/
public class RelationshipStorageImpl extends AbstractStorage implements RelationshipStorage {
/** Logger */
private static final Log LOG = ExoLogger.getLogger(RelationshipStorage.class);
private final IdentityStorage identityStorage;
private RelationshipStorage relationshipStorage;
public RelationshipStorageImpl(IdentityStorage identityStorage) {
this.identityStorage = identityStorage;
}
private enum Origin { FROM, TO }
private void putRelationshipToList(List<Relationship> relationships, RelationshipListEntity list) {
if (list != null) {
for (Map.Entry<String, RelationshipEntity> entry : list.getRelationships().entrySet()) {
Relationship relationship = new Relationship(entry.getValue().getId());
RelationshipEntity relationshipEntity = entry.getValue();
IdentityEntity senderEntity = relationshipEntity.getFrom();
IdentityEntity receiverEntity = relationshipEntity.getTo();
Identity sender = new Identity(senderEntity.getId());
sender.setRemoteId(senderEntity.getRemoteId());
sender.setProviderId(senderEntity.getProviderId());
ProfileEntity senderProfileEntity = senderEntity.getProfile();
if (senderProfileEntity != null) {
loadProfile(sender);
}
Identity receiver = new Identity(receiverEntity.getId());
receiver.setRemoteId(receiverEntity.getRemoteId());
receiver.setProviderId(receiverEntity.getProviderId());
ProfileEntity receiverProfileEntity = receiverEntity.getProfile();
if (receiverProfileEntity != null) {
loadProfile(receiver);
}
if (relationshipEntity.isSender()) {
relationship.setSender(sender);
relationship.setReceiver(receiver);
}
else {
relationship.setSender(receiver);
relationship.setReceiver(sender);
}
if (SENDER.equals(entry.getValue().getParent().getName()) ||
RECEIVER.equals(entry.getValue().getParent().getName())) {
relationship.setStatus(Relationship.Type.PENDING);
}
else {
relationship.setStatus(Relationship.Type.CONFIRMED);
}
// TODO : IGNORED
relationships.add(relationship);
}
}
}
private void loadProfile(Identity identity) {
Profile profile = new Profile(identity);
profile = identityStorage.loadProfile(profile);
identity.setProfile(profile);
}
private List<Identity> getIdentitiesFromRelationship(Iterator<RelationshipEntity> it, Origin origin, long offset, long limit) {
//
List<Identity> identities = new ArrayList<Identity>();
int i = 0;
_skip(it, offset);
while (it.hasNext()) {
RelationshipEntity relationshipEntity = it.next();
switch (origin) {
case FROM:
identities.add(createIdentityFromEntity(relationshipEntity.getFrom()));
break;
case TO:
identities.add(createIdentityFromEntity(relationshipEntity.getTo()));
break;
}
if (limit != -1 && limit > 0 && ++i >= limit) {
break;
}
}
return identities;
}
private Identity createIdentityFromEntity(IdentityEntity entity) {
Identity identity = identityStorage.findIdentityById(entity.getId());
loadProfile(identity);
return identity;
}
private List<Identity> getIdentitiesRelationsByFilter(final List<Identity> relations, final ProfileFilter filter, final long offset, final long limit) {
if (relations.isEmpty()) return new ArrayList<Identity>();
//
List<Identity> found = new ArrayList<Identity>();
if(relations.isEmpty()) return found ;
QueryBuilder<ProfileEntity> builder = getSession().createQueryBuilder(ProfileEntity.class);
WhereExpression whereExpression = new WhereExpression();
StorageUtils.applyWhereFromIdentity(whereExpression, relations);
//
StorageUtils.applyFilter(whereExpression, filter);
//
QueryResult<ProfileEntity> result = builder.where(whereExpression.toString()).get().objects(offset, limit);
while(result.hasNext()) {
IdentityEntity current = result.next().getIdentity();
Identity i = new Identity(current.getProviderId(), current.getRemoteId());
i.setId(current.getId());
found.add(i);
}
//
return found;
}
private int getIdentitiesRelationsByFilterCount(final List<Identity> relations, final ProfileFilter filter) {
if (relations.size() == 0) {
return 0;
}
//
QueryBuilder<ProfileEntity> builder = getSession().createQueryBuilder(ProfileEntity.class);
//
WhereExpression whereExpression = new WhereExpression();
StorageUtils.applyWhereFromIdentity(whereExpression, relations);
//
StorageUtils.applyFilter(whereExpression, filter);
//
return builder.where(whereExpression.toString()).get().objects().size();
}
private RelationshipStorage getStorage() {
return (relationshipStorage != null ? relationshipStorage : this);
}
/*
* Internal
*/
protected RelationshipEntity _createRelationship(final Relationship relationship) throws NodeNotFoundException {
String identityId1 = relationship.getSender().getId();
String identityId2 = relationship.getReceiver().getId();
IdentityEntity identity1 = _findById(IdentityEntity.class, identityId1);
IdentityEntity identity2 = _findById(IdentityEntity.class, identityId2);
RelationshipEntity createdRelationship = identity1.createRelationship();
RelationshipEntity symmetricalRelationship = identity1.createRelationship();
switch (relationship.getStatus()) {
case PENDING:
identity1.getSender().getRelationships().put(identity2.getRemoteId(), createdRelationship);
identity2.getReceiver().getRelationships().put(identity1.getRemoteId(), symmetricalRelationship);
break;
case CONFIRMED:
identity1.getRelationship().getRelationships().put(identity2.getRemoteId(), createdRelationship);
identity2.getRelationship().getRelationships().put(identity1.getRemoteId(), symmetricalRelationship);
break;
case IGNORED:
identity1.getIgnore().getRelationships().put(identity2.getRemoteId(), createdRelationship);
identity2.getIgnored().getRelationships().put(identity2.getRemoteId(), symmetricalRelationship);
break;
}
long createdTimeStamp = System.currentTimeMillis();
createdRelationship.setFrom(identity1);
createdRelationship.setTo(identity2);
createdRelationship.setReciprocal(symmetricalRelationship);
createdRelationship.setStatus(relationship.getStatus().toString());
createdRelationship.setCreatedTime(createdTimeStamp);
symmetricalRelationship.setFrom(identity2);
symmetricalRelationship.setTo(identity1);
symmetricalRelationship.setReciprocal(createdRelationship);
symmetricalRelationship.setStatus(relationship.getStatus().toString());
symmetricalRelationship.setCreatedTime(createdTimeStamp);
relationship.setId(createdRelationship.getId());
getSession().save();
//
LOG.debug(String.format(
"Relationship from %s:%s to %s:%s created (%s)",
createdRelationship.getFrom().getProviderId(),
createdRelationship.getFrom().getRemoteId(),
createdRelationship.getTo().getProviderId(),
createdRelationship.getTo().getRemoteId(),
createdRelationship.getPath()
));
//
LOG.debug(String.format(
"Symmetrical relationship from %s:%s to %s:%s created (%s)",
symmetricalRelationship.getFrom().getProviderId(),
symmetricalRelationship.getFrom().getRemoteId(),
symmetricalRelationship.getTo().getProviderId(),
symmetricalRelationship.getTo().getRemoteId(),
symmetricalRelationship.getPath()
));
return createdRelationship;
}
protected RelationshipEntity _saveRelationship(final Relationship relationship) throws NodeNotFoundException {
RelationshipEntity savedRelationship = _findById(RelationshipEntity.class, relationship.getId());
RelationshipEntity symmetricalRelationship = savedRelationship.getReciprocal();
savedRelationship.setStatus(relationship.getStatus().toString());
symmetricalRelationship.setStatus(relationship.getStatus().toString());
switch (relationship.getStatus()) {
case PENDING:
// Move to sender / receiver
savedRelationship.getParent().getParent().getSender().getRelationships()
.put(savedRelationship.getName(), savedRelationship);
symmetricalRelationship.getParent().getParent().getReceiver().getRelationships()
.put(symmetricalRelationship.getName(), symmetricalRelationship);
break;
case CONFIRMED:
// Move to relationship
savedRelationship.getParent().getParent().getRelationship().getRelationships()
.put(savedRelationship.getName(), savedRelationship);
symmetricalRelationship.getParent().getParent().getRelationship().getRelationships()
.put(symmetricalRelationship.getName(), symmetricalRelationship);
break;
// TODO : IGNORED
}
getSession().save();
//
LOG.debug(String.format(
"Relationship from %s:%s to %s:%s saved (%s)",
savedRelationship.getFrom().getProviderId(),
savedRelationship.getFrom().getRemoteId(),
savedRelationship.getTo().getProviderId(),
savedRelationship.getTo().getRemoteId(),
savedRelationship.getPath()
));
//
LOG.debug(String.format(
"Symmetrical relationship from %s:%s to %s:%s saved (%s)",
symmetricalRelationship.getFrom().getProviderId(),
symmetricalRelationship.getFrom().getRemoteId(),
symmetricalRelationship.getTo().getProviderId(),
symmetricalRelationship.getTo().getRemoteId(),
symmetricalRelationship.getPath()
));
return savedRelationship;
}
protected List<Relationship> _getSenderRelationships(
final Identity sender, final Relationship.Type type, final List<Identity> listCheckIdentity)
throws NodeNotFoundException {
// TODO : listCheckIdentity ?
List<Relationship> relationships = new ArrayList<Relationship>();
//
IdentityEntity senderEntity = _findById(IdentityEntity.class, sender.getId());
if (type == null) {
putRelationshipToList(relationships, senderEntity.getRelationship());
putRelationshipToList(relationships, senderEntity.getSender());
}
else {
switch (type) {
case CONFIRMED:
putRelationshipToList(relationships, senderEntity.getRelationship());
break;
case PENDING:
putRelationshipToList(relationships, senderEntity.getSender());
break;
// TODO : IGNORED
}
}
return relationships;
}
protected List<Relationship> _getReceiverRelationships(
final Identity receiver, final Relationship.Type type, final List<Identity> listCheckIdentity)
throws NodeNotFoundException {
List<Relationship> relationships = new ArrayList<Relationship>();
//
IdentityEntity receiverEntity = _findById(IdentityEntity.class, receiver.getId());
if (type == null) {
putRelationshipToList(relationships, receiverEntity.getRelationship());
putRelationshipToList(relationships, receiverEntity.getReceiver());
}
else {
switch (type) {
case CONFIRMED:
putRelationshipToList(relationships, receiverEntity.getRelationship());
break;
case PENDING:
putRelationshipToList(relationships, receiverEntity.getReceiver());
break;
// TODO : IGNORED
}
}
return relationships;
}
protected Relationship _getRelationship(String uuid) throws NodeNotFoundException {
RelationshipEntity relationshipEntity = _findById(RelationshipEntity.class, uuid);
IdentityEntity receiverEntity = relationshipEntity.getTo();
IdentityEntity senderEntity = relationshipEntity.getFrom();
Identity receiver = identityStorage.findIdentityById(receiverEntity.getId());
Identity sender = identityStorage.findIdentityById(senderEntity.getId());
Relationship relationship = new Relationship(uuid);
if (relationshipEntity.isReceiver()) {
relationship.setSender(receiver);
relationship.setReceiver(sender);
}
else {
relationship.setSender(sender);
relationship.setReceiver(receiver);
}
if (SENDER.equals(relationshipEntity.getParent().getName()) ||
RECEIVER.equals(relationshipEntity.getParent().getName())) {
relationship.setStatus(Relationship.Type.PENDING);
}
else {
relationship.setStatus(Relationship.Type.CONFIRMED);
}
// TODO : IGNORED
return relationship;
}
protected Relationship _getRelationship(final Identity identity1, final Identity identity2)
throws RelationshipStorageException, NodeNotFoundException {
IdentityEntity identityEntity1 = _findById(IdentityEntity.class, identity1.getId());
IdentityEntity identityEntity2 = _findById(IdentityEntity.class, identity2.getId());
RelationshipEntity got = identityEntity1.getRelationship().getRelationships().get(identity2.getRemoteId());
if (got == null) {
got = identityEntity1.getSender().getRelationships().get(identity2.getRemoteId());
}
if (got == null) {
got = identityEntity2.getSender().getRelationships().get(identity1.getRemoteId());
}
if (got == null) {
throw new NodeNotFoundException();
}
Relationship relationship = new Relationship(got.getId());
//
IdentityEntity senderEntity = got.getFrom();
IdentityEntity receiverEntity = got.getTo();
Identity sender = new Identity(senderEntity.getId());
sender.setRemoteId(senderEntity.getRemoteId());
sender.setProviderId(senderEntity.getProviderId());
Identity receiver = new Identity(receiverEntity.getId());
receiver.setRemoteId(receiverEntity.getRemoteId());
receiver.setProviderId(receiverEntity.getProviderId());
relationship.setSender(sender);
relationship.setReceiver(receiver);
relationship.setStatus(Relationship.Type.valueOf(got.getStatus()));
return relationship;
}
/*
* Public
*/
/**
* {@inheritDoc}
*/
public Relationship saveRelationship(final Relationship relationship) throws RelationshipStorageException {
try {
if (relationship.getId() == null) {
_createRelationship(relationship);
}
else {
_saveRelationship(relationship);
}
}
catch (NodeNotFoundException e) {
throw new RelationshipStorageException(
RelationshipStorageException.Type.ILLEGAL_ARGUMENTS,
new String[] { Relationship.class.getSimpleName() });
}
return relationship;
}
/**
* {@inheritDoc}
*/
public void removeRelationship(Relationship relationship) throws RelationshipStorageException {
try {
RelationshipEntity toDeleteRelationship = _findById(RelationshipEntity.class, relationship.getId());
RelationshipEntity symmetricalRelationship = toDeleteRelationship.getReciprocal();
IdentityEntity from = toDeleteRelationship.getFrom();
IdentityEntity to = toDeleteRelationship.getFrom();
_removeById(RelationshipEntity.class, symmetricalRelationship.getId());
_removeById(RelationshipEntity.class, relationship.getId());
getSession().save();
//
LOG.debug(String.format(
"Symmetrical relationship from %s:%s to %s:%s removed",
to.getProviderId(),
to.getRemoteId(),
from.getProviderId(),
from.getRemoteId()
));
//
LOG.debug(String.format(
"Relationship from %s:%s to %s:%s removed",
from.getProviderId(),
from.getRemoteId(),
to.getProviderId(),
to.getRemoteId()
));
}
catch (NodeNotFoundException e) {
throw new RelationshipStorageException(RelationshipStorageException.Type.FAILED_TO_GET_RELATIONSHIP);
}
}
/**
* {@inheritDoc}
*/
public Relationship getRelationship(String uuid) throws RelationshipStorageException {
try {
return _getRelationship(uuid);
}
catch (NodeNotFoundException e) {
return null;
}
}
/**
* {@inheritDoc}
*/
public List<Relationship> getSenderRelationships(
final Identity sender, final Relationship.Type type, final List<Identity> listCheckIdentity)
throws RelationshipStorageException {
try {
return _getSenderRelationships(sender, type, listCheckIdentity);
}
catch (NodeNotFoundException e) {
throw new RelationshipStorageException(
RelationshipStorageException.Type.FAILED_TO_GET_RELATIONSHIP, null, e, sender.getId(), type.toString());
}
}
/**
* {@inheritDoc}
*/
public List<Relationship> getSenderRelationships(
final String senderId, final Relationship.Type type, final List<Identity> listCheckIdentity)
throws RelationshipStorageException {
return getSenderRelationships(new Identity(senderId), type, listCheckIdentity);
}
/**
* {@inheritDoc}
*/
public List<Relationship> getReceiverRelationships(
final Identity receiver, final Relationship.Type type, final List<Identity> listCheckIdentity)
throws RelationshipStorageException {
try {
return _getReceiverRelationships(receiver, type, listCheckIdentity);
}
catch (NodeNotFoundException e) {
throw new RelationshipStorageException(
RelationshipStorageException.Type.FAILED_TO_GET_RELATIONSHIP, null, e, receiver.getId(), type.toString());
}
}
/**
* {@inheritDoc}
*/
public Relationship getRelationship(final Identity identity1, final Identity identity2)
throws RelationshipStorageException {
try {
return _getRelationship(identity1, identity2);
}
catch (NodeNotFoundException e) {
return null;
}
}
/**
* {@inheritDoc}
*/
public List<Relationship> getRelationships(
final Identity identity, final Relationship.Type type, final List<Identity> listCheckIdentity)
throws RelationshipStorageException {
try {
List<Relationship> relationships = new ArrayList<Relationship>();
//
IdentityEntity receiverEntity = _findById(IdentityEntity.class, identity.getId());
if (type == null) {
putRelationshipToList(relationships, receiverEntity.getRelationship());
putRelationshipToList(relationships, receiverEntity.getReceiver());
putRelationshipToList(relationships, receiverEntity.getSender());
}
else {
switch (type) {
case CONFIRMED:
putRelationshipToList(relationships, receiverEntity.getRelationship());
break;
case PENDING:
putRelationshipToList(relationships, receiverEntity.getReceiver());
putRelationshipToList(relationships, receiverEntity.getSender());
break;
case IGNORED:
putRelationshipToList(relationships, receiverEntity.getIgnored());
break;
}
}
return relationships;
}
catch (NodeNotFoundException e) {
return new ArrayList<Relationship>();
}
}
/**
* {@inheritDoc}
*/
public List<Identity> getRelationships(final Identity identity, long offset, long limit)
throws RelationshipStorageException {
List<Identity> identities = new ArrayList<Identity>();
try {
IdentityEntity identityEntity = _findById(IdentityEntity.class, identity.getId());
QueryBuilder<RelationshipEntity> builder = getSession().createQueryBuilder(RelationshipEntity.class);
WhereExpression whereExpression = new WhereExpression();
whereExpression.like(JCRProperties.path, identityEntity.getPath() + StorageUtils.SLASH_STR + StorageUtils.PERCENT_STR);
whereExpression.orderBy(RelationshipEntity.createdTime, Order.DESC);
QueryResult<RelationshipEntity> results = builder.where(whereExpression.toString()).get().objects(offset, limit);
while (results.hasNext()) {
RelationshipEntity currentRelationshipEntity = results.next();
IdentityEntity gotIdentityEntity;
if (currentRelationshipEntity.isReceiver()) {
gotIdentityEntity = currentRelationshipEntity.getFrom();
}
else {
gotIdentityEntity = currentRelationshipEntity.getTo();
}
Identity newIdentity = new Identity(gotIdentityEntity.getId());
newIdentity.setProviderId(gotIdentityEntity.getProviderId());
newIdentity.setRemoteId(gotIdentityEntity.getRemoteId());
identities.add(newIdentity);
}
}
catch (NodeNotFoundException e) {
throw new RelationshipStorageException(
RelationshipStorageException.Type.FAILED_TO_GET_RELATIONSHIP,
e.getMessage());
}
return identities;
}
/**
* {@inheritDoc}
*/
public List<Identity> getIncomingRelationships(Identity receiver,
long offset, long limit) throws RelationshipStorageException {
try {
IdentityEntity receiverEntity = _findById(IdentityEntity.class, receiver.getId());
Iterator<RelationshipEntity> it = receiverEntity.getReceiver().getRelationships().values().iterator();
return getIdentitiesFromRelationship(it, Origin.TO, offset, limit);
}
catch (NodeNotFoundException e) {
throw new RelationshipStorageException(
RelationshipStorageException.Type.FAILED_TO_GET_RELATIONSHIP,
e.getMessage());
}
}
/**
* {@inheritDoc}
*/
public int getIncomingRelationshipsCount(Identity receiver) throws RelationshipStorageException {
try {
IdentityEntity receiverEntity = _findById(IdentityEntity.class, receiver.getId());
return receiverEntity.getReceiver().getRelationships().size();
}
catch (NodeNotFoundException e) {
throw new RelationshipStorageException(
RelationshipStorageException.Type.FAILED_TO_GET_RELATIONSHIP,
e.getMessage());
}
}
/**
* {@inheritDoc}
*/
public List<Identity> getOutgoingRelationships(Identity sender,
long offset, long limit) throws RelationshipStorageException {
try {
IdentityEntity senderEntity = _findById(IdentityEntity.class, sender.getId());
Iterator<RelationshipEntity> it = senderEntity.getSender().getRelationships().values().iterator();
return getIdentitiesFromRelationship(it, Origin.TO, offset, limit);
}
catch (NodeNotFoundException e) {
throw new RelationshipStorageException(
RelationshipStorageException.Type.FAILED_TO_GET_RELATIONSHIP,
e.getMessage());
}
}
/**
* {@inheritDoc}
*/
public int getOutgoingRelationshipsCount(Identity sender) throws RelationshipStorageException {
try {
IdentityEntity receiverEntity = _findById(IdentityEntity.class, sender.getId());
return receiverEntity.getSender().getRelationships().size();
}
catch (NodeNotFoundException e) {
throw new RelationshipStorageException(
RelationshipStorageException.Type.FAILED_TO_GET_RELATIONSHIP,
e.getMessage());
}
}
/**
* {@inheritDoc}
*/
public int getRelationshipsCount(Identity identity) throws RelationshipStorageException {
int nb = 0;
//
try {
IdentityEntity identityEntity = _findById(IdentityEntity.class, identity.getId());
nb += identityEntity.getRelationship().getRelationships().size();
nb += identityEntity.getSender().getRelationships().size();
nb += identityEntity.getReceiver().getRelationships().size();
nb += identityEntity.getIgnore().getRelationships().size();
return nb;
}
catch (NodeNotFoundException e) {
throw new RelationshipStorageException(
RelationshipStorageException.Type.FAILED_TO_GET_RELATIONSHIP,
e.getMessage());
}
}
/**
* {@inheritDoc}
*/
public List<Identity> getConnections(Identity identity, long offset, long limit) throws RelationshipStorageException {
try {
IdentityEntity identityEntity = _findById(IdentityEntity.class, identity.getId());
Iterator<RelationshipEntity> it = identityEntity.getRelationship().getRelationships().values().iterator();
return getIdentitiesFromRelationship(it, Origin.TO, offset, limit);
}
catch (NodeNotFoundException e) {
throw new RelationshipStorageException(RelationshipStorageException.Type.ILLEGAL_ARGUMENTS);
}
}
/**
* {@inheritDoc}
*/
public List<Identity> getConnections(Identity identity) throws RelationshipStorageException {
return getConnections(identity, 0, -1);
}
/**
* {@inheritDoc}
*/
public int getConnectionsCount(Identity identity) throws RelationshipStorageException {
try {
// TODO : use property to improve the perfs
IdentityEntity identityEntity = _findById(IdentityEntity.class, identity.getId());
return identityEntity.getRelationship().getRelationships().size();
}
catch (NodeNotFoundException e) {
throw new RelationshipStorageException(RelationshipStorageException.Type.ILLEGAL_ARGUMENTS);
}
}
/**
* {@inheritDoc}
*/
public List<Identity> getConnectionsByFilter(
final Identity existingIdentity, final ProfileFilter profileFilter, final long offset, final long limit)
throws RelationshipStorageException {
List<Identity> identities = getStorage().getConnections(existingIdentity);
return getIdentitiesRelationsByFilter(identities, profileFilter, offset, limit);
}
/**
* {@inheritDoc}
*/
public List<Identity> getIncomingByFilter(
final Identity existingIdentity, final ProfileFilter profileFilter, final long offset, final long limit)
throws RelationshipStorageException {
List<Identity> identities = getStorage().getIncomingRelationships(existingIdentity, 0, -1);
return getIdentitiesRelationsByFilter(identities, profileFilter, offset, limit);
}
/**
* {@inheritDoc}
*/
public List<Identity> getOutgoingByFilter(
final Identity existingIdentity, final ProfileFilter profileFilter, final long offset, final long limit)
throws RelationshipStorageException {
List<Identity> identities = getStorage().getOutgoingRelationships(existingIdentity, 0, -1);
return getIdentitiesRelationsByFilter(identities, profileFilter, offset, limit);
}
/**
* {@inheritDoc}
*/
public int getIncomingCountByFilter(
final Identity existingIdentity, final ProfileFilter profileFilter) throws RelationshipStorageException {
List<Identity> identities = getStorage().getIncomingRelationships(existingIdentity, 0, -1);
return getIdentitiesRelationsByFilterCount(identities, profileFilter);
}
/**
* {@inheritDoc}
*/
public int getConnectionsCountByFilter(
final Identity existingIdentity, final ProfileFilter profileFilter) throws RelationshipStorageException {
List<Identity> identities = getStorage().getConnections(existingIdentity);
return getIdentitiesRelationsByFilterCount(identities, profileFilter);
}
/**
* {@inheritDoc}
*/
public int getOutgoingCountByFilter(
final Identity existingIdentity, final ProfileFilter profileFilter) throws RelationshipStorageException {
List<Identity> identities = getStorage().getOutgoingRelationships(existingIdentity, 0, -1);
return getIdentitiesRelationsByFilterCount(identities, profileFilter);
}
public void setStorage(RelationshipStorage storage) {
this.relationshipStorage = storage;
}
}