Java tutorial
/* * This software was designed and created by Jason Carroll. * Copyright (c) 2002, 2003, 2004 Jason Carroll. * The author can be reached at jcarroll@cowsultants.com * ITracker website: http://www.cowsultants.com * ITracker forums: http://www.cowsultants.com/phpBB/index.php * * This program is free software; you can redistribute it and/or modify * it only under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. */ package org.itracker.services.implementations; import org.apache.log4j.Logger; import org.itracker.PasswordException; import org.itracker.UserException; import org.itracker.core.AuthenticationConstants; import org.itracker.model.*; import org.itracker.model.util.ProjectUtilities; import org.itracker.model.util.UserUtilities; import org.itracker.persistence.dao.*; import org.itracker.services.ConfigurationService; import org.itracker.services.ProjectService; import org.itracker.services.UserService; import org.itracker.services.authentication.ITrackerUserDetails; import org.itracker.services.authentication.PluggableAuthenticator; import org.itracker.services.exceptions.AuthenticatorException; import org.springframework.security.core.userdetails.UserDetails; import org.springframework.security.core.userdetails.UsernameNotFoundException; import java.util.*; /** * Implements the UserService interface. See that interface for method * descriptions. * * @see UserService */ public class UserServiceImpl implements UserService { private static final String DEFAULT_AUTHENTICATOR = "org.itracker.services.authentication.DefaultAuthenticator"; private String authenticatorClassName = null; private Class<?> authenticatorClass = null; private boolean allowSelfRegister = false; private static final Logger logger = Logger.getLogger(UserServiceImpl.class); private PermissionDAO permissionDAO = null; private UserDAO userDAO = null; private UserPreferencesDAO userPreferencesDAO = null; private ProjectService projectService; private ConfigurationService configurationService; public UserServiceImpl(ConfigurationService configurationService, ProjectService projectService, UserDAO userDAO, PermissionDAO permissionDAO, UserPreferencesDAO userPreferencesDAO) { this.configurationService = configurationService; this.projectService = projectService; this.userDAO = userDAO; this.userPreferencesDAO = userPreferencesDAO; this.permissionDAO = permissionDAO; try { allowSelfRegister = configurationService.getBooleanProperty("allow_self_register", false); authenticatorClassName = configurationService.getProperty("authenticator_class", DEFAULT_AUTHENTICATOR); authenticatorClass = Class.forName(authenticatorClassName); } catch (ClassNotFoundException ex) { throw new RuntimeException(ex); } } /** * @deprecated use constructor without projectDA= und reportDAO instead */ public UserServiceImpl(ConfigurationService configurationService, ProjectService projectService, UserDAO userDAO, ProjectDAO projectDAO, ReportDAO reportDAO, PermissionDAO permissionDAO, UserPreferencesDAO userPreferencesDAO) { this(configurationService, projectService, userDAO, permissionDAO, userPreferencesDAO); } public User getUser(Integer userId) { User user = userDAO.findByPrimaryKey(userId); return user; } public User getUserByLogin(String login) throws NoSuchEntityException { User user = userDAO.findByLogin(login); if (user == null) throw new NoSuchEntityException("User " + login + " not found."); return user; } @Override public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException { try { final User model = getUserByLogin(username); return new ITrackerUserDetails(model, getPermissionsByUserId(model.getId())); } catch (NoSuchEntityException e) { throw new UsernameNotFoundException(username, e); } } public String getUserPasswordByLogin(String login) { User user = userDAO.findByLogin(login); return user.getPassword(); } public List<User> getAllUsers() { List<User> users = userDAO.findAll(); return users; } public int getNumberUsers() { Collection<User> users = userDAO.findAll(); return users.size(); } public List<User> getActiveUsers() { List<User> users = userDAO.findActive(); return users; } public List<User> getSuperUsers() { List<User> superUsers = userDAO.findSuperUsers(); return superUsers; } public User createUser(User user) throws UserException { try { if (user == null || user.getLogin() == null || user.getLogin().equals("")) { throw new UserException("User data was null, or login was empty."); } try { this.getUserByLogin(user.getLogin()); throw new UserException("User already exists with login: " + user.getLogin()); } catch (NoSuchEntityException e) { // doesn't exist, we'll create him } try { PluggableAuthenticator authenticator = (PluggableAuthenticator) authenticatorClass.newInstance(); if (authenticator != null) { HashMap<String, Object> values = new HashMap<String, Object>(); values.put("userService", this); values.put("configurationService", configurationService); authenticator.initialize(values); authenticator.createProfile(user, null, AuthenticationConstants.AUTH_TYPE_UNKNOWN, AuthenticationConstants.REQ_SOURCE_UNKNOWN); } else { throw new AuthenticatorException("Unable to create new authenticator.", AuthenticatorException.SYSTEM_ERROR); } } catch (IllegalAccessException ex) { throw new AuthenticatorException( "Authenticator class " + authenticatorClassName + " can not be instantiated.", AuthenticatorException.SYSTEM_ERROR, ex); } catch (InstantiationException ex) { throw new AuthenticatorException( "Authenticator class " + authenticatorClassName + " can not be instantiated.", AuthenticatorException.SYSTEM_ERROR, ex); } catch (ClassCastException ex) { throw new AuthenticatorException( "Authenticator class " + authenticatorClassName + " does not extend the PluggableAuthenticator class.", AuthenticatorException.SYSTEM_ERROR, ex); } user.setStatus(UserUtilities.STATUS_ACTIVE); user.setRegistrationType(user.getRegistrationType()); addPreferences(user); userDAO.save(user); return user; } catch (AuthenticatorException ex) { throw new UserException("Could not create user.", ex); } } public User updateUser(User user) throws UserException { try { PluggableAuthenticator authenticator = (PluggableAuthenticator) authenticatorClass.newInstance(); if (authenticator != null) { HashMap<String, Object> values = new HashMap<String, Object>(); values.put("userService", this); values.put("configurationService", configurationService); authenticator.initialize(values); authenticator.updateProfile(user, AuthenticationConstants.UPDATE_TYPE_CORE, null, AuthenticationConstants.AUTH_TYPE_UNKNOWN, AuthenticationConstants.REQ_SOURCE_UNKNOWN); } else { logger.warn("updateUser: no authenticator, throwing AuthenticatorException"); throw new AuthenticatorException("Unable to create new authenticator.", AuthenticatorException.SYSTEM_ERROR); } } catch (IllegalAccessException ex) { logger.error("updateUser: IllegalAccessException caught, throwing AuthenticatorException", ex); throw new AuthenticatorException( "Authenticator class " + authenticatorClassName + " can not be instantiated.", AuthenticatorException.SYSTEM_ERROR, ex); } catch (InstantiationException ex) { logger.error("updateUser: InstantiationException caught, throwing AuthenticatorException", ex); throw new AuthenticatorException( "Authenticator class " + authenticatorClassName + " can not be instantiated.", AuthenticatorException.SYSTEM_ERROR, ex); } catch (ClassCastException ex) { logger.error("updateUser: ClassCastException caught, throwing AuthenticatorException", ex); throw new AuthenticatorException( "Authenticator class " + authenticatorClassName + " does not extend the PluggableAuthenticator class.", AuthenticatorException.SYSTEM_ERROR, ex); } catch (AuthenticatorException ex) { logger.error("updateUser: AuthenticatorException caught, throwing AuthenticatorException", ex); throw new UserException("Unable to update user.", ex); } // detach, so we can compare the new loaded with changed user Integer id = user.getId(); userDAO.detach(user); User existinguser = userDAO.findByPrimaryKey(id); userDAO.refresh(existinguser); existinguser.setLogin(user.getLogin()); existinguser.setFirstName(user.getFirstName()); existinguser.setLastName(user.getLastName()); existinguser.setEmail(user.getEmail()); existinguser.setSuperUser(user.isSuperUser()); existinguser.setStatus(user.getStatus()); if (user.getPassword() != null && (!user.getPassword().equals(""))) { if (logger.isInfoEnabled()) { logger.info("updateUser: setting new password for " + user.getLogin()); } existinguser.setPassword(user.getPassword()); } if (null == existinguser.getPreferences()) { addPreferences(existinguser); } else { updateUserPreferences(user.getPreferences()); } userDAO.saveOrUpdate(existinguser); return existinguser; } private static void addPreferences(User user) { UserPreferences prefs = new UserPreferences(); prefs.setUser(user); user.setPreferences(prefs); } public String generateUserPassword(User user) throws PasswordException { String password = UserUtilities.generatePassword(); user.setPassword(UserUtilities.encryptPassword(password)); return password; // throw new PasswordException(PasswordException.UNKNOWN_USER); } public UserPreferences updateUserPreferences(UserPreferences userPrefs) throws UserException { UserPreferences newUserPrefs; try { User user = userPrefs.getUser(); newUserPrefs = userPreferencesDAO.findByUserId(user.getId()); if (newUserPrefs == null) { newUserPrefs = new UserPreferences(); } newUserPrefs.setUserLocale(userPrefs.getUserLocale()); newUserPrefs.setNumItemsOnIndex(userPrefs.getNumItemsOnIndex()); newUserPrefs.setNumItemsOnIssueList(userPrefs.getNumItemsOnIssueList()); newUserPrefs.setShowClosedOnIssueList(userPrefs.getShowClosedOnIssueList()); newUserPrefs.setSortColumnOnIssueList(userPrefs.getSortColumnOnIssueList()); newUserPrefs.setHiddenIndexSections(userPrefs.getHiddenIndexSections()); newUserPrefs.setRememberLastSearch(userPrefs.getRememberLastSearch()); newUserPrefs.setUseTextActions(userPrefs.getUseTextActions()); newUserPrefs.setUser(user); if (userPrefs.isNew()) { newUserPrefs.setCreateDate(new Date()); newUserPrefs.setLastModifiedDate(userPrefs.getCreateDate()); // first time create UserPreferences user.setPreferences(newUserPrefs); userDAO.saveOrUpdate(user); } else { this.userPreferencesDAO.saveOrUpdate(newUserPrefs); newUserPrefs = userPreferencesDAO.findByUserId(user.getId()); user.setPreferences(newUserPrefs); } try { PluggableAuthenticator authenticator = (PluggableAuthenticator) authenticatorClass.newInstance(); if (authenticator != null) { HashMap<String, Object> values = new HashMap<String, Object>(); values.put("userService", this); values.put("configurationService", configurationService); authenticator.initialize(values); authenticator.updateProfile(user, AuthenticationConstants.UPDATE_TYPE_PREFERENCE, null, AuthenticationConstants.AUTH_TYPE_UNKNOWN, AuthenticationConstants.REQ_SOURCE_UNKNOWN); } else { throw new AuthenticatorException("Unable to create new authenticator.", AuthenticatorException.SYSTEM_ERROR); } } catch (IllegalAccessException ex) { throw new AuthenticatorException( "Authenticator class " + authenticatorClassName + " can not be instantiated.", AuthenticatorException.SYSTEM_ERROR, ex); } catch (InstantiationException ex) { throw new AuthenticatorException( "Authenticator class " + authenticatorClassName + " can not be instantiated.", AuthenticatorException.SYSTEM_ERROR, ex); } catch (ClassCastException ex) { throw new AuthenticatorException( "Authenticator class " + authenticatorClassName + " does not extend the PluggableAuthenticator class.", AuthenticatorException.SYSTEM_ERROR, ex); } if (newUserPrefs != null) return newUserPrefs; } catch (AuthenticatorException ex) { throw new UserException("Unable to create new preferences.", ex); } // } finally { return userPrefs; // } } public void clearOwnedProjects(User user) { user.getProjects().clear(); userDAO.save(user); } @Override public List<User> findUsersForProjectByPermissionTypeList(Integer projectID, PermissionType[] permissionTypes) { return userDAO.findUsersForProjectByAllPermissionTypeList(projectID, permissionTypes); } @Override public List<User> getUsersWithPermissionLocal(Integer projectId, PermissionType permissionType) { List<User> users = new ArrayList<User>(); if (projectId != null) { List<Permission> permissions = permissionDAO.findByProjectIdAndPermission(projectId, permissionType); for (Permission permission : permissions) { users.add(permission.getUser()); } } return users; } public List<User> getUsersWithPermissionLocal(Integer projectId, int permissionType) { return getUsersWithPermissionLocal(projectId, PermissionType.valueOf(permissionType)); } public List<Permission> getUserPermissionsLocal(User user) { List<Permission> permissions = permissionDAO.findByUserId(user.getId()); return permissions; } public List<Permission> getPermissionsByUserId(Integer userId) { List<Permission> permissions = new ArrayList<Permission>(); User user = getUser(userId); if (user != null) { try { PluggableAuthenticator authenticator = (PluggableAuthenticator) authenticatorClass.newInstance(); if (authenticator != null) { HashMap<String, Object> values = new HashMap<String, Object>(); values.put("userService", this); values.put("configurationService", configurationService); authenticator.initialize(values); permissions = authenticator.getUserPermissions(user, AuthenticationConstants.REQ_SOURCE_UNKNOWN); } logger.debug("Found " + permissions.size() + " permissions for user " + user.getLogin()); } catch (IllegalAccessException ex) { throw new RuntimeException( "Authenticator class " + authenticatorClassName + " can not be instantiated.", ex); } catch (InstantiationException ex) { throw new RuntimeException( "Authenticator class " + authenticatorClassName + " can not be instantiated.", ex); } catch (ClassCastException ex) { throw new RuntimeException("Authenticator class " + authenticatorClassName + " does not extend the PluggableAuthenticator class.", ex); } catch (AuthenticatorException ex) { throw new RuntimeException("Authenticator exception: ", ex); } } return permissions; } public boolean updateAuthenticator(Integer userId, List<Permission> permissions) { boolean successful; try { User user = userDAO.findByPrimaryKey(userId); user.getPermissions().addAll(permissions); try { PluggableAuthenticator authenticator = (PluggableAuthenticator) authenticatorClass.newInstance(); if (authenticator != null) { HashMap<String, Object> values = new HashMap<String, Object>(); values.put("userService", this); values.put("configurationService", configurationService); authenticator.initialize(values); if (authenticator.updateProfile(user, AuthenticationConstants.UPDATE_TYPE_PERMISSION_SET, null, AuthenticationConstants.AUTH_TYPE_UNKNOWN, AuthenticationConstants.REQ_SOURCE_UNKNOWN)) { } } else { logger.error("Unable to create new authenticator."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } successful = true; } catch (IllegalAccessException | InstantiationException iae) { logger.error("Authenticator class " + authenticatorClassName + " can not be instantiated."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } catch (ClassCastException cce) { logger.error("Authenticator class " + authenticatorClassName + " does not extend the PluggableAuthenticator class."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } } catch (AuthenticatorException ae) { logger.warn("Error setting user (" + userId + ") permissions. AuthenticatorException.", ae); successful = false; } return successful; } public boolean addUserPermissions(Integer userId, List<Permission> newPermissions) { boolean successful = false; if (newPermissions == null || newPermissions.size() == 0) { return false; } try { newPermissions.addAll(getUserPermissionsLocal(getUser(userId))); setUserPermissions(userId, newPermissions); successful = true; } catch (AuthenticatorException ae) { logger.warn("Error setting user (" + userId + ") permissions. AuthenticatorException.", ae); successful = false; } return successful; } /** * private util for collection searching (contains) */ private static Permission find(Collection<Permission> permissions, Permission permission) { for (Permission permission2 : permissions) { if (Permission.PERMISSION_PROPERTIES_COMPARATOR.compare(permission, permission2) == 0) { // found in list, return the found object return permission2; } } return null; } /** * @param userId - id of update-user * @param newPermissions - set of new permissions for this user */ @Override public boolean setUserPermissions(final Integer userId, final List<Permission> newPermissions) { boolean hasChanges = false; // rewriting this method TreeSet<Permission> pSet = new TreeSet<Permission>(Permission.PERMISSION_PROPERTIES_COMPARATOR); pSet.addAll(newPermissions); User usermodel = this.getUser(userId); Set<Permission> current = new TreeSet<Permission>(Permission.PERMISSION_PROPERTIES_COMPARATOR); current.addAll(usermodel.getPermissions()); // setup permissions to be removed Set<Permission> remove = new TreeSet<Permission>(Permission.PERMISSION_PROPERTIES_COMPARATOR); remove.addAll(current); remove.removeAll(pSet); // setup permissions to be added Set<Permission> add = new TreeSet<Permission>(Permission.PERMISSION_PROPERTIES_COMPARATOR); add.addAll(pSet); add.removeAll(current); // look permission Permission p; Iterator<Permission> pIt = remove.iterator(); while (pIt.hasNext()) { p = find(usermodel.getPermissions(), (Permission) pIt.next()); if (null == p) { continue; } if (usermodel.getPermissions().contains(p)) { usermodel.getPermissions().remove(p); permissionDAO.delete(p); hasChanges = true; } } pIt = add.iterator(); while (pIt.hasNext()) { p = pIt.next(); if (null == find(usermodel.getPermissions(), p) && !usermodel.getPermissions().contains(p)) { p.setUser(usermodel); usermodel.getPermissions().add(p); permissionDAO.save(p); hasChanges = true; } } if (hasChanges) { userDAO.saveOrUpdate(usermodel); } return hasChanges; } @Override public boolean removeUserPermissions(Integer userId, List<Permission> newPermissions) { boolean successful = false; if (newPermissions == null || newPermissions.size() == 0) { return successful; } try { for (Iterator<Permission> delIterator = newPermissions.iterator(); delIterator.hasNext();) { Permission permission = (Permission) delIterator.next(); permissionDAO.delete(permission); } successful = true; } catch (AuthenticatorException ae) { logger.warn("Error setting user (" + userId + ") permissions. AuthenticatorException.", ae); successful = false; } return successful; } @Override @Deprecated public Map<Integer, Set<PermissionType>> getUsersMapOfProjectIdsAndSetOfPermissionTypes(User user, int reqSource) { Map<Integer, Set<PermissionType>> permissionsMap = new HashMap<Integer, Set<PermissionType>>(); if (user == null) { return permissionsMap; } List<Permission> permissionList = new ArrayList<Permission>(); try { PluggableAuthenticator authenticator = (PluggableAuthenticator) authenticatorClass.newInstance(); if (authenticator != null) { HashMap<String, Object> values = new HashMap<String, Object>(); values.put("userService", this); values.put("configurationService", configurationService); authenticator.initialize(values); permissionList = authenticator.getUserPermissions(user, (reqSource == 0 ? AuthenticationConstants.REQ_SOURCE_UNKNOWN : reqSource)); } logger.debug("Found " + permissionList.size() + " permissions for user " + user.getLogin()); } catch (IllegalAccessException iae) { logger.error("Authenticator class " + authenticatorClassName + " can not be instantiated."); } catch (InstantiationException ie) { logger.error("Authenticator class " + authenticatorClassName + " can not be instantiated."); } catch (ClassCastException cce) { logger.error("Authenticator class " + authenticatorClassName + " does not extend the PluggableAuthenticator class."); } catch (AuthenticatorException ae) { logger.error("Authenticator exception: " + ae.getMessage()); logger.debug("Authenticator exception: ", ae); } permissionsMap = UserUtilities.mapPermissionTypesByProjectId(permissionList); if (allowSelfRegister) { List<Project> projects = projectService.getAllProjects(); for (int i = 0; i < projects.size(); i++) { Project project = projects.get(i); if (project.getOptions() >= ProjectUtilities.OPTION_ALLOW_SELF_REGISTERED_CREATE) { Set<PermissionType> projectPermissions = permissionsMap.get(project.getId()); if (projectPermissions == null) { projectPermissions = new HashSet<PermissionType>(); permissionsMap.put(project.getId(), projectPermissions); } if (ProjectUtilities.hasOption(ProjectUtilities.OPTION_ALLOW_SELF_REGISTERED_CREATE, project.getOptions())) { projectPermissions.add(PermissionType.ISSUE_VIEW_USERS); projectPermissions.add(PermissionType.ISSUE_CREATE); } if (ProjectUtilities.hasOption(ProjectUtilities.OPTION_ALLOW_SELF_REGISTERED_VIEW_ALL, project.getOptions())) { projectPermissions.add(PermissionType.ISSUE_VIEW_ALL); } } } } return permissionsMap; } @Override public List<User> getUsersWithProjectPermission(Integer projectId, PermissionType permission) { return getUsersWithProjectPermission(projectId, permission, true); } @Override public List<User> getUsersWithProjectPermission(Integer projectId, int permissionType) { return getUsersWithProjectPermission(projectId, PermissionType.valueOf(permissionType), true); } @Override public List<User> getUsersWithProjectPermission(Integer projectId, int permissionType, boolean activeOnly) { return getUsersWithProjectPermission(projectId, PermissionType.valueOf(permissionType), activeOnly); } @Override public List<User> getUsersWithProjectPermission(Integer projectId, PermissionType permissionType, boolean activeOnly) { return getUsersWithAnyProjectPermission(projectId, new PermissionType[] { permissionType }, activeOnly); } @Override public List<User> getUsersWithAnyProjectPermission(Integer projectId, int[] permissions) { return getUsersWithAnyProjectPermission(projectId, PermissionType.valueOf(permissions), true); } @Override public List<User> getUsersWithAnyProjectPermission(Integer projectId, PermissionType[] permissions, boolean activeOnly) { return getUsersWithProjectPermission(projectId, permissions, false, activeOnly); } @Override public List<User> getUsersWithAnyProjectPermission(Integer projectId, PermissionType[] permissionTypes) { return getUsersWithAnyProjectPermission(projectId, permissionTypes, true); } @Override public List<User> getUsersWithAnyProjectPermission(Integer projectId, int[] permissionTypes, boolean activeOnly) { return getUsersWithProjectPermission(projectId, permissionTypes, false, activeOnly); } @Override public List<User> getUsersWithProjectPermission(Integer projectId, int[] permissionTypes, boolean requireAll, boolean activeOnly) { return getUsersWithProjectPermission(projectId, PermissionType.valueOf(permissionTypes), requireAll, activeOnly); } @Override public List<User> getUsersWithProjectPermission(Integer projectId, PermissionType[] permissionTypes, boolean requireAll, boolean activeOnly) { List<User> userList = new ArrayList<User>(); try { // TODO: use a factory to hide this. PluggableAuthenticator authenticator = (PluggableAuthenticator) authenticatorClass.newInstance(); if (authenticator != null) { Map<String, Object> values = new HashMap<String, Object>(); values.put("userService", this); values.put("configurationService", configurationService); authenticator.initialize(values); userList = authenticator.getUsersWithProjectPermission(projectId, permissionTypes, requireAll, activeOnly, AuthenticationConstants.REQ_SOURCE_UNKNOWN); } if (logger.isDebugEnabled()) { logger.debug("getUsersWithProjectPermission: Found " + userList.size() + " users with project " + projectId + " permissions " + Arrays.toString(permissionTypes) + (requireAll ? "[AllReq," : "[AnyReq,") + (activeOnly ? "ActiveUsersOnly]" : "AllUsers]")); } // TODO : don't swallow exceptions!! MUST be propagated to the caller!! } catch (IllegalAccessException iae) { logger.error("getUsersWithProjectPermission: Authenticator class " + authenticatorClassName + " can not be instantiated.", iae); } catch (InstantiationException ie) { logger.error("getUsersWithProjectPermission: Authenticator class " + authenticatorClassName + " can not be instantiated.", ie); } catch (ClassCastException cce) { logger.error("getUsersWithProjectPermission: Authenticator class " + authenticatorClassName + " does not extend the PluggableAuthenticator class.", cce); } catch (AuthenticatorException ae) { logger.error("getUsersWithProjectPermission: Authenticator exception caught.", ae); } return userList; } @Override public List<User> getPossibleOwners(Issue issue, Integer projectId, Integer userId) { HashSet<User> users = new HashSet<User>(); List<User> editUsers = getUsersWithProjectPermission(projectId, UserUtilities.PERMISSION_EDIT, true); for (User editUser : editUsers) { users.add(editUser); } List<User> otherUsers = getUsersWithProjectPermission(projectId, new int[] { UserUtilities.PERMISSION_EDIT_USERS, UserUtilities.PERMISSION_ASSIGNABLE }, true, true); for (User otherUser : otherUsers) { users.add(otherUser); } if (issue != null) { // Now add in the creator if the have edit own issues, and always // the owner User creator = issue.getCreator(); if (UserUtilities.hasPermission(getUsersMapOfProjectIdsAndSetOfPermissionTypes(creator, 0), projectId, PermissionType.ISSUE_EDIT_USERS)) { users.add(creator); } if (issue.getOwner() != null) { User owner = issue.getOwner(); users.add(owner); } } else if (userId != null) { // New issue, so add in the creator if needed User creator = getUser(userId); if (UserUtilities.hasPermission(getUsersMapOfProjectIdsAndSetOfPermissionTypes(creator, 0), projectId, PermissionType.ISSUE_EDIT_USERS)) { users.add(creator); } } int i = 0; List<User> userList = new ArrayList<User>(); for (Iterator<User> iter = users.iterator(); iter.hasNext(); i++) { userList.add((User) iter.next()); } return userList; } public User checkLogin(String login, Object authentication, int authType, int reqSource) throws AuthenticatorException { try { PluggableAuthenticator authenticator = (PluggableAuthenticator) authenticatorClass.newInstance(); if (authenticator != null) { HashMap<String, Object> values = new HashMap<String, Object>(); values.put("userService", this); values.put("configurationService", configurationService); authenticator.initialize(values); return authenticator.checkLogin(login, authentication, authType, (reqSource == 0 ? AuthenticationConstants.REQ_SOURCE_UNKNOWN : reqSource)); } logger.error("Unable to create new authenticator."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } catch (IllegalAccessException iae) { logger.error("Authenticator class " + authenticatorClassName + " can not be instantiated."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } catch (InstantiationException ie) { logger.error("Authenticator class " + authenticatorClassName + " can not be instantiated."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } catch (ClassCastException cce) { logger.error("Authenticator class " + authenticatorClassName + " does not extend the PluggableAuthenticator class."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } } public boolean allowRegistration(User user, Object authentication, int authType, int reqSource) throws AuthenticatorException { try { PluggableAuthenticator authenticator = (PluggableAuthenticator) authenticatorClass.newInstance(); if (authenticator != null) { HashMap<String, Object> values = new HashMap<String, Object>(); values.put("userService", this); values.put("configurationService", configurationService); authenticator.initialize(values); if (authenticator.allowProfileCreation(user, authentication, authType, (reqSource == 0 ? AuthenticationConstants.REQ_SOURCE_UNKNOWN : reqSource))) { return authenticator.allowRegistration(user, authentication, authType, (reqSource == 0 ? AuthenticationConstants.REQ_SOURCE_UNKNOWN : reqSource)); } return false; } logger.error("Unable to create new authenticator."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } catch (IllegalAccessException iae) { logger.error("Authenticator class " + authenticatorClassName + " can not be instantiated."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } catch (InstantiationException ie) { logger.error("Authenticator class " + authenticatorClassName + " can not be instantiated."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } catch (ClassCastException cce) { logger.error("Authenticator class " + authenticatorClassName + " does not extend the PluggableAuthenticator class."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } } public boolean allowProfileCreation(User user, Object authentication, int authType, int reqSource) throws AuthenticatorException { try { PluggableAuthenticator authenticator = (PluggableAuthenticator) authenticatorClass.newInstance(); if (authenticator != null) { HashMap<String, Object> values = new HashMap<String, Object>(); values.put("userService", this); values.put("configurationService", configurationService); authenticator.initialize(values); return authenticator.allowProfileCreation(user, authentication, authType, (reqSource == 0 ? AuthenticationConstants.REQ_SOURCE_UNKNOWN : reqSource)); } logger.error("Unable to create new authenticator."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } catch (IllegalAccessException iae) { logger.error("Authenticator class " + authenticatorClassName + " can not be instantiated."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } catch (InstantiationException ie) { logger.error("Authenticator class " + authenticatorClassName + " can not be instantiated."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } catch (ClassCastException cce) { logger.error("Authenticator class " + authenticatorClassName + " does not extend the PluggableAuthenticator class."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } } public boolean allowProfileUpdates(User user, Object authentication, int authType, int reqSource) throws AuthenticatorException { try { PluggableAuthenticator authenticator = (PluggableAuthenticator) authenticatorClass.newInstance(); if (authenticator != null) { HashMap<String, Object> values = new HashMap<String, Object>(); values.put("userService", this); values.put("configurationService", configurationService); authenticator.initialize(values); return authenticator.allowProfileUpdates(user, authentication, authType, (reqSource == 0 ? AuthenticationConstants.REQ_SOURCE_UNKNOWN : reqSource)); } logger.error("Unable to create new authenticator."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } catch (IllegalAccessException iae) { logger.error("Authenticator class " + authenticatorClassName + " can not be instantiated."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } catch (InstantiationException ie) { logger.error("Authenticator class " + authenticatorClassName + " can not be instantiated."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } catch (ClassCastException cce) { logger.error("Authenticator class " + authenticatorClassName + " does not extend the PluggableAuthenticator class."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } } public boolean allowPasswordUpdates(User user, Object authentication, int authType, int reqSource) throws AuthenticatorException { try { PluggableAuthenticator authenticator = (PluggableAuthenticator) authenticatorClass.newInstance(); if (authenticator != null) { HashMap<String, Object> values = new HashMap<String, Object>(); values.put("userService", this); values.put("configurationService", configurationService); authenticator.initialize(values); return authenticator.allowPasswordUpdates(user, authentication, authType, (reqSource == 0 ? AuthenticationConstants.REQ_SOURCE_UNKNOWN : reqSource)); } logger.error("Unable to create new authenticator."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } catch (IllegalAccessException iae) { logger.error("Authenticator class " + authenticatorClassName + " can not be instantiated."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } catch (InstantiationException ie) { logger.error("Authenticator class " + authenticatorClassName + " can not be instantiated."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } catch (ClassCastException cce) { logger.error("Authenticator class " + authenticatorClassName + " does not extend the PluggableAuthenticator class."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } } public boolean allowPermissionUpdates(User user, Object authentication, int authType, int reqSource) throws AuthenticatorException { try { PluggableAuthenticator authenticator = (PluggableAuthenticator) authenticatorClass.newInstance(); if (authenticator != null) { HashMap<String, Object> values = new HashMap<String, Object>(); values.put("userService", this); values.put("configurationService", configurationService); authenticator.initialize(values); return authenticator.allowPermissionUpdates(user, authentication, authType, (reqSource == 0 ? AuthenticationConstants.REQ_SOURCE_UNKNOWN : reqSource)); } logger.error("Unable to create new authenticator."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } catch (IllegalAccessException iae) { logger.error("Authenticator class " + authenticatorClassName + " can not be instantiated."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } catch (InstantiationException ie) { logger.error("Authenticator class " + authenticatorClassName + " can not be instantiated."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } catch (ClassCastException cce) { logger.error("Authenticator class " + authenticatorClassName + " does not extend the PluggableAuthenticator class."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } } public boolean allowPreferenceUpdates(User user, Object authentication, int authType, int reqSource) throws AuthenticatorException { try { PluggableAuthenticator authenticator = (PluggableAuthenticator) authenticatorClass.newInstance(); if (authenticator != null) { HashMap<String, Object> values = new HashMap<String, Object>(); values.put("userService", this); values.put("configurationService", configurationService); authenticator.initialize(values); return authenticator.allowPreferenceUpdates(user, authentication, authType, (reqSource == 0 ? AuthenticationConstants.REQ_SOURCE_UNKNOWN : reqSource)); } logger.error("Unable to create new authenticator."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } catch (IllegalAccessException iae) { logger.error("Authenticator class " + authenticatorClassName + " can not be instantiated."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } catch (InstantiationException ie) { logger.error("Authenticator class " + authenticatorClassName + " can not be instantiated."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } catch (ClassCastException cce) { logger.error("Authenticator class " + authenticatorClassName + " does not extend the PluggableAuthenticator class."); throw new AuthenticatorException(AuthenticatorException.SYSTEM_ERROR); } } }