/*
* 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.ChromatticSession;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import org.chromattic.api.query.Query;
import org.chromattic.api.query.QueryBuilder;
import org.chromattic.api.query.QueryResult;
import org.chromattic.ext.ntdef.NTFile;
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.SpaceEntity;
import org.exoplatform.social.core.chromattic.entity.SpaceListEntity;
import org.exoplatform.social.core.chromattic.entity.SpaceRef;
import org.exoplatform.social.core.chromattic.entity.SpaceRootEntity;
import org.exoplatform.social.core.identity.provider.OrganizationIdentityProvider;
import org.exoplatform.social.core.identity.provider.SpaceIdentityProvider;
import org.exoplatform.social.core.service.LinkProvider;
import org.exoplatform.social.core.space.SpaceFilter;
import org.exoplatform.social.core.space.model.Space;
import org.exoplatform.social.core.storage.SpaceStorageException;
import org.exoplatform.social.core.storage.api.SpaceStorage;
import org.exoplatform.social.core.storage.exception.NodeNotFoundException;
import org.exoplatform.social.core.storage.query.QueryFunction;
import org.exoplatform.social.core.storage.query.WhereExpression;
/**
* Space storage layer.
*
* @author <a href="mailto:alain.defrance@exoplatform.com">Alain Defrance</a>
* @version $Revision$
*/
public class SpaceStorageImpl extends AbstractStorage implements SpaceStorage {
/** Logger */
private static final Log LOG = ExoLogger.getLogger(SpaceStorageImpl.class);
/**
* The identity storage
*/
private final IdentityStorageImpl identityStorage;
/**
* Constructor.
*
* @param identityStorage the identity storage
*/
public SpaceStorageImpl(IdentityStorageImpl identityStorage) {
this.identityStorage = identityStorage;
}
/**
* Fills {@link Space}'s properties to {@link SpaceEntity}'s.
*
* @param entity the space entity from chromattic
* @param space the space pojo for services
*/
private void fillSpaceFromEntity(SpaceEntity entity, Space space) {
space.setApp(entity.getApp());
space.setId(entity.getId());
space.setPrettyName(entity.getPrettyName());
space.setDisplayName(entity.getDisplayName());
space.setRegistration(entity.getRegistration());
space.setDescription(entity.getDescription());
space.setType(entity.getType());
space.setVisibility(entity.getVisibility());
space.setPriority(entity.getPriority());
space.setGroupId(entity.getGroupId());
space.setUrl(entity.getURL());
space.setMembers(entity.getMembersId());
space.setManagers(entity.getManagerMembersId());
space.setPendingUsers(entity.getPendingMembersId());
space.setInvitedUsers(entity.getInvitedMembersId());
if (entity.getAvatarLastUpdated() != null) {
try {
ChromatticSession chromatticSession = getSession();
String url = String.format("/%s/jcr/%s/%s/production/soc:providers/soc:space/soc:%s/soc:profile/soc:avatar/?upd=%d",
container.getRestContextName(),
lifeCycle.getRepositoryName(),
chromatticSession.getJCRSession().getWorkspace().getName(),
entity.getPrettyName(),
entity.getAvatarLastUpdated());
space.setAvatarUrl(LinkProvider.escapeJCRSpecialCharacters(url));
} catch (Exception e) {
LOG.warn("Failed to build avatar url: " + e.getMessage());
}
}
space.setAvatarLastUpdated(entity.getAvatarLastUpdated());
}
/**
* Fills {@link SpaceEntity}'s properties from {@link Space}'s.
*
* @param space the space pojo for services
* @param entity the space entity from chromattic
*/
private void fillEntityFromSpace(Space space, SpaceEntity entity) {
entity.setApp(space.getApp());
entity.setPrettyName(space.getPrettyName());
entity.setDisplayName(space.getDisplayName());
entity.setRegistration(space.getRegistration());
entity.setDescription(space.getDescription());
entity.setType(space.getType());
entity.setVisibility(space.getVisibility());
entity.setPriority(space.getPriority());
entity.setGroupId(space.getGroupId());
entity.setURL(space.getUrl());
entity.setMembersId(space.getMembers());
entity.setManagerMembersId(space.getManagers());
entity.setPendingMembersId(space.getPendingUsers());
entity.setInvitedMembersId(space.getInvitedUsers());
entity.setAvatarLastUpdated(space.getAvatarLastUpdated());
}
/**
* The reference types.
*/
private enum RefType {
MEMBER() {
@Override
public SpaceListEntity refsOf(IdentityEntity identityEntity) {
return identityEntity.getSpaces();
}},
MANAGER() {
@Override
public SpaceListEntity refsOf(IdentityEntity identityEntity) {
return identityEntity.getManagerSpaces();
}},
PENDING() {
@Override
public SpaceListEntity refsOf(IdentityEntity identityEntity) {
return identityEntity.getPendingSpaces();
}},
INVITED() {
@Override
public SpaceListEntity refsOf(IdentityEntity identityEntity) {
return identityEntity.getInvitedSpaces();
}};
public abstract SpaceListEntity refsOf(IdentityEntity identityEntity);
}
private class UpdateContext {
private String[] added;
private String[] removed;
private UpdateContext(String[] added, String[] removed) {
this.added = added;
this.removed = removed;
}
public String[] getAdded() {
return added;
}
public String[] getRemoved() {
return removed;
}
}
private String[] sub(String[] l1, String[] l2) {
if (l1 == null) {
return new String[]{};
}
if (l2 == null) {
return l1;
}
List<String> l = new ArrayList(Arrays.asList(l1));
l.removeAll(Arrays.asList(l2));
return l.toArray(new String[]{});
}
private void createRefs(SpaceEntity spaceEntity, Space space) throws NodeNotFoundException {
String[] removedMembers = sub(spaceEntity.getMembersId(), space.getMembers());
String[] removedManagers = sub(spaceEntity.getManagerMembersId(), space.getManagers());
String[] removedInvited = sub(spaceEntity.getInvitedMembersId(), space.getInvitedUsers());
String[] removedPending = sub(spaceEntity.getPendingMembersId(), space.getPendingUsers());
String[] addedMembers = sub(space.getMembers(), spaceEntity.getMembersId());
String[] addedManagers = sub(space.getManagers(), spaceEntity.getManagerMembersId());
String[] addedInvited = sub(space.getInvitedUsers(), spaceEntity.getInvitedMembersId());
String[] addedPending = sub(space.getPendingUsers(), spaceEntity.getPendingMembersId());
manageRefList(new UpdateContext(addedMembers, removedMembers), spaceEntity, RefType.MEMBER);
manageRefList(new UpdateContext(addedManagers, removedManagers), spaceEntity, RefType.MANAGER);
manageRefList(new UpdateContext(addedInvited, removedInvited), spaceEntity, RefType.INVITED);
manageRefList(new UpdateContext(addedPending, removedPending), spaceEntity, RefType.PENDING);
}
private void manageRefList(UpdateContext context, SpaceEntity spaceEntity, RefType type) {
if (context.getAdded() != null) {
for (String userName : context.getAdded()) {
try {
IdentityEntity identityEntity = identityStorage._findIdentityEntity(OrganizationIdentityProvider.NAME, userName);
SpaceListEntity listRef = type.refsOf(identityEntity);
SpaceRef ref = listRef.getRef(spaceEntity.getName());
ref.setSpaceRef(spaceEntity);
}
catch (NodeNotFoundException e) {
LOG.warn(e.getMessage(), e);
}
}
for (String userName : context.getRemoved()) {
try {
IdentityEntity identityEntity = identityStorage._findIdentityEntity(OrganizationIdentityProvider.NAME, userName);
SpaceListEntity listRef = type.refsOf(identityEntity);
SpaceRef ref = listRef.getRef(spaceEntity.getName());
getSession().remove(ref);
}
catch (NodeNotFoundException e) {
LOG.warn(e.getMessage(), e);
}
}
}
}
private boolean validateFilter(SpaceFilter filter) {
if (filter == null) {
return false;
}
if (filter.getSpaceNameSearchCondition() != null &&
filter.getSpaceNameSearchCondition().length() != 0) {
return isValidInput(filter.getSpaceNameSearchCondition());
}
else if (!Character.isDigit(filter.getFirstCharacterOfSpaceName())) {
return true;
}
return false;
}
private SpaceEntity createSpace(Space space) throws SpaceStorageException {
SpaceRootEntity spaceRootEntity = getSpaceRoot();
SpaceEntity spaceEntity = spaceRootEntity.getSpace(space.getPrettyName());
space.setId(spaceEntity.getId());
return spaceEntity;
}
private SpaceEntity _saveSpace(Space space) throws NodeNotFoundException {
return _findById(SpaceEntity.class, space.getId());
}
private void _applyFilter(WhereExpression whereExpression, SpaceFilter spaceFilter) {
String spaceNameSearchCondition = spaceFilter.getSpaceNameSearchCondition();
char firstCharacterOfName = spaceFilter.getFirstCharacterOfSpaceName();
if (spaceNameSearchCondition != null && spaceNameSearchCondition.length() != 0) {
if (this.isValidInput(spaceNameSearchCondition)) {
spaceNameSearchCondition = this.processSearchCondition(spaceNameSearchCondition);
if (spaceNameSearchCondition.contains(StorageUtils.PERCENT_STR)) {
whereExpression.startGroup();
whereExpression
.like(SpaceEntity.name, spaceNameSearchCondition)
.or()
.like(SpaceEntity.description, spaceNameSearchCondition);
whereExpression.endGroup();
}
else {
whereExpression.startGroup();
whereExpression
.contains(SpaceEntity.name, spaceNameSearchCondition)
.or()
.contains(SpaceEntity.description, spaceNameSearchCondition);
whereExpression.endGroup();
}
}
}
else if (!Character.isDigit(firstCharacterOfName)) {
String firstCharacterOfNameString = Character.toString(firstCharacterOfName);
String firstCharacterOfNameLowerCase = firstCharacterOfNameString.toLowerCase() + StorageUtils.PERCENT_STR;
whereExpression
.like(whereExpression.callFunction(QueryFunction.LOWER, SpaceEntity.name), firstCharacterOfNameLowerCase);
}
}
private boolean isValidInput(String input) {
if (input == null || input.length() == 0) {
return false;
}
String cleanString = input.replaceAll("\\*", "");
cleanString = cleanString.replaceAll("\\%", "");
if (cleanString.length() == 0) {
return false;
}
return true;
}
private String processSearchCondition(String searchCondition) {
StringBuffer searchConditionBuffer = new StringBuffer();
if (!searchCondition.contains(StorageUtils.ASTERISK_STR) && !searchCondition.contains(StorageUtils.PERCENT_STR)) {
if (searchCondition.charAt(0) != StorageUtils.ASTERISK_CHAR) {
searchConditionBuffer.append(StorageUtils.ASTERISK_STR).append(searchCondition);
}
if (searchCondition.charAt(searchCondition.length() - 1) != StorageUtils.ASTERISK_CHAR) {
searchConditionBuffer.append(StorageUtils.ASTERISK_STR);
}
} else {
searchCondition = searchCondition.replace(StorageUtils.ASTERISK_STR, StorageUtils.PERCENT_STR);
searchConditionBuffer.append(StorageUtils.PERCENT_STR).append(searchCondition).append(StorageUtils.PERCENT_STR);
}
return searchConditionBuffer.toString();
}
/*
Filter query
*/
private Query<SpaceEntity> _getSpacesByFilterQuery(String userId, SpaceFilter spaceFilter) {
QueryBuilder<SpaceEntity> builder = getSession().createQueryBuilder(SpaceEntity.class);
WhereExpression whereExpression = new WhereExpression();
_applyFilter(whereExpression, spaceFilter);
if (userId != null) {
whereExpression
.and()
.equals(SpaceEntity.membersId, userId);
}
if (whereExpression.toString().length() == 0) {
return builder.get();
}
else {
return builder.where(whereExpression.toString()).get();
}
}
private Query<SpaceEntity> getAccessibleSpacesByFilterQuery(String userId, SpaceFilter spaceFilter) {
QueryBuilder<SpaceEntity> builder = getSession().createQueryBuilder(SpaceEntity.class);
WhereExpression whereExpression = new WhereExpression();
if (validateFilter(spaceFilter)) {
_applyFilter(whereExpression, spaceFilter);
whereExpression.and();
whereExpression.startGroup();
}
whereExpression
.equals(SpaceEntity.membersId, userId)
.or()
.equals(SpaceEntity.managerMembersId, userId);
whereExpression.endAllGroup();
return builder.where(whereExpression.toString()).get();
}
private Query<SpaceEntity> getPublicSpacesQuery(String userId) {
return getPublicSpacesQuery(userId, null);
}
private Query<SpaceEntity> getPublicSpacesQuery(String userId, SpaceFilter spaceFilter) {
QueryBuilder<SpaceEntity> builder = getSession().createQueryBuilder(SpaceEntity.class);
WhereExpression whereExpression = new WhereExpression();
if (validateFilter(spaceFilter)) {
_applyFilter(whereExpression, spaceFilter);
whereExpression.and();
}
builder.where(whereExpression
.not().equals(SpaceEntity.membersId, userId)
.and().not().equals(SpaceEntity.managerMembersId, userId)
.and().not().equals(SpaceEntity.invitedMembersId, userId)
.and().not().equals(SpaceEntity.pendingMembersId, userId)
.toString()
);
return builder.where(whereExpression.toString()).get();
}
private Query<SpaceEntity> getPendingSpacesFilterQuery(String userId, SpaceFilter spaceFilter) {
QueryBuilder<SpaceEntity> builder = getSession().createQueryBuilder(SpaceEntity.class);
WhereExpression whereExpression = new WhereExpression();
if (validateFilter(spaceFilter)) {
_applyFilter(whereExpression, spaceFilter);
whereExpression.and();
}
builder.where(whereExpression
.equals(SpaceEntity.pendingMembersId, userId)
.toString()
);
return builder.where(whereExpression.toString()).get();
}
private Query<SpaceEntity> getInvitedSpacesFilterQuery(String userId, SpaceFilter spaceFilter) {
QueryBuilder<SpaceEntity> builder = getSession().createQueryBuilder(SpaceEntity.class);
WhereExpression whereExpression = new WhereExpression();
if (validateFilter(spaceFilter)) {
_applyFilter(whereExpression, spaceFilter);
whereExpression.and();
}
builder.where(whereExpression
.equals(SpaceEntity.invitedMembersId, userId)
.toString()
);
return builder.where(whereExpression.toString()).get();
}
private Query<SpaceEntity> getEditableSpacesFilterQuery(String userId, SpaceFilter spaceFilter) {
QueryBuilder<SpaceEntity> builder = getSession().createQueryBuilder(SpaceEntity.class);
WhereExpression whereExpression = new WhereExpression();
if (validateFilter(spaceFilter)) {
_applyFilter(whereExpression, spaceFilter);
whereExpression.and();
}
builder.where(whereExpression
.equals(SpaceEntity.managerMembersId, userId)
.toString()
);
return builder.where(whereExpression.toString()).get();
}
private Query<SpaceEntity> getSpacesByFilterQuery(SpaceFilter spaceFilter) {
return _getSpacesByFilterQuery(null, spaceFilter);
}
/*
Public
*/
/**
* {@inheritDoc}
*/
public Space getSpaceByDisplayName(String spaceDisplayName) throws SpaceStorageException {
Space space = null;
QueryBuilder<SpaceEntity> builder = getSession().createQueryBuilder(SpaceEntity.class);
WhereExpression whereExpression = new WhereExpression();
whereExpression.equals(SpaceEntity.displayName, spaceDisplayName);
QueryResult<SpaceEntity> result = builder.where(whereExpression.toString()).get().objects();
if (result.hasNext()) {
space = new Space();
fillSpaceFromEntity(result.next(), space);
}
return space;
}
/**
* {@inheritDoc}
*/
public void saveSpace(Space space, boolean isNew) throws SpaceStorageException {
SpaceEntity entity;
try {
if (isNew) {
entity = createSpace(space);
}
else {
entity = _saveSpace(space);
}
//
createRefs(entity, space);
fillEntityFromSpace(space, entity);
//
getSession().save();
//
LOG.debug(String.format(
"Space %s (%s) saved",
space.getPrettyName(),
space.getId()
));
}
catch (NodeNotFoundException e) {
throw new SpaceStorageException(SpaceStorageException.Type.FAILED_TO_SAVE_SPACE, e.getMessage(), e);
}
}
/**
* {@inheritDoc}
*/
public void deleteSpace(String id) throws SpaceStorageException {
String name;
//
try {
name = _findById(SpaceEntity.class, id).getPrettyName();
}
catch (NodeNotFoundException e) {
throw new SpaceStorageException(SpaceStorageException.Type.FAILED_TO_DELETE_SPACE, e.getMessage());
}
//
_removeById(SpaceEntity.class, id);
//
getSession().save();
//
LOG.debug(String.format(
"Space %s removed",
name)
);
}
/*
Member spaces
*/
/**
* {@inheritDoc}
*/
public int getMemberSpacesCount(String userId) throws SpaceStorageException {
try {
return identityStorage._findIdentityEntity(OrganizationIdentityProvider.NAME, userId).getSpaces().getRefs().size();
}
catch (NodeNotFoundException e){
return 0;
}
}
/**
* {@inheritDoc}
*/
public int getMemberSpacesByFilterCount(String userId, SpaceFilter spaceFilter) {
return _getSpacesByFilterQuery(userId, spaceFilter).objects().size();
}
/**
* {@inheritDoc}
*/
public List<Space> getMemberSpaces(String userId) throws SpaceStorageException {
try {
IdentityEntity identityEntity = identityStorage._findIdentityEntity(OrganizationIdentityProvider.NAME, userId);
List<Space> spaces = new ArrayList<Space>();
for (SpaceRef space : identityEntity.getSpaces().getRefs().values()) {
Space newSpace = new Space();
fillSpaceFromEntity(space.getSpaceRef(), newSpace);
spaces.add(newSpace);
}
return spaces;
}
catch (NodeNotFoundException e) {
throw new SpaceStorageException(SpaceStorageException.Type.FAILED_TO_GET_MEMBER_SPACES, e.getMessage(), e);
}
}
/**
* {@inheritDoc}
*/
public List<Space> getMemberSpaces(String userId, long offset, long limit) throws SpaceStorageException {
List<Space> spaces = new ArrayList<Space>();
try {
int i = 0;
IdentityEntity identityEntity = identityStorage._findIdentityEntity(OrganizationIdentityProvider.NAME, userId);
Collection<SpaceRef> spaceEntities = identityEntity.getSpaces().getRefs().values();
if (spaceEntities != null) {
Iterator<SpaceRef> it = spaceEntities.iterator();
_skip(it, offset);
while (it.hasNext()) {
SpaceRef spaceRef = it.next();
Space space = new Space();
fillSpaceFromEntity(spaceRef.getSpaceRef(), space);
spaces.add(space);
if (++i >= limit) {
return spaces;
}
}
}
}
catch (NodeNotFoundException e) {
return spaces;
}
return spaces;
}
/**
* {@inheritDoc}
*/
public List<Space> getMemberSpacesByFilter(String userId, SpaceFilter spaceFilter, long offset, long limit) {
List<Space> spaces = new ArrayList<Space>();
//
QueryResult<SpaceEntity> results = _getSpacesByFilterQuery(userId, spaceFilter).objects(offset, limit);
while (results.hasNext()) {
SpaceEntity currentSpace = results.next();
Space space = new Space();
fillSpaceFromEntity(currentSpace, space);
spaces.add(space);
}
return spaces;
}
/*
Pending spaces
*/
/**
* {@inheritDoc}
*/
public int getPendingSpacesCount(String userId) throws SpaceStorageException {
try {
IdentityEntity identityEntity = identityStorage._findIdentityEntity(OrganizationIdentityProvider.NAME, userId);
Collection<SpaceRef> spaceEntities = identityEntity.getPendingSpaces().getRefs().values();
return spaceEntities.size();
}
catch (NodeNotFoundException e) {
return 0;
}
}
/**
* {@inheritDoc}
*/
public int getPendingSpacesByFilterCount(String userId, SpaceFilter spaceFilter) {
return getPendingSpacesFilterQuery(userId, spaceFilter).objects().size();
}
/**
* {@inheritDoc}
*/
public List<Space> getPendingSpaces(String userId) throws SpaceStorageException {
List<Space> spaces = new ArrayList<Space>();
try {
IdentityEntity identityEntity = identityStorage._findIdentityEntity(OrganizationIdentityProvider.NAME, userId);
Collection<SpaceRef> spaceEntities = identityEntity.getPendingSpaces().getRefs().values();
for (SpaceRef ref : spaceEntities) {
Space space = new Space();
fillEntityFromSpace(space, ref.getSpaceRef());
spaces.add(space);
}
}
catch (NodeNotFoundException e) {
LOG.debug(e.getMessage(), e);
}
return spaces;
}
/**
* {@inheritDoc}
*/
public List<Space> getPendingSpaces(String userId, long offset, long limit) throws SpaceStorageException {
List<Space> spaces = new ArrayList<Space>();
try {
int i = 0;
IdentityEntity identityEntity = identityStorage._findIdentityEntity(OrganizationIdentityProvider.NAME, userId);
Collection<SpaceRef> spaceEntities = identityEntity.getPendingSpaces().getRefs().values();
if (spaceEntities != null) {
Iterator<SpaceRef> it = spaceEntities.iterator();
_skip(it, offset);
while (it.hasNext()) {
SpaceRef spaceRef = it.next();
Space space = new Space();
fillSpaceFromEntity(spaceRef.getSpaceRef(), space);
spaces.add(space);
if (++i >= limit) {
return spaces;
}
}
}
}
catch (NodeNotFoundException e) {
LOG.debug(e.getMessage(), e);
}
return spaces;
}
/**
* {@inheritDoc}
*/
public List<Space> getPendingSpacesByFilter(String userId, SpaceFilter spaceFilter, long offset, long limit) {
List<Space> spaces = new ArrayList<Space>();
//
QueryResult<SpaceEntity> results = getPendingSpacesFilterQuery(userId, spaceFilter).objects(offset, limit);
while (results.hasNext()) {
SpaceEntity currentSpace = results.next();
Space space = new Space();
fillSpaceFromEntity(currentSpace, space);
spaces.add(space);
}
return spaces;
}
/*
Invited spaces
*/
/**
* {@inheritDoc}
*/
public int getInvitedSpacesCount(String userId) throws SpaceStorageException {
try {
IdentityEntity identityEntity = identityStorage._findIdentityEntity(OrganizationIdentityProvider.NAME, userId);
Collection<SpaceRef> spaceEntities = identityEntity.getInvitedSpaces().getRefs().values();
return spaceEntities.size();
}
catch (NodeNotFoundException e) {
return 0;
}
}
/**
* {@inheritDoc}
*/
public int getInvitedSpacesByFilterCount(String userId, SpaceFilter spaceFilter) {
if (validateFilter(spaceFilter)) {
return getInvitedSpacesFilterQuery(userId, spaceFilter).objects().size();
}
else {
return 0;
}
}
/**
* {@inheritDoc}
*/
public List<Space> getInvitedSpaces(String userId) throws SpaceStorageException {
List<Space> spaces = new ArrayList<Space>();
try {
IdentityEntity identityEntity = identityStorage._findIdentityEntity(OrganizationIdentityProvider.NAME, userId);
Collection<SpaceRef> spaceEntities = identityEntity.getInvitedSpaces().getRefs().values();
for (SpaceRef ref : spaceEntities) {
Space space = new Space();
fillEntityFromSpace(space, ref.getSpaceRef());
spaces.add(space);
}
}
catch (NodeNotFoundException e) {
LOG.debug(e.getMessage(), e);
}
return spaces;
}
/**
* {@inheritDoc}
*/
public List<Space> getInvitedSpaces(String userId, long offset, long limit) throws SpaceStorageException {
List<Space> spaces = new ArrayList<Space>();
try {
int i = 0;
IdentityEntity identityEntity = identityStorage._findIdentityEntity(OrganizationIdentityProvider.NAME, userId);
Collection<SpaceRef> spaceEntities = identityEntity.getInvitedSpaces().getRefs().values();
if (spaceEntities != null) {
Iterator<SpaceRef> it = spaceEntities.iterator();
_skip(it, offset);
while (it.hasNext()) {
SpaceRef spaceRef = it.next();
Space space = new Space();
fillSpaceFromEntity(spaceRef.getSpaceRef(), space);
spaces.add(space);
if (++i >= limit) {
return spaces;
}
}
}
}
catch (NodeNotFoundException e) {
LOG.debug(e.getMessage(), e);
}
return spaces;
}
/**
* {@inheritDoc}
*/
public List<Space> getInvitedSpacesByFilter(String userId, SpaceFilter spaceFilter, long offset, long limit) {
List<Space> spaces = new ArrayList<Space>();
//
QueryResult<SpaceEntity> results = getInvitedSpacesFilterQuery(userId, spaceFilter).objects(offset, limit);
while (results.hasNext()) {
SpaceEntity currentSpace = results.next();
Space space = new Space();
fillSpaceFromEntity(currentSpace, space);
spaces.add(space);
}
return spaces;
}
/*
Public spaces
*/
/**
* {@inheritDoc}
*/
public int getPublicSpacesCount(String userId) throws SpaceStorageException {
return getPublicSpacesQuery(userId).objects().size();
}
/**
* {@inheritDoc}
*/
public int getPublicSpacesByFilterCount(String userId, SpaceFilter spaceFilter) {
if (validateFilter(spaceFilter)) {
return getPublicSpacesQuery(userId, spaceFilter).objects().size();
}
else {
return 0;
}
}
/**
* {@inheritDoc}
*/
public List<Space> getPublicSpacesByFilter(String userId, SpaceFilter spaceFilter, long offset, long limit) {
try {
identityStorage._findIdentityEntity(OrganizationIdentityProvider.NAME, userId);
}
catch (NodeNotFoundException e) {
userId = null;
}
List<Space> spaces = new ArrayList<Space>();
//
QueryResult<SpaceEntity> results = getPublicSpacesQuery(userId, spaceFilter).objects(offset, limit);
while (results.hasNext()) {
SpaceEntity currentSpace = results.next();
Space space = new Space();
fillSpaceFromEntity(currentSpace, space);
spaces.add(space);
}
return spaces;
}
/**
* {@inheritDoc}
*/
public List<Space> getPublicSpaces(String userId) throws SpaceStorageException {
List<Space> spaces = new ArrayList<Space>();
//
QueryResult<SpaceEntity> results = getPublicSpacesQuery(userId).objects();
while (results.hasNext()) {
SpaceEntity currentSpace = results.next();
Space space = new Space();
fillSpaceFromEntity(currentSpace, space);
spaces.add(space);
}
return spaces;
}
/**
* {@inheritDoc}
*/
public List<Space> getPublicSpaces(String userId, long offset, long limit) throws SpaceStorageException {
List<Space> spaces = new ArrayList<Space>();
//
QueryResult<SpaceEntity> results = getPublicSpacesQuery(userId).objects(offset, limit);
while (results.hasNext()) {
SpaceEntity currentSpace = results.next();
Space space = new Space();
fillSpaceFromEntity(currentSpace, space);
spaces.add(space);
}
return spaces;
}
/*
Accessible spaces
*/
/**
* {@inheritDoc}
*/
public int getAccessibleSpacesCount(String userId) throws SpaceStorageException {
return getAccessibleSpacesByFilterQuery(userId, null).objects().size();
}
/**
* {@inheritDoc}
*/
public int getAccessibleSpacesByFilterCount(String userId, SpaceFilter spaceFilter) {
return getAccessibleSpacesByFilterQuery(userId, spaceFilter).objects().size();
}
/**
* {@inheritDoc}
*/
public List<Space> getAccessibleSpaces(String userId) throws SpaceStorageException {
List<Space> spaces = new ArrayList<Space>();
//
QueryResult<SpaceEntity> results = getAccessibleSpacesByFilterQuery(userId, null).objects();
while (results.hasNext()) {
SpaceEntity currentSpace = results.next();
Space space = new Space();
fillSpaceFromEntity(currentSpace, space);
spaces.add(space);
}
return spaces;
}
/**
* {@inheritDoc}
*/
public List<Space> getAccessibleSpaces(String userId, long offset, long limit) throws SpaceStorageException {
List<Space> spaces = new ArrayList<Space>();
//
QueryResult<SpaceEntity> results = getAccessibleSpacesByFilterQuery(userId, null).objects(offset, limit);
while (results.hasNext()) {
SpaceEntity currentSpace = results.next();
Space space = new Space();
fillSpaceFromEntity(currentSpace, space);
spaces.add(space);
}
return spaces;
}
/**
* {@inheritDoc}
*/
public List<Space> getAccessibleSpacesByFilter(String userId, SpaceFilter spaceFilter, long offset, long limit) {
List<Space> spaces = new ArrayList<Space>();
//
QueryResult<SpaceEntity> results = getAccessibleSpacesByFilterQuery(userId, spaceFilter).objects(offset, limit);
while (results.hasNext()) {
SpaceEntity currentSpace = results.next();
Space space = new Space();
fillSpaceFromEntity(currentSpace, space);
spaces.add(space);
}
return spaces;
}
/*
Editable spaces
*/
/**
* {@inheritDoc}
*/
public int getEditableSpacesCount(String userId) throws SpaceStorageException {
try {
IdentityEntity identityEntity = identityStorage._findIdentityEntity(OrganizationIdentityProvider.NAME, userId);
return identityEntity.getManagerSpaces().getRefs().size();
}
catch (NodeNotFoundException e) {
return 0;
}
}
/**
* {@inheritDoc}
*/
public int getEditableSpacesByFilterCount(String userId, SpaceFilter spaceFilter) {
return getEditableSpacesFilterQuery(userId, spaceFilter).objects().size();
}
/**
* {@inheritDoc}
*/
public List<Space> getEditableSpaces(String userId) throws SpaceStorageException {
List<Space> spaces = new ArrayList<Space>();
try {
IdentityEntity identityEntity = identityStorage._findIdentityEntity(OrganizationIdentityProvider.NAME, userId);
Collection<SpaceRef> spaceEntities = identityEntity.getManagerSpaces().getRefs().values();
if (spaceEntities != null) {
for (SpaceRef spaceRef : spaceEntities) {
Space space = new Space();
fillSpaceFromEntity(spaceRef.getSpaceRef(), space);
spaces.add(space);
}
}
}
catch (NodeNotFoundException e) {
LOG.debug(e.getMessage(), e);
}
return spaces;
}
/**
* {@inheritDoc}
*/
public List<Space> getEditableSpaces(String userId, long offset, long limit) throws SpaceStorageException {
List<Space> spaces = new ArrayList<Space>();
try {
int i = 0;
IdentityEntity identityEntity = identityStorage._findIdentityEntity(OrganizationIdentityProvider.NAME, userId);
Collection<SpaceRef> spaceEntities = identityEntity.getManagerSpaces().getRefs().values();
if (spaceEntities != null) {
Iterator<SpaceRef> it = spaceEntities.iterator();
_skip(it, offset);
while (it.hasNext()) {
SpaceRef spaceRef = it.next();
Space space = new Space();
fillSpaceFromEntity(spaceRef.getSpaceRef(), space);
spaces.add(space);
if (++i >= limit) {
return spaces;
}
}
}
}
catch (NodeNotFoundException e) {
LOG.debug(e.getMessage(), e);
}
return spaces;
}
/**
* {@inheritDoc}
*/
public List<Space> getEditableSpacesByFilter(String userId, SpaceFilter spaceFilter, long offset, long limit) {
List<Space> spaces = new ArrayList<Space>();
//
QueryResult<SpaceEntity> results = getEditableSpacesFilterQuery(userId, spaceFilter).objects(offset, limit);
while (results.hasNext()) {
SpaceEntity currentSpace = results.next();
Space space = new Space();
fillSpaceFromEntity(currentSpace, space);
spaces.add(space);
}
return spaces;
}
/*
All spaces
*/
/**
* {@inheritDoc}
*/
public int getAllSpacesCount() throws SpaceStorageException {
// TODO : use property to improve the perfs
return getSpaceRoot().getSpaces().size();
}
/**
* {@inheritDoc}
*/
public List<Space> getAllSpaces() throws SpaceStorageException {
List<Space> spaces = new ArrayList<Space>();
for (SpaceEntity spaceEntity : getSpaceRoot().getSpaces().values()) {
Space space = new Space();
fillSpaceFromEntity(spaceEntity, space);
spaces.add(space);
}
return spaces;
}
/**
* {@inheritDoc}
*/
public int getAllSpacesByFilterCount(SpaceFilter spaceFilter) {
if (validateFilter(spaceFilter)) {
return getSpacesByFilterQuery(spaceFilter).objects().size();
}
else {
return 0;
}
}
/*
Get spaces
*/
/**
* {@inheritDoc}
*/
public List<Space> getSpaces(long offset, long limit) throws SpaceStorageException {
List<Space> spaces = new ArrayList<Space>();
int i = 0;
Iterator<SpaceEntity> it = getSpaceRoot().getSpaces().values().iterator();
_skip(it, offset);
while (it.hasNext()) {
SpaceEntity spaceEntity = it.next();
Space space = new Space();
fillSpaceFromEntity(spaceEntity, space);
spaces.add(space);
if (++i >= limit) {
break;
}
}
return spaces;
}
/**
* {@inheritDoc}
*/
public List<Space> getSpacesByFilter(SpaceFilter spaceFilter, long offset, long limit) {
List<Space> spaces = new ArrayList<Space>();
if (!validateFilter(spaceFilter)) {
return spaces;
}
//
QueryResult<SpaceEntity> results = getSpacesByFilterQuery(spaceFilter).objects(offset, limit);
while (results.hasNext()) {
SpaceEntity currentSpace = results.next();
Space space = new Space();
fillSpaceFromEntity(currentSpace, space);
spaces.add(space);
}
return spaces;
}
/**
* {@inheritDoc}
*/
public Space getSpaceById(String id) throws SpaceStorageException {
try {
SpaceEntity spaceEntity = _findById(SpaceEntity.class, id);
Space space = new Space();
fillSpaceFromEntity(spaceEntity, space);
return space;
}
catch (NodeNotFoundException e) {
return null;
}
}
/**
* {@inheritDoc}
*/
public Space getSpaceByPrettyName(String spacePrettyName) throws SpaceStorageException {
try {
SpaceEntity entity = _findByPath(SpaceEntity.class, String.format("/production/soc:spaces/soc:%s", spacePrettyName));
Space space = new Space();
fillSpaceFromEntity(entity, space);
return space;
}
catch (NodeNotFoundException e) {
return null;
}
}
/**
* {@inheritDoc}
*/
public Space getSpaceByGroupId(String groupId) throws SpaceStorageException {
// TODO : avoid JCR query ?
QueryBuilder<SpaceEntity> builder = getSession().createQueryBuilder(SpaceEntity.class);
WhereExpression whereExpression = new WhereExpression();
builder.where(whereExpression.equals(SpaceEntity.groupId, groupId).toString());
QueryResult<SpaceEntity> result = builder.get().objects();
if (result.hasNext()) {
SpaceEntity entity = result.next();
Space space = new Space();
fillSpaceFromEntity(entity, space);
return space;
}
else {
return null;
}
}
/**
* {@inheritDoc}
*/
public Space getSpaceByUrl(String url) throws SpaceStorageException {
// TODO : avoid JCR query ?
QueryBuilder<SpaceEntity> builder = getSession().createQueryBuilder(SpaceEntity.class);
if (url != null) {
WhereExpression whereExpression = new WhereExpression();
whereExpression.equals(SpaceEntity.url, url);
builder.where(whereExpression.toString());
}
QueryResult<SpaceEntity> result = builder.get().objects();
if (result.hasNext()) {
Space space = new Space();
SpaceEntity entity = builder.get().objects().next();
fillSpaceFromEntity(entity, space);
return space;
}
else {
return null;
}
}
}