com.communote.server.core.blog

Class BlogRightsManagementBase

java.lang.Object

com.communote.server.core.blog.BlogRightsManagementBase

All Implemented Interfaces:

BlogRightsManagement

Direct Known Subclasses:

BlogRightsManagementImpl

@Transactional(propagation=REQUIRED)
public abstract class BlogRightsManagementBase
extends Object
implements BlogRightsManagement

Spring Service base class for BlogRightsManagement, provides access to all services and entities referenced by this service.

Author:

Communote GmbH - http://www.communote.com/

See Also:

BlogRightsManagement

Constructor Summary

Constructors

Constructor and Description
BlogRightsManagementBase()

Method Summary

Modifier and Type	Method and Description
void	addEntity(Long blogId, Long entityId, BlogRole role) Adds member with the given role to the blog.
void	addEntityForExternal(Long blogId, Long entityId, BlogRole role, String externalSystemId, String externalId) Add a member with the given role to the blog on the behalf of an external system.
void	addEntityForExternalTrusted(Long blogId, Long entityId, BlogRole role, String externalSystemId) Add a member with the given role to the blog on the behalf of an external system.
void	assignEntity(Long blogId, Long entityId, BlogRole role) Add a member with the given role to the blog.
void	assignEntity(Long blogId, Long entityId, BlogRole role, boolean createNote) Adds member with the given role to the blog.
void	assignEntityForExternal(Long blogId, Long entityId, BlogRole role, String externalSystemId, String externalId) Add or update a member with the given role on the behalf of an external system.
void	assignEntityForExternalTrusted(Long topicId, Long entityId, BlogRole role, String externalSystemId) Add or update a member with the given role on the behalf of an external system.
void	assignManagementAccessToCurrentUser(Long blogId) Assigns the management role to the current user.
void	changePublicAccess(Long blogId, boolean allowPublicAccess) Change the public access to a blog.
void	changeRoleOfMemberByEntityId(Long blogId, Long entityId, BlogRole role) Changes the role of a blog member.
void	changeRoleOfMemberByEntityIdForExternal(Long blogId, Long entityId, BlogRole role, String externalSystemId) Change the role of a blog member that was added on the behalf of an external system.
boolean	currentUserHasManagementAccess(Long blogId) Tests whether the current user is manager of a blog.
boolean	currentUserHasReadAccess(Long blogId, boolean ignoreAllCanFlags) Tests whether the current user has read access to a blog.
boolean	currentUserHasWriteAccess(Long blogId, boolean ignoreAllCanFlags) Tests whether the current user has write access to a blog.
Blog	getAndCheckBlogAccess(Long blogId, BlogRole blogRole) Check if a topic exists and the current user has access to that topic.
protected Principal	getPrincipal() Gets the current principal if one has been set, otherwise returns null.
BlogRole	getRoleOfCurrentUser(Long blogId, boolean ignoreAllCanFlags) Returns the blog role of the current user.
BlogRole	getRoleOfEntity(Long blogId, Long entityId, boolean ignoreAllCanFlags) Returns the blog role of an entity or null if the entity does not have access to the blog.
BlogRole	getRoleOfUser(Long blogId, Long userId, boolean ignoreAllCanFlags) Returns the blog role of a user.
protected abstract void	handleAddEntity(Long blogId, Long entityId, BlogRole role) Performs the core logic for addEntity(Long, Long, BlogRole)
protected abstract void	handleAddEntityForExternal(Long blogId, Long entityId, BlogRole role, String externalSystemId, String externalObjectId) Performs the core logic for addEntityForExternal(Long, Long, BlogRole, String externalSystemId, String externalId )
protected abstract void	handleAddEntityForExternalTrusted(Long blogId, Long entityId, BlogRole role, String externalSystemId) Performs the core logic for addEntityForExternalTrusted(Long, Long, BlogRole, String)
protected abstract void	handleAssignEntity(Long blogId, Long entityId, BlogRole role) Performs the core logic for assignEntity(Long, Long, BlogRole)
protected abstract void	handleAssignEntity(Long blogId, Long entityId, BlogRole role, boolean createNote) Performs the core logic for assignEntity(Long, Long, BlogRole, boolean)
protected abstract void	handleAssignEntityForExternal(Long topicId, Long entityId, BlogRole role, String externalSystemId, String externalId) Handle the assign of an external entity role to an internal topic
protected abstract void	handleAssignEntityForExternalTrusted(Long topicId, Long entityId, BlogRole role, String externalSystemId)
protected abstract void	handleAssignManagementAccessToCurrentUser(Long blogId) Performs the core logic for assignManagementAccessToCurrentUser(Long)
protected abstract void	handleChangePublicAccess(Long blogId, boolean allowPublicAccess) Performs the core logic for changePublicAccess(Long, boolean)
protected abstract void	handleChangeRoleOfMemberByEntityId(Long blogId, Long entityId, BlogRole role) Performs the core logic for changeRoleOfMemberByEntityId(Long, Long, BlogRole)
protected abstract void	handleChangeRoleOfMemberByEntityIdForExternal(Long blogId, Long entityId, BlogRole role, String externalSystemId) Performs the core logic for changeRoleOfMemberByEntityIdForExternal(Long, Long, BlogRole, String)
protected abstract boolean	handleCurrentUserHasManagementAccess(Long blogId) Performs the core logic for currentUserHasManagementAccess(Long)
protected abstract boolean	handleCurrentUserHasReadAccess(Long blogId, boolean ignoreAllCanFlags) Performs the core logic for currentUserHasReadAccess(Long, boolean)
protected abstract boolean	handleCurrentUserHasWriteAccess(Long blogId, boolean ignoreAllCanFlags) Performs the core logic for currentUserHasWriteAccess(Long, boolean)
protected abstract Blog	handleGetAndCheckBlogAccess(Long blogId, BlogRole blogRole) Performs the core logic for getAndCheckBlogAccess(Long, BlogRole)
protected abstract BlogRole	handleGetRoleOfCurrentUser(Long blogId, boolean ignoreAllCanFlags) Performs the core logic for getRoleOfCurrentUser(Long, boolean)
protected abstract BlogRole	handleGetRoleOfEntity(Long blogId, Long entityId, boolean ignoreAllCanFlags) Performs the core logic for getRoleOfEntity(Long, Long, boolean)
protected abstract BlogRole	handleGetRoleOfUser(Long blogId, Long userId, boolean ignoreAllCanFlags) Performs the core logic for getRoleOfUser(Long, Long, boolean)
protected abstract boolean	handleHasAnotherManager(Long blogId, Long userId) Performs the core logic for hasAnotherManager(Long, Long)
protected abstract boolean	handleHasAnotherReader(Long blogId, Long userId) Performs the core logic for hasAnotherReader(Long, Long)
protected abstract boolean	handleIsEntityDirectMember(Long blogId, Long entityId) Performs the core logic for isEntityDirectMember(Long, Long)
protected abstract void	handleRemoveMemberByEntityId(Long blogId, Long entityId) Performs the core logic for removeMemberByEntityId(Long, Long)
protected abstract void	handleRemoveMemberByEntityIdForExternal(Long blogId, Long entityId, String externalSystemId) Performs the core logic for removeMemberByEntityIdForExternal(Long, Long, String)
protected abstract void	handleRemoveUserFromAllBlogs(Long userId, Collection<Long> blogsToNotCheckForLastManager) Performs the core logic for #removeUserFromAllBlogs(Long, java.util.Collection)
protected abstract Blog	handleSetAllCanReadAllCanWrite(Long blogId, boolean allCanRead, boolean allCanWrite) Performs the core logic for setAllCanReadAllCanWrite(Long, boolean, boolean)
protected abstract boolean	handleUserHasManagementAccess(Long blogId, Long userId) Performs the core logic for userHasManagementAccess(Long, Long)
protected abstract boolean	handleUserHasReadAccess(Long blogId, Long userId, boolean ignoreAllCanFlags) Performs the core logic for userHasReadAccess(Long, Long, boolean)
protected abstract boolean	handleUserHasWriteAccess(Long blogId, Long userId, boolean ignoreAllCanFlags) Performs the core logic for userHasWriteAccess(Long, Long, boolean)
boolean	hasAnotherManager(Long blogId, Long userId) Returns true if the blog has another active user as member with management access right.
boolean	hasAnotherReader(Long blogId, Long userId) Returns true if the blog has another reader than the user passed in.
boolean	isEntityDirectMember(Long blogId, Long entityId) Returns true if the entity was added to the blog.
void	removeMemberByEntityId(Long blogId, Long entityId)
void	removeMemberByEntityIdForExternal(Long blogId, Long entityId, String externalSystemId)
void	removeUserFromAllBlogs(Long userId, Collection<Long> blogsToNotCheckForLastManager) Removes all the direct blog memberships of a user.
Blog	setAllCanReadAllCanWrite(Long blogId, boolean allCanRead, boolean allCanWrite) Update the blog all you can read /write only
boolean	userHasManagementAccess(Long blogId, Long userId) Test whether a user is manager of a blog.
boolean	userHasReadAccess(Long blogId, Long userId, boolean ignoreAllCanFlags) Test whether a user has read access to a blog.
boolean	userHasWriteAccess(Long blogId, Long userId, boolean ignoreAllCanFlags) Tests whether a user has write access to a blog.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface com.communote.server.api.core.blog.BlogRightsManagement

