org.squashtest.tm.service.user

Interface UserManagerService

All Known Subinterfaces:

AdministrationService

All Known Implementing Classes:

AdministrationServiceImpl

public interface UserManagerService

Author:

bsiri, Gregory Fouquet

Method Summary

Methods

Modifier and Type	Method and Description
void	activateUser(long userId)
void	activateUsers(Collection<Long> userIds)
void	addUser(org.squashtest.tm.domain.users.User aUser, long groupId, String password)
void	checkLoginAvailability(String login) Checks if a user already exist with the same login in the database.
org.squashtest.tm.domain.users.User	createAdministrator(org.squashtest.tm.domain.users.User user, String password) Creates a user with the given password.
void	createAuthentication(long userId, String newPassword) Creates authentication data for given user.
org.squashtest.tm.domain.users.User	createUserFromLogin(String login) Creates a stub User using the given login and returns it.
void	createUserWithoutCredentials(org.squashtest.tm.domain.users.User user, long groupId) Creates a user without credentials.
void	deactivateUser(long userId)
void	deactivateUsers(Collection<Long> userIds)
void	deassociateTeams(long userId, List<Long> teamIds) Will remove user from teams members lists.
void	deleteUsers(Collection<Long> userIds)
List<org.squashtest.tm.domain.users.User>	findAllActiveUsersOrderedByLogin()
List<org.squashtest.tm.domain.users.User>	findAllAdminOrManager()
List<String>	findAllDuplicateLogins() Logins are considered as duplicate when they are equal without case-sensitivity.
List<org.squashtest.tm.domain.users.Team>	findAllNonAssociatedTeams(long userId) Will return a list of all Team that do not have the concerned User as a member access restricted to admins
org.squashtest.tm.core.foundation.collection.PagedCollectionHolder<List<org.squashtest.tm.domain.users.User>>	findAllUsersFiltered(org.squashtest.tm.core.foundation.collection.PagingAndSorting sorter, org.squashtest.tm.core.foundation.collection.Filtering filter)
List<org.squashtest.tm.domain.users.UsersGroup>	findAllUsersGroupOrderedByQualifiedName()
List<org.squashtest.tm.domain.users.User>	findAllUsersOrderedByLogin()
org.squashtest.tm.domain.users.User	findByLogin(String login)
String	findCaseAwareLogin(String login) Given a login, returns the unique actual matching login without case sensisivity
org.squashtest.tm.core.foundation.collection.PagedCollectionHolder<List<org.squashtest.tm.domain.users.Team>>	findSortedAssociatedTeams(long userId, org.squashtest.tm.core.foundation.collection.PagingAndSorting paging, org.squashtest.tm.core.foundation.collection.Filtering filtering) Will return an paged and filtered list of Teams that have the concerned user as a member.
AuthenticatedUser	findUserById(long userId)
void	modifyUserEmail(long userId, String newEmail)
void	modifyUserFirstName(long userId, String newName)
void	modifyUserLastName(long userId, String newName)
void	modifyUserLogin(long userId, String newLogin)
void	resetUserPassword(long userId, String newPassword)
void	setUserGroupAuthority(long userId, long groupId)

Method Detail

modifyUserFirstName

void modifyUserFirstName(long userId,
                       String newName)

modifyUserLastName

void modifyUserLastName(long userId,
                      String newName)

modifyUserLogin

void modifyUserLogin(long userId,
                   String newLogin)

modifyUserEmail

void modifyUserEmail(long userId,
                   String newEmail)

findUserById

AuthenticatedUser findUserById(long userId)

findByLogin

org.squashtest.tm.domain.users.User findByLogin(@NotNull
                                              String login)

findCaseAwareLogin

String findCaseAwareLogin(String login)

Given a login, returns the unique actual matching login without case sensisivity

Parameters:

login -

Returns:

actual login or `null` when the login was not found.

Throws:

org.hibernate.HibernateException - when more than one login is gound

findAllUsersOrderedByLogin

List<org.squashtest.tm.domain.users.User> findAllUsersOrderedByLogin()

findAllActiveUsersOrderedByLogin

