AdminUserHome.java
/*
* Copyright (c) 2002-2022, City of Paris
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright notice
* and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice
* and the following disclaimer in the documentation and/or other materials
* provided with the distribution.
*
* 3. Neither the name of 'Mairie de Paris' nor 'Lutece' nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* License 1.0
*/
package fr.paris.lutece.portal.business.user;
import fr.paris.lutece.portal.business.rbac.RBACRole;
import fr.paris.lutece.portal.business.right.Right;
import fr.paris.lutece.portal.business.user.authentication.LuteceDefaultAdminUser;
import fr.paris.lutece.portal.service.spring.SpringContextService;
import fr.paris.lutece.portal.service.util.CryptoService;
import fr.paris.lutece.util.password.IPassword;
import java.sql.Timestamp;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Map;
/**
* This class provides instances management methods (create, find, ...) for AdminUser objects
*/
public final class AdminUserHome
{
// Static variable pointed at the DAO instance
private static IAdminUserDAO _dao = SpringContextService.getBean( "adminUserDAO" );
/**
* Private constructor
*/
private AdminUserHome( )
{
}
/**
* Get the user infos from the access code.
*
* @param strUserLogin
* the login
* @return user info
*/
public static AdminUser findUserByLogin( String strUserLogin )
{
return _dao.selectUserByAccessCode( strUserLogin );
}
/**
* Get the user infos from the access code.
*
* @param strUserLogin
* the login
* @param user the user to load
* @return user info
*/
public static <T extends AdminUser> T findUserByLogin( String strUserLogin,T user )
{
return _dao.selectUserByAccessCode( strUserLogin ,user);
}
/**
* Get the user access code from its email.
*
* @param strEmail
* The email
* @return The access code of the user with the given email, or null if no user has been found
*/
public static String findUserByEmail( String strEmail )
{
return _dao.selectUserByEmail( strEmail );
}
/**
* Get the user infos from user id
*
* @param nUserId
* the user identifier
* @return The user
*/
public static AdminUser findByPrimaryKey( int nUserId )
{
return _dao.load( nUserId );
}
/**
* @return the user list
*/
public static Collection<AdminUser> findUserList( )
{
return _dao.selectUserList( );
}
/**
* @param user
* The AdminUser
*/
public static void create( AdminUser user )
{
_dao.insert( user );
}
/**
* @param user
* The AdminUser
*/
public static void update( AdminUser user )
{
_dao.store( user );
}
/**
* @param nUserId
* the user identifier
*/
public static void remove( int nUserId )
{
_dao.delete( nUserId );
}
/**
* Get the right list associated to a given user id
*
* @param nUserId
* the id of the user to retrieve rights
* @return the right list
*/
public static Map<String, Right> getRightsListForUser( int nUserId )
{
return _dao.selectRightsListForUser( nUserId );
}
/**
* @param nUserId
* The user identifier
* @param strRightId
* The right identifier
*/
public static void createRightForUser( int nUserId, String strRightId )
{
_dao.insertRightsListForUser( nUserId, strRightId );
}
/**
* @param nUserId
* The user identifier
*/
public static void removeAllRightsForUser( int nUserId )
{
_dao.deleteAllRightsForUser( nUserId );
}
/**
* @param user
* The Admin User object
*/
public static void removeAllDelegatedRightsForUser( AdminUser user )
{
_dao.deleteAllDelegatedRightsForUser( user.getUserId( ), user.getUserLevel( ) );
}
/**
* @param user
* The Admin User object
*/
public static void removeAllOwnRightsForUser( AdminUser user )
{
_dao.deleteAllOwnRightsForUser( user.getUserId( ), user.getUserLevel( ) );
}
/**
* Get the role list associated to a given user id
*
* @param nUserId
* the id of the user to retrieve rights
* @return the role list
*/
public static Map<String, RBACRole> getRolesListForUser( int nUserId )
{
return _dao.selectRolesListForUser( nUserId );
}
/**
* @param nUserId
* the id of the user
* @param strRightId
* the right identifier
*/
public static void createRoleForUser( int nUserId, String strRightId )
{
_dao.insertRolesListForUser( nUserId, strRightId );
}
/**
* @param nUserId
* the user identifier
*/
public static void removeAllRolesForUser( int nUserId )
{
_dao.deleteAllRolesForUser( nUserId );
}
/**
* Checks wether the role is in use or not
*
* @param strRoleKey
* the role key to check
* @return true if the role is attributed, false otherwise
*/
public static boolean checkRoleAttributed( String strRoleKey )
{
return _dao.checkRoleAttributed( strRoleKey );
}
/**
* Checks if a given login is already in use
*
* @param strAccessCode
* The login
* @return user ID if the access code is already used by another user, -1 otherwise
*/
public static int checkAccessCodeAlreadyInUse( String strAccessCode )
{
return _dao.checkAccessCodeAlreadyInUse( strAccessCode );
}
/**
* Checks if a given email is already in use
*
* @param strEmail
* The email
* @return user ID if the email is already used by another user, -1 otherwise
*/
public static int checkEmailAlreadyInUse( String strEmail )
{
return _dao.checkEmailAlreadyInUse( strEmail );
}
/**
* Check if the user has the role
*
* @param user
* The AdminUser
* @param strRoleKey
* The role Key
* @return true if the user has the role
*/
public static boolean hasRole( AdminUser user, String strRoleKey )
{
return _dao.hasRole( user.getUserId( ), strRoleKey );
}
/**
* Remove role for an user
*
* @param nUserId
* The ID of the user
* @param strRoleKey
* The role key
*/
public static void removeRoleForUser( int nUserId, String strRoleKey )
{
_dao.deleteRoleForUser( nUserId, strRoleKey );
}
// ////////////////////////////////////////////////////////////////
// / for no-module mode
/**
* @param user
* the LuteceDefaultAdminUSer
*/
public static void create( LuteceDefaultAdminUser user )
{
_dao.insert( user );
}
/**
* @param user
* the LuteceDefaultAdminUSer
*/
public static void update( LuteceDefaultAdminUser user )
{
update( user, PasswordUpdateMode.UPDATE );
}
/**
* @param user
* the LuteceDefaultAdminUSer
* @param passwordMode
* should the password be updated or not
*/
public static void update( LuteceDefaultAdminUser user, PasswordUpdateMode passwordMode )
{
_dao.store( user, passwordMode );
}
/**
* Get the user infos from user id
*
* @param nUserId
* the user identifier
* @return the delfault admin user
*/
public static LuteceDefaultAdminUser findLuteceDefaultAdminUserByPrimaryKey( int nUserId )
{
return _dao.loadDefaultAdminUser( nUserId );
}
/**
* Get all users having a given role
*
* @param strRoleKey
* The role key
* @return A collection of AdminUser
*/
public static Collection<AdminUser> findByRole( String strRoleKey )
{
return _dao.selectUsersByRole( strRoleKey );
}
/**
* Get all users having a given level
*
* @param nIdLevel
* The level
* @return A collection of AdminUser
*/
public static Collection<AdminUser> findByLevel( int nIdLevel )
{
return _dao.selectUsersByLevel( nIdLevel );
}
/**
* Update role key if role key name has change
*
* @param strOldRoleKey
* The old role key name
* @param role
* The new role
*/
public static void updateUsersRole( String strOldRoleKey, RBACRole role )
{
_dao.storeUsersRole( strOldRoleKey, role );
}
/**
* Get all users by using a filter.
*
* @param auFilter
* The filter
* @return A collection of AdminUser
*/
public static Collection<AdminUser> findUserByFilter( AdminUserFilter auFilter )
{
return _dao.selectUsersByFilter( auFilter );
}
/**
* Get all users having a given right
*
* @param strIdRight
* The ID right
* @return A collection of AdminUser
*/
public static Collection<AdminUser> findByRight( String strIdRight )
{
return _dao.selectUsersByRight( strIdRight );
}
/**
* Check if the user has the given right
*
* @param user
* The Admin User
* @param strIdRight
* The ID right
* @return true if the user has the right
*/
public static boolean hasRight( AdminUser user, String strIdRight )
{
return _dao.hasRight( user.getUserId( ), strIdRight );
}
/**
* Remove a right for an user
*
* @param nUserId
* The user ID
* @param strIdRight
* The right ID
*/
public static void removeRightForUser( int nUserId, String strIdRight )
{
_dao.deleteRightForUser( nUserId, strIdRight );
}
/**
* Gets the history of password of the given user
*
* @param nUserID
* Id of the user
* @return The collection of recent passwords used by the user.
*/
public static List<IPassword> selectUserPasswordHistory( int nUserID )
{
return _dao.selectUserPasswordHistory( nUserID );
}
/**
* Get the number of password change done by a user since the given date.
*
* @param minDate
* Minimum date to consider.
* @param nUserId
* Id of the user
* @return The number of password change done by the user since the given date.
*/
public static int countUserPasswordHistoryFromDate( Timestamp minDate, int nUserId )
{
return _dao.countUserPasswordHistoryFromDate( minDate, nUserId );
}
/**
* Log a password change in the password history
*
* @param password
* New password of the user
* @param nUserId
* Id of the user
*/
public static void insertNewPasswordInHistory( IPassword password, int nUserId )
{
_dao.insertNewPasswordInHistory( password, nUserId );
}
/**
* Remove every password saved in the password history for a user.
*
* @param nUserId
* Id of the user
*/
public static void removeAllPasswordHistoryForUser( int nUserId )
{
_dao.removeAllPasswordHistoryForUser( nUserId );
}
/**
* Get a map of anonymization status of a user field.
*
* @return A map containing the associations of user field name and a boolean describing whether the field should be anonymized.
*/
public static Map<String, Boolean> getAnonymizationStatusUserStaticField( )
{
return _dao.selectAnonymizationStatusUserStaticField( );
}
/**
* Update the anonymization status of a user field.
*
* @param strFieldName
* Name of the field to update
* @param bAnonymizeFiled
* True if the field should be anonymize, false otherwise
*/
public static void updateAnonymizationStatusUserStaticField( String strFieldName, boolean bAnonymizeFiled )
{
_dao.updateAnonymizationStatusUserStaticField( strFieldName, bAnonymizeFiled );
}
/**
* Get the list of id of user with the expired status.
*
* @return The list of if of user with the expired status.
*/
public static List<Integer> findAllExpiredUserId( )
{
return _dao.findAllExpiredUserId( );
}
/**
* Get the list of id of users that have an expired time life but not the expired status
*
* @param currentTimestamp
* Timestamp describing the current time.
* @return the list of id of users with expired time life
*/
public static List<Integer> getIdUsersWithExpiredLifeTimeList( Timestamp currentTimestamp )
{
return _dao.getIdUsersWithExpiredLifeTimeList( currentTimestamp );
}
/**
* Get the list of id of users that need to receive their first alert
*
* @param firstAlertMaxDate
* The maximum expiration date to send first alert.
* @return the list of id of users that need to receive their first alert
*/
public static List<Integer> getIdUsersToSendFirstAlert( Timestamp firstAlertMaxDate )
{
return _dao.getIdUsersToSendFirstAlert( firstAlertMaxDate );
}
/**
* Get the list of id of users that need to receive their first alert
*
* @param alertMaxDate
* The maximum date to send alerts.
* @param timeBetweenAlerts
* Timestamp describing the time between two alerts.
* @param maxNumberAlerts
* Maximum number of alerts to send to a user
* @return the list of id of users that need to receive their first alert
*/
public static List<Integer> getIdUsersToSendOtherAlert( Timestamp alertMaxDate, Timestamp timeBetweenAlerts, int maxNumberAlerts )
{
return _dao.getIdUsersToSendOtherAlert( alertMaxDate, timeBetweenAlerts, maxNumberAlerts );
}
/**
* Get the list of id of users that have an expired password but not the change password flag
*
* @param currentTimestamp
* Timestamp describing the current time.
* @return the list of id of users with expired passwords
*/
public static List<Integer> getIdUsersWithExpiredPasswordsList( Timestamp currentTimestamp )
{
return _dao.getIdUsersWithExpiredPasswordsList( currentTimestamp );
}
/**
* Update status of a list of user accounts
*
* @param listIdUser
* List of user accounts to update
* @param nNewStatus
* New status of the user
*/
public static void updateUserStatus( List<Integer> listIdUser, int nNewStatus )
{
_dao.updateUserStatus( listIdUser, nNewStatus );
}
/**
* Increment the number of alert send to users by 1
*
* @param listIdUser
* The list of users to update
*/
public static void updateNbAlert( List<Integer> listIdUser )
{
_dao.updateNbAlert( listIdUser );
}
/**
* Set the "change password" flag of users to true
*
* @param listIdUser
* The list of users to update
*/
public static void updateChangePassword( List<Integer> listIdUser )
{
_dao.updateChangePassword( listIdUser );
}
/**
* Update the admin user expiration date with the new values. Also update his alert account to 0
*
* @param nIdUser
* Id of the admin user to update
* @param newExpirationDate
* Id of the user to update
*/
public static void updateUserExpirationDate( int nIdUser, Timestamp newExpirationDate )
{
_dao.updateUserExpirationDate( nIdUser, newExpirationDate );
}
/**
* Update the admin user last login date.
*
* @param nIdUser
* Id of the admin user to update
* @param dateLastLogin
* New last login date of the user
*/
public static void updateDateLastLogin( int nIdUser, Timestamp dateLastLogin )
{
_dao.updateDateLastLogin( nIdUser, dateLastLogin );
}
/**
* Construct a password reset token. Use the numerical userId as it does not change. Use the stored password, so that the token is invalidated if the
* password is changed. Use a timestamp to allow limiting the validity of the token in time. Optionally bind the token to the user session. Finally return
* an HMAC of this info using the application crypto key.
*
* @param nIdUser
* the user ID
* @param timestamp
* the timestamp
* @param strSessionId
* the session ID
* @return the password reset token
*/
public static String getUserPasswordResetToken( int nIdUser, Date timestamp, String strSessionId )
{
LuteceDefaultAdminUser user = _dao.loadDefaultAdminUser( nIdUser );
StringBuilder builder = new StringBuilder( );
builder.append( "userId:" ).append( nIdUser );
IPassword password = user.getPassword( );
if ( password != null )
{
builder.append( ":password:" );
if ( password.isLegacy( ) )
{
builder.append( "legacy" );
}
else
{
builder.append( password.getStorableRepresentation( ) );
}
}
builder.append( ":timestamp:" ).append( timestamp.getTime( ) );
if ( strSessionId != null )
{
builder.append( ":sessionId:" ).append( strSessionId );
}
return CryptoService.hmacSHA256( builder.toString( ) );
}
}