getMappedUsers

Constructor Detail

BlogRightsManagementBase

public BlogRightsManagementBase()

Method Detail

addEntity

public void addEntity(Long blogId,
                      Long entityId,
                      BlogRole role)
               throws CommunoteEntityNotFoundException,
                      BlogNotFoundException,
                      BlogAccessException

Description copied from interface: BlogRightsManagement

Adds member with the given role to the blog. If the entity already is a member of the blog, nothing will happen.

Specified by:

addEntity in interface BlogRightsManagement

Parameters:

blogId - ID of the blog

entityId - ID of a user or a group

role - the role describing the access right the entity should get

Throws:

CommunoteEntityNotFoundException - in case the user or group does not exist

BlogNotFoundException - in case the blog does not exist

BlogAccessException - in case the current user is not allowed to add an entity to the blog. This exception won't be thrown during blog creation.

addEntityForExternal

public void addEntityForExternal(Long blogId,
                                 Long entityId,
                                 BlogRole role,
                                 String externalSystemId,
                                 String externalId)
                          throws BlogNotFoundException,
                                 CommunoteEntityNotFoundException,
                                 ExternalObjectNotAssignedException,
                                 BlogAccessException

Add a member with the given role to the blog on the behalf of an external system. If the entity already is a member of the blog and was added on the behalf of the same external system, nothing will happen.

