EventBean.java

package fi.insomnia.bortal.beans;

import java.util.ArrayList;
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 javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

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

import fi.insomnia.bortal.clientutils.BortalLocalContextHolder;
import fi.insomnia.bortal.enums.apps.EventPermission;
import fi.insomnia.bortal.enums.apps.SpecialPermission;
import fi.insomnia.bortal.facade.EventFacade;
import fi.insomnia.bortal.facade.EventOrganiserFacade;
import fi.insomnia.bortal.facade.LanEventDomainFacade;
import fi.insomnia.bortal.facade.LanEventPrivatePropertyFacade;
import fi.insomnia.bortal.facade.LanEventPropertyFacade;
import fi.insomnia.bortal.model.EventOrganiser;
import fi.insomnia.bortal.model.LanEvent;
import fi.insomnia.bortal.model.LanEventDomain;
import fi.insomnia.bortal.model.LanEventPrivateProperty;
import fi.insomnia.bortal.model.LanEventPrivatePropertyKey;
import fi.insomnia.bortal.model.LanEventProperty;
import fi.insomnia.bortal.model.LanEventPropertyKey;

/**
 * Session Bean implementation class EventBean
 */
@Stateless
@LocalBean
@DeclareRoles({ EventPermission.S_MANAGE_PRIVATE_PROPERTIES,
		EventPermission.S_MANAGE_PROPERTIES,
		SpecialPermission.S_ORGANISATION_ADMIN,
		SpecialPermission.S_SUPERADMIN,
})
public class EventBean implements EventBeanLocal {

	private static final String DEFAULT_EVENT_NAME = "Default event";
	private static final String DEFAULT_ORGANISATION_NAME = "Default organisation";
	private static final Logger logger = LoggerFactory.getLogger(EventBean.class);
	private static final String DEFAULT_EVENT_DOMAIN = null;
	@EJB
	private EventFacade eventFacade;

	@EJB
	private EventOrganiserFacade eventOrganiserFacade;

	@PersistenceContext
	private EntityManager em;
	@EJB
	private LoggingBeanLocal loggingbean;
	@EJB
	private PermissionBeanLocal permbean;
	@EJB
	private LanEventDomainFacade domainfacade;
	@EJB
	private LanEventPropertyFacade eventPropertyFacade;
	@EJB
	private LanEventPrivatePropertyFacade eventPrivatePropertyFacade;

	@Override
	public LanEvent getEventByHostname(String hostname) {

		LanEvent ret = eventFacade.findByHostname(hostname);
		if (ret == null) {
			ret = findOrCreateDefaultEvent();
		}
		return ret;
	}

	public LanEvent findOrCreateDefaultEvent() {
		LanEvent ret = eventFacade.findByName(DEFAULT_EVENT_NAME);
		if (ret == null) {
			logger.info("Default Event does not exist! creating new.");
			ret = new LanEvent();

			ret.setName(DEFAULT_EVENT_NAME);
			ret.setOrganiser(findOrCreateDefaultEventOrganisation());
			eventFacade.create(ret);
			em.flush();
		}
		return ret;
	}

	public EventOrganiser findOrCreateDefaultEventOrganisation() {
		EventOrganiser settings = eventOrganiserFacade.findByOrganisation(DEFAULT_ORGANISATION_NAME);

		if (settings == null) {
			settings = new EventOrganiser();
			settings.setOrganisation(DEFAULT_ORGANISATION_NAME);

			eventOrganiserFacade.create(settings);
		}

		return settings;
	}

	@Override
	public LanEvent getCurrentEvent() {
		String hostname = BortalLocalContextHolder.getHostname();

		// logger.info("Current hostname from context: {}", hostname);
		LanEvent ret = null;

		if (BortalLocalContextHolder.getHostnameId() != null) {
			ret = eventFacade.find(BortalLocalContextHolder.getHostnameId());
			if (ret != null) {
				return ret;
			}
		}

		if (hostname == null || hostname.isEmpty()) {
			hostname = DEFAULT_EVENT_DOMAIN;
		}
		LanEventDomain domain = domainfacade.findByDomain(hostname);

		if (domain != null) {
			ret = domain.getEvent();
		}

		if (ret == null) {
			ret = this.findOrCreateDefaultEvent();
		}

		BortalLocalContextHolder.setHostnameId(ret.getId());
		return ret;

	}

