mirror of
https://github.com/Alfresco/alfresco-community-repo.git
synced 2025-08-14 17:58:59 +00:00
25895187d8
64416: Merged WAT1 (4.3/Cloud) to HEAD-BUG-FIX (4.3/Cloud)
61735: ACE-493: Made Sites Public REST API Get method callable by Admins or by users that are made members of the new "Site Admin" group.
ACE-503: Created a new PUT method in Sites Public REST API, such that it is possible to modify the visibility of a site.
ACE-511: Created a new DELETE method in Sites Public REST API, such that it is possible to delete a site.
git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@64562 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
854 lines
30 KiB
Java
854 lines
30 KiB
Java
/*
|
|
* Copyright (C) 2005-2012 Alfresco Software Limited.
|
|
*
|
|
* This file is part of Alfresco
|
|
*
|
|
* Alfresco is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Alfresco 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 Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
/*
|
|
* Copyright (C) 2005-2012 Alfresco Software Limited.
|
|
*
|
|
* This file is part of Alfresco
|
|
*
|
|
* Alfresco is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Alfresco 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 Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
package org.alfresco.rest.api.impl;
|
|
|
|
import java.io.Serializable;
|
|
import java.text.Collator;
|
|
import java.util.AbstractList;
|
|
import java.util.ArrayList;
|
|
import java.util.Comparator;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Map.Entry;
|
|
import java.util.Set;
|
|
import java.util.TreeSet;
|
|
|
|
import org.alfresco.error.AlfrescoRuntimeException;
|
|
import org.alfresco.model.ContentModel;
|
|
import org.alfresco.query.PageDetails;
|
|
import org.alfresco.query.PagingRequest;
|
|
import org.alfresco.query.PagingResults;
|
|
import org.alfresco.repo.security.authentication.AuthenticationUtil;
|
|
import org.alfresco.repo.site.SiteMembership;
|
|
import org.alfresco.repo.site.SiteModel;
|
|
import org.alfresco.rest.api.Nodes;
|
|
import org.alfresco.rest.api.People;
|
|
import org.alfresco.rest.api.Sites;
|
|
import org.alfresco.rest.api.model.FavouriteSite;
|
|
import org.alfresco.rest.api.model.MemberOfSite;
|
|
import org.alfresco.rest.api.model.Site;
|
|
import org.alfresco.rest.api.model.SiteContainer;
|
|
import org.alfresco.rest.api.model.SiteImpl;
|
|
import org.alfresco.rest.api.model.SiteMember;
|
|
import org.alfresco.rest.framework.core.exceptions.ConstraintViolatedException;
|
|
import org.alfresco.rest.framework.core.exceptions.EntityNotFoundException;
|
|
import org.alfresco.rest.framework.core.exceptions.InvalidArgumentException;
|
|
import org.alfresco.rest.framework.core.exceptions.NotFoundException;
|
|
import org.alfresco.rest.framework.core.exceptions.PermissionDeniedException;
|
|
import org.alfresco.rest.framework.core.exceptions.RelationshipResourceNotFoundException;
|
|
import org.alfresco.rest.framework.jacksonextensions.BeanPropertiesFilter;
|
|
import org.alfresco.rest.framework.resource.parameters.CollectionWithPagingInfo;
|
|
import org.alfresco.rest.framework.resource.parameters.Paging;
|
|
import org.alfresco.rest.framework.resource.parameters.Parameters;
|
|
import org.alfresco.service.cmr.dictionary.DictionaryService;
|
|
import org.alfresco.service.cmr.favourites.FavouritesService;
|
|
import org.alfresco.service.cmr.model.FileInfo;
|
|
import org.alfresco.service.cmr.preference.PreferenceService;
|
|
import org.alfresco.service.cmr.repository.NodeRef;
|
|
import org.alfresco.service.cmr.repository.NodeService;
|
|
import org.alfresco.service.cmr.site.SiteInfo;
|
|
import org.alfresco.service.cmr.site.SiteRole;
|
|
import org.alfresco.service.cmr.site.SiteService;
|
|
import org.alfresco.service.cmr.site.SiteVisibility;
|
|
import org.alfresco.service.namespace.QName;
|
|
import org.alfresco.util.Pair;
|
|
|
|
/**
|
|
* Centralises access to site services and maps between representations.
|
|
*
|
|
* @author steveglover
|
|
* @since publicapi1.0
|
|
*/
|
|
public class SitesImpl implements Sites
|
|
{
|
|
private static final String FAVOURITE_SITES_PREFIX = "org.alfresco.share.sites.favourites.";
|
|
private static final int FAVOURITE_SITES_PREFIX_LENGTH = FAVOURITE_SITES_PREFIX.length();
|
|
|
|
protected Nodes nodes;
|
|
protected People people;
|
|
protected NodeService nodeService;
|
|
protected DictionaryService dictionaryService;
|
|
protected SiteService siteService;
|
|
protected FavouritesService favouritesService;
|
|
protected PreferenceService preferenceService;
|
|
|
|
public void setPreferenceService(PreferenceService preferenceService)
|
|
{
|
|
this.preferenceService = preferenceService;
|
|
}
|
|
|
|
public void setDictionaryService(DictionaryService dictionaryService)
|
|
{
|
|
this.dictionaryService = dictionaryService;
|
|
}
|
|
|
|
public void setNodes(Nodes nodes)
|
|
{
|
|
this.nodes = nodes;
|
|
}
|
|
|
|
public void setFavouritesService(FavouritesService favouritesService)
|
|
{
|
|
this.favouritesService = favouritesService;
|
|
}
|
|
|
|
public void setPeople(People people)
|
|
{
|
|
this.people = people;
|
|
}
|
|
|
|
public void setNodeService(NodeService nodeService)
|
|
{
|
|
this.nodeService = nodeService;
|
|
}
|
|
|
|
public void setSiteService(SiteService siteService)
|
|
{
|
|
this.siteService = siteService;
|
|
}
|
|
|
|
public SiteInfo validateSite(NodeRef guid)
|
|
{
|
|
SiteInfo siteInfo = null;
|
|
|
|
if (guid == null)
|
|
{
|
|
throw new InvalidArgumentException("guid is null");
|
|
}
|
|
nodes.validateNode(guid);
|
|
QName type = nodeService.getType(guid);
|
|
boolean isSiteNodeRef = dictionaryService.isSubClass(type, SiteModel.TYPE_SITE);
|
|
if (isSiteNodeRef)
|
|
{
|
|
siteInfo = siteService.getSite(guid);
|
|
if (siteInfo == null)
|
|
{
|
|
// not a site
|
|
throw new InvalidArgumentException(guid.getId() + " is not a site");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// site does not exist
|
|
throw new EntityNotFoundException(guid.getId());
|
|
}
|
|
|
|
return siteInfo;
|
|
}
|
|
|
|
public SiteInfo validateSite(String siteId)
|
|
{
|
|
if (siteId == null)
|
|
{
|
|
throw new InvalidArgumentException("siteId is null");
|
|
}
|
|
SiteInfo siteInfo = siteService.getSite(siteId);
|
|
return siteInfo;
|
|
}
|
|
|
|
public CollectionWithPagingInfo<SiteMember> getSiteMembers(String siteId, Parameters parameters)
|
|
{
|
|
SiteInfo siteInfo = validateSite(siteId);
|
|
if (siteInfo == null)
|
|
{
|
|
// site does not exist
|
|
throw new EntityNotFoundException(siteId);
|
|
}
|
|
// set the site id to the short name (to deal with case sensitivity
|
|
// issues with using the siteId from the url)
|
|
siteId = siteInfo.getShortName();
|
|
|
|
Paging paging = parameters.getPaging();
|
|
|
|
PagingRequest pagingRequest = Util.getPagingRequest(paging);
|
|
|
|
final List<Pair<SiteService.SortFields, Boolean>> sort = new ArrayList<Pair<SiteService.SortFields, Boolean>>();
|
|
sort.add(new Pair<SiteService.SortFields, Boolean>(SiteService.SortFields.LastName, Boolean.TRUE));
|
|
sort.add(new Pair<SiteService.SortFields, Boolean>(SiteService.SortFields.FirstName, Boolean.TRUE));
|
|
sort.add(new Pair<SiteService.SortFields, Boolean>(SiteService.SortFields.Role, Boolean.TRUE));
|
|
sort.add(new Pair<SiteService.SortFields, Boolean>(SiteService.SortFields.Username, Boolean.TRUE));
|
|
PagingResults<SiteMembership> pagedResults = siteService.listMembersPaged(siteId, true, sort, pagingRequest);
|
|
|
|
List<SiteMembership> siteMembers = pagedResults.getPage();
|
|
List<SiteMember> ret = new ArrayList<SiteMember>(siteMembers.size());
|
|
for (SiteMembership siteMembership : siteMembers)
|
|
{
|
|
SiteMember siteMember = new SiteMember(siteMembership.getPersonId(), siteMembership.getRole());
|
|
ret.add(siteMember);
|
|
}
|
|
|
|
return CollectionWithPagingInfo.asPaged(paging, ret, pagedResults.hasMoreItems(), null);
|
|
}
|
|
|
|
public SiteRole getSiteRole(String siteId)
|
|
{
|
|
String personId = AuthenticationUtil.getFullyAuthenticatedUser();
|
|
return getSiteRole(siteId, personId);
|
|
}
|
|
|
|
public SiteRole getSiteRole(String siteId, String personId)
|
|
{
|
|
String roleStr = siteService.getMembersRole(siteId, personId);
|
|
SiteRole role = (roleStr != null ? SiteRole.valueOf(roleStr) : null);
|
|
return role;
|
|
}
|
|
|
|
public Site getSite(String siteId)
|
|
{
|
|
return getSite(siteId, true);
|
|
}
|
|
|
|
public Site getSite(String siteId, boolean includeRole)
|
|
{
|
|
SiteInfo siteInfo = validateSite(siteId);
|
|
if (siteInfo == null)
|
|
{
|
|
// site does not exist
|
|
throw new EntityNotFoundException(siteId);
|
|
}
|
|
// set the site id to the short name (to deal with case sensitivity
|
|
// issues with using the siteId from the url)
|
|
siteId = siteInfo.getShortName();
|
|
SiteRole role = null;
|
|
if (includeRole)
|
|
{
|
|
role = getSiteRole(siteId);
|
|
}
|
|
return new SiteImpl(siteInfo, role);
|
|
}
|
|
|
|
/**
|
|
* people/<personId>/sites/<siteId>
|
|
*
|
|
* @param siteId
|
|
* @param personId
|
|
* @return
|
|
*/
|
|
public MemberOfSite getMemberOfSite(String personId, String siteId)
|
|
{
|
|
MemberOfSite siteMember = null;
|
|
|
|
personId = people.validatePerson(personId);
|
|
SiteInfo siteInfo = validateSite(siteId);
|
|
if (siteInfo == null)
|
|
{
|
|
// site does not exist
|
|
throw new RelationshipResourceNotFoundException(personId, siteId);
|
|
}
|
|
// set the site id to the short name (to deal with case sensitivity
|
|
// issues with using the siteId from the url)
|
|
siteId = siteInfo.getShortName();
|
|
|
|
String roleStr = siteService.getMembersRole(siteInfo.getShortName(), personId);
|
|
if (roleStr != null)
|
|
{
|
|
SiteRole role = SiteRole.valueOf(roleStr);
|
|
SiteImpl site = new SiteImpl(siteInfo, role);
|
|
siteMember = new MemberOfSite(site.getId(), siteInfo.getNodeRef(), role);
|
|
}
|
|
else
|
|
{
|
|
throw new RelationshipResourceNotFoundException(personId, siteId);
|
|
}
|
|
|
|
return siteMember;
|
|
}
|
|
|
|
public SiteMember getSiteMember(String personId, String siteId)
|
|
{
|
|
SiteMember siteMember = null;
|
|
|
|
personId = people.validatePerson(personId);
|
|
SiteInfo siteInfo = validateSite(siteId);
|
|
if (siteInfo == null)
|
|
{
|
|
// site does not exist
|
|
throw new RelationshipResourceNotFoundException(personId, siteId);
|
|
}
|
|
siteId = siteInfo.getShortName();
|
|
|
|
String role = siteService.getMembersRole(siteId, personId);
|
|
if (role != null)
|
|
{
|
|
siteMember = new SiteMember(personId, SiteRole.valueOf(role));
|
|
}
|
|
else
|
|
{
|
|
throw new RelationshipResourceNotFoundException(personId, siteId);
|
|
}
|
|
|
|
return siteMember;
|
|
}
|
|
|
|
public SiteMember addSiteMember(String siteId, SiteMember siteMember)
|
|
{
|
|
String personId = people.validatePerson(siteMember.getPersonId());
|
|
SiteInfo siteInfo = validateSite(siteId);
|
|
if (siteInfo == null)
|
|
{
|
|
// site does not exist
|
|
throw new EntityNotFoundException(siteId);
|
|
}
|
|
// set the site id to the short name (to deal with case sensitivity
|
|
// issues with using the siteId from the url)
|
|
siteId = siteInfo.getShortName();
|
|
|
|
SiteRole siteRole = siteMember.getRole();
|
|
if (siteRole == null)
|
|
{
|
|
throw new InvalidArgumentException("Must provide a role");
|
|
}
|
|
String role = siteRole.name();
|
|
|
|
if (siteService.isMember(siteId, personId))
|
|
{
|
|
throw new ConstraintViolatedException(personId + " is already a member of site " + siteId);
|
|
}
|
|
|
|
if (!siteService.canAddMember(siteId, personId, role))
|
|
{
|
|
throw new PermissionDeniedException();
|
|
}
|
|
|
|
siteService.setMembership(siteId, personId, role);
|
|
return siteMember;
|
|
}
|
|
|
|
public void removeSiteMember(String personId, String siteId)
|
|
{
|
|
personId = people.validatePerson(personId);
|
|
SiteInfo siteInfo = validateSite(siteId);
|
|
if (siteInfo == null)
|
|
{
|
|
// site does not exist
|
|
throw new RelationshipResourceNotFoundException(personId, siteId);
|
|
}
|
|
// set the site id to the short name (to deal with case sensitivity
|
|
// issues with using the siteId from the url)
|
|
siteId = siteInfo.getShortName();
|
|
|
|
boolean isMember = siteService.isMember(siteId, personId);
|
|
if (!isMember)
|
|
{
|
|
throw new InvalidArgumentException();
|
|
}
|
|
String role = siteService.getMembersRole(siteId, personId);
|
|
if (role != null)
|
|
{
|
|
if (role.equals(SiteModel.SITE_MANAGER))
|
|
{
|
|
int numAuthorities = siteService.countAuthoritiesWithRole(siteId, SiteModel.SITE_MANAGER);
|
|
if (numAuthorities <= 1)
|
|
{
|
|
throw new InvalidArgumentException("Can't remove last manager of site " + siteId);
|
|
}
|
|
siteService.removeMembership(siteId, personId);
|
|
}
|
|
else
|
|
{
|
|
siteService.removeMembership(siteId, personId);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw new AlfrescoRuntimeException("Unable to determine role of site member");
|
|
}
|
|
}
|
|
|
|
public SiteMember updateSiteMember(String siteId, SiteMember siteMember)
|
|
{
|
|
String siteMemberId = siteMember.getPersonId();
|
|
if (siteMemberId == null)
|
|
{
|
|
throw new InvalidArgumentException("Member id is null");
|
|
}
|
|
siteMemberId = people.validatePerson(siteMemberId);
|
|
SiteInfo siteInfo = validateSite(siteId);
|
|
if (siteInfo == null)
|
|
{
|
|
// site does not exist
|
|
throw new EntityNotFoundException(siteId);
|
|
}
|
|
siteId = siteInfo.getShortName();
|
|
SiteRole siteRole = siteMember.getRole();
|
|
if (siteRole == null)
|
|
{
|
|
throw new InvalidArgumentException("Must provide a role");
|
|
}
|
|
|
|
siteService.setMembership(siteId, siteMember.getPersonId(), siteRole.toString());
|
|
return siteMember;
|
|
}
|
|
|
|
public CollectionWithPagingInfo<MemberOfSite> getSites(String personId, Parameters parameters)
|
|
{
|
|
Paging paging = parameters.getPaging();
|
|
|
|
personId = people.validatePerson(personId);
|
|
|
|
PagingRequest pagingRequest = Util.getPagingRequest(paging);
|
|
|
|
final List<Pair<SiteService.SortFields, Boolean>> sort = new ArrayList<Pair<SiteService.SortFields, Boolean>>();
|
|
sort.add(new Pair<SiteService.SortFields, Boolean>(SiteService.SortFields.SiteTitle, Boolean.TRUE));
|
|
sort.add(new Pair<SiteService.SortFields, Boolean>(SiteService.SortFields.Role, Boolean.TRUE));
|
|
|
|
PagingResults<SiteMembership> results = siteService.listSitesPaged(personId, sort, pagingRequest);
|
|
List<SiteMembership> siteMembers = results.getPage();
|
|
List<MemberOfSite> ret = new ArrayList<MemberOfSite>(siteMembers.size());
|
|
for (SiteMembership siteMember : siteMembers)
|
|
{
|
|
SiteInfo siteInfo = siteMember.getSiteInfo();
|
|
MemberOfSite memberOfSite = new MemberOfSite(siteInfo.getShortName(), siteInfo.getNodeRef(),
|
|
siteMember.getRole());
|
|
ret.add(memberOfSite);
|
|
}
|
|
|
|
return CollectionWithPagingInfo.asPaged(paging, ret, results.hasMoreItems(), null);
|
|
}
|
|
|
|
public SiteContainer getSiteContainer(String siteId, String containerId)
|
|
{
|
|
// check site and container node validity
|
|
SiteInfo siteInfo = validateSite(siteId);
|
|
if (siteInfo == null)
|
|
{
|
|
// site does not exist
|
|
throw new RelationshipResourceNotFoundException(siteId, containerId);
|
|
}
|
|
// set the site id to the short name (to deal with case sensitivity
|
|
// issues with using the siteId from the url)
|
|
siteId = siteInfo.getShortName();
|
|
|
|
NodeRef containerNodeRef = siteService.getContainer(siteId, containerId);
|
|
if (containerNodeRef == null)
|
|
{
|
|
throw new RelationshipResourceNotFoundException(siteId, containerId);
|
|
}
|
|
|
|
// check that the containerId is actually a container for the specified
|
|
// site
|
|
SiteInfo testSiteInfo = siteService.getSite(containerNodeRef);
|
|
if (testSiteInfo == null)
|
|
{
|
|
throw new RelationshipResourceNotFoundException(siteId, containerId);
|
|
}
|
|
else
|
|
{
|
|
if (!testSiteInfo.getShortName().equals(siteId))
|
|
{
|
|
throw new RelationshipResourceNotFoundException(siteId, containerId);
|
|
}
|
|
}
|
|
|
|
String folderId = (String) nodeService.getProperty(containerNodeRef, SiteModel.PROP_COMPONENT_ID);
|
|
|
|
SiteContainer siteContainer = new SiteContainer(folderId, containerNodeRef);
|
|
return siteContainer;
|
|
}
|
|
|
|
public PagingResults<SiteContainer> getSiteContainers(String siteId, Paging paging)
|
|
{
|
|
SiteInfo siteInfo = validateSite(siteId);
|
|
if (siteInfo == null)
|
|
{
|
|
// site does not exist
|
|
throw new EntityNotFoundException(siteId);
|
|
}
|
|
|
|
final PagingResults<FileInfo> pagingResults = siteService.listContainers(siteInfo.getShortName(),
|
|
Util.getPagingRequest(paging));
|
|
List<FileInfo> containerFileInfos = pagingResults.getPage();
|
|
final List<SiteContainer> siteContainers = new ArrayList<SiteContainer>(containerFileInfos.size());
|
|
for (FileInfo containerFileInfo : containerFileInfos)
|
|
{
|
|
NodeRef nodeRef = containerFileInfo.getNodeRef();
|
|
String containerId = (String) nodeService.getProperty(nodeRef, SiteModel.PROP_COMPONENT_ID);
|
|
SiteContainer siteContainer = new SiteContainer(containerId, nodeRef);
|
|
siteContainers.add(siteContainer);
|
|
}
|
|
|
|
return new PagingResults<SiteContainer>()
|
|
{
|
|
@Override
|
|
public List<SiteContainer> getPage()
|
|
{
|
|
return siteContainers;
|
|
}
|
|
|
|
@Override
|
|
public boolean hasMoreItems()
|
|
{
|
|
return pagingResults.hasMoreItems();
|
|
}
|
|
|
|
@Override
|
|
public Pair<Integer, Integer> getTotalResultCount()
|
|
{
|
|
return pagingResults.getTotalResultCount();
|
|
}
|
|
|
|
@Override
|
|
public String getQueryExecutionId()
|
|
{
|
|
return null;
|
|
}
|
|
};
|
|
}
|
|
|
|
public CollectionWithPagingInfo<Site> getSites(final Parameters parameters)
|
|
{
|
|
final BeanPropertiesFilter filter = parameters.getFilter();
|
|
|
|
Paging paging = parameters.getPaging();
|
|
final PagingRequest pagingRequest = Util.getPagingRequest(paging);
|
|
// pagingRequest.setRequestTotalCountMax(requestTotalCountMax)
|
|
final List<Pair<QName, Boolean>> sortProps = new ArrayList<Pair<QName, Boolean>>();
|
|
sortProps.add(new Pair<QName, Boolean>(ContentModel.PROP_NAME, Boolean.TRUE));
|
|
|
|
PagingResults<SiteInfo> pagingResult = null;
|
|
boolean withSiteAdminScope = Boolean.valueOf(parameters.getParameter("admin"));
|
|
if (withSiteAdminScope && siteService.isSiteAdmin(AuthenticationUtil.getFullyAuthenticatedUser()))
|
|
{
|
|
pagingResult = AuthenticationUtil.runAs(new AuthenticationUtil.RunAsWork<PagingResults<SiteInfo>>()
|
|
{
|
|
public PagingResults<SiteInfo> doWork() throws Exception
|
|
{
|
|
return siteService.listSites(null, sortProps, pagingRequest);
|
|
}
|
|
}, AuthenticationUtil.getSystemUserName());
|
|
}
|
|
else
|
|
{
|
|
pagingResult = siteService.listSites(null, sortProps, pagingRequest);
|
|
}
|
|
|
|
final List<SiteInfo> sites = pagingResult.getPage();
|
|
int totalItems = pagingResult.getTotalResultCount().getFirst();
|
|
final String personId = AuthenticationUtil.getFullyAuthenticatedUser();
|
|
List<Site> page = new AbstractList<Site>()
|
|
{
|
|
@Override
|
|
public SiteImpl get(int index)
|
|
{
|
|
SiteInfo siteInfo = sites.get(index);
|
|
|
|
SiteRole role = null;
|
|
if (filter.isAllowed(Site.ROLE))
|
|
{
|
|
String roleStr = siteService.getMembersRole(siteInfo.getShortName(), personId);
|
|
role = (roleStr != null ? SiteRole.valueOf(roleStr) : null);
|
|
}
|
|
return new SiteImpl(siteInfo, role);
|
|
}
|
|
|
|
@Override
|
|
public int size()
|
|
{
|
|
return sites.size();
|
|
}
|
|
};
|
|
|
|
return CollectionWithPagingInfo.asPaged(paging, page, pagingResult.hasMoreItems(), totalItems);
|
|
}
|
|
|
|
public FavouriteSite getFavouriteSite(String personId, String siteId)
|
|
{
|
|
personId = people.validatePerson(personId);
|
|
SiteInfo siteInfo = validateSite(siteId);
|
|
if (siteInfo == null)
|
|
{
|
|
// site does not exist
|
|
throw new RelationshipResourceNotFoundException(personId, siteId);
|
|
}
|
|
// set the site id to the short name (to deal with case sensitivity
|
|
// issues with using the siteId from the url)
|
|
siteId = siteInfo.getShortName();
|
|
NodeRef nodeRef = siteInfo.getNodeRef();
|
|
|
|
if (favouritesService.isFavourite(personId, nodeRef))
|
|
{
|
|
SiteRole role = getSiteRole(siteId, personId);
|
|
return new FavouriteSite(siteInfo, role);
|
|
}
|
|
else
|
|
{
|
|
throw new RelationshipResourceNotFoundException(personId, siteId);
|
|
}
|
|
}
|
|
|
|
public void addFavouriteSite(String personId, FavouriteSite favouriteSite)
|
|
{
|
|
personId = people.validatePerson(personId);
|
|
String siteId = favouriteSite.getId();
|
|
SiteInfo siteInfo = validateSite(siteId);
|
|
if (siteInfo == null)
|
|
{
|
|
// site does not exist
|
|
throw new EntityNotFoundException(siteId);
|
|
}
|
|
// set the site id to the short name (to deal with case sensitivity
|
|
// issues with using the siteId from the url)
|
|
siteId = siteInfo.getShortName();
|
|
|
|
StringBuilder prefKey = new StringBuilder(FAVOURITE_SITES_PREFIX);
|
|
prefKey.append(siteId);
|
|
String value = (String) preferenceService.getPreference(personId, prefKey.toString());
|
|
boolean isFavouriteSite = (value == null ? false : value.equalsIgnoreCase("true"));
|
|
|
|
if (isFavouriteSite)
|
|
{
|
|
throw new ConstraintViolatedException("Site " + siteId + " is already a favourite site");
|
|
}
|
|
|
|
prefKey = new StringBuilder(FAVOURITE_SITES_PREFIX);
|
|
prefKey.append(siteId);
|
|
|
|
Map<String, Serializable> preferences = new HashMap<String, Serializable>(1);
|
|
preferences.put(prefKey.toString(), Boolean.TRUE);
|
|
preferenceService.setPreferences(personId, preferences);
|
|
}
|
|
|
|
public void removeFavouriteSite(String personId, String siteId)
|
|
{
|
|
personId = people.validatePerson(personId);
|
|
SiteInfo siteInfo = validateSite(siteId);
|
|
if (siteInfo == null)
|
|
{
|
|
// site does not exist
|
|
throw new RelationshipResourceNotFoundException(personId, siteId);
|
|
}
|
|
siteId = siteInfo.getShortName();
|
|
|
|
StringBuilder prefKey = new StringBuilder(FAVOURITE_SITES_PREFIX);
|
|
prefKey.append(siteId);
|
|
String value = (String) preferenceService.getPreference(personId, prefKey.toString());
|
|
boolean isFavouriteSite = (value == null ? false : value.equalsIgnoreCase("true"));
|
|
|
|
if (!isFavouriteSite)
|
|
{
|
|
throw new NotFoundException("Site " + siteId + " is not a favourite site");
|
|
}
|
|
|
|
preferenceService.clearPreferences(personId, prefKey.toString());
|
|
}
|
|
|
|
private PagingResults<SiteInfo> getFavouriteSites(String userName, PagingRequest pagingRequest)
|
|
{
|
|
final Collator collator = Collator.getInstance();
|
|
|
|
final Set<SiteInfo> sortedFavouriteSites = new TreeSet<SiteInfo>(new Comparator<SiteInfo>()
|
|
{
|
|
@Override
|
|
public int compare(SiteInfo o1, SiteInfo o2)
|
|
{
|
|
return collator.compare(o1.getTitle(), o2.getTitle());
|
|
}
|
|
});
|
|
|
|
Map<String, Serializable> prefs = preferenceService.getPreferences(userName, FAVOURITE_SITES_PREFIX);
|
|
for (Entry<String, Serializable> entry : prefs.entrySet())
|
|
{
|
|
boolean isFavourite = false;
|
|
Serializable s = entry.getValue();
|
|
if (s instanceof Boolean)
|
|
{
|
|
isFavourite = (Boolean) s;
|
|
}
|
|
if (isFavourite)
|
|
{
|
|
String siteShortName = entry.getKey().substring(FAVOURITE_SITES_PREFIX_LENGTH)
|
|
.replace(".favourited", "");
|
|
SiteInfo siteInfo = siteService.getSite(siteShortName);
|
|
if (siteInfo != null)
|
|
{
|
|
sortedFavouriteSites.add(siteInfo);
|
|
}
|
|
}
|
|
}
|
|
|
|
int totalSize = sortedFavouriteSites.size();
|
|
final PageDetails pageDetails = PageDetails.getPageDetails(pagingRequest, totalSize);
|
|
|
|
final List<SiteInfo> page = new ArrayList<SiteInfo>(pageDetails.getPageSize());
|
|
Iterator<SiteInfo> it = sortedFavouriteSites.iterator();
|
|
for (int counter = 0; counter < pageDetails.getEnd() && it.hasNext(); counter++)
|
|
{
|
|
SiteInfo favouriteSite = it.next();
|
|
|
|
if (counter < pageDetails.getSkipCount())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (counter > pageDetails.getEnd() - 1)
|
|
{
|
|
break;
|
|
}
|
|
|
|
page.add(favouriteSite);
|
|
}
|
|
|
|
return new PagingResults<SiteInfo>()
|
|
{
|
|
@Override
|
|
public List<SiteInfo> getPage()
|
|
{
|
|
return page;
|
|
}
|
|
|
|
@Override
|
|
public boolean hasMoreItems()
|
|
{
|
|
return pageDetails.hasMoreItems();
|
|
}
|
|
|
|
@Override
|
|
public Pair<Integer, Integer> getTotalResultCount()
|
|
{
|
|
Integer total = Integer.valueOf(sortedFavouriteSites.size());
|
|
return new Pair<Integer, Integer>(total, total);
|
|
}
|
|
|
|
@Override
|
|
public String getQueryExecutionId()
|
|
{
|
|
return null;
|
|
}
|
|
};
|
|
}
|
|
|
|
public CollectionWithPagingInfo<FavouriteSite> getFavouriteSites(String personId, Parameters parameters)
|
|
{
|
|
personId = people.validatePerson(personId);
|
|
|
|
Paging paging = parameters.getPaging();
|
|
BeanPropertiesFilter filter = parameters.getFilter();
|
|
|
|
PagingResults<SiteInfo> favouriteSites = getFavouriteSites(personId, Util.getPagingRequest(paging));
|
|
List<FavouriteSite> favourites = new ArrayList<FavouriteSite>(favouriteSites.getPage().size());
|
|
for (SiteInfo favouriteSite : favouriteSites.getPage())
|
|
{
|
|
SiteRole role = null;
|
|
if (filter.isAllowed(Site.ROLE))
|
|
{
|
|
role = getSiteRole(favouriteSite.getShortName(), personId);
|
|
}
|
|
FavouriteSite favourite = new FavouriteSite(favouriteSite, role);
|
|
favourites.add(favourite);
|
|
}
|
|
|
|
return CollectionWithPagingInfo.asPaged(paging, favourites, favouriteSites.hasMoreItems(), favouriteSites
|
|
.getTotalResultCount().getFirst());
|
|
}
|
|
|
|
@Override
|
|
public SiteImpl updateSite(final String siteShortName, final SiteImpl siteImpl)
|
|
{
|
|
if (siteService.isSiteAdmin(AuthenticationUtil.getFullyAuthenticatedUser()))
|
|
{
|
|
return AuthenticationUtil.runAs(new AuthenticationUtil.RunAsWork<SiteImpl>()
|
|
{
|
|
public SiteImpl doWork() throws Exception
|
|
{
|
|
// We have to wrap the whole method not just
|
|
// siteService.updateSite, as validateSite
|
|
// won't give us the private sites for site-admins
|
|
return updateSiteImpl(siteShortName, siteImpl);
|
|
}
|
|
}, AuthenticationUtil.getSystemUserName());
|
|
}
|
|
else
|
|
{
|
|
return updateSiteImpl(siteShortName, siteImpl);
|
|
}
|
|
}
|
|
|
|
private SiteImpl updateSiteImpl(String siteShortName, SiteImpl siteImpl)
|
|
{
|
|
SiteInfo siteInfo = validateSite(siteShortName);
|
|
if (siteInfo == null)
|
|
{
|
|
// site does not exist
|
|
throw new EntityNotFoundException(siteShortName);
|
|
}
|
|
// Set the site's visibility
|
|
SiteVisibility siteVisibility = siteImpl.getVisibility();
|
|
if (siteVisibility == null)
|
|
{
|
|
throw new InvalidArgumentException("Must provide visibility");
|
|
}
|
|
siteInfo.setVisibility(siteImpl.getVisibility());
|
|
siteService.updateSite(siteInfo);
|
|
|
|
return siteImpl;
|
|
}
|
|
|
|
@Override
|
|
public void deleteSite(final String siteShortName)
|
|
{
|
|
if (siteService.isSiteAdmin(AuthenticationUtil.getFullyAuthenticatedUser()))
|
|
{
|
|
AuthenticationUtil.runAs(new AuthenticationUtil.RunAsWork<Void>()
|
|
{
|
|
public Void doWork() throws Exception
|
|
{
|
|
deleteSiteImpl(siteShortName);
|
|
return null;
|
|
}
|
|
}, AuthenticationUtil.getSystemUserName());
|
|
}
|
|
else
|
|
{
|
|
deleteSiteImpl(siteShortName);
|
|
}
|
|
}
|
|
|
|
private void deleteSiteImpl(String siteShortName)
|
|
{
|
|
SiteInfo siteInfo = validateSite(siteShortName);
|
|
if (siteInfo == null)
|
|
{
|
|
// site does not exist
|
|
throw new EntityNotFoundException(siteShortName);
|
|
}
|
|
siteService.deleteSite(siteInfo.getShortName());
|
|
}
|
|
}
|