org.alfresco.service.cmr.security
Interface PersonService

All Known Implementing Classes:
PersonServiceImpl

public interface PersonService

This service encapsulates the management of people and groups.

People and groups may be managed entirely in the repository or entirely in some other implementation such as LDAP or via NTLM. Some properties may in the repository and some in another store. Individual properties may or may not be mutable.


Nested Class Summary
static class PersonService.PersonInfo
          Data pojo to carry common person information
 
Method Summary
 boolean createMissingPeople()
          Does this service create people on demand if they are missing.
 org.alfresco.service.cmr.repository.NodeRef createPerson(java.util.Map properties)
          Create a new person with the given properties.
 org.alfresco.service.cmr.repository.NodeRef createPerson(java.util.Map properties, java.util.Set zones)
          Create a new person with the given properties, recording them against the given zone name (usually identifying an external user registry from which the details were obtained).
 void deletePerson(org.alfresco.service.cmr.repository.NodeRef personRef)
          Delete the person identified by the given ref.
 void deletePerson(java.lang.String userName)
          Delete the person identified by the given user name.
 java.util.Set getAllPeople()
          Deprecated. see getPeople
 java.util.Set getMutableProperties()
          Get the list of properties that are mutable.
 org.alfresco.query.PagingResults getPeople(java.util.List stringPropFilters, boolean filterIgnoreCase, java.util.List sortProps, org.alfresco.query.PagingRequest pagingRequest)
          Get paged list of people optionally filtered and/or sorted
 org.alfresco.service.cmr.repository.NodeRef getPeopleContainer()
          Return the container that stores people.
 java.util.Set getPeopleFilteredByProperty(org.alfresco.service.namespace.QName propertyKey, java.io.Serializable propertyValue)
          Deprecated. see getPeople
 org.alfresco.service.cmr.repository.NodeRef getPerson(java.lang.String userName)
          Get a person by userName.
 org.alfresco.service.cmr.repository.NodeRef getPerson(java.lang.String userName, boolean autoCreate)
          Retrieve the person NodeRef for a username key.
 java.lang.String getUserIdentifier(java.lang.String caseSensitiveUserName)
          Given the case sensitive user name find the approriate identifier from the person service.
 boolean getUserNamesAreCaseSensitive()
          Are user names case sensitive?
 boolean isMutable()
          Can this service create, delete and update person information?
 void notifyPerson(java.lang.String userName, java.lang.String password)
          Notifies a user by email that their account has been created, and the details of it.
 boolean personExists(java.lang.String userName)
          Check if a person exists.
 void setCreateMissingPeople(boolean createMissing)
          Set if missing people should be created.
 void setPersonProperties(java.lang.String userName, java.util.Map properties)
          Set the properties on a person - some of these may be persisted in different locations.
 void setPersonProperties(java.lang.String userName, java.util.Map properties, boolean autoCreate)
          Set the properties on a person - some of these may be persisted in different locations.
 

Method Detail

getPerson

@Auditable(parameters="userName")
org.alfresco.service.cmr.repository.NodeRef getPerson(java.lang.String userName)
Get a person by userName. The person is store in the repository. The person may be created as a side effect of this call, depending on the setting to create missing people or not.

Parameters:
userName - - the userName key to find the person
Returns:
Returns the person node, either existing or new
Throws:
NoSuchPersonException - if the user doesn't exist and could not be created automatically
See Also:
PersonService.setCreateMissingPeople(boolean), PersonService.createMissingPeople()

getPerson

@Auditable(parameters={"userName", "autoCreate"})
org.alfresco.service.cmr.repository.NodeRef getPerson(java.lang.String userName,
                                                                boolean autoCreate)
Retrieve the person NodeRef for a username key. Depending on the autoCreate parameter and configuration missing people will be created if not found, else a NoSuchPersonException exception will be thrown.

Parameters:
userName - of the person NodeRef to retrieve
autoCreate - should we auto-create the person node and home folder if they don't exist? (and configuration allows us to)
Returns:
NodeRef of the person as specified by the username
Throws:
NoSuchPersonException - if the person doesn't exist and can't be created

personExists

@Auditable(parameters="userName")
boolean personExists(java.lang.String userName)
Check if a person exists.

Parameters:
userName - the user name
Returns:
Returns true if the user exists, otherwise false

createMissingPeople

@Auditable
boolean createMissingPeople()
Does this service create people on demand if they are missing. If this is true, a call to getPerson() will create a person if they are missing.

Returns:
true if people are created on demand and false otherwise.

setCreateMissingPeople

@Auditable(parameters="createMissing")
void setCreateMissingPeople(boolean createMissing)
Set if missing people should be created.

Parameters:
createMissing - set to true to create people
See Also:
PersonService.getPerson(String)

getMutableProperties

