TorqueAbstractUserManager.java
package org.apache.fulcrum.security.torque;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import java.sql.Connection;
import java.util.List;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.fulcrum.security.entity.User;
import org.apache.fulcrum.security.spi.AbstractUserManager;
import org.apache.fulcrum.security.torque.security.TorqueAbstractSecurityEntity;
import org.apache.fulcrum.security.util.DataBackendException;
import org.apache.fulcrum.security.util.UnknownEntityException;
import org.apache.fulcrum.security.util.UserSet;
import org.apache.torque.NoRowsException;
import org.apache.torque.TooManyRowsException;
import org.apache.torque.TorqueException;
import org.apache.torque.util.Transaction;
/**
* This implementation persists to a database via Torque.
*
* @author <a href="mailto:tv@apache.org">Thomas Vandahl</a>
* @version $Id:$
*/
public abstract class TorqueAbstractUserManager extends AbstractUserManager {
/** Serial version */
private static final long serialVersionUID = 2050218990148719292L;
/**
* Avalon Service lifecycle method
*/
@Override
public void configure(Configuration conf) throws ConfigurationException {
super.configure(conf);
}
/**
* Get all specialized Users
*
* @param con a database connection
*
* @return a List of User instances
*
* @throws TorqueException if any database error occurs
*/
protected abstract <T extends User> List<T> doSelectAllUsers(Connection con) throws TorqueException;
/**
* Get a specialized User by name
*
* @param name the name of the group
* @param con a database connection
*
* @return a User instance
*
* @throws NoRowsException if no such group exists
* @throws TooManyRowsException if multiple groups with the given name exist
* @throws TorqueException if any database error occurs if any other
* database error occurs
*/
protected abstract <T extends User> T doSelectByName(String name, Connection con)
throws NoRowsException, TooManyRowsException, TorqueException;
/**
* Get a specialized User by id
*
* @param id the id of the group
* @param con a database connection
*
* @return a User instance
*
* @throws NoRowsException if no such group exists
* @throws TooManyRowsException if multiple groups with the given id exist
* @throws TorqueException if any database error occurs if any other
* database error occurs
*/
protected abstract <T extends User> T doSelectById(Integer id, Connection con)
throws NoRowsException, TooManyRowsException, TorqueException;
/**
* Removes an user account from the system.
*
* @param user the object describing the account to be removed.
* @throws DataBackendException if there was an error accessing the data
* backend.
* @throws UnknownEntityException if the user account is not present.
*/
@Override
public synchronized void removeUser(User user) throws DataBackendException, UnknownEntityException {
try {
((TorqueAbstractSecurityEntity) user).delete();
} catch (TorqueException e) {
throw new DataBackendException("Removing User '" + user.getName() + "' failed", e);
}
}
/**
* Creates new user account with specified attributes.
*
* @param user the object describing account to be created.
*
* @throws DataBackendException if there was an error accessing the data
* backend.
*/
@Override
protected synchronized <T extends User> T persistNewUser(T user) throws DataBackendException {
try {
TorqueAbstractSecurityEntity u = (TorqueAbstractSecurityEntity) user;
u.save();
} catch (Exception e) {
throw new DataBackendException("Adding User '" + user.getName() + "' failed", e);
}
return user;
}
/**
* Stores User attributes. The User is required to exist in the system.
*
* @param user The User to be stored.
* @throws DataBackendException if there was an error accessing the data
* backend.
* @throws UnknownEntityException if the role does not exist.
*/
@Override
public synchronized void saveUser(User user) throws DataBackendException, UnknownEntityException {
if (checkExists(user)) {
try {
TorqueAbstractSecurityEntity u = (TorqueAbstractSecurityEntity) user;
u.setNew(false);
u.save();
} catch (Exception e) {
throw new DataBackendException("Saving User '" + user.getName() + "' failed", e);
}
} else {
throw new UnknownEntityException("Unknown user '" + user + "'");
}
}
/**
* Check whether a specified user's account exists.
*
* The login name is used for looking up the account.
*
* @param userName The name of the user to be checked.
* @return true if the specified account exists
* @throws DataBackendException if there was an error accessing the data
* backend.
*/
@Override
public boolean checkExists(String userName) throws DataBackendException {
boolean exists = false;
Connection con = null;
try {
con = Transaction.begin();
doSelectByName(userName, con);
Transaction.commit(con);
con = null;
exists = true;
} catch (NoRowsException e) {
exists = false;
} catch (TooManyRowsException e) {
throw new DataBackendException("Multiple Users with same username '" + userName + "'");
} catch (TorqueException e) {
throw new DataBackendException("Error retrieving user information", e);
} finally {
if (con != null) {
Transaction.safeRollback(con);
}
}
return exists;
}
/**
* Retrieve a user from persistent storage using username as the key.
*
* Additionally retrieves all attached objects from {@link TorqueAbstractSecurityEntity#retrieveAttachedObjects(Connection, Boolean)}
*
* @param userName the name of the user.
* @return an User object.
* @exception UnknownEntityException if the user's account does not exist in the
* database.
* @exception DataBackendException if there is a problem accessing the
* storage.
*/
@Override
public <T extends User> T getUser(String userName) throws UnknownEntityException, DataBackendException {
T user = null;
Connection con = null;
try {
con = Transaction.begin();
user = doSelectByName(userName.toLowerCase(), con);
// Add attached objects if they exist
((TorqueAbstractSecurityEntity) user).retrieveAttachedObjects(con, false);
Transaction.commit(con);
con = null;
} catch (NoRowsException e) {
throw new UnknownEntityException("Unknown user '" + userName + "'");
} catch (TooManyRowsException e) {
throw new DataBackendException("Multiple Users with same username '" + userName + "'");
} catch (TorqueException e) {
throw new DataBackendException("Error retrieving user information", e);
} finally {
if (con != null) {
Transaction.safeRollback(con);
}
}
return user;
}
/**
* Retrieves all users defined in the system.
*
* @return the names of all users defined in the system.
* @throws DataBackendException if there was an error accessing the data
* backend.
*/
@Override
public <T extends User> UserSet<T> getAllUsers() throws DataBackendException {
UserSet<T> userSet = new UserSet<T>();
Connection con = null;
try {
con = Transaction.begin();
List<User> users = doSelectAllUsers(con);
for (User user : users) {
// Add attached objects if they exist
((TorqueAbstractSecurityEntity) user).retrieveAttachedObjects(con, false);
userSet.add(user);
}
Transaction.commit(con);
con = null;
} catch (TorqueException e) {
throw new DataBackendException("Error retrieving all users", e);
} finally {
if (con != null) {
Transaction.safeRollback(con);
}
}
return userSet;
}
/**
* Retrieve a User object with specified id.
*
* @param id the id of the User.
* @return an object representing the User with specified id.
* @throws DataBackendException if there was an error accessing the data
* backend.
* @throws UnknownEntityException if the user does not exist.
*/
@Override
public <T extends User> T getUserById(Object id) throws DataBackendException, UnknownEntityException {
T user;
if (id != null && id instanceof Integer) {
Connection con = null;
try {
con = Transaction.begin();
user = doSelectById((Integer) id, con);
// Add attached objects if they exist
((TorqueAbstractSecurityEntity) user).retrieveAttachedObjects(con, false); //
Transaction.commit(con);
con = null;
} catch (NoRowsException e) {
throw new UnknownEntityException("User with id '" + id + "' does not exist.", e);
} catch (TorqueException e) {
throw new DataBackendException("Error retrieving user information", e);
} finally {
if (con != null) {
Transaction.safeRollback(con);
}
}
} else {
throw new UnknownEntityException("Invalid user id '" + id + "'");
}
return user;
}
}