RoleBean.java

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package fi.insomnia.bortal.beans;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import javax.annotation.Resource;
import javax.annotation.security.DeclareRoles;
import javax.annotation.security.RolesAllowed;
import javax.ejb.EJB;
import javax.ejb.SessionContext;
import javax.ejb.Stateless;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import fi.insomnia.bortal.enums.apps.IAppPermission;
import fi.insomnia.bortal.enums.apps.UserPermission;
import fi.insomnia.bortal.facade.RoleFacade;
import fi.insomnia.bortal.facade.UserFacade;
import fi.insomnia.bortal.model.ApplicationPermission;
import fi.insomnia.bortal.model.Role;
import fi.insomnia.bortal.model.User;

/**
 * 
 * @author tuukka
 */
@Stateless
@DeclareRoles({ UserPermission.S_READ_ROLES, UserPermission.S_WRITE_ROLES })
public class RoleBean implements RoleBeanLocal {

	// private static final String PUBLIC_ROLE_NAME =
	// BeanRole.ANONYMOUS.toString();
	private static final Logger logger = LoggerFactory.getLogger(RoleBean.class);
	@Resource
	private SessionContext sc;
	@EJB
	private EventBeanLocal eventBean;
	@EJB
	private RoleFacade roleFacade;
	@EJB
	private UserFacade userFacade;

	@Override
	@RolesAllowed(UserPermission.S_READ_ROLES)
	public List<Role> listRoles() {
		return roleFacade.findAll();
	}

	@Override
	@RolesAllowed(UserPermission.S_WRITE_ROLES)
	public Role mergeChanges(Role role) {
		return roleFacade.merge(role);
	}

	@Override
	@RolesAllowed(UserPermission.S_WRITE_ROLES)
	public void create(Role role) {
		roleFacade.create(role);
	}

	@Override
	@RolesAllowed(UserPermission.S_READ_ROLES)
	public List<Role> getPossibleParents(Role role) {

		List<Role> roleList = listRoles();
		if (role == null) {
			return roleList;
		}

		List<Role> children = getAllChilds(role, new HashSet<Role>());

		for (Role unit : children) {
			if (roleList.contains(unit)) {
				roleList.remove(unit);
			}
		}
		roleList.remove(role);
		return roleList;
	}

	private static List<Role> getAllChilds(Role role, Set<Role> checkedRoles) {

		List<Role> returnList = new ArrayList<Role>();

		if (checkedRoles.contains(role) || role == null) {
			return returnList;
		}

		for (Role unit : role.getChildren()) {
			List<Role> someList = getAllChilds(unit, checkedRoles);

			returnList.addAll(someList);
		}
		checkedRoles.add(role);

		return returnList;
	}

	// @Override
	// @RolesAllowed("ROLE_MANAGEMENT/READ")
	// public List<RoleRight> getRoleRights(Role r) {
	//
	// List<RoleRight> ret = new ArrayList<RoleRight>();
	// for (Permission perm : Permission.values()) {
	// ret.add(findRoleRight(r, perm));
	// }
	// return ret;
	// }

	// @Override
	// @RolesAllowed("ROLE_MANAGEMENT/WRITE")
	// public RoleRight mergeChanges(RoleRight row) {
	//
	// return rrfacade.merge(row);
	// }

	// @RolesAllowed("ROLE_MANAGEMENT/READ")
	// public RoleRight findRoleRight(Role role, Permission perm) {
	// RoleRight rr = rrfacade.find(perm, role);
	// if (rr == null) {
	// rr = new RoleRight(role, perm, false, false, false);
	// rrfacade.create(rr);
	// }
	// return rr;
	// }

	@Override
	public Role find(int id) {
		return roleFacade.find(id);
	}

	@Override
	@RolesAllowed(UserPermission.S_WRITE_ROLES)
	public Role setPermissions(Role role, List<IAppPermission> newPerms) {
		role = roleFacade.find(role.getId());
		List<ApplicationPermission> permissions = role.getPermissions();
		HashSet<ApplicationPermission> rmlist = new HashSet<ApplicationPermission>();

		for (ApplicationPermission appPerm : permissions) {
			// If role contains permission not in parameter newPerms remove
			// it.
			if (!newPerms.contains(appPerm.getPermission())) {
				rmlist.add(appPerm);
			}
			// remove handled permission from newPerms
			newPerms.remove(appPerm.getPermission());
		}

		// Concurrent modification prevention!!
		if (!rmlist.isEmpty()) {
			permissions.removeAll(rmlist);
		}

		// Add permissions not existing in role
		for (IAppPermission perm : newPerms) {
			permissions.add(new ApplicationPermission(role, perm));
		}
		roleFacade.flush();
		return role;
	}

	@Override
	@RolesAllowed(UserPermission.S_READ_ROLES)
	public List<Role> getRoles(User user) {
		return roleFacade.findForUser(user);
	}

	@Override
	@RolesAllowed(UserPermission.S_WRITE_ROLES)
	public void saveRoles(User usr, List<Role> usersRoles) {

		List<Role> allRoles = roleFacade.findAll();
		for (Role ur : allRoles)
		{
			if (usersRoles.contains(ur)) {
				if (!ur.getUsers().contains(usr)) {
					ur.getUsers().add(usr);
				}
			} else {
				ur.getUsers().remove(usr);
			}
		}
	}
}