UserRoleServiceImpl.java

/**
 * Copyright 2011 the original author or authors.
 *
 * Licensed 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.
 */
package org.bricket.plugin.user_role.service.impl;

import java.util.ArrayList;
import java.util.List;

import javax.annotation.Resource;

import org.bricket.plugin.role.domain.Role;
import org.bricket.plugin.role.service.RoleService;
import org.bricket.plugin.role.service.RoleService.Roles;
import org.bricket.plugin.user.domain.User;
import org.bricket.plugin.user.service.UserService;
import org.bricket.plugin.user.service.UserService.Users;
import org.bricket.plugin.user_role.domain.UserRole;
import org.bricket.plugin.user_role.domain.UserRole.Type;
import org.bricket.plugin.user_role.repository.UserRoleDao;
import org.bricket.plugin.user_role.repository.impl.UserRoleSpecifications;
import org.bricket.plugin.user_role.service.UserRoleService;
import org.bricket.plugin.user_role.service.UserRoleServiceException;
import org.bricket.service.BricketServiceException;
import org.bricket.service.BricketServiceImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.synyx.hades.domain.Order;
import org.synyx.hades.domain.PageRequest;

/**
 * @author Ingo Renner
 * @author Henning Teek
 */
@Service(value = "userRoleService")
@Transactional(readOnly = true)
public class UserRoleServiceImpl extends BricketServiceImpl implements UserRoleService {
    private final Logger log = LoggerFactory.getLogger(UserRoleServiceImpl.class);

    @Autowired
    private RoleService roleService;

    @Autowired
    private UserService userService;

    @Resource
    private UserRoleDao userRoleDao;

    @Transactional
    @Override
    protected void onInit() throws BricketServiceException {
        roleService.init();
        userService.init();

        User user = userService.loadUserByEmail(Users.SUPER_ADMIN.getEmail());
        if (user != null && loadRolesByUser(user).size() == 0) {
            try {
                assignRole(user, Roles.ROLE_SUPERUSER.name());
                assignRole(user, Roles.ROLE_ADMIN.name());
                assignRole(user, Roles.ROLE_USER.name());
            } catch (BricketServiceException e) {
                log.error("error assigning super admin user role to user: " + user, e);
            }
        }

        user = userService.loadUserByEmail(Users.ADMIN.getEmail());
        if (user != null && loadRolesByUser(user).size() == 0) {
            try {
                assignRole(user, Roles.ROLE_ADMIN.name());
                assignRole(user, Roles.ROLE_USER.name());
            } catch (BricketServiceException e) {
                log.error("error assigning admin user role to user: " + user, e);
            }
        }
        log.info("user role service initialized");
    }

    @Override
    @Transactional
    public UserRole saveUserRole(UserRole userRole) throws BricketServiceException {
        return userRoleDao.save(userRole);
    }

    @Override
    @Transactional
    public void deleteUserRole(UserRole userRole) throws BricketServiceException {
        userRoleDao.delete(userRoleDao.readByPrimaryKey(userRole.getId()));
    }

    @Override
    public UserRole loadUserRole(Long id) {
        return userRoleDao.readByPrimaryKey(id);
    }

    @Override
    public List<UserRole> loadUserRoleByUser(long userId, int from, int count, String sortProperty, boolean sortAsc) {
        final PageRequest pageable;

        int page;

        if (from > 0) {
            page = from / count;
        } else {
            page = 0;
        }

        if (sortProperty == null || "".equals(sortProperty.trim())) {
            pageable = new PageRequest(page, count);
        } else {
            pageable = new PageRequest(page, count, sortAsc ? Order.ASCENDING : Order.DESCENDING, sortProperty);
        }
        return userRoleDao.findByUser(userService.loadUser(userId), pageable);
    }

    @Override
    public int getCountByUser(long userId) {
        return userRoleDao.count(UserRoleSpecifications.hasUser(userId)).intValue();
    }

    @Override
    public UserRole createDomainObject() {
        UserRole userRole = new UserRole();
        userRole.setType(Type.DEFAULT);
        return userRole;
    }

    @Override
    public List<Role> loadRolesByUser(User user) {
        ArrayList<Role> roles = new ArrayList<Role>();
        for (UserRole userRole : userRoleDao.findByUser(user)) {
            Role role = userRole.getRole();
            if (!roles.contains(role)) {
                roles.add(role);
                log.debug("added role: {} to user: {}", role, user);
            }
        }
        return roles;
    }

    @Override
    public List<Role> loadRolesByUser(long userId) {
        return loadRolesByUser(userService.loadUser(userId));
    }

    @Override
    @Transactional
    public void assignRole(long userId, String rolename) throws BricketServiceException {
        assignRole(userService.loadUser(userId), roleService.loadRoleByName(rolename));
    }

    @Override
    @Transactional
    public void assignRole(User user, String rolename) throws BricketServiceException {
        assignRole(user, roleService.loadRoleByName(rolename));
    }

    private void assignRole(User user, Role role) throws BricketServiceException {
        if (role != null) {
            UserRole ur = createDomainObject();
            ur.setUser(user);
            ur.setRole(role);
            saveUserRole(ur);
            return;
        }
        throw new BricketServiceException(UserRoleServiceException.USER_ROLE_SERVICE_ASSIGN_ROLE_FAILED);
    }

    @Override
    @Transactional
    public void assignRoles(User user, List<String> roles) throws BricketServiceException {
        if (roles != null && !roles.isEmpty()) {
            for (String role : roles) {
                assignRole(user, roleService.loadRoleByName(role));
            }
        }
    }

    @Override
    public boolean hasRole(User user, String rolename) {
        Role role = roleService.loadRoleByName(rolename);
        if (role != null) {
            return !userRoleDao.findByUserAndRole(user, role).isEmpty();
        }
        return false;
    }

    @Override
    public List<Role> loadAllRoles() {
        return roleService.loadAllRoles();
    }
}