AdminUserDAO.java

  1. /*
  2.  * Copyright (c) 2002-2022, City of Paris
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  *
  9.  *  1. Redistributions of source code must retain the above copyright notice
  10.  *     and the following disclaimer.
  11.  *
  12.  *  2. Redistributions in binary form must reproduce the above copyright notice
  13.  *     and the following disclaimer in the documentation and/or other materials
  14.  *     provided with the distribution.
  15.  *
  16.  *  3. Neither the name of 'Mairie de Paris' nor 'Lutece' nor the names of its
  17.  *     contributors may be used to endorse or promote products derived from
  18.  *     this software without specific prior written permission.
  19.  *
  20.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21.  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23.  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
  24.  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25.  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26.  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27.  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28.  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30.  * POSSIBILITY OF SUCH DAMAGE.
  31.  *
  32.  * License 1.0
  33.  */
  34. package fr.paris.lutece.portal.business.user;

  36. import fr.paris.lutece.portal.business.rbac.RBACRole;
  37. import fr.paris.lutece.portal.business.right.Right;
  38. import fr.paris.lutece.portal.business.user.authentication.LuteceDefaultAdminUser;
  39. import fr.paris.lutece.util.password.IPassword;
  40. import fr.paris.lutece.util.password.IPasswordFactory;
  41. import fr.paris.lutece.util.sql.DAOUtil;

  43. import java.sql.Statement;
  44. import java.sql.Timestamp;
  45. import java.util.ArrayList;
  46. import java.util.Collection;
  47. import java.util.HashMap;
  48. import java.util.List;
  49. import java.util.Locale;
  50. import java.util.Map;

  52. import javax.inject.Inject;

  54. import org.apache.commons.collections.CollectionUtils;

  56. /**
  57.  * This class porvides Data Access methods for AdminUser objects
  58.  */
  59. public class AdminUserDAO implements IAdminUserDAO
  60. {
  61.     // Constants
  62.     private static final String CONSTANT_AND_STATUS = " AND status = ?";
  63.     private static final String CONSTANT_AND_USER_LEVEL = " AND level_user = ?";
  64.     private static final String CONSTANT_ORDER_BY_LAST_NAME = " ORDER BY last_name ";
  65.     private static final String CONSTANT_PERCENT = "%";
  66.     private static final String SQL_QUERY_INSERT = "INSERT INTO core_admin_user ( access_code, last_name , first_name, email, status, locale, level_user, accessibility_mode, password_max_valid_date, account_max_valid_date )  VALUES ( ?, ?, ?, ?, ?, ?, ?, ?, ?, ? ) ";
  67.     private static final String SQL_QUERY_SELECTALL = "SELECT id_user , access_code, last_name , first_name, email, status, locale, level_user, accessibility_mode, reset_password, password_max_valid_date, account_max_valid_date, last_login, workgroup_key FROM core_admin_user ORDER BY last_name ";
  68.     private static final String SQL_QUERY_SELECT_USER_FROM_USER_ID = "SELECT id_user , access_code, last_name , first_name, email, status, password, locale, level_user, reset_password, accessibility_mode, password_max_valid_date, account_max_valid_date, workgroup_key FROM core_admin_user WHERE id_user = ? ";
  69.     private static final String SQL_QUERY_SELECT_USER_FROM_ACCESS_CODE = "SELECT id_user, access_code, last_name, first_name, email, status, locale, level_user, reset_password, accessibility_mode, password_max_valid_date, last_login FROM core_admin_user  WHERE access_code = ? ";
  70.     private static final String SQL_QUERY_SELECT_USER_FROM_EMAIL = "SELECT access_code FROM core_admin_user  WHERE email = ? ";
  71.     private static final String SQL_QUERY_SELECT_RIGHTS_FROM_USER_ID = " SELECT a.id_right , a.name, a.admin_url , a.description , a.plugin_name, a.id_feature_group, a.icon_url, a.level_right, a.documentation_url, a.id_order, a.is_external_feature "
  72.             + " FROM core_admin_right a , core_user_right b " + " WHERE a.id_right = b.id_right " + " AND b.id_user = ? "
  73.             + " ORDER BY a.id_order ASC, a.id_right ASC ";
  74.     private static final String SQL_QUERY_UPDATE = "UPDATE core_admin_user SET access_code = ? , last_name = ? , first_name = ?, email = ?, status = ?, locale = ?, reset_password = ?, accessibility_mode = ?, password_max_valid_date = ?, level_user = ? WHERE id_user = ?  ";
  75.     private static final String SQL_QUERY_DELETE = "DELETE FROM core_admin_user WHERE id_user = ? ";
  76.     private static final String SQL_QUERY_INSERT_USER_RIGHT = "INSERT INTO core_user_right ( id_right, id_user )  VALUES ( ? , ? ) ";
  77.     private static final String SQL_QUERY_DELETE_ALL_USER_RIGHTS = "DELETE FROM core_user_right WHERE id_user = ? ";
  78.     private static final String SQL_QUERY_SELECT_ROLES_FROM_USER_ID = " SELECT a.role_key , a.role_description "
  79.             + " FROM core_admin_role a , core_user_role b WHERE a.role_key = b.role_key " + " AND b.id_user = ?  ORDER BY a.role_key ";
  80.     private static final String SQL_QUERY_INSERT_USER_ROLE = " INSERT INTO core_user_role ( role_key, id_user )  VALUES ( ? , ? ) ";
  81.     private static final String SQL_QUERY_DELETE_ALL_USER_ROLES = " DELETE FROM core_user_role WHERE id_user = ? ";
  82.     private static final String SQL_CHECK_ROLE_ATTRIBUTED = " SELECT id_user FROM core_user_role WHERE role_key = ?";
  83.     private static final String SQL_CHECK_ACCESS_CODE_IN_USE = " SELECT id_user FROM core_admin_user WHERE access_code = ?";
  84.     private static final String SQL_CHECK_EMAIL_IN_USE = " SELECT id_user FROM core_admin_user WHERE email = ?";
  85.     private static final String SQL_QUERY_INSERT_DEFAULT_USER = " INSERT INTO core_admin_user ( access_code, last_name, first_name, email, status, password, locale, level_user, accessibility_mode, reset_password, password_max_valid_date, account_max_valid_date, last_login, workgroup_key )  VALUES ( ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? ) ";
  86.     private static final String SQL_QUERY_UPDATE_DEFAULT_USER = " UPDATE core_admin_user SET access_code = ?, last_name = ?, first_name = ?, email = ?, status = ?, password = ?, locale = ?, reset_password = ?, accessibility_mode = ?, password_max_valid_date = ?, workgroup_key = ?, level_user = ? WHERE id_user = ?  ";
  87.     private static final String SQL_QUERY_UPDATE_DEFAULT_USER_IGNORE_PASSWORD = " UPDATE core_admin_user SET access_code = ?, last_name = ?, first_name = ?, email = ?, status = ?, locale = ?, reset_password = ?, accessibility_mode = ?, password_max_valid_date = ?, workgroup_key = ?, level_user = ?  WHERE id_user = ?  ";
  88.     private static final String SQL_QUERY_SELECT_USERS_ID_BY_ROLES = " SELECT a.id_user , a.access_code, a.last_name , a.first_name, a.email, a.status, a.locale, a.accessibility_mode, a.password_max_valid_date "
  89.             + " FROM core_admin_user a, core_user_role b WHERE a.id_user = b.id_user AND b.role_key = ? ";
  90.     private static final String SQL_QUERY_SELECT_USER_RIGHTS_OWN = " SELECT DISTINCT b.id_right FROM core_admin_right a , core_user_right b WHERE b.id_user = ? and a.id_right = b.id_right and a.level_right >= ?";
  91.     private static final String SQL_QUERY_SELECT_USER_RIGHTS_DELEGATED = " SELECT DISTINCT b.id_right FROM core_admin_right a , core_user_right b WHERE b.id_user = ? and a.id_right = b.id_right and a.level_right < ?";
  92.     private static final String SQL_QUERY_DELETE_USER_RIGHTS = " DELETE FROM core_user_right WHERE id_user = ? and id_right = ?";
  93.     private static final String SQL_QUERY_SELECT_USERS_BY_LEVEL = " SELECT a.id_user, a.access_code, a.last_name, a.first_name, a.email, a.status, a.locale, a.accessibility_mode "
  94.             + " FROM core_admin_user a WHERE a.level_user = ? ";
  95.     private static final String SQL_QUERY_UPDATE_USERS_ROLE = "UPDATE core_user_role SET role_key = ? WHERE role_key = ?";
  96.     private static final String SQL_QUERY_SELECT_USER_ROLE = " SELECT id_user FROM core_user_role WHERE id_user = ? AND role_key = ? ";
  97.     private static final String SQL_QUERY_DELETE_ROLE_FOR_USER = " DELETE FROM core_user_role WHERE id_user = ? AND role_key = ? ";
  98.     private static final String SQL_QUERY_SELECT_USER_FROM_SEARCH = " SELECT id_user, access_code, last_name, first_name, email, status, locale, level_user, accessibility_mode "
  99.             + " FROM core_admin_user WHERE access_code LIKE ? AND last_name LIKE ? AND email LIKE ? AND first_name LIKE ? ";
  100.     private static final String SQL_QUERY_SELECT_USERS_BY_RIGHT = " SELECT  u.id_user , u.access_code, u.last_name , u.first_name, u.email, u.status, u.locale, u.level_user, u.accessibility_mode "
  101.             + " FROM core_admin_user u INNER JOIN core_user_right r ON u.id_user = r.id_user WHERE r.id_right = ? ";
  102.     private static final String SQL_QUERY_SELECT_USER_RIGHT = " SELECT id_user FROM core_user_right WHERE id_user = ? AND id_right = ? ";
  103.     private static final String SQL_SELECT_USER_PASSWORD_HISTORY = "SELECT password FROM core_user_password_history WHERE id_user = ? ORDER BY date_password_change desc";
  104.     private static final String SQL_COUNT_USER_PASSWORD_HISTORY = "SELECT COUNT(*) FROM core_user_password_history WHERE id_user = ? AND date_password_change > ?";
  105.     private static final String SQL_INSERT_PASSWORD_HISTORY = "INSERT INTO core_user_password_history (id_user, password) VALUES ( ?, ? ) ";
  106.     private static final String SQL_DELETE_PASSWORD_HISTORY = "DELETE FROM core_user_password_history WHERE id_user = ?";
  107.     private static final String SQL_SELECT_ANONYMIZATION_STATUS_USER_FILED = "SELECT field_name, anonymize from core_admin_user_anonymize_field";
  108.     private static final String SQL_UPDATE_ANONYMIZATION_STATUS_USER_FILED = "UPDATE core_admin_user_anonymize_field  SET anonymize = ? WHERE field_name = ? ";
  109.     private static final String SQL_QUERY_SELECT_EXPIRED_USER_ID = "SELECT id_user FROM core_admin_user WHERE status = ?";
  110.     private static final String SQL_QUERY_SELECT_EXPIRED_LIFE_TIME_USER_ID = "SELECT id_user FROM core_admin_user WHERE account_max_valid_date < ? and status < ? ";
  111.     private static final String SQL_QUERY_SELECT_USER_ID_FIRST_ALERT = "SELECT id_user FROM core_admin_user WHERE nb_alerts_sent = 0 and status < ? and account_max_valid_date < ? ";
  112.     private static final String SQL_QUERY_SELECT_USER_ID_OTHER_ALERT = "SELECT id_user FROM core_admin_user "
  113.             + "WHERE nb_alerts_sent > 0 and nb_alerts_sent <= ? and status < ? and (account_max_valid_date + nb_alerts_sent * ?) < ? ";
  114.     private static final String SQL_QUERY_SELECT_USER_ID_PASSWORD_EXPIRED = " SELECT id_user FROM core_admin_user WHERE password_max_valid_date < ? AND reset_password = 0 ";
  115.     private static final String SQL_QUERY_UPDATE_STATUS = " UPDATE core_admin_user SET status = ? WHERE id_user IN ( ";
  116.     private static final String SQL_QUERY_UPDATE_NB_ALERT = " UPDATE core_admin_user SET nb_alerts_sent = nb_alerts_sent + 1 WHERE id_user IN ( ";
  117.     private static final String SQL_QUERY_UPDATE_RESET_PASSWORD_LIST_ID = " UPDATE core_admin_user SET reset_password = 1 WHERE id_user IN ( ";
  118.     private static final String SQL_QUERY_UPDATE_REACTIVATE_ACCOUNT = " UPDATE core_admin_user SET nb_alerts_sent = 0, account_max_valid_date = ? WHERE id_user = ? ";
  119.     private static final String SQL_QUERY_UPDATE_DATE_LAST_LOGIN = " UPDATE core_admin_user SET last_login = ? WHERE id_user = ? ";
  120.     private static final String CONSTANT_CLOSE_PARENTHESIS = " ) ";
  121.     private static final String CONSTANT_COMMA = ", ";

  123.     @Inject
  124.     private IPasswordFactory _passwordFactory;

  126.     /**
  127.      * {@inheritDoc}
  128.      */
  129.     @Override
  130.     public AdminUser load( int nUserId )
  131.     {
  132.         AdminUser user = null;
  133.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_SELECT_USER_FROM_USER_ID ) )
  134.         {
  135.             daoUtil.setInt( 1, nUserId );
  136.             daoUtil.executeQuery( );

  138.             if ( daoUtil.next( ) )
  139.             {
  140.                 user = new AdminUser( );
  141.                 user.setUserId( daoUtil.getInt( 1 ) );
  142.                 user.setAccessCode( daoUtil.getString( 2 ) );
  143.                 user.setLastName( daoUtil.getString( 3 ) );
  144.                 user.setFirstName( daoUtil.getString( 4 ) );
  145.                 user.setEmail( daoUtil.getString( 5 ) );
  146.                 user.setStatus( daoUtil.getInt( 6 ) );
  147.                 user.setLocale( new Locale( daoUtil.getString( 8 ) ) );
  148.                 user.setUserLevel( daoUtil.getInt( 9 ) );
  149.                 user.setPasswordReset( daoUtil.getBoolean( 10 ) );
  150.                 user.setAccessibilityMode( daoUtil.getBoolean( 11 ) );
  151.                 user.setPasswordMaxValidDate( daoUtil.getTimestamp( 12 ) );

  153.                 long accountTime = daoUtil.getLong( 13 );

  155.                 if ( accountTime > 0 )
  156.                 {
  157.                     user.setAccountMaxValidDate( new Timestamp( accountTime ) );
  158.                 }
  159.             }

  161.         }

  163.         return user;
  164.     }

  166.     /**
  167.      * {@inheritDoc}
  168.      */
  169.     @Override
  170.     public AdminUser selectUserByAccessCode( String strUserAccessCode )
  171.     {
  172.         AdminUser user = null;
  173.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_SELECT_USER_FROM_ACCESS_CODE ) )
  174.         {
  175.             daoUtil.setString( 1, strUserAccessCode );
  176.             daoUtil.executeQuery( );

  178.             if ( daoUtil.next( ) )
  179.             {
  180.                 user = new AdminUser( );
  181.                 user.setUserId( daoUtil.getInt( 1 ) );
  182.                 user.setAccessCode( daoUtil.getString( 2 ) );
  183.                 user.setLastName( daoUtil.getString( 3 ) );
  184.                 user.setFirstName( daoUtil.getString( 4 ) );
  185.                 user.setEmail( daoUtil.getString( 5 ) );
  186.                 user.setStatus( daoUtil.getInt( 6 ) );
  187.                 user.setLocale( new Locale( daoUtil.getString( 7 ) ) );
  188.                 user.setUserLevel( daoUtil.getInt( 8 ) );
  189.                 user.setPasswordReset( daoUtil.getBoolean( 9 ) );
  190.                 user.setAccessibilityMode( daoUtil.getBoolean( 10 ) );
  191.                 user.setPasswordMaxValidDate( daoUtil.getTimestamp( 11 ) );

  193.                 Timestamp dateLastLogin = daoUtil.getTimestamp( 12 );

  195.                 if ( ( dateLastLogin != null ) && !dateLastLogin.equals( AdminUser.getDefaultDateLastLogin( ) ) )
  196.                 {
  197.                     user.setDateLastLogin( dateLastLogin );
  198.                 }
  199.             }

  201.         }

  203.         return user;
  204.     }
  205.     
  206.     /**
  207.      * {@inheritDoc}
  208.      */
  209.     @Override
  210.     public <T extends AdminUser> T selectUserByAccessCode(String strUserAccessCode, T user) {
  211.     
  212.         if(user != null)
  213.         {
  214.              try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_SELECT_USER_FROM_ACCESS_CODE ) )
  215.              {
  216.                  daoUtil.setString( 1, strUserAccessCode );
  217.                  daoUtil.executeQuery( );
  218.     
  219.                  if ( daoUtil.next( ) )
  220.                  {
  221.                      user.setUserId( daoUtil.getInt( 1 ) );
  222.                      user.setAccessCode( daoUtil.getString( 2 ) );
  223.                      user.setLastName( daoUtil.getString( 3 ) );
  224.                      user.setFirstName( daoUtil.getString( 4 ) );
  225.                      user.setEmail( daoUtil.getString( 5 ) );
  226.                      user.setStatus( daoUtil.getInt( 6 ) );
  227.                      user.setLocale( new Locale( daoUtil.getString( 7 ) ) );
  228.                      user.setUserLevel( daoUtil.getInt( 8 ) );
  229.                      user.setPasswordReset( daoUtil.getBoolean( 9 ) );
  230.                      user.setAccessibilityMode( daoUtil.getBoolean( 10 ) );
  231.                      user.setPasswordMaxValidDate( daoUtil.getTimestamp( 11 ) );
  232.     
  233.                      Timestamp dateLastLogin = daoUtil.getTimestamp( 12 );
  234.     
  235.                      if ( ( dateLastLogin != null ) && !dateLastLogin.equals( AdminUser.getDefaultDateLastLogin( ) ) )
  236.                      {
  237.                          user.setDateLastLogin( dateLastLogin );
  238.                      }
  239.                  }
  240.                  else
  241.                  {
  242.                      //there is no user in database with  strUserAccessCode the user return must be null
  243.                       user= null;    
  244.                  }
  245.                 
  246.     
  247.              }
  248.         }

  250.          return user;
  251.     }

  253.     /**
  254.      * {@inheritDoc}
  255.      */
  256.     @Override
  257.     public String selectUserByEmail( String strEmail )
  258.     {
  259.         String strAccessCode = null;
  260.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_SELECT_USER_FROM_EMAIL ) )
  261.         {
  262.             daoUtil.setString( 1, strEmail );
  263.             daoUtil.executeQuery( );

  265.             if ( daoUtil.next( ) )
  266.             {
  267.                 strAccessCode = daoUtil.getString( 1 );
  268.             }

  270.         }

  272.         return strAccessCode;
  273.     }

  275.     /**
  276.      * {@inheritDoc}
  277.      */
  278.     @Override
  279.     public Collection<AdminUser> selectUserList( )
  280.     {
  281.         Collection<AdminUser> userList = new ArrayList<>( );
  282.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_SELECTALL ) )
  283.         {
  284.             daoUtil.executeQuery( );

  286.             while ( daoUtil.next( ) )
  287.             {
  288.                 AdminUser user = new AdminUser( );
  289.                 user.setUserId( daoUtil.getInt( 1 ) );
  290.                 user.setAccessCode( daoUtil.getString( 2 ) );
  291.                 user.setLastName( daoUtil.getString( 3 ) );
  292.                 user.setFirstName( daoUtil.getString( 4 ) );
  293.                 user.setEmail( daoUtil.getString( 5 ) );
  294.                 user.setStatus( daoUtil.getInt( 6 ) );
  295.                 user.setLocale( new Locale( daoUtil.getString( 7 ) ) );
  296.                 user.setUserLevel( daoUtil.getInt( 8 ) );
  297.                 user.setAccessibilityMode( daoUtil.getBoolean( 9 ) );
  298.                 user.setPasswordReset( daoUtil.getBoolean( 10 ) );
  299.                 user.setPasswordMaxValidDate( daoUtil.getTimestamp( 11 ) );

  301.                 long accountTime = daoUtil.getLong( 12 );

  303.                 if ( accountTime > 0 )
  304.                 {
  305.                     user.setAccountMaxValidDate( new Timestamp( accountTime ) );
  306.                 }

  308.                 Timestamp dateLastLogin = daoUtil.getTimestamp( 13 );

  310.                 if ( ( dateLastLogin != null ) && !dateLastLogin.equals( AdminUser.getDefaultDateLastLogin( ) ) )
  311.                 {
  312.                     user.setDateLastLogin( dateLastLogin );
  313.                 }

  315.                 user.setWorkgroupKey( daoUtil.getString( 14 ) );
  316.                 userList.add( user );
  317.             }

  319.         }

  321.         return userList;
  322.     }

  324.     /**
  325.      * {@inheritDoc}
  326.      */
  327.     @Override
  328.     public void insert( AdminUser user )
  329.     {
  330.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_INSERT, Statement.RETURN_GENERATED_KEYS ) )
  331.         {
  332.             int nIndex = 1;
  333.             daoUtil.setString( nIndex++, user.getAccessCode( ) );
  334.             daoUtil.setString( nIndex++, user.getLastName( ) );
  335.             daoUtil.setString( nIndex++, user.getFirstName( ) );
  336.             daoUtil.setString( nIndex++, user.getEmail( ) );
  337.             daoUtil.setInt( nIndex++, user.getStatus( ) );
  338.             daoUtil.setString( nIndex++, user.getLocale( ).toString( ) );
  339.             daoUtil.setInt( nIndex++, user.getUserLevel( ) );
  340.             daoUtil.setBoolean( nIndex++, user.getAccessibilityMode( ) );
  341.             daoUtil.setTimestamp( nIndex++, user.getPasswordMaxValidDate( ) );

  343.             if ( user.getAccountMaxValidDate( ) == null )
  344.             {
  345.                 daoUtil.setLongNull( nIndex );
  346.             }
  347.             else
  348.             {
  349.                 daoUtil.setLong( nIndex, user.getAccountMaxValidDate( ).getTime( ) );
  350.             }

  352.             daoUtil.executeUpdate( );

  354.             if ( daoUtil.nextGeneratedKey( ) )
  355.             {
  356.                 user.setUserId( daoUtil.getGeneratedKeyInt( 1 ) );
  357.             }
  358.         }
  359.     }

  361.     /**
  362.      * {@inheritDoc}
  363.      */
  364.     @Override
  365.     public void store( AdminUser user )
  366.     {
  367.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_UPDATE ) )
  368.         {

  370.             daoUtil.setString( 1, user.getAccessCode( ) );
  371.             daoUtil.setString( 2, user.getLastName( ) );
  372.             daoUtil.setString( 3, user.getFirstName( ) );
  373.             daoUtil.setString( 4, user.getEmail( ) );
  374.             daoUtil.setInt( 5, user.getStatus( ) );
  375.             daoUtil.setString( 6, user.getLocale( ).toString( ) );
  376.             daoUtil.setBoolean( 7, user.isPasswordReset( ) );
  377.             daoUtil.setBoolean( 8, user.getAccessibilityMode( ) );
  378.             daoUtil.setTimestamp( 9, user.getPasswordMaxValidDate( ) );
  379.             daoUtil.setInt( 10, user.getUserLevel( ) );

  381.             daoUtil.setInt( 11, user.getUserId( ) );

  383.             daoUtil.executeUpdate( );
  384.         }
  385.     }

  387.     /**
  388.      * {@inheritDoc}
  389.      */
  390.     @Override
  391.     public void delete( int nUserId )
  392.     {
  393.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_DELETE ) )
  394.         {
  395.             daoUtil.setInt( 1, nUserId );
  396.             daoUtil.executeUpdate( );
  397.         }
  398.     }

  400.     /**
  401.      * {@inheritDoc}
  402.      */
  403.     @Override
  404.     public Map<String, Right> selectRightsListForUser( int nUserId )
  405.     {
  406.         Map<String, Right> rightsMap = new HashMap<>( );

  408.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_SELECT_RIGHTS_FROM_USER_ID ) )
  409.         {
  410.             daoUtil.setInt( 1, nUserId );
  411.             daoUtil.executeQuery( );

  413.             while ( daoUtil.next( ) )
  414.             {
  415.                 Right right = new Right( );
  416.                 right.setId( daoUtil.getString( 1 ) );
  417.                 right.setNameKey( daoUtil.getString( 2 ) );
  418.                 right.setUrl( daoUtil.getString( 3 ) );
  419.                 right.setDescriptionKey( daoUtil.getString( 4 ) );
  420.                 right.setPluginName( daoUtil.getString( 5 ) );
  421.                 right.setFeatureGroup( daoUtil.getString( 6 ) );
  422.                 right.setIconUrl( daoUtil.getString( 7 ) );
  423.                 right.setLevel( daoUtil.getInt( 8 ) );
  424.                 right.setDocumentationUrl( daoUtil.getString( 9 ) );
  425.                 right.setOrder( daoUtil.getInt( 10 ) );
  426.                 right.setExternalFeature( daoUtil.getBoolean( 11 ) );
  427.                 rightsMap.put( right.getId( ), right );
  428.             }

  430.         }

  432.         return rightsMap;
  433.     }

  435.     /**
  436.      * {@inheritDoc}
  437.      */
  438.     @Override
  439.     public void insertRightsListForUser( int nUserId, String strRightId )
  440.     {
  441.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_INSERT_USER_RIGHT ) )
  442.         {
  443.             daoUtil.setString( 1, strRightId );
  444.             daoUtil.setInt( 2, nUserId );
  445.             daoUtil.executeUpdate( );
  446.         }
  447.     }

  449.     /**
  450.      * {@inheritDoc}
  451.      */
  452.     @Override
  453.     public void deleteAllRightsForUser( int nUserId )
  454.     {
  455.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_DELETE_ALL_USER_RIGHTS ) )
  456.         {
  457.             daoUtil.setInt( 1, nUserId );
  458.             daoUtil.executeUpdate( );
  459.         }
  460.     }

  462.     /**
  463.      * {@inheritDoc}
  464.      */
  465.     @Override
  466.     public Map<String, RBACRole> selectRolesListForUser( int nUserId )
  467.     {
  468.         Map<String, RBACRole> rolesMap = new HashMap<>( );

  470.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_SELECT_ROLES_FROM_USER_ID ) )
  471.         {
  472.             daoUtil.setInt( 1, nUserId );
  473.             daoUtil.executeQuery( );

  475.             while ( daoUtil.next( ) )
  476.             {
  477.                 RBACRole role = new RBACRole( );
  478.                 role.setKey( daoUtil.getString( 1 ) );
  479.                 role.setDescription( daoUtil.getString( 2 ) );

  481.                 rolesMap.put( role.getKey( ), role );
  482.             }

  484.         }

  486.         return rolesMap;
  487.     }

  489.     /**
  490.      * {@inheritDoc}
  491.      */
  492.     @Override
  493.     public void insertRolesListForUser( int nUserId, String strRoleKey )
  494.     {
  495.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_INSERT_USER_ROLE ) )
  496.         {
  497.             daoUtil.setString( 1, strRoleKey );
  498.             daoUtil.setInt( 2, nUserId );
  499.             daoUtil.executeUpdate( );
  500.         }
  501.     }

  503.     /**
  504.      * {@inheritDoc}
  505.      */
  506.     @Override
  507.     public void deleteAllRolesForUser( int nUserId )
  508.     {
  509.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_DELETE_ALL_USER_ROLES ) )
  510.         {
  511.             daoUtil.setInt( 1, nUserId );
  512.             daoUtil.executeUpdate( );
  513.         }
  514.     }

  516.     /**
  517.      * {@inheritDoc}
  518.      */
  519.     @Override
  520.     public boolean checkRoleAttributed( String strRoleKey )
  521.     {
  522.         boolean bInUse = false;

  524.         try ( DAOUtil daoUtil = new DAOUtil( SQL_CHECK_ROLE_ATTRIBUTED ) )
  525.         {
  526.             daoUtil.setString( 1, strRoleKey );
  527.             daoUtil.executeQuery( );

  529.             if ( daoUtil.next( ) )
  530.             {
  531.                 bInUse = true;
  532.             }

  534.         }

  536.         return bInUse;
  537.     }

  539.     /**
  540.      * {@inheritDoc}
  541.      */
  542.     @Override
  543.     public int checkAccessCodeAlreadyInUse( String strAccessCode )
  544.     {
  545.         int nIdUser = -1;
  546.         try ( DAOUtil daoUtil = new DAOUtil( SQL_CHECK_ACCESS_CODE_IN_USE ) )
  547.         {
  548.             daoUtil.setString( 1, strAccessCode );
  549.             daoUtil.executeQuery( );

  551.             if ( daoUtil.next( ) )
  552.             {
  553.                 nIdUser = daoUtil.getInt( 1 );
  554.             }

  556.         }

  558.         return nIdUser;
  559.     }

  561.     /**
  562.      * {@inheritDoc}
  563.      */
  564.     @Override
  565.     public int checkEmailAlreadyInUse( String strEmail )
  566.     {
  567.         int nIdUser = -1;
  568.         try ( DAOUtil daoUtil = new DAOUtil( SQL_CHECK_EMAIL_IN_USE ) )
  569.         {
  570.             daoUtil.setString( 1, strEmail );
  571.             daoUtil.executeQuery( );

  573.             if ( daoUtil.next( ) )
  574.             {
  575.                 nIdUser = daoUtil.getInt( 1 );
  576.             }

  578.         }

  580.         return nIdUser;
  581.     }

  583.     // ////////////////////////////////////////////////////////////////
  584.     // for no-module mode
  585.     /**
  586.      * {@inheritDoc}
  587.      */
  588.     @Override
  589.     public void insert( LuteceDefaultAdminUser user )
  590.     {
  591.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_INSERT_DEFAULT_USER, Statement.RETURN_GENERATED_KEYS ) )
  592.         {
  593.             int nIndex = 1;
  594.             daoUtil.setString( nIndex++, user.getAccessCode( ) );
  595.             daoUtil.setString( nIndex++, user.getLastName( ) );
  596.             daoUtil.setString( nIndex++, user.getFirstName( ) );
  597.             daoUtil.setString( nIndex++, user.getEmail( ) );
  598.             daoUtil.setInt( nIndex++, user.getStatus( ) );
  599.             daoUtil.setString( nIndex++, user.getPassword( ).getStorableRepresentation( ) );
  600.             daoUtil.setString( nIndex++, user.getLocale( ).toString( ) );
  601.             daoUtil.setInt( nIndex++, user.getUserLevel( ) );
  602.             daoUtil.setBoolean( nIndex++, user.getAccessibilityMode( ) );
  603.             daoUtil.setBoolean( nIndex++, user.isPasswordReset( ) );
  604.             daoUtil.setTimestamp( nIndex++, user.getPasswordMaxValidDate( ) );

  606.             if ( user.getAccountMaxValidDate( ) == null )
  607.             {
  608.                 daoUtil.setLongNull( nIndex++ );
  609.             }
  610.             else
  611.             {
  612.                 daoUtil.setLong( nIndex++, user.getAccountMaxValidDate( ).getTime( ) );
  613.             }

  615.             daoUtil.setTimestamp( nIndex++, user.getDateLastLogin( ) );
  616.             daoUtil.setString( nIndex, user.getWorkgroupKey( ) );
  617.             daoUtil.executeUpdate( );

  619.             if ( daoUtil.nextGeneratedKey( ) )
  620.             {
  621.                 user.setUserId( daoUtil.getGeneratedKeyInt( 1 ) );
  622.             }
  623.         }
  624.     }

  626.     /**
  627.      * {@inheritDoc}
  628.      */
  629.     @Override
  630.     public void store( LuteceDefaultAdminUser user, PasswordUpdateMode passwordMode )
  631.     {
  632.         String query = SQL_QUERY_UPDATE_DEFAULT_USER_IGNORE_PASSWORD;
  633.         if ( PasswordUpdateMode.UPDATE.equals( passwordMode ) )
  634.         {
  635.             query = SQL_QUERY_UPDATE_DEFAULT_USER;
  636.         }
  637.         try ( DAOUtil daoUtil = new DAOUtil( query ) )
  638.         {

  640.             int nArgIndex = 1;
  641.             daoUtil.setString( nArgIndex++, user.getAccessCode( ) );
  642.             daoUtil.setString( nArgIndex++, user.getLastName( ) );
  643.             daoUtil.setString( nArgIndex++, user.getFirstName( ) );
  644.             daoUtil.setString( nArgIndex++, user.getEmail( ) );
  645.             daoUtil.setInt( nArgIndex++, user.getStatus( ) );
  646.             if ( PasswordUpdateMode.UPDATE.equals( passwordMode ) )
  647.             {
  648.                 daoUtil.setString( nArgIndex++, user.getPassword( ).getStorableRepresentation( ) );
  649.             }
  650.             daoUtil.setString( nArgIndex++, user.getLocale( ).toString( ) );
  651.             daoUtil.setBoolean( nArgIndex++, user.isPasswordReset( ) );
  652.             daoUtil.setBoolean( nArgIndex++, user.getAccessibilityMode( ) );
  653.             daoUtil.setTimestamp( nArgIndex++, user.getPasswordMaxValidDate( ) );
  654.             daoUtil.setString( nArgIndex++, user.getWorkgroupKey( ) );
  655.             daoUtil.setInt( nArgIndex++, user.getUserLevel( ) );

  657.             daoUtil.setInt( nArgIndex++, user.getUserId( ) );

  659.             daoUtil.executeUpdate( );
  660.         }
  661.     }

  663.     /**
  664.      * {@inheritDoc}
  665.      */
  666.     @Override
  667.     public LuteceDefaultAdminUser loadDefaultAdminUser( int nUserId )
  668.     {
  669.         LuteceDefaultAdminUser user = new LuteceDefaultAdminUser( );
  670.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_SELECT_USER_FROM_USER_ID ) )
  671.         {
  672.             daoUtil.setInt( 1, nUserId );
  673.             daoUtil.executeQuery( );

  675.             if ( daoUtil.next( ) )
  676.             {
  677.                 user.setUserId( daoUtil.getInt( 1 ) );
  678.                 user.setAccessCode( daoUtil.getString( 2 ) );
  679.                 user.setLastName( daoUtil.getString( 3 ) );
  680.                 user.setFirstName( daoUtil.getString( 4 ) );
  681.                 user.setEmail( daoUtil.getString( 5 ) );
  682.                 user.setStatus( daoUtil.getInt( 6 ) );
  683.                 user.setPassword( _passwordFactory.getPassword( daoUtil.getString( 7 ) ) );

  685.                 Locale locale = new Locale( daoUtil.getString( 8 ) );
  686.                 user.setLocale( locale );
  687.                 user.setUserLevel( daoUtil.getInt( 9 ) );
  688.                 user.setPasswordReset( daoUtil.getBoolean( 10 ) );
  689.                 user.setAccessibilityMode( daoUtil.getBoolean( 11 ) );
  690.                 user.setWorkgroupKey( daoUtil.getString( 14 ) );
  691.             }
  692.         }

  694.         return user;
  695.     }

  697.     /**
  698.      * {@inheritDoc}
  699.      */
  700.     @Override
  701.     public Collection<AdminUser> selectUsersByRole( String strRoleKey )
  702.     {
  703.         Collection<AdminUser> userList = new ArrayList<>( );
  704.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_SELECT_USERS_ID_BY_ROLES ) )
  705.         {
  706.             daoUtil.setString( 1, strRoleKey );
  707.             daoUtil.executeQuery( );

  709.             while ( daoUtil.next( ) )
  710.             {
  711.                 AdminUser user = new AdminUser( );
  712.                 user.setUserId( daoUtil.getInt( 1 ) );
  713.                 user.setAccessCode( daoUtil.getString( 2 ) );
  714.                 user.setLastName( daoUtil.getString( 3 ) );
  715.                 user.setFirstName( daoUtil.getString( 4 ) );
  716.                 user.setEmail( daoUtil.getString( 5 ) );
  717.                 user.setStatus( daoUtil.getInt( 6 ) );
  718.                 user.setLocale( new Locale( daoUtil.getString( 7 ) ) );
  719.                 user.setAccessibilityMode( daoUtil.getBoolean( 8 ) );
  720.                 user.setPasswordMaxValidDate( daoUtil.getTimestamp( 9 ) );
  721.                 userList.add( user );
  722.             }

  724.         }

  726.         return userList;
  727.     }

  729.     /**
  730.      * {@inheritDoc}
  731.      */
  732.     @Override
  733.     public Collection<AdminUser> selectUsersByLevel( int nIdLevel )
  734.     {
  735.         Collection<AdminUser> userList = new ArrayList<>( );
  736.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_SELECT_USERS_BY_LEVEL ) )
  737.         {
  738.             daoUtil.setInt( 1, nIdLevel );
  739.             daoUtil.executeQuery( );

  741.             while ( daoUtil.next( ) )
  742.             {
  743.                 AdminUser user = new AdminUser( );
  744.                 user.setUserId( daoUtil.getInt( 1 ) );
  745.                 user.setAccessCode( daoUtil.getString( 2 ) );
  746.                 user.setLastName( daoUtil.getString( 3 ) );
  747.                 user.setFirstName( daoUtil.getString( 4 ) );
  748.                 user.setEmail( daoUtil.getString( 5 ) );
  749.                 user.setStatus( daoUtil.getInt( 6 ) );
  750.                 user.setLocale( new Locale( daoUtil.getString( 7 ) ) );
  751.                 user.setAccessibilityMode( daoUtil.getBoolean( 8 ) );
  752.                 userList.add( user );
  753.             }

  755.         }

  757.         return userList;
  758.     }

  760.     /**
  761.      * Select rights by user, by user level and by type (Delegated or own)
  762.      *
  763.      * @param nUserId
  764.      *            the id of the user
  765.      * @param nUserLevel
  766.      *            the id of the user level
  767.      * @param bDelegated
  768.      *            true if select concern delegated rights
  769.      * @return collection of id rights
  770.      */
  771.     private Collection<String> selectIdRights( int nUserId, int nUserLevel, boolean bDelegated )
  772.     {
  773.         String strSqlQuery = bDelegated ? SQL_QUERY_SELECT_USER_RIGHTS_DELEGATED : SQL_QUERY_SELECT_USER_RIGHTS_OWN;
  774.         Collection<String> idRightList = new ArrayList<>( );
  775.         try ( DAOUtil daoUtil = new DAOUtil( strSqlQuery ) )
  776.         {
  777.             daoUtil.setInt( 1, nUserId );
  778.             daoUtil.setInt( 2, nUserLevel );
  779.             daoUtil.executeQuery( );

  781.             while ( daoUtil.next( ) )
  782.             {
  783.                 idRightList.add( daoUtil.getString( 1 ) );
  784.             }

  786.         }

  788.         return idRightList;
  789.     }

  791.     /**
  792.      * Deletes rights by user and by id right
  793.      *
  794.      * @param nUserId
  795.      *            the user id
  796.      * @param idRightList
  797.      *            the list of rights to delete
  798.      */
  799.     private void deleteRightsForUser( int nUserId, Collection<String> idRightList )
  800.     {
  801.         for ( String strIdRight : idRightList )
  802.         {
  803.             try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_DELETE_USER_RIGHTS ) )
  804.             {
  805.                 daoUtil.setInt( 1, nUserId );
  806.                 daoUtil.setString( 2, strIdRight );
  807.                 daoUtil.executeUpdate( );
  808.             }
  809.         }
  810.     }

  812.     /**
  813.      * {@inheritDoc}
  814.      */
  815.     @Override
  816.     public void deleteAllOwnRightsForUser( int nUserId, int nUserLevel )
  817.     {
  818.         Collection<String> idRightList = selectIdRights( nUserId, nUserLevel, false );

  820.         deleteRightsForUser( nUserId, idRightList );
  821.     }

  823.     /**
  824.      * {@inheritDoc}
  825.      */
  826.     @Override
  827.     public void deleteAllDelegatedRightsForUser( int nUserId, int nUserLevel )
  828.     {
  829.         Collection<String> idRightList = selectIdRights( nUserId, nUserLevel, true );

  831.         deleteRightsForUser( nUserId, idRightList );
  832.     }

  834.     /**
  835.      * {@inheritDoc}
  836.      */
  837.     @Override
  838.     public void storeUsersRole( String strOldRoleKey, RBACRole role )
  839.     {
  840.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_UPDATE_USERS_ROLE ) )
  841.         {
  842.             daoUtil.setString( 1, role.getKey( ) );
  843.             daoUtil.setString( 2, strOldRoleKey );

  845.             daoUtil.executeUpdate( );
  846.         }
  847.     }

  849.     /**
  850.      * {@inheritDoc}
  851.      */
  852.     @Override
  853.     public boolean hasRole( int nUserId, String strRoleKey )
  854.     {
  855.         boolean bHasRole = false;
  856.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_SELECT_USER_ROLE ) )
  857.         {
  858.             daoUtil.setInt( 1, nUserId );
  859.             daoUtil.setString( 2, strRoleKey );
  860.             daoUtil.executeQuery( );

  862.             if ( daoUtil.next( ) )
  863.             {
  864.                 bHasRole = true;
  865.             }

  867.         }

  869.         return bHasRole;
  870.     }

  872.     /**
  873.      * {@inheritDoc}
  874.      */
  875.     @Override
  876.     public void deleteRoleForUser( int nUserId, String strRoleKey )
  877.     {
  878.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_DELETE_ROLE_FOR_USER ) )
  879.         {
  880.             daoUtil.setInt( 1, nUserId );
  881.             daoUtil.setString( 2, strRoleKey );
  882.             daoUtil.executeUpdate( );
  883.         }
  884.     }

  886.     /**
  887.      * {@inheritDoc}
  888.      */
  889.     @Override
  890.     public Collection<AdminUser> selectUsersByFilter( AdminUserFilter auFilter )
  891.     {
  892.         Collection<AdminUser> userList = new ArrayList<>( );

  894.         String query = SQL_QUERY_SELECT_USER_FROM_SEARCH;

  896.         if ( auFilter.getStatus( ) != -1 )
  897.         {
  898.             query += CONSTANT_AND_STATUS;
  899.         }

  901.         if ( auFilter.getUserLevel( ) != -1 )
  902.         {
  903.             query += CONSTANT_AND_USER_LEVEL;
  904.         }

  906.         query += CONSTANT_ORDER_BY_LAST_NAME;

  908.         try ( DAOUtil daoUtil = new DAOUtil( query ) )
  909.         {
  910.             int nIndex = 0;
  911.             daoUtil.setString( ++nIndex, CONSTANT_PERCENT + auFilter.getAccessCode( ) + CONSTANT_PERCENT );
  912.             daoUtil.setString( ++nIndex, CONSTANT_PERCENT + auFilter.getLastName( ) + CONSTANT_PERCENT );
  913.             daoUtil.setString( ++nIndex, CONSTANT_PERCENT + auFilter.getEmail( ) + CONSTANT_PERCENT );
  914.             daoUtil.setString( ++nIndex, CONSTANT_PERCENT + auFilter.getFirstName( ) + CONSTANT_PERCENT );

  916.             if ( auFilter.getStatus( ) != -1 )
  917.             {
  918.                 daoUtil.setInt( ++nIndex, auFilter.getStatus( ) );
  919.             }

  921.             if ( auFilter.getUserLevel( ) != -1 )
  922.             {
  923.                 daoUtil.setInt( ++nIndex, auFilter.getUserLevel( ) );
  924.             }

  926.             daoUtil.executeQuery( );

  928.             while ( daoUtil.next( ) )
  929.             {
  930.                 AdminUser user = new AdminUser( );
  931.                 user.setUserId( daoUtil.getInt( 1 ) );
  932.                 user.setAccessCode( daoUtil.getString( 2 ) );
  933.                 user.setLastName( daoUtil.getString( 3 ) );
  934.                 user.setFirstName( daoUtil.getString( 4 ) );
  935.                 user.setEmail( daoUtil.getString( 5 ) );
  936.                 user.setStatus( daoUtil.getInt( 6 ) );
  937.                 user.setLocale( new Locale( daoUtil.getString( 7 ) ) );
  938.                 user.setUserLevel( daoUtil.getInt( 8 ) );
  939.                 user.setAccessibilityMode( daoUtil.getBoolean( 9 ) );
  940.                 userList.add( user );
  941.             }

  943.         }

  945.         return userList;
  946.     }

  948.     /**
  949.      * {@inheritDoc}
  950.      */
  951.     @Override
  952.     public Collection<AdminUser> selectUsersByRight( String strIdRight )
  953.     {
  954.         Collection<AdminUser> userList = new ArrayList<>( );
  955.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_SELECT_USERS_BY_RIGHT ) )
  956.         {
  957.             daoUtil.setString( 1, strIdRight );
  958.             daoUtil.executeQuery( );

  960.             while ( daoUtil.next( ) )
  961.             {
  962.                 AdminUser user = new AdminUser( );
  963.                 user.setUserId( daoUtil.getInt( 1 ) );
  964.                 user.setAccessCode( daoUtil.getString( 2 ) );
  965.                 user.setLastName( daoUtil.getString( 3 ) );
  966.                 user.setFirstName( daoUtil.getString( 4 ) );
  967.                 user.setEmail( daoUtil.getString( 5 ) );
  968.                 user.setStatus( daoUtil.getInt( 6 ) );
  969.                 user.setLocale( new Locale( daoUtil.getString( 7 ) ) );
  970.                 user.setUserLevel( daoUtil.getInt( 8 ) );
  971.                 user.setAccessibilityMode( daoUtil.getBoolean( 9 ) );
  972.                 userList.add( user );
  973.             }

  975.         }

  977.         return userList;
  978.     }

  980.     /**
  981.      * {@inheritDoc}
  982.      */
  983.     @Override
  984.     public boolean hasRight( int nUserId, String strIdRight )
  985.     {
  986.         boolean bHasRight = false;
  987.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_SELECT_USER_RIGHT ) )
  988.         {
  989.             daoUtil.setInt( 1, nUserId );
  990.             daoUtil.setString( 2, strIdRight );
  991.             daoUtil.executeQuery( );

  993.             if ( daoUtil.next( ) )
  994.             {
  995.                 bHasRight = true;
  996.             }

  998.         }

  1000.         return bHasRight;
  1001.     }

  1003.     /**
  1004.      * {@inheritDoc}
  1005.      */
  1006.     @Override
  1007.     public void deleteRightForUser( int nUserId, String strIdRight )
  1008.     {
  1009.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_DELETE_USER_RIGHTS ) )
  1010.         {
  1011.             daoUtil.setInt( 1, nUserId );
  1012.             daoUtil.setString( 2, strIdRight );
  1013.             daoUtil.executeUpdate( );
  1014.         }
  1015.     }

  1017.     /**
  1018.      * {@inheritDoc}
  1019.      */
  1020.     @Override
  1021.     public List<IPassword> selectUserPasswordHistory( int nUserID )
  1022.     {
  1023.         List<IPassword> listPasswordHistory = new ArrayList<>( );

  1025.         try ( DAOUtil daoUtil = new DAOUtil( SQL_SELECT_USER_PASSWORD_HISTORY ) )
  1026.         {
  1027.             daoUtil.setInt( 1, nUserID );
  1028.             daoUtil.executeQuery( );

  1030.             while ( daoUtil.next( ) )
  1031.             {
  1032.                 listPasswordHistory.add( _passwordFactory.getPassword( daoUtil.getString( 1 ) ) );
  1033.             }

  1035.         }

  1037.         return listPasswordHistory;
  1038.     }

  1040.     /**
  1041.      * {@inheritDoc}
  1042.      */
  1043.     @Override
  1044.     public int countUserPasswordHistoryFromDate( Timestamp minDate, int nUserId )
  1045.     {
  1046.         int nNbRes = 0;

  1048.         try ( DAOUtil daoUtil = new DAOUtil( SQL_COUNT_USER_PASSWORD_HISTORY ) )
  1049.         {
  1050.             daoUtil.setInt( 1, nUserId );
  1051.             daoUtil.setTimestamp( 2, minDate );
  1052.             daoUtil.executeQuery( );

  1054.             if ( daoUtil.next( ) )
  1055.             {
  1056.                 nNbRes = daoUtil.getInt( 1 );
  1057.             }

  1059.         }

  1061.         return nNbRes;
  1062.     }

  1064.     /**
  1065.      * {@inheritDoc}
  1066.      */
  1067.     @Override
  1068.     public void insertNewPasswordInHistory( IPassword password, int nUserId )
  1069.     {
  1070.         try ( DAOUtil daoUtil = new DAOUtil( SQL_INSERT_PASSWORD_HISTORY ) )
  1071.         {
  1072.             daoUtil.setInt( 1, nUserId );
  1073.             daoUtil.setString( 2, password.getStorableRepresentation( ) );

  1075.             daoUtil.executeUpdate( );
  1076.         }
  1077.     }

  1079.     /**
  1080.      * {@inheritDoc}
  1081.      */
  1082.     @Override
  1083.     public void removeAllPasswordHistoryForUser( int nUserId )
  1084.     {
  1085.         try ( DAOUtil daoUtil = new DAOUtil( SQL_DELETE_PASSWORD_HISTORY ) )
  1086.         {
  1087.             daoUtil.setInt( 1, nUserId );
  1088.             daoUtil.executeUpdate( );
  1089.         }
  1090.     }

  1092.     /**
  1093.      * {@inheritDoc}
  1094.      */
  1095.     @Override
  1096.     public Map<String, Boolean> selectAnonymizationStatusUserStaticField( )
  1097.     {
  1098.         Map<String, Boolean> resultMap = new HashMap<>( );
  1099.         try ( DAOUtil daoUtil = new DAOUtil( SQL_SELECT_ANONYMIZATION_STATUS_USER_FILED ) )
  1100.         {
  1101.             daoUtil.executeQuery( );

  1103.             while ( daoUtil.next( ) )
  1104.             {
  1105.                 resultMap.put( daoUtil.getString( 1 ), daoUtil.getBoolean( 2 ) );
  1106.             }

  1108.         }

  1110.         return resultMap;
  1111.     }

  1113.     /**
  1114.      * {@inheritDoc}
  1115.      */
  1116.     @Override
  1117.     public void updateAnonymizationStatusUserStaticField( String strFieldName, boolean bAnonymizeFiled )
  1118.     {
  1119.         try ( DAOUtil daoUtil = new DAOUtil( SQL_UPDATE_ANONYMIZATION_STATUS_USER_FILED ) )
  1120.         {
  1121.             daoUtil.setBoolean( 1, bAnonymizeFiled );
  1122.             daoUtil.setString( 2, strFieldName );
  1123.             daoUtil.executeUpdate( );
  1124.         }
  1125.     }

  1127.     /**
  1128.      * {@inheritDoc}
  1129.      */
  1130.     @Override
  1131.     public List<Integer> findAllExpiredUserId( )
  1132.     {
  1133.         List<Integer> listIdExpiredUser = new ArrayList<>( );
  1134.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_SELECT_EXPIRED_USER_ID ) )
  1135.         {
  1136.             daoUtil.setInt( 1, AdminUser.EXPIRED_CODE );

  1138.             daoUtil.executeQuery( );

  1140.             while ( daoUtil.next( ) )
  1141.             {
  1142.                 listIdExpiredUser.add( daoUtil.getInt( 1 ) );
  1143.             }

  1145.         }

  1147.         return listIdExpiredUser;
  1148.     }

  1150.     /**
  1151.      * {@inheritDoc}
  1152.      */
  1153.     @Override
  1154.     public List<Integer> getIdUsersWithExpiredLifeTimeList( Timestamp currentTimestamp )
  1155.     {
  1156.         List<Integer> listIdExpiredUser = new ArrayList<>( );
  1157.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_SELECT_EXPIRED_LIFE_TIME_USER_ID ) )
  1158.         {
  1159.             daoUtil.setLong( 1, currentTimestamp.getTime( ) );
  1160.             daoUtil.setInt( 2, AdminUser.EXPIRED_CODE );

  1162.             daoUtil.executeQuery( );

  1164.             while ( daoUtil.next( ) )
  1165.             {
  1166.                 listIdExpiredUser.add( daoUtil.getInt( 1 ) );
  1167.             }

  1169.         }

  1171.         return listIdExpiredUser;
  1172.     }

  1174.     /**
  1175.      * {@inheritDoc}
  1176.      */
  1177.     @Override
  1178.     public List<Integer> getIdUsersToSendFirstAlert( Timestamp alertMaxDate )
  1179.     {
  1180.         List<Integer> listIdUserFirstAlert = new ArrayList<>( );
  1181.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_SELECT_USER_ID_FIRST_ALERT ) )
  1182.         {
  1183.             daoUtil.setInt( 1, AdminUser.EXPIRED_CODE );
  1184.             daoUtil.setLong( 2, alertMaxDate.getTime( ) );

  1186.             daoUtil.executeQuery( );

  1188.             while ( daoUtil.next( ) )
  1189.             {
  1190.                 listIdUserFirstAlert.add( daoUtil.getInt( 1 ) );
  1191.             }

  1193.         }

  1195.         return listIdUserFirstAlert;
  1196.     }

  1198.     /**
  1199.      * {@inheritDoc}
  1200.      */
  1201.     @Override
  1202.     public List<Integer> getIdUsersToSendOtherAlert( Timestamp alertMaxDate, Timestamp timeBetweenAlerts, int maxNumberAlerts )
  1203.     {
  1204.         List<Integer> listIdUserFirstAlert = new ArrayList<>( );
  1205.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_SELECT_USER_ID_OTHER_ALERT ) )
  1206.         {
  1207.             daoUtil.setInt( 1, maxNumberAlerts );
  1208.             daoUtil.setInt( 2, AdminUser.EXPIRED_CODE );
  1209.             daoUtil.setLong( 3, timeBetweenAlerts.getTime( ) );
  1210.             daoUtil.setLong( 4, alertMaxDate.getTime( ) );

  1212.             daoUtil.executeQuery( );

  1214.             while ( daoUtil.next( ) )
  1215.             {
  1216.                 listIdUserFirstAlert.add( daoUtil.getInt( 1 ) );
  1217.             }

  1219.         }

  1221.         return listIdUserFirstAlert;
  1222.     }

  1224.     /**
  1225.      * {@inheritDoc}
  1226.      */
  1227.     @Override
  1228.     public List<Integer> getIdUsersWithExpiredPasswordsList( Timestamp currentTimestamp )
  1229.     {
  1230.         List<Integer> idUserPasswordExpiredlist = new ArrayList<>( );
  1231.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_SELECT_USER_ID_PASSWORD_EXPIRED ) )
  1232.         {
  1233.             daoUtil.setTimestamp( 1, currentTimestamp );

  1235.             daoUtil.executeQuery( );

  1237.             while ( daoUtil.next( ) )
  1238.             {
  1239.                 idUserPasswordExpiredlist.add( daoUtil.getInt( 1 ) );
  1240.             }

  1242.         }

  1244.         return idUserPasswordExpiredlist;
  1245.     }

  1247.     /**
  1248.      * {@inheritDoc}
  1249.      */
  1250.     @Override
  1251.     public void updateUserStatus( List<Integer> listIdUser, int nNewStatus )
  1252.     {
  1253.         if ( CollectionUtils.isNotEmpty( listIdUser ) )
  1254.         {
  1255.             StringBuilder sbSQL = new StringBuilder( );
  1256.             sbSQL.append( SQL_QUERY_UPDATE_STATUS );

  1258.             for ( int i = 0; i < listIdUser.size( ); i++ )
  1259.             {
  1260.                 if ( i > 0 )
  1261.                 {
  1262.                     sbSQL.append( CONSTANT_COMMA );
  1263.                 }

  1265.                 sbSQL.append( listIdUser.get( i ) );
  1266.             }

  1268.             sbSQL.append( CONSTANT_CLOSE_PARENTHESIS );

  1270.             try ( DAOUtil daoUtil = new DAOUtil( sbSQL.toString( ) ) )
  1271.             {
  1272.                 daoUtil.setInt( 1, nNewStatus );
  1273.                 daoUtil.executeUpdate( );
  1274.             }
  1275.         }
  1276.     }

  1278.     /**
  1279.      * {@inheritDoc}
  1280.      */
  1281.     @Override
  1282.     public void updateNbAlert( List<Integer> listIdUser )
  1283.     {
  1284.         if ( CollectionUtils.isNotEmpty( listIdUser ) )
  1285.         {
  1286.             StringBuilder sbSQL = new StringBuilder( );
  1287.             sbSQL.append( SQL_QUERY_UPDATE_NB_ALERT );

  1289.             for ( int i = 0; i < listIdUser.size( ); i++ )
  1290.             {
  1291.                 if ( i > 0 )
  1292.                 {
  1293.                     sbSQL.append( CONSTANT_COMMA );
  1294.                 }

  1296.                 sbSQL.append( listIdUser.get( i ) );
  1297.             }

  1299.             sbSQL.append( CONSTANT_CLOSE_PARENTHESIS );

  1301.             try ( DAOUtil daoUtil = new DAOUtil( sbSQL.toString( ) ) )
  1302.             {
  1303.                 daoUtil.executeUpdate( );
  1304.             }
  1305.         }
  1306.     }

  1308.     /**
  1309.      * {@inheritDoc}
  1310.      */
  1311.     @Override
  1312.     public void updateChangePassword( List<Integer> listIdUser )
  1313.     {
  1314.         if ( CollectionUtils.isNotEmpty( listIdUser ) )
  1315.         {
  1316.             StringBuilder sbSQL = new StringBuilder( );
  1317.             sbSQL.append( SQL_QUERY_UPDATE_RESET_PASSWORD_LIST_ID );

  1319.             for ( int i = 0; i < listIdUser.size( ); i++ )
  1320.             {
  1321.                 if ( i > 0 )
  1322.                 {
  1323.                     sbSQL.append( CONSTANT_COMMA );
  1324.                 }

  1326.                 sbSQL.append( listIdUser.get( i ) );
  1327.             }

  1329.             sbSQL.append( CONSTANT_CLOSE_PARENTHESIS );

  1331.             try ( DAOUtil daoUtil = new DAOUtil( sbSQL.toString( ) ) )
  1332.             {
  1333.                 daoUtil.executeUpdate( );
  1334.             }
  1335.         }
  1336.     }

  1338.     /**
  1339.      * {@inheritDoc}
  1340.      */
  1341.     @Override
  1342.     public void updateUserExpirationDate( int nIdUser, Timestamp newExpirationDate )
  1343.     {
  1344.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_UPDATE_REACTIVATE_ACCOUNT ) )
  1345.         {

  1347.             if ( newExpirationDate == null )
  1348.             {
  1349.                 daoUtil.setLongNull( 1 );
  1350.             }
  1351.             else
  1352.             {
  1353.                 daoUtil.setLong( 1, newExpirationDate.getTime( ) );
  1354.             }

  1356.             daoUtil.setInt( 2, nIdUser );

  1358.             daoUtil.executeUpdate( );
  1359.         }
  1360.     }

  1362.     /**
  1363.      * {@inheritDoc}
  1364.      */
  1365.     @Override
  1366.     public void updateDateLastLogin( int nIdUser, Timestamp dateLastLogin )
  1367.     {
  1368.         try ( DAOUtil daoUtil = new DAOUtil( SQL_QUERY_UPDATE_DATE_LAST_LOGIN ) )
  1369.         {
  1370.             daoUtil.setTimestamp( 1, dateLastLogin );
  1371.             daoUtil.setInt( 2, nIdUser );
  1372.             daoUtil.executeUpdate( );
  1373.         }
  1374.     }

  1376.     
  1377. }
Created with JaCoCo 0.8.4.201905082037