List<org.squashtest.tm.domain.users.User> findAllActiveUsersOrderedByLogin()

findAllUsersFiltered

org.squashtest.tm.core.foundation.collection.PagedCollectionHolder<List<org.squashtest.tm.domain.users.User>> findAllUsersFiltered(org.squashtest.tm.core.foundation.collection.PagingAndSorting sorter,
                                                                                                                                 org.squashtest.tm.core.foundation.collection.Filtering filter)

addUser

void addUser(org.squashtest.tm.domain.users.User aUser,
           long groupId,
           String password)

setUserGroupAuthority

void setUserGroupAuthority(long userId,
                         long groupId)

resetUserPassword

void resetUserPassword(long userId,
                     String newPassword)

deactivateUser

void deactivateUser(long userId)

activateUser

void activateUser(long userId)

deactivateUsers

void deactivateUsers(Collection<Long> userIds)

activateUsers

void activateUsers(Collection<Long> userIds)

deleteUsers

void deleteUsers(Collection<Long> userIds)

deassociateTeams

void deassociateTeams(long userId,
                    List<Long> teamIds)

Will remove user from teams members lists.
access restricted to admins

Parameters:

userId - : the id of the concerned User

teamIds - : ids of Teams to remove user from.

findSortedAssociatedTeams

org.squashtest.tm.core.foundation.collection.PagedCollectionHolder<List<org.squashtest.tm.domain.users.Team>> findSortedAssociatedTeams(long userId,
                                                                                                                                      org.squashtest.tm.core.foundation.collection.PagingAndSorting paging,
                                                                                                                                      org.squashtest.tm.core.foundation.collection.Filtering filtering)

Will return an paged and filtered list of Teams that have the concerned user as a member.
access restricted to admins

Parameters:

userId - : the id of the concerned user

paging - : the PagingAndSorting criteria that the result has to match

filtering - : the Filtering criteria that the result has to match

Returns:

findAllNonAssociatedTeams

List<org.squashtest.tm.domain.users.Team> findAllNonAssociatedTeams(long userId)

Will return a list of all Team that do not have the concerned User as a member
access restricted to admins

Parameters:

userId - : the id of the concerned User

Returns:

the list of all non associated Teams

createUserFromLogin

org.squashtest.tm.domain.users.User createUserFromLogin(@NotNull
                                                      String login)

Creates a stub User using the given login and returns it. This should throw an exception when the user already exists.

Returns:

the new User

Throws:

org.squashtest.tm.exception.user.LoginAlreadyExistsException - when user already exists

createUserWithoutCredentials

void createUserWithoutCredentials(org.squashtest.tm.domain.users.User user,
                                long groupId)

Creates a user without credentials. This should be used when authentication is managed by an external provider only.

Parameters:

user -

groupId -

createAuthentication

void createAuthentication(long userId,
                        String newPassword)
                          throws org.squashtest.tm.exception.user.LoginAlreadyExistsException

Creates authentication data for given user.

Parameters:

userId -

newPassword -

Throws:

org.squashtest.tm.exception.user.LoginAlreadyExistsException - when authentication data already exixts

findAllAdminOrManager

List<org.squashtest.tm.domain.users.User> findAllAdminOrManager()

findAllUsersGroupOrderedByQualifiedName

List<org.squashtest.tm.domain.users.UsersGroup> findAllUsersGroupOrderedByQualifiedName()

createAdministrator

org.squashtest.tm.domain.users.User createAdministrator(org.squashtest.tm.domain.users.User user,
                                                      String password)

Creates a user with the given password. This new user shall have the ROLE_ADMIN role. This method should not have any security constraint because we might need it to provision the authentication system (ie there is no user yet).

Parameters:

user -

password -

checkLoginAvailability

void checkLoginAvailability(String login)

Checks if a user already exist with the same login in the database.
If so, raises a LoginAlreadyExistsException The login is checked according to the state of the case-sensitivity feature.

Parameters:

login -

findAllDuplicateLogins

List<String> findAllDuplicateLogins()

Logins are considered as duplicate when they are equal without case-sensitivity.

Returns:

the list of duplicate logins / username