When adding a member on the behalf of an external system, the role will not interfere with roles added for other external systems or those that were not added for an external system (for instance by the blog manager via the web FE). Because of this a user can have different roles for the same blog. For such a case the actual access right will always be the highest of all the assigned rights.

It is assumed that the blog is associated with an external object from the external system. In case the blog is not associated with the external object identified by the externalObjectId an exception is thrown.

Specified by:

addEntityForExternal in interface BlogRightsManagement

Parameters:

blogId - ID of the blog

entityId - ID of a user or a group

role - the role describing the access right the entity should get

externalSystemId - identifier of the external system

externalId - identifier of the external object within the external system

Throws:

BlogNotFoundException - in case the blog does not exist

CommunoteEntityNotFoundException - in case the user or group does not exist

ExternalObjectNotAssignedException - in case the external object is not assigned to the blog

BlogAccessException - in case the current user is not manager of the blog

addEntityForExternalTrusted

public void addEntityForExternalTrusted(Long blogId,
                                        Long entityId,
                                        BlogRole role,
                                        String externalSystemId)
                                 throws BlogNotFoundException,
                                        CommunoteEntityNotFoundException,
                                        BlogAccessException

Description copied from interface: BlogRightsManagement

Add a member with the given role to the blog on the behalf of an external system. If the entity already is a member of the blog and was added on the behalf of the same external system, nothing will happen.

When adding a member on the behalf of an external system, the role will not interfere with roles added for other external systems or those that were not added for an external system (for instance by the blog manager via the web FE). Because of this a user can have different roles for the same blog. For such a case the actual access right will always be the highest of all the assigned rights.

It is assumed that the blog is associated with an external object from the external system. The 'Trusted' suffix in the method name denotes that the caller has to take care that there is such an external object. As of for now only the client manager is allowed to call this method.

Specified by:

addEntityForExternalTrusted in interface BlogRightsManagement

Parameters:

blogId - ID of the blog

entityId - ID of a user or a group

role - the role describing the access right the entity should get

externalSystemId - identifier of the external system

Throws:

BlogNotFoundException - in case the blog does not exist

CommunoteEntityNotFoundException - in case the user or group does not exist

BlogAccessException - in case the current user is not client manager

assignEntity

public void assignEntity(Long blogId,
                         Long entityId,
                         BlogRole role)
                  throws BlogAccessException,
                         BlogNotFoundException,
                         CommunoteEntityNotFoundException,
                         NoBlogManagerLeftException

Add a member with the given role to the blog. If the entity is already a member the role will be changed to the provided role. This method won't change a role that was added on the behalf of an external system.

Specified by:

assignEntity in interface BlogRightsManagement

Parameters:

blogId - The topics id.

entityId - The entity to assign.

role - The role for the entity.

Throws:

BlogAccessException

BlogNotFoundException

CommunoteEntityNotFoundException

NoBlogManagerLeftException

assignEntity

public void assignEntity(Long blogId,
                         Long entityId,
                         BlogRole role,
                         boolean createNote)
                  throws BlogAccessException,
                         BlogNotFoundException,
                         CommunoteEntityNotFoundException,
                         NoBlogManagerLeftException

Adds member with the given role to the blog. If the entity already is a member of the blog, nothing will happen.

Specified by:

assignEntity in interface BlogRightsManagement

entityId - ID of a user or a group

role - the role describing the access right the entity should get

createNote - true to create the activity note

Throws:

BlogAccessException - in case the current user is not allowed to add an entity to the blog. This exception won't be thrown during blog creation.

BlogNotFoundException - in case the blog does not exist

CommunoteEntityNotFoundException - in case the user or group does not exist

NoBlogManagerLeftException

assignEntityForExternal

public void assignEntityForExternal(Long blogId,
                                    Long entityId,
                                    BlogRole role,
                                    String externalSystemId,
                                    String externalId)
                             throws BlogNotFoundException,
                                    CommunoteEntityNotFoundException,
                                    BlogAccessException,
                                    ExternalObjectNotAssignedException

Add or update a member with the given role on the behalf of an external system.

