EventBean.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.security.Principal;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

import javax.annotation.Resource;
import javax.annotation.security.DeclareRoles;
import javax.annotation.security.RolesAllowed;
import javax.ejb.*;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import fi.codecrew.moya.utilities.UserLoginUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import fi.codecrew.moya.enums.apps.EventPermission;
import fi.codecrew.moya.enums.apps.SpecialPermission;
import fi.codecrew.moya.enums.apps.UserPermission;
import fi.codecrew.moya.facade.EventFacade;
import fi.codecrew.moya.facade.EventOrganiserFacade;
import fi.codecrew.moya.facade.LanEventDomainFacade;
import fi.codecrew.moya.facade.LanEventPrivatePropertyFacade;
import fi.codecrew.moya.facade.LanEventPropertyFacade;
import fi.codecrew.moya.model.EventOrganiser;
import fi.codecrew.moya.model.LanEvent;
import fi.codecrew.moya.model.LanEventDomain;
import fi.codecrew.moya.model.LanEventPrivateProperty;
import fi.codecrew.moya.model.LanEventPrivatePropertyKey;
import fi.codecrew.moya.model.LanEventProperty;
import fi.codecrew.moya.model.LanEventPropertyKey;

/**
 * Session Bean implementation class EventBean
 */
@Stateless
@LocalBean
@DeclareRoles({
	EventPermission.S_MANAGE_PRIVATE_PROPERTIES,
	EventPermission.S_MANAGE_PROPERTIES,
	EventPermission.S_MANAGE_EVENT,
	SpecialPermission.S_SUPERADMIN,
	SpecialPermission.S_USER
})
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;

	@Resource
	private SessionContext context;

	@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;
	@EJB
	private LoggingBeanLocal logbean;

	public LanEvent findOrCreateDefaultEvent() {
		LanEvent ret = eventFacade.find(1);
		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;
	}

	public String getCurrentHostname() {
		Principal principal = context.getCallerPrincipal();
		String hostname = null;
		if (principal != null) {
			hostname = UserLoginUtils.getDomainFromJaas(principal);
		}
		return hostname;

	}

	@Override
	public LanEvent getCurrentEvent() {
		LanEvent ret = null;
		String hostname = getCurrentHostname();
		ret = getEventForHostname(hostname);
		return ret;
	}

	public LanEvent getEventForHostname(String hostname) {

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

		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();
		}

		return ret;
	}

	@Override
	@RolesAllowed({SpecialPermission.S_SUPERADMIN, EventPermission.S_MANAGE_EVENT})
	public LanEvent mergeChanges(LanEvent event) {
		if (!permbean.hasPermission(SpecialPermission.SUPERADMIN) && !getCurrentEvent().equals(event)) {
			throw new EJBAccessException("Trying to save another event.");
		}
		return eventFacade.merge(event);
	}

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

		eventFacade.create(event);

	}

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

	}

	@Override
	@RolesAllowed({EventPermission.S_MANAGE_PRIVATE_PROPERTIES, EventPermission.S_MANAGE_EVENT})
	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 long getPropertyLong(LanEventPropertyKey property) {
		LanEventProperty retProp = eventPropertyFacade.find(getCurrentEvent(), property);
		long ret = 0;
		if (retProp == null) {
			ret = property.getDefaultLong();
		} else {
			ret = retProp.getLongValue();
		}
		return ret;
	}

	@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
	public boolean getPropertyBoolean(LanEventPropertyKey property) {

		LanEventProperty retProp = eventPropertyFacade.find(getCurrentEvent(), property);
		boolean ret = false;

		if (retProp == null) {
			String def = property.getDefaultvalue();
			if (def != null && !def.trim().isEmpty() && def.trim().equals("1"))
				ret = true;

		} else {
			ret = retProp.isBooleanValue();
		}

		return ret;
	}

	@Override
	@RolesAllowed({SpecialPermission.S_SUPERADMIN, EventPermission.S_MANAGE_EVENT})
	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());
			property.setEvent(event);
			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, EventPermission.S_MANAGE_EVENT})
	public EventOrganiser mergeChanges(EventOrganiser eventorg) {
		return eventOrganiserFacade.merge(eventorg);
	}

	@Override
	@RolesAllowed({EventPermission.S_MANAGE_PRIVATE_PROPERTIES, EventPermission.S_MANAGE_EVENT})
	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;
			eventPrivatePropertyFacade.create(privateProperty);
		} else {
			ret = eventPrivatePropertyFacade.merge(privateProperty);
		}
		return ret;
	}

	/**
	 * If you want this event, user getCurrentEvent() This method should be used
	 * only in special cases...
	 */
	@Override
	@RolesAllowed(EventPermission.S_MANAGE_EVENT)
	public LanEvent getEventById(Integer id) {
		return eventFacade.find(id);
	}

	@Override
	@RolesAllowed(EventPermission.S_MANAGE_EVENT)
	public LanEvent deleteProperty(LanEventProperty property) {
		property = eventPropertyFacade.reload(property);
		LanEvent event = property.getEvent();
		eventPropertyFacade.remove(property);
		event.getProperties().remove(property);
		return event;
	}

	@Override
	@RolesAllowed({EventPermission.S_MANAGE_PRIVATE_PROPERTIES, EventPermission.S_MANAGE_EVENT})
	public LanEvent deletePrivateProperty(LanEventPrivateProperty property) {
		property = eventPrivatePropertyFacade.reload(property);
		LanEvent event = property.getEvent();
		eventPrivatePropertyFacade.remove(property);
		return event;
	}

	@Override
	@RolesAllowed(EventPermission.S_MANAGE_EVENT)
	public List<LanEvent> findAllEvents() {
		return eventFacade.findAll();
	}

	@Override
	@RolesAllowed({SpecialPermission.S_USER})
	public List<LanEvent> findAllEventsForCurrentUser() {
		return eventFacade.findAll(permbean.getCurrentUser().getUser());
	}

	@Override
	@RolesAllowed({SpecialPermission.S_USER})
	public List<LanEvent> findFutureAndRunningEventsForCurrentUser() {

		List<LanEvent> events = findAllEventsForCurrentUser();

		List<LanEvent> retlist = new ArrayList<>();

		Calendar tmp = Calendar.getInstance();
		tmp.add(Calendar.DAY_OF_MONTH, -5);
		Date compareDate = tmp.getTime();

		for (LanEvent event : events) {

			if (event.getEndTime() == null) {
				retlist.add(event);
				continue;
			}

			if (event.getEndTime().compareTo(compareDate) > 0) {
				retlist.add(event);
			}
		}

		return retlist;
	}

	@Override
	@RolesAllowed(SpecialPermission.S_SUPERADMIN)
	public List<LanEvent> findFutureEvents() {
		return eventFacade.findFutureEvents();
	}

	@Override
	@RolesAllowed(EventPermission.S_MANAGE_EVENT)
	public List<LanEvent> findAllEventsForOrganizer(EventOrganiser organiser) {
		return eventFacade.findForOrganizer(organiser);
	}

}