	@Override
	@RolesAllowed({ SpecialPermission.S_SUPERADMIN, SpecialPermission.S_ORGANISATION_ADMIN })
	public LanEvent mergeChanges(LanEvent event) {

		return eventFacade.merge(event);
	}

	@Override
	@RolesAllowed({ SpecialPermission.S_SUPERADMIN, SpecialPermission.S_ORGANISATION_ADMIN })
	public void create(LanEvent event) {

		eventFacade.create(event);

	}

	@Override
	public String flushCache() {
		return eventFacade.flushCache();

	}

	@Override
	@RolesAllowed({ EventPermission.S_MANAGE_PRIVATE_PROPERTIES, SpecialPermission.S_ORGANISATION_ADMIN })
	public List<LanEventPrivateProperty> getPrivateProperties()
	{
		return eventPrivatePropertyFacade.findAllForEvent();
	}

	// This method should not be overridden!
	// Private properties should not be viewable outside EJB layer
	// without MANAGE_PRIVATE_PROPERTIES role
	public LanEventPrivateProperty getPrivateProperty(LanEventPrivatePropertyKey property) {
		logger.info("Returning property {} from {}", property, eventPrivatePropertyFacade);
		return eventPrivatePropertyFacade.getPropertyForEvent(property);
	}

	public String getPrivatePropertyString(LanEventPrivatePropertyKey property) {
		LanEventPrivateProperty retProp = eventPrivatePropertyFacade.getPropertyForEvent(property);
		String ret = null;
		if (retProp == null) {
			ret = property.getDefaultvalue();
		} else {
			ret = retProp.getTextvalue();
		}
		return ret;
	}

	@Override
	public LanEventProperty getProperty(LanEventPropertyKey property) {
		return eventPropertyFacade.find(getCurrentEvent(), property);
	}

	@Override
	public String getPropertyString(LanEventPropertyKey property)
	{
		LanEventProperty retProp = eventPropertyFacade.find(getCurrentEvent(), property);
		String ret = null;
		if (retProp == null) {
			ret = property.getDefaultvalue();
		} else {
			ret = retProp.getTextvalue();
		}
		return ret;
	}

	@Override
	@RolesAllowed({ SpecialPermission.S_SUPERADMIN, SpecialPermission.S_ORGANISATION_ADMIN })
	public LanEventProperty saveOrCreateProperty(LanEventProperty property) {
		LanEventProperty ret = null;
		logger.info("Saving property {}, eventorg {}, key {}", new Object[] { property.getEvent(), property.getEventorg(), property.getKey() });

		if (property.getId() == null)
		{
			ret = property;
			// eventPropertyFacade.create(property);
			LanEvent event = eventFacade.reload(property.getEvent());
			if (event.getProperties() == null)
			{
				event.setProperties(new ArrayList<LanEventProperty>());
			}
			event.getProperties().add(property);

		}
		else
		{
			ret = eventPropertyFacade.merge(property);
		}
		return ret;

	}

	@Override
	@RolesAllowed({ SpecialPermission.S_SUPERADMIN, SpecialPermission.S_ORGANISATION_ADMIN })
	public EventOrganiser mergeChanges(EventOrganiser eventorg) {
		return eventOrganiserFacade.merge(eventorg);
	}

	@Override
	@RolesAllowed({ EventPermission.S_MANAGE_PRIVATE_PROPERTIES, SpecialPermission.S_ORGANISATION_ADMIN })
	public LanEventPrivateProperty saveOrCreatePrivateProperty(LanEventPrivateProperty privateProperty) {
		LanEventPrivateProperty ret = null;
		logger.info("Saving property {}, eventorg {}, key {}", new Object[] { privateProperty.getEvent(), privateProperty.getEventorg(), privateProperty.getKey() });

		if (privateProperty.getId() == null)
		{
			ret = privateProperty;
			// eventPropertyFacade.create(property);
			eventPrivatePropertyFacade.create(privateProperty);
		} else {
			ret = eventPrivatePropertyFacade.merge(privateProperty);
		}
		return ret;
	}

}