This method first checks whether there is already a member that was added for the given external system and if this is the case it behaves exactly like BlogRightsManagement.changeRoleOfMemberByEntityIdForExternal(Long, Long, BlogRole, String), if it is not the case it does the same as BlogRightsManagement.addEntityForExternal(Long, Long, BlogRole, String, String)

Specified by:

assignEntityForExternal in interface BlogRightsManagement

Parameters:

blogId - ID of the blog

entityId - ID of a user or a group

role - the role describing the access right the entity should get

externalSystemId - identifier of the external system

externalId - identifier of the external object within the external system

Throws:

BlogNotFoundException - in case the blog does not exist

CommunoteEntityNotFoundException - in case the user or group does not exist

BlogAccessException - in case the current user is not allowed to modify the blog access rights

ExternalObjectNotAssignedException - in case the entity is not yet a member and the external object is not associated with the blog

assignEntityForExternalTrusted

public void assignEntityForExternalTrusted(Long topicId,
                                           Long entityId,
                                           BlogRole role,
                                           String externalSystemId)
                                    throws BlogAccessException,
                                           BlogNotFoundException,
                                           CommunoteEntityNotFoundException

Add or update a member with the given role on the behalf of an external system.

This method first checks whether there is already a member that was added for the given external system and if this is the case it behaves exactly like BlogRightsManagement.changeRoleOfMemberByEntityIdForExternal(Long, Long, BlogRole, String), if it is not the case it does the same as BlogRightsManagement.addEntityForExternalTrusted(Long, Long, BlogRole, String)

Specified by:

assignEntityForExternalTrusted in interface BlogRightsManagement

Parameters:

topicId - ID of the blog

entityId - ID of a user or a group

role - the role describing the access right the entity should get

externalSystemId - identifier of the external system

Throws:

BlogAccessException - in case the current user is not allowed to modify the blog access rights

BlogNotFoundException - in case the blog does not exist

CommunoteEntityNotFoundException - in case the user or group does not exist

assignManagementAccessToCurrentUser

public void assignManagementAccessToCurrentUser(Long blogId)
                                         throws BlogNotFoundException,
                                                AuthorizationException

Assigns the management role to the current user.

Specified by:

assignManagementAccessToCurrentUser in interface BlogRightsManagement

Parameters:

blogId - The topics id.

Throws:

BlogNotFoundException - in case the topic does not exist

AuthorizationException - in case the current user is not client manager

changePublicAccess

public void changePublicAccess(Long blogId,
                               boolean allowPublicAccess)
                        throws BlogNotFoundException,
                               BlogAccessException

Description copied from interface: BlogRightsManagement

Change the public access to a blog.

Specified by:

changePublicAccess in interface BlogRightsManagement

Parameters:

blogId - ID of the blog

allowPublicAccess - if true the blog will also be accessible by the unauthorized public user

Throws:

BlogNotFoundException - in case the blog does not exist

BlogAccessException - in case the current user is not allowed to modify the blog access rights

changeRoleOfMemberByEntityId

public void changeRoleOfMemberByEntityId(Long blogId,
                                         Long entityId,
                                         BlogRole role)
                                  throws BlogMemberNotFoundException,
                                         BlogNotFoundException,
                                         NoBlogManagerLeftException,
                                         BlogAccessException

Changes the role of a blog member. This method won't change the role of a member that was added on the behalf of an external system.

Specified by:

changeRoleOfMemberByEntityId in interface BlogRightsManagement

Parameters:

blogId - ID of the blog

entityId - ID of a user or a group that has previously added to the blog

role - the role describing the new access right the entity should get

Throws:

BlogMemberNotFoundException - in case the entity is not a member of the blog

BlogNotFoundException - in case the blog does not exist

NoBlogManagerLeftException - in case the operation would remove the last active blog manager

BlogAccessException - in case the current user is not allowed to modify the blog access rights

changeRoleOfMemberByEntityIdForExternal

public void changeRoleOfMemberByEntityIdForExternal(Long blogId,
                                                    Long entityId,
                                                    BlogRole role,
                                                    String externalSystemId)
                                             throws BlogNotFoundException,
                                                    BlogMemberNotFoundException,
                                                    BlogAccessException

Change the role of a blog member that was added on the behalf of an external system. This method won't change the role of a member that was added on the behalf of another external system or that was added directly.

Specified by:

changeRoleOfMemberByEntityIdForExternal in interface BlogRightsManagement

Parameters:

blogId - ID of the blog

entityId - ID of a user or a group that has previously added to the blog on the behalf of the external system

role - the role describing the new access right the entity should get

Throws:

BlogNotFoundException - in case the blog does not exist

BlogMemberNotFoundException - in case the entity is not a member of the blog

BlogAccessException - in case the current user is not allowed to modify the blog access rights

currentUserHasManagementAccess

@Transactional(readOnly=true)
public boolean currentUserHasManagementAccess(Long blogId)

Tests whether the current user is manager of a blog.