@Auditable
java.util.Set getMutableProperties()
Get the list of properties that are mutable. Some service may only allow a limited list of properties to be changed. This may be those persisted in the repository or those that can be changed in some other implementation such as LDAP.

Returns:
A set of QNames that identify properties that can be changed

setPersonProperties

@Auditable(parameters={"userName", "properties"})
void setPersonProperties(java.lang.String userName,
                                   java.util.Map properties)
Set the properties on a person - some of these may be persisted in different locations.

Parameters:
userName - - the user for which the properties should be set.
properties - - the map of properties to set (as the NodeService)

setPersonProperties

@Auditable(parameters={"userName", "properties", "autoCreate"})
void setPersonProperties(java.lang.String userName,
                                   java.util.Map properties,
                                   boolean autoCreate)
Set the properties on a person - some of these may be persisted in different locations.

Parameters:
userName - - the user for which the properties should be set.
properties - - the map of properties to set (as the NodeService)
autoCreate - should we auto-create the home folder if it doesn't exist? (and configuration allows us to)

isMutable

@Auditable
boolean isMutable()
Can this service create, delete and update person information?

Returns:
true if this service allows mutation to people.

createPerson

@Auditable(parameters="properties")
org.alfresco.service.cmr.repository.NodeRef createPerson(java.util.Map properties)
Create a new person with the given properties. The userName is one of the properties. Users with duplicate userNames are not allowed.

Parameters:
properties -
Returns:

createPerson

@Auditable(parameters={"properties", "zones"})
org.alfresco.service.cmr.repository.NodeRef createPerson(java.util.Map properties,
                                                                   java.util.Set zones)
Create a new person with the given properties, recording them against the given zone name (usually identifying an external user registry from which the details were obtained). The userName is one of the properties. Users with duplicate userNames are not allowed.

Parameters:
properties - the properties
zones - a set if zones including the identifier for the external user registry owning the person information, or null or an empty set
Returns:
the node ref

notifyPerson

@Auditable(parameters="userName")
void notifyPerson(java.lang.String userName,
                            java.lang.String password)
Notifies a user by email that their account has been created, and the details of it. Normally called after PersonService.createPerson(Map) or PersonService.createPerson(Map, Set) where email notifications are required.

Parameters:
userName - of the person to notify
password - of the person to notify
Throws:
NoSuchPersonException - if the person doesn't exist

deletePerson

@Auditable(parameters="userName")
void deletePerson(java.lang.String userName)
Delete the person identified by the given user name.

Parameters:
userName -

deletePerson

@Auditable(parameters="personRef")
void deletePerson(org.alfresco.service.cmr.repository.NodeRef personRef)
Delete the person identified by the given ref.

Parameters:
personRef -

getAllPeople

@Auditable
java.util.Set getAllPeople()
Deprecated. see getPeople

Get all the people we know about.

Returns:
a set of people in no specific order.

getPeople

@Auditable(parameters={"stringPropFilters", "filterIgnoreCase", "sortProps", "pagingRequest"})
org.alfresco.query.PagingResults getPeople(java.util.List stringPropFilters,
                                                     boolean filterIgnoreCase,
                                                     java.util.List sortProps,
                                                     org.alfresco.query.PagingRequest pagingRequest)
Get paged list of people optionally filtered and/or sorted

Parameters:
filterProps - list of filter properties (with "startsWith" values), eg. cm:username "al" might match "alex", "alice", ...
filterIgnoreCase - true to ignore case when filtering, false to be case-sensitive when filtering
sortProps - sort property, eg. cm:username ascending
pagingRequest - skip, max + optional query execution id
Since:
4.0

getPeopleFilteredByProperty

@Auditable
java.util.Set getPeopleFilteredByProperty(org.alfresco.service.namespace.QName propertyKey,
                                                    java.io.Serializable propertyValue)
Deprecated. see getPeople

Get people filtered by the given property name/value pair

Parameters:
propertyKey - property key of property to filter people by
propertyValue - property value of property to filter people by
Returns:
people filtered by the given property name/value pair

getPeopleContainer

@Auditable
org.alfresco.service.cmr.repository.NodeRef getPeopleContainer()
Return the container that stores people.

Returns:

getUserNamesAreCaseSensitive

@Auditable
boolean getUserNamesAreCaseSensitive()
Are user names case sensitive?

Returns:

getUserIdentifier

@NotAuditable
java.lang.String getUserIdentifier(java.lang.String caseSensitiveUserName)
Given the case sensitive user name find the approriate identifier from the person service. If the system is case sensitive it will return the same string. If case insentive it will return the common object. If the user does not exist it will return null;

Parameters:
caseSensitiveUserName -
Returns:


Copyright © 2005 - 2010 Alfresco Software, Inc. All Rights Reserved.