OrgRoleBean.java

/*
 * Copyright Codecrew Ry
 * 
 * All rights reserved.
 * 
 * This license applies to any software containing a notice placed by the 
 * copyright holder. Such software is herein referred to as the Software. 
 * This license covers modification, distribution and use of the Software. 
 * 
 * Any distribution and use in source and binary forms, with or without 
 * modification is not permitted without explicit written permission from the 
 * copyright owner. 
 * 
 * A non-exclusive royalty-free right is granted to the copyright owner of the 
 * Software to use, modify and distribute all modifications to the Software in 
 * future versions of the Software. 
 * 
 */
package fi.codecrew.moya.beans;

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

import javax.annotation.security.DeclareRoles;
import javax.annotation.security.RolesAllowed;
import javax.ejb.EJB;
import javax.ejb.LocalBean;
import javax.ejb.Stateless;

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

import fi.codecrew.moya.enums.apps.UserPermission;
import fi.codecrew.moya.facade.OrgRoleFacade;
import fi.codecrew.moya.facade.OrgRoleRequestFacade;
import fi.codecrew.moya.facade.RoleFacade;
import fi.codecrew.moya.facade.UserFacade;
import fi.codecrew.moya.model.OrgRole;
import fi.codecrew.moya.model.OrgRoleRequest;
import fi.codecrew.moya.model.Role;
import fi.codecrew.moya.model.User;
import fi.codecrew.moya.utilities.jpa.GenericFacade;

/**
 * Session Bean implementation class OrgRoleBean
 */
@Stateless
@LocalBean
@DeclareRoles({
		UserPermission.S_READ_ORGROLES,
		UserPermission.S_WRITE_ORGROLES,
		UserPermission.S_REQUEST_ORGROLES,
})
public class OrgRoleBean implements OrgRoleBeanLocal {

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

	@EJB
	private EventBeanLocal eventBean;

	@EJB
	private OrgRoleFacade orgRoleFacade;

	@EJB
	private RoleBean rolebean;
	@EJB
	private UserFacade userFacade;
	@EJB
	private RoleFacade roleFacade;
	@EJB
	private PermissionBean permbean;
	@EJB
	private OrgRoleRequestFacade orgrolerequestfacade;

	public OrgRoleBean() {
	}

	@Override
	@RolesAllowed({ UserPermission.S_READ_ORGROLES, })
	public List<OrgRole> listOrgRoles() {
		return orgRoleFacade.findByOrganizer(eventBean.getCurrentEvent().getOrganiser());
	}

	@Override
	@RolesAllowed({ UserPermission.S_READ_ORGROLES, })
	public OrgRole find(Integer id) {
		return orgRoleFacade.find(id);
	}

	@Override
	@RolesAllowed({ UserPermission.S_READ_ORGROLES, })
	public List<OrgRole> getPossibleParents(OrgRole orgRole) {

		List<OrgRole> roleList = orgRoleFacade.findAll();

		if (orgRole == null) {
			return roleList;
		}

		List<OrgRole> children = getAllChilds(orgRole, new HashSet<OrgRole>());

		for (OrgRole unit : children) {
			if (roleList.contains(unit)) {
				roleList.remove(unit);
			}
		}
		roleList.remove(orgRole);
		return roleList;
	}

	@RolesAllowed({ UserPermission.S_READ_ORGROLES, })
	private List<OrgRole> getAllChilds(OrgRole orgRole,
			HashSet<OrgRole> checkedRoles) {
		List<OrgRole> returnList = new ArrayList<OrgRole>();

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

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

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

		return returnList;
	}

	@Override
	@RolesAllowed({ UserPermission.S_WRITE_ORGROLES })
	public void create(OrgRole orgRole) {
		orgRoleFacade.create(orgRole);
	}

	@Override
	@RolesAllowed({ UserPermission.S_WRITE_ORGROLES })
	public OrgRole addRole(User user, OrgRole orgRole) {
		orgRole = orgRoleFacade.reload(orgRole);
		user = userFacade.reload(user);
		if (!orgRole.getUsers().contains(user)) {
			orgRole.getUsers().add(user);
		}
		return orgRole;
	}

	@Override
	@RolesAllowed({ UserPermission.S_WRITE_ORGROLES })
	public OrgRole save(OrgRole orgRole) {
		orgRole = orgRoleFacade.merge(orgRole);
		return orgRole;
	}

	@Override
	@RolesAllowed({ UserPermission.S_READ_ORGROLES })
	public List<Role> getPossibleEventroles(OrgRole orgRole) {
		orgRole = orgRoleFacade.reload(orgRole);
		List<Role> roles = rolebean.listRoles();
		if (orgRole != null) {
			HashSet<Role> childroles = new HashSet<Role>();

			for (Role r : orgRole.getEventRoles()) {
				RoleBean.getAllChildren(r, childroles);
			}
			roles.removeAll(childroles);
		}
		return roles;
	}

	@Override
	@RolesAllowed({ UserPermission.S_READ_ORGROLES })
	public OrgRole addEventRole(Role eventRole, OrgRole orgRole) {
		eventRole = roleFacade.reload(eventRole);

		orgRole = orgRoleFacade.reload(orgRole);

		if (eventRole.getOrgRoles() == null) {
			eventRole.setOrgRoles(new ArrayList<>());
		}
		if (orgRole.getEventRoles() == null) {
			orgRole.setEventRoles(new ArrayList<>());
		}

		if (!orgRole.getEventRoles().contains(orgRole)) {
			orgRole.getEventRoles().add(eventRole);
		}

		if (!eventRole.getOrgRoles().contains(orgRole)) {
			eventRole.getOrgRoles().add(orgRole);
		}

		return orgRole;
	}

	@Override
	@RolesAllowed({ UserPermission.S_REQUEST_ORGROLES })
	public void createRequest(OrgRoleRequest request) {
		request.setRequestDate(new Date());
		request.setUser(permbean.getCurrentUser().getUser());
		orgrolerequestfacade.create(request);
	}

	@Override
	@RolesAllowed({ UserPermission.S_REQUEST_ORGROLES })
	public List<OrgRole> getRequestableRoles() {
		return orgRoleFacade.findUserRequestable();
	}

	@Override
	@RolesAllowed({ UserPermission.S_WRITE_ORGROLES })
	public List<OrgRoleRequest> getRequests(boolean showAll) {
		return orgrolerequestfacade.findForOrganiser(showAll);
	}

	@Override
	@RolesAllowed({ UserPermission.S_WRITE_ORGROLES })
	public OrgRoleRequest saveRequest(OrgRoleRequest request) {
		return orgrolerequestfacade.merge(request);
	}

	@Override
	@RolesAllowed({ UserPermission.S_WRITE_ORGROLES })
	public OrgRoleRequest requestOk(OrgRoleRequest request) {
		OrgRoleRequest req = orgrolerequestfacade.reload(request);
		req.setHandler(permbean.getCurrentUser().getUser());
		req.setHandledNotes(request.getHandledNotes());
		req.setRequestHandled(new Date());
		addRole(req.getUser(), req.getRequestedRole());
		return req;
	}
}