/**
   * Do create a new database user
   *
   * @param user the user
   * @param strPassword the password
   * @param plugin the plugin
   * @return the new database user with a new ID
   */
  public DatabaseUser doCreateUser(DatabaseUser user, String strPassword, Plugin plugin) {
    String strEncryptedPassword = strPassword;

    if (_userParamService.isPasswordEncrypted(plugin)) {
      String strAlgorithm = _userParamService.getEncryptionAlgorithm(plugin);
      strEncryptedPassword = CryptoService.encrypt(strPassword, strAlgorithm);
    }

    user.setPasswordMaxValidDate(SecurityUtils.getPasswordMaxValidDate(_userParamService, plugin));
    user.setAccountMaxValidDate(SecurityUtils.getAccountMaxValidDate(_userParamService, plugin));

    return DatabaseUserHome.create(user, strEncryptedPassword, plugin);
  }
  /**
   * Update the user expiration date with new values, and notify him with an email.
   *
   * @param nIdUser Id of the user to update
   * @param plugin The plugin
   */
  @SuppressWarnings("deprecation")
  public void updateUserExpirationDate(int nIdUser, Plugin plugin) {
    // We update the user account
    int nbMailSend = DatabaseUserHome.getNbAccountLifeTimeNotification(nIdUser, plugin);
    Timestamp newExpirationDate = SecurityUtils.getAccountMaxValidDate(_userParamService, plugin);
    DatabaseUserHome.updateUserExpirationDate(nIdUser, newExpirationDate, plugin);

    // We notify the user
    DatabaseAccountLifeTimeService accountLifeTimeService = new DatabaseAccountLifeTimeService();
    String strUserMail = accountLifeTimeService.getUserMainEmail(nIdUser);

    if ((nbMailSend > 0) && StringUtils.isNotBlank(strUserMail)) {
      String strBody =
          DatabaseTemplateService.getTemplateFromKey(PARAMETER_ACCOUNT_REACTIVATED_MAIL_BODY);

      ReferenceItem referenceItem =
          _userParamService.findByKey(PARAMETER_ACCOUNT_REACTIVATED_MAIL_SENDER, plugin);
      String strSender = (referenceItem == null) ? StringUtils.EMPTY : referenceItem.getName();

      referenceItem =
          _userParamService.findByKey(PARAMETER_ACCOUNT_REACTIVATED_MAIL_SUBJECT, plugin);

      String strSubject = (referenceItem == null) ? StringUtils.EMPTY : referenceItem.getName();

      Map<String, String> model = new HashMap<String, String>();
      accountLifeTimeService.addParametersToModel(model, nIdUser);

      HtmlTemplate template =
          AppTemplateService.getTemplateFromStringFtl(strBody, Locale.getDefault(), model);
      MailService.sendMailHtml(strUserMail, strSender, strSender, strSubject, template.getHtml());
    }
  }
  /**
   * Build the advanced parameters management
   *
   * @param user the admin user
   * @return The model for the advanced parameters
   */
  public Map<String, Object> getManageAdvancedParameters(AdminUser user) {
    Map<String, Object> model = new HashMap<String, Object>();
    Plugin plugin = PluginService.getPlugin(DatabasePlugin.PLUGIN_NAME);

    if (RBACService.isAuthorized(
        DatabaseResourceIdService.RESOURCE_TYPE,
        RBAC.WILDCARD_RESOURCES_ID,
        DatabaseResourceIdService.PERMISSION_MANAGE,
        user)) {
      // Encryption Password
      String strAlgorithms = AppPropertiesService.getProperty(PROPERTY_ENCRYPTION_ALGORITHMS_LIST);

      if (StringUtils.isNotBlank(strAlgorithms)) {
        String[] listAlgorithms = strAlgorithms.split(COMMA);

        model.put(MARK_ENCRYPTION_ALGORITHMS_LIST, listAlgorithms);
        model.put(MARK_IS_PLUGIN_JCAPTCHA_ENABLE, isPluginJcaptchaEnable());

        if (isPluginJcaptchaEnable()) {
          model.put(
              MARK_ENABLE_JCAPTCHA,
              SecurityUtils.getBooleanSecurityParameter(
                  _userParamService, plugin, MARK_ENABLE_JCAPTCHA));
        }
      }

      model.put(
          PARAMETER_ACCOUNT_CREATION_VALIDATION_EMAIL,
          SecurityUtils.getBooleanSecurityParameter(
              _userParamService, plugin, PARAMETER_ACCOUNT_CREATION_VALIDATION_EMAIL));

      model.put(
          PARAMETER_AUTO_LOGIN_AFTER_VALIDATION_EMAIL,
          SecurityUtils.getBooleanSecurityParameter(
              _userParamService, plugin, PARAMETER_AUTO_LOGIN_AFTER_VALIDATION_EMAIL));

      model.put(
          MARK_BANNED_DOMAIN_NAMES,
          SecurityUtils.getLargeSecurityParameter(
              _userParamService, plugin, MARK_BANNED_DOMAIN_NAMES));

      model = SecurityUtils.checkSecurityParameters(_userParamService, model, plugin);
    }

    return model;
  }
  /**
   * Do modify the password
   *
   * @param user the DatabaseUser
   * @param strPassword the new password not encrypted
   * @param plugin the plugin
   */
  public void doModifyPassword(DatabaseUser user, String strPassword, Plugin plugin) {
    // Updates password
    if (StringUtils.isNotBlank(strPassword)) {
      // Encrypts password or not
      String strEncryptedPassword = strPassword;

      if (_userParamService.isPasswordEncrypted(plugin)) {
        String strAlgorithm = _userParamService.getEncryptionAlgorithm(plugin);
        strEncryptedPassword = CryptoService.encrypt(strPassword, strAlgorithm);
      }

      DatabaseUser userStored = DatabaseUserHome.findByPrimaryKey(user.getUserId(), plugin);

      if (userStored != null) {
        userStored.setPasswordMaxValidDate(
            SecurityUtils.getPasswordMaxValidDate(_userParamService, plugin));
        DatabaseUserHome.updatePassword(userStored, strEncryptedPassword, plugin);
      }
    }
  }
  /**
   * Change all user's password and notify them with an email.
   *
   * @param strBaseURL The base url of the application
   * @param plugin The plugin
   * @param locale The locale to use
   */
  public void changeUserPasswordAndNotify(String strBaseURL, Plugin plugin, Locale locale) {
    // Alert all users their password have been reinitialized.
    Collection<DatabaseUser> listUsers = DatabaseUserHome.findDatabaseUsersList(plugin);

    for (DatabaseUser user : listUsers) {
      // Makes password
      String strPassword = SecurityUtils.makePassword(_userParamService, plugin);
      doModifyPassword(user, strPassword, plugin);

      if (StringUtils.isNotBlank(user.getEmail())) {
        // Sends password by e-mail
        ReferenceItem referenceItem =
            _userParamService.findByKey(PARAMETER_MAIL_PASSWORD_ENCRYPTION_CHANGED_SENDER, plugin);
        String strSenderEmail =
            (referenceItem == null) ? StringUtils.EMPTY : referenceItem.getName();
        referenceItem =
            _userParamService.findByKey(PARAMETER_MAIL_PASSWORD_ENCRYPTION_CHANGED_SUBJECT, plugin);

        String strEmailSubject =
            (referenceItem == null) ? StringUtils.EMPTY : referenceItem.getName();

        Map<String, Object> model = new HashMap<String, Object>();
        model.put(MARK_NEW_PASSWORD, strPassword);
        model.put(
            MARK_LOGIN_URL,
            strBaseURL + AdminAuthenticationService.getInstance().getLoginPageUrl());
        model.put(MARK_SITE_LINK, MailService.getSiteLink(strBaseURL, true));

        String strTemplate =
            DatabaseTemplateService.getTemplateFromKey(PARAMETER_MAIL_PASSWORD_ENCRYPTION_CHANGED);

        HtmlTemplate template =
            AppTemplateService.getTemplateFromStringFtl(strTemplate, locale, model);

        MailService.sendMailHtml(
            user.getEmail(), strSenderEmail, strSenderEmail, strEmailSubject, template.getHtml());
      }
    }
  }
 /**
  * Log a password change in the password history
  *
  * @param strPassword New password of the user
  * @param nUserId Id of the user
  * @param plugin The plugin
  */
 public void doInsertNewPasswordInHistory(String strPassword, int nUserId, Plugin plugin) {
   strPassword = SecurityUtils.buildPassword(_userParamService, plugin, strPassword);
   DatabaseUserHome.insertNewPasswordInHistory(strPassword, nUserId, plugin);
 }