Specified by:

currentUserHasManagementAccess in interface BlogRightsManagement

Parameters:

blogId - ID of the blog

Returns:

true if the current user has management access, false otherwise

currentUserHasReadAccess

@Transactional(readOnly=true)
public boolean currentUserHasReadAccess(Long blogId,
                                                                      boolean ignoreAllCanFlags)

Description copied from interface: BlogRightsManagement

Tests whether the current user has read access to a blog.

Specified by:

currentUserHasReadAccess in interface BlogRightsManagement

Parameters:

blogId - ID of the blog

ignoreAllCanFlags - ignore the all can read and all can write flags and only consider the individual blog members

Returns:

true if the current user has read access, false otherwise

See Also:

BlogRightsManagement.currentUserHasReadAccess(Long, boolean)

currentUserHasWriteAccess

@Transactional(readOnly=true)
public boolean currentUserHasWriteAccess(Long blogId,
                                                                       boolean ignoreAllCanFlags)

Description copied from interface: BlogRightsManagement

Tests whether the current user has write access to a blog.

Specified by:

currentUserHasWriteAccess in interface BlogRightsManagement

Parameters:

blogId - ID of the blog

ignoreAllCanFlags - ignore the all can write flag and only consider the individual blog members

Returns:

true if the current user has write access, false otherwise

See Also:

BlogRightsManagement.currentUserHasWriteAccess(Long, boolean)

getAndCheckBlogAccess

@Transactional(readOnly=true)
public Blog getAndCheckBlogAccess(Long blogId,
                                                                BlogRole blogRole)
                                                         throws BlogNotFoundException,
                                                                BlogAccessException

Description copied from interface: BlogRightsManagement

Check if a topic exists and the current user has access to that topic. If this method returns a topic the following holds: The current user has access to the blog as specified by blogRole and the blog does exist.

Specified by:

getAndCheckBlogAccess in interface BlogRightsManagement

Parameters:

blogId - the ID of the topic to retrieve

blogRole - the access rights the current user needs to have

Returns:

the topic

Throws:

BlogNotFoundException - in case there is no topic with the given ID

BlogAccessException - in case the current user has no access to the topic

See Also:

BlogRightsManagement.getAndCheckBlogAccess(Long, BlogRole)

getPrincipal

protected Principal getPrincipal()

Gets the current principal if one has been set, otherwise returns null.

Returns:

the current principal

getRoleOfCurrentUser

@Transactional(readOnly=true)
public BlogRole getRoleOfCurrentUser(Long blogId,
                                                                   boolean ignoreAllCanFlags)

Description copied from interface: BlogRightsManagement

Returns the blog role of the current user.

Specified by:

getRoleOfCurrentUser in interface BlogRightsManagement

See Also:

BlogRightsManagement.getRoleOfCurrentUser(Long, boolean)

getRoleOfEntity

@Transactional(readOnly=true)
public BlogRole getRoleOfEntity(Long blogId,
                                                              Long entityId,
                                                              boolean ignoreAllCanFlags)

Description copied from interface: BlogRightsManagement

Returns the blog role of an entity or null if the entity does not have access to the blog.

Specified by:

getRoleOfEntity in interface BlogRightsManagement

See Also:

BlogRightsManagement.getRoleOfEntity(Long, Long, boolean)

getRoleOfUser

@Transactional(readOnly=true)
public BlogRole getRoleOfUser(Long blogId,
                                                            Long userId,
                                                            boolean ignoreAllCanFlags)

Description copied from interface: BlogRightsManagement

Returns the blog role of a user.

Specified by:

getRoleOfUser in interface BlogRightsManagement

See Also:

BlogRightsManagement.getRoleOfUser(Long, Long, boolean)

handleAddEntity

protected abstract void handleAddEntity(Long blogId,
                                        Long entityId,
                                        BlogRole role)
                                 throws CommunoteEntityNotFoundException,
                                        BlogNotFoundException,
                                        BlogAccessException

Performs the core logic for addEntity(Long, Long, BlogRole)

Throws:

CommunoteEntityNotFoundException

BlogNotFoundException

BlogAccessException

handleAddEntityForExternal

protected abstract void handleAddEntityForExternal(Long blogId,
                                                   Long entityId,
                                                   BlogRole role,
                                                   String externalSystemId,
                                                   String externalObjectId)
                                            throws BlogNotFoundException,
                                                   CommunoteEntityNotFoundException,
                                                   ExternalObjectNotAssignedException,
                                                   BlogAccessException

Performs the core logic for addEntityForExternal(Long, Long, BlogRole, String externalSystemId, String externalId )

Parameters:

blogId - ID of the blog

entityId - ID of a user or a group

role - the role describing the access right the entity should get

externalSystemId - identifier of the external system

externalObjectId - identifier of the external object within the external system

Throws:

CommunoteEntityNotFoundException - in case the user or group does not exist

BlogNotFoundException - in case the blog does not exist

