RoleView.java

package fi.codecrew.moya.web.cdiview.user;

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

import javax.ejb.EJB;
import javax.enterprise.context.ConversationScoped;
import javax.inject.Named;

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

import fi.codecrew.moya.beans.EventBeanLocal;
import fi.codecrew.moya.beans.RoleBeanLocal;
import fi.codecrew.moya.beans.UserBeanLocal;
import fi.codecrew.moya.enums.BortalApplication;
import fi.codecrew.moya.enums.apps.IAppPermission;
import fi.codecrew.moya.enums.apps.UserPermission;
import fi.codecrew.moya.model.ApplicationPermission;
import fi.codecrew.moya.model.EventUser;
import fi.codecrew.moya.model.Role;
import fi.codecrew.moya.model.User;
import fi.codecrew.moya.util.UserSearchQuery;
import fi.codecrew.moya.utilities.SearchResult;
import fi.codecrew.moya.web.cdiview.GenericCDIView;
import fi.codecrew.moya.web.helpers.BortalApplicationWrapper;

@ConversationScoped
@Named
public class RoleView extends GenericCDIView {

	/**
	 * 
	 */
	private static final long serialVersionUID = -5165373936500592099L;

	private Role role;
	private Integer roleid;

	@EJB
	private transient RoleBeanLocal rolebean;
	@EJB
	private transient EventBeanLocal eventbean;

	private ArrayList<BortalApplicationWrapper> rolePermissions;
	@EJB
	private UserBeanLocal userbean;

	private User addableUser;

	private static final Logger logger = LoggerFactory.getLogger(RoleView.class);

	public void permissionCreate() {
		requirePermissions(permbean.hasPermission(UserPermission.WRITE_ROLES));
	}

	public void permissionRead() {
		requirePermissions(permbean.hasPermission(UserPermission.READ_ROLES));
	}

	public void initForCreate() {
		if (requirePermissions(permbean.hasPermission(UserPermission.WRITE_ROLES))) {
			setRole(new Role(eventbean.getCurrentEvent()));
			super.beginConversation();
		}
	}

	public void addUser()
	{
		EventUser eu = userbean.getEventUser(addableUser, false);
		role = rolebean.addRole(eu, role);
		addableUser = null;
	}

	public List<User> searchUser(String user)
	{
		// By default this returns only 20 first results.
		UserSearchQuery usq = new UserSearchQuery();
		usq.setSearch(user);
		usq.setOnlyThisEvent(false);
		SearchResult<User> ret = userbean.getUsers(usq);
		return ret.getResults();
	}

	public boolean isCanReadRoles() {
		return permbean.hasPermission(UserPermission.READ_ROLES);
	}

	public boolean isCanWriteRoles() {
		return permbean.hasPermission(UserPermission.WRITE_ROLES);
	}

	public void initViewFromId() {
		if (requirePermissions(UserPermission.READ_ROLES) && role == null) {
			super.beginConversation();
			setRole(rolebean.find(getRoleid()));

			logger.debug("Initialized role: {} from id ", getRole(), getRoleid());
		}
	}

	private void initPermissions() {

		logger.info("Initializing permissions for role {}", role);
		EnumMap<BortalApplication, Set<IAppPermission>> rolePermissionMap = new EnumMap<BortalApplication, Set<IAppPermission>>(BortalApplication.class);
		if (role.getPermissions() == null) {
			role.setPermissions(new ArrayList<ApplicationPermission>());
		}
		for (ApplicationPermission perm : role.getPermissions()) {
			Set<IAppPermission> permlist = rolePermissionMap.get(perm.getApplication());
			if (permlist == null) {
				permlist = new HashSet<IAppPermission>();
				rolePermissionMap.put(perm.getApplication(), permlist);
				logger.info("Initing Role permisions App {}, role {}", perm.getApplication(), perm.getPermission());

			}

			permlist.add(perm.getPermission());
		}

		setRolePermissions(new ArrayList<BortalApplicationWrapper>());
		for (BortalApplication bApp : BortalApplication.values()) {

			getRolePermissions().add(new BortalApplicationWrapper(bApp, rolePermissionMap.get(bApp)));
		}

	}

	public String create() {
		super.requirePermissions(permbean.hasPermission(UserPermission.WRITE_ROLES));
		rolebean.create(getRole());

		return "/role/edit";
	}

	public String save() {

		setRole(rolebean.mergeChanges(getRole()));
		return "roleSaved";
	}

	public String savePermissions() {
		if (isCanWriteRoles()) {
			ArrayList<IAppPermission> newPerms = new ArrayList<IAppPermission>();
			for (BortalApplicationWrapper appWrap : rolePermissions) {
				for (IAppPermission apWrap : appWrap.getPermissions()) {
					if (appWrap.getSelected().contains(apWrap.toString())) {
						newPerms.add(apWrap);
					}
				}
			}
			setRole(rolebean.setPermissions(getRole(), newPerms));

			this.addFaceMessage("role.permissionsSaved");

		} else {
			this.addFaceMessage("global.notAuthorizedExecute");
		}

		return null;
	}

	public Role getRole() {
		return role;
	}

	/**
	 * @return the possibleParents
	 */
	public List<Role> getPossibleParents() {
		return rolebean.getPossibleParents(getRole());
	}

	public void setRoleid(Integer roleid) {
		this.roleid = roleid;
	}

	public Integer getRoleid() {
		return roleid;
	}

	public void setRolePermissions(ArrayList<BortalApplicationWrapper> rolePermissions) {
		this.rolePermissions = rolePermissions;
	}

	public ArrayList<BortalApplicationWrapper> getRolePermissions() {
		return rolePermissions;
	}

	public void setRole(Role role) {

		this.role = role;
		initPermissions();
	}

	public User getAddableUser() {
		return addableUser;
	}

	public void setAddableUser(User addableUser) {
		this.addableUser = addableUser;
	}

}