DatabaseUserServer.java

package org.pegadi.server.user;

import no.dusken.common.model.Person;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.dao.DataAccessException;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.simple.ParameterizedRowMapper;

import javax.sql.DataSource;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

/**
 * User: jan-preben
 * Date: Sep 9, 2010
 *
 * Sub classes of this class generate all sql query strings used
 */
public abstract class DatabaseUserServer extends AbstractUserServer {

    private final Logger log = LoggerFactory.getLogger(getClass());

    private ParameterizedRowMapper<Person> rowMapper;
    private JdbcTemplate template;

    public DatabaseUserServer() {

        rowMapper = getRowMapper();
    }

    protected abstract ParameterizedRowMapper<Person> getRowMapper();

    protected abstract String getUserByIdQuery();   //GetUserByIdQuery
    protected abstract String getUserByUsernameQuery();
    protected abstract String loginQuery();
    protected abstract String getUsersByRoleQuery();
    protected abstract String getAllUsersQuery(boolean inactive); //getAllUsersQuery
    protected abstract String isActiveQuery();
    protected abstract String hasRoleQuery();


    public void setDataSource(DataSource dataSource) {
        super.setDataSource(dataSource);
        template = new JdbcTemplate(dataSource);
    }

    @Cacheable("Person")
    public Person getUserByUsername(String username) {
        log.info("querying for user with username: {}", username);
        try {
            return template.queryForObject(getUserByUsernameQuery(), rowMapper, username);
        } catch(EmptyResultDataAccessException e) {
            log.info("User not found: {}", username, e);
            return null;
        }
    }

    @Override
    public Person getUserByLegacyId(Integer legacyId) {
        log.info("querying for user with legacy id: {}", legacyId);
        try {
            return template.queryForObject("SELECT * FROM person INNER JOIN users_transform on (person.username = users_transform.username) WHERE users_transform.asInt = ?", rowMapper, legacyId.toString());
        } catch(EmptyResultDataAccessException e) {
            log.info("User not found: {}", legacyId, e);
            return null;
        }
    }

    public String login(String userName) {
        log.info("trying to login user: {}", userName);
        try {
            Integer userId = template.queryForInt(loginQuery(), userName);
            return userName;
        } catch(DataAccessException e) {
            log.info("user not found");
            return null;
        }
    }


    public List<Person> getUsersByRole(int roleID, int active) {
        try {
            String query = getUsersByRoleQuery();
            return template.query(query, rowMapper, roleID, active);
        } catch(DataAccessException e) {
            log.error("error getting users by role", e);
            return new ArrayList<Person>();
        }
    }

    public boolean canPublish(Long userID) {
        return true;
    } 

    public List<Person> getJournalists() {
        return getUsersByRole(journalistRoleId, 1);  // Kanskje unødvendig å hå med active parameteren, blir den noengang brukt?
    }

    public List<Person> getPhotographers() {
        return getUsersByRole(photographerRoleId, 1);
    }

    public List<Person> getAllUsers(boolean inactive) {
        return template.query(getAllUsersQuery(inactive), rowMapper);
    }

    public boolean isActive(String userID) {
        int active = template.queryForInt(isActiveQuery(), userID);
        return active > 0;
    }


    public boolean hasRole(Integer roleID, Long userID) {
        try {
            int hasRole = template.queryForInt(hasRoleQuery(), roleID, userID);
            return hasRole > 0;
        } catch(DataAccessException e) {

            return false;
        }
    }


    protected String createInitials(String name) {
        StringBuilder res = new StringBuilder(10);
        StringTokenizer st = new StringTokenizer(name, " ");

        while (st.hasMoreTokens()) {
            res.append(st.nextToken().charAt(0));
        }

        return res.toString().toLowerCase();
    }

}