ExternalObjectNotAssignedException - in case the external object is not assigned to the blog

BlogAccessException - in case the current user is not manager of the blog

handleAddEntityForExternalTrusted

protected abstract void handleAddEntityForExternalTrusted(Long blogId,
                                                          Long entityId,
                                                          BlogRole role,
                                                          String externalSystemId)
                                                   throws BlogNotFoundException,
                                                          CommunoteEntityNotFoundException,
                                                          BlogAccessException

Performs the core logic for addEntityForExternalTrusted(Long, Long, BlogRole, String)

Parameters:

blogId - ID of the blog

entityId - ID of a user or a group

role - the role describing the access right the entity should get

externalSystemId - identifier of the external system

Throws:

CommunoteEntityNotFoundException - in case the user or group does not exist

BlogNotFoundException - in case the blog does not exist

BlogAccessException - in case the current user is not allowed to add the entity

handleAssignEntity

protected abstract void handleAssignEntity(Long blogId,
                                           Long entityId,
                                           BlogRole role)
                                    throws BlogAccessException,
                                           BlogNotFoundException,
                                           CommunoteEntityNotFoundException,
                                           NoBlogManagerLeftException

Performs the core logic for assignEntity(Long, Long, BlogRole)

Throws:

BlogAccessException

BlogNotFoundException

CommunoteEntityNotFoundException

NoBlogManagerLeftException

handleAssignEntity

protected abstract void handleAssignEntity(Long blogId,
                                           Long entityId,
                                           BlogRole role,
                                           boolean createNote)
                                    throws BlogAccessException,
                                           BlogNotFoundException,
                                           CommunoteEntityNotFoundException,
                                           NoBlogManagerLeftException

Performs the core logic for assignEntity(Long, Long, BlogRole, boolean)

Throws:

BlogAccessException

BlogNotFoundException

CommunoteEntityNotFoundException

NoBlogManagerLeftException

handleAssignEntityForExternal

protected abstract void handleAssignEntityForExternal(Long topicId,
                                                      Long entityId,
                                                      BlogRole role,
                                                      String externalSystemId,
                                                      String externalId)
                                               throws BlogAccessException,
                                                      BlogNotFoundException,
                                                      CommunoteEntityNotFoundException,
                                                      ExternalObjectNotAssignedException

Handle the assign of an external entity role to an internal topic

Parameters:

topicId - identifier of topic

entityId - user or group identifier

role - of external

externalSystemId - identifier of external system

externalId - identifier of external object in external system

Throws:

CommunoteEntityNotFoundException - can not found user BlogAccessException

BlogNotFoundException - can not found topic

BlogAccessException - can not access topic

ExternalObjectNotAssignedException - external object is not assigned to topic

handleAssignEntityForExternalTrusted

protected abstract void handleAssignEntityForExternalTrusted(Long topicId,
                                                             Long entityId,
                                                             BlogRole role,
                                                             String externalSystemId)
                                                      throws BlogAccessException,
                                                             BlogNotFoundException,
                                                             CommunoteEntityNotFoundException

Throws:

BlogAccessException

BlogNotFoundException

CommunoteEntityNotFoundException

handleAssignManagementAccessToCurrentUser

protected abstract void handleAssignManagementAccessToCurrentUser(Long blogId)
                                                           throws BlogNotFoundException,
                                                                  AuthorizationException

Performs the core logic for assignManagementAccessToCurrentUser(Long)

Throws:

BlogNotFoundException

AuthorizationException

handleChangePublicAccess

protected abstract void handleChangePublicAccess(Long blogId,
                                                 boolean allowPublicAccess)
                                          throws BlogNotFoundException,
                                                 BlogAccessException

Performs the core logic for changePublicAccess(Long, boolean)

Throws:

BlogNotFoundException

BlogAccessException

handleChangeRoleOfMemberByEntityId

protected abstract void handleChangeRoleOfMemberByEntityId(Long blogId,
                                                           Long entityId,
                                                           BlogRole role)
                                                    throws BlogMemberNotFoundException,
                                                           BlogNotFoundException,
                                                           NoBlogManagerLeftException,
                                                           BlogAccessException

Performs the core logic for changeRoleOfMemberByEntityId(Long, Long, BlogRole)

Throws:

BlogMemberNotFoundException

BlogNotFoundException

NoBlogManagerLeftException

BlogAccessException

handleChangeRoleOfMemberByEntityIdForExternal

protected abstract void handleChangeRoleOfMemberByEntityIdForExternal(Long blogId,
                                                                      Long entityId,
                                                                      BlogRole role,
                                                                      String externalSystemId)
                                                               throws BlogNotFoundException,
                                                                      BlogMemberNotFoundException,
                                                                      BlogAccessException

Performs the core logic for changeRoleOfMemberByEntityIdForExternal(Long, Long, BlogRole, String)

Throws:

BlogNotFoundException

BlogMemberNotFoundException

BlogAccessException

handleCurrentUserHasManagementAccess

protected abstract boolean handleCurrentUserHasManagementAccess(Long blogId)

Performs the core logic for currentUserHasManagementAccess(Long)

handleCurrentUserHasReadAccess

protected abstract boolean handleCurrentUserHasReadAccess(Long blogId,
                                                          boolean ignoreAllCanFlags)

Performs the core logic for currentUserHasReadAccess(Long, boolean)

handleCurrentUserHasWriteAccess

protected abstract boolean handleCurrentUserHasWriteAccess(Long blogId,
                                                           boolean ignoreAllCanFlags)

Performs the core logic for currentUserHasWriteAccess(Long, boolean)

handleGetAndCheckBlogAccess

protected abstract Blog handleGetAndCheckBlogAccess(Long blogId,
                                                    BlogRole blogRole)
                                             throws BlogNotFoundException,
                                                    BlogAccessException

Performs the core logic for getAndCheckBlogAccess(Long, BlogRole)

Throws:

BlogNotFoundException

BlogAccessException

handleGetRoleOfCurrentUser

protected abstract BlogRole handleGetRoleOfCurrentUser(Long blogId,
                                                       boolean ignoreAllCanFlags)

Performs the core logic for getRoleOfCurrentUser(Long, boolean)

handleGetRoleOfEntity

protected abstract BlogRole handleGetRoleOfEntity(Long blogId,
                                                  Long entityId,
                                                  boolean ignoreAllCanFlags)

Performs the core logic for getRoleOfEntity(Long, Long, boolean)

handleGetRoleOfUser

protected abstract BlogRole handleGetRoleOfUser(Long blogId,
                                                Long userId,
                                                boolean ignoreAllCanFlags)

Performs the core logic for getRoleOfUser(Long, Long, boolean)

handleHasAnotherManager

protected abstract boolean handleHasAnotherManager(Long blogId,
                                                   Long userId)

Performs the core logic for hasAnotherManager(Long, Long)

handleHasAnotherReader

protected abstract boolean handleHasAnotherReader(Long blogId,
                                                  Long userId)

Performs the core logic for hasAnotherReader(Long, Long)

handleIsEntityDirectMember

protected abstract boolean handleIsEntityDirectMember(Long blogId,
                                                      Long entityId)

Performs the core logic for isEntityDirectMember(Long, Long)

handleRemoveMemberByEntityId

protected abstract void handleRemoveMemberByEntityId(Long blogId,
                                                     Long entityId)
                                              throws NoBlogManagerLeftException,
                                                     BlogNotFoundException,
                                                     BlogAccessException

Performs the core logic for removeMemberByEntityId(Long, Long)

Throws:

NoBlogManagerLeftException

BlogNotFoundException

BlogAccessException

handleRemoveMemberByEntityIdForExternal

protected abstract void handleRemoveMemberByEntityIdForExternal(Long blogId,
                                                                Long entityId,
                                                                String externalSystemId)
                                                         throws BlogNotFoundException,
                                                                BlogAccessException

Performs the core logic for removeMemberByEntityIdForExternal(Long, Long, String)

Throws:

BlogAccessException

BlogNotFoundException

handleRemoveUserFromAllBlogs

protected abstract void handleRemoveUserFromAllBlogs(Long userId,
                                                     Collection<Long> blogsToNotCheckForLastManager)
                                              throws AuthorizationException,
                                                     NoBlogManagerLeftException

Performs the core logic for #removeUserFromAllBlogs(Long, java.util.Collection)

Throws:

AuthorizationException

NoBlogManagerLeftException

handleSetAllCanReadAllCanWrite

protected abstract Blog handleSetAllCanReadAllCanWrite(Long blogId,
                                                       boolean allCanRead,
                                                       boolean allCanWrite)
                                                throws BlogAccessException,
                                                       BlogNotFoundException

Performs the core logic for setAllCanReadAllCanWrite(Long, boolean, boolean)

Throws:

BlogAccessException

BlogNotFoundException

handleUserHasManagementAccess

protected abstract boolean handleUserHasManagementAccess(Long blogId,
                                                         Long userId)

Performs the core logic for userHasManagementAccess(Long, Long)

handleUserHasReadAccess

protected abstract boolean handleUserHasReadAccess(Long blogId,
                                                   Long userId,
                                                   boolean ignoreAllCanFlags)

Performs the core logic for userHasReadAccess(Long, Long, boolean)

handleUserHasWriteAccess

protected abstract boolean handleUserHasWriteAccess(Long blogId,
                                                    Long userId,
                                                    boolean ignoreAllCanFlags)

Performs the core logic for userHasWriteAccess(Long, Long, boolean)

hasAnotherManager

@Transactional(readOnly=true)
public boolean hasAnotherManager(Long blogId,
                                                               Long userId)

Description copied from interface: BlogRightsManagement

Returns true if the blog has another active user as member with management access right.

Specified by:

hasAnotherManager in interface BlogRightsManagement

See Also:

BlogRightsManagement.hasAnotherManager(Long, Long)

hasAnotherReader

@Transactional(readOnly=true)
public boolean hasAnotherReader(Long blogId,
                                                              Long userId)

Description copied from interface: BlogRightsManagement

Returns true if the blog has another reader than the user passed in.

Specified by:

hasAnotherReader in interface BlogRightsManagement

See Also:

BlogRightsManagement.hasAnotherReader(Long, Long)

isEntityDirectMember

@Transactional(readOnly=true)
public boolean isEntityDirectMember(Long blogId,
                                                                  Long entityId)

Description copied from interface: BlogRightsManagement

Returns true if the entity was added to the blog. This will return false if the entity has blog access through other means like being member of a group that was added to the blog or the blog has allCanRead, allCanWrite access. If the entity has no blog access false will be returned as well.

Specified by:

isEntityDirectMember in interface BlogRightsManagement

See Also:

BlogRightsManagement.isEntityDirectMember(Long, Long)

removeMemberByEntityId

public void removeMemberByEntityId(Long blogId,
                                   Long entityId)
                            throws NoBlogManagerLeftException,
                                   BlogNotFoundException,
                                   BlogAccessException

Specified by:

removeMemberByEntityId in interface BlogRightsManagement

Throws:

NoBlogManagerLeftException

BlogNotFoundException

BlogAccessException

See Also:

BlogRightsManagement.removeMemberByEntityId(Long, Long)

removeMemberByEntityIdForExternal

public void removeMemberByEntityIdForExternal(Long blogId,
                                              Long entityId,
                                              String externalSystemId)
                                       throws BlogNotFoundException,
                                              BlogAccessException

Specified by:

removeMemberByEntityIdForExternal in interface BlogRightsManagement

Parameters:

blogId - Id of the topic.

entityId - Id of the entity to remove.

externalSystemId - Id of the entities external system.

Throws:

BlogNotFoundException

BlogAccessException

See Also:

BlogRightsManagement.removeMemberByEntityIdForExternal(Long, Long, String)

removeUserFromAllBlogs

public void removeUserFromAllBlogs(Long userId,
                                   Collection<Long> blogsToNotCheckForLastManager)
                            throws AuthorizationException,
                                   NoBlogManagerLeftException

Description copied from interface: BlogRightsManagement

Removes all the direct blog memberships of a user. If the user to remove is not the current user or the current user is not a client manager an AuthorizationException will be thrown. If the blog would end without mananger a NoBlogManagerLEftException is thrown.

Specified by:

removeUserFromAllBlogs in interface BlogRightsManagement

Throws:

AuthorizationException

NoBlogManagerLeftException

See Also:

BlogRightsManagement#removeUserFromAllBlogs(java .lang.Long, java.util.Collection)

setAllCanReadAllCanWrite

public Blog setAllCanReadAllCanWrite(Long blogId,
                                     boolean allCanRead,
                                     boolean allCanWrite)
                              throws BlogAccessException,
                                     BlogNotFoundException

Description copied from interface: BlogRightsManagement

Update the blog all you can read /write only

Specified by:

setAllCanReadAllCanWrite in interface BlogRightsManagement

Throws:

BlogAccessException

BlogNotFoundException

See Also:

BlogRightsManagement.setAllCanReadAllCanWrite(Long, boolean, boolean)

userHasManagementAccess

@Transactional(readOnly=true)
public boolean userHasManagementAccess(Long blogId,
                                                                     Long userId)

Description copied from interface: BlogRightsManagement

Test whether a user is manager of a blog.

Specified by:

userHasManagementAccess in interface BlogRightsManagement

Parameters:

blogId - ID of the blog

userId - identifier of user

Returns:

true if the user has management access, false otherwise

See Also:

BlogRightsManagement.userHasManagementAccess(Long, Long)

userHasReadAccess

@Transactional(readOnly=true)
public boolean userHasReadAccess(Long blogId,
                                                               Long userId,
                                                               boolean ignoreAllCanFlags)

Description copied from interface: BlogRightsManagement

Test whether a user has read access to a blog.

Specified by:

userHasReadAccess in interface BlogRightsManagement

Parameters:

blogId - ID of the blog

userId - identifier of user

ignoreAllCanFlags - ignore the all can read and all can write flags and only consider the individual blog members

Returns:

true if the user has read access, false otherwise

See Also:

BlogRightsManagement.userHasReadAccess(Long, Long, boolean)

userHasWriteAccess

@Transactional(readOnly=true)
public boolean userHasWriteAccess(Long blogId,
                                                                Long userId,
                                                                boolean ignoreAllCanFlags)

Description copied from interface: BlogRightsManagement

Tests whether a user has write access to a blog.

Specified by:

userHasWriteAccess in interface BlogRightsManagement

Parameters:

blogId - identifier of topic

userId - identifier of user

ignoreAllCanFlags - ignore all can read or write

Returns:

user has write access true or false

See Also:

BlogRightsManagement.userHasWriteAccess(Long, Long, boolean)