PlaceBean.java

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

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
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.EJBAccessException;
import javax.ejb.EJBException;
import javax.ejb.LocalBean;
import javax.ejb.Stateless;
import javax.ejb.Timeout;
import javax.ejb.Timer;
import javax.ejb.TimerService;

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

import fi.insomnia.bortal.enums.apps.MapPermission;
import fi.insomnia.bortal.enums.apps.SpecialPermission;
import fi.insomnia.bortal.exceptions.BortalCatchableException;
import fi.insomnia.bortal.facade.EventUserFacade;
import fi.insomnia.bortal.facade.GroupMembershipFacade;
import fi.insomnia.bortal.facade.PlaceFacade;
import fi.insomnia.bortal.facade.PlaceGroupFacade;
import fi.insomnia.bortal.facade.UserFacade;
import fi.insomnia.bortal.model.EventMap;
import fi.insomnia.bortal.model.EventUser;
import fi.insomnia.bortal.model.GroupMembership;
import fi.insomnia.bortal.model.LanEvent;
import fi.insomnia.bortal.model.Place;
import fi.insomnia.bortal.model.PlaceGroup;
import fi.insomnia.bortal.model.Product;
import fi.insomnia.bortal.model.ProductFlag;

/**
 * 
 * @author tuukka
 */
@Stateless
@LocalBean
@DeclareRoles({
		MapPermission.S_BUY_PLACES,
		MapPermission.S_MANAGE_MAPS,
		MapPermission.S_VIEW,
		MapPermission.S_MANAGE_OTHERS,
})
public class PlaceBean implements PlaceBeanLocal {
	private static final String PLACE_RESERVE_TIMEOUTER = "Map reserve timeouter";
	private static final Logger logger = LoggerFactory.getLogger(PlaceBean.class);
	public static final int RESERVE_MINUTES = 20;

	@EJB
	private GroupMembershipFacade gmemfacade;
	@Resource
	private TimerService ts;

	@EJB
	private PlaceFacade placeFacade;

	@EJB
	private ProductBeanLocal productBean;

	@EJB
	private EventBeanLocal eventBean;

	@EJB
	private LoggingBeanLocal logbean;
	@EJB
	private PermissionBeanLocal permbean;

	@EJB
	private UserFacade userfacade;

	@EJB
	private EventUserFacade eventUserFacade;

	@EJB
	private LoggingBeanLocal loggerbean;
	@EJB
	private AccountEventBeanLocal acbean;
	@EJB
	private PlaceGroupFacade pgfacade;
	@EJB
	private ProductPBean productPBean;

	@Override
	@RolesAllowed(MapPermission.S_MANAGE_MAPS)
	public Place mergeChanges(Place place) {
		return placeFacade.merge(place);
	}

	/**
	 * Calculate the price of reserved places for the user Optional parameter
	 * newPlace can be given when the place is added to the price calculations;
	 * 
	 * User parameter can be used to select another user than the currently
	 * logged in user, but if user does not have enough rights an exception will
	 * be thrown
	 * 
	 */

	@RolesAllowed(SpecialPermission.S_USER)
	@Override
	public BigDecimal getTotalReservationPrice(Place newPlace)
	{
		return addAndCalcPrice(permbean.getCurrentUser(), newPlace);
	}

	@RolesAllowed(MapPermission.S_MANAGE_OTHERS)
	@Override
	public BigDecimal getTotalReservationPrice(EventUser user, Place newPlace)
	{
		return addAndCalcPrice(user, newPlace);

	}

	private BigDecimal addAndCalcPrice(EventUser user, Place newPlace) {

		Set<Place> places = new HashSet<Place>();
		places.addAll(placeFacade.findUsersReservations(eventBean.getCurrentEvent(), user));

		if (newPlace != null) {
			places.add(newPlace);
		}

		Map<Product, Integer> mockmap = getPlaceProductcount(places);

		BigDecimal total = BigDecimal.ZERO;

		Calendar now = Calendar.getInstance();
		for (Entry<Product, Integer> entry : mockmap.entrySet()) {
			logger.debug("Adding to price {} of {}", entry.getValue(), entry.getKey().getName());
			if (entry.getKey() != null) {
				total = total.add(productBean.calculateTotal(entry.getKey(), new BigDecimal(entry.getValue()), now));
			}
		}
		return total;
	}

	private static Map<Product, Integer> getPlaceProductcount(Collection<Place> places) {
		HashMap<Product, Integer> mockmap = new HashMap<Product, Integer>();

		for (Place p : places) {
			if (p != null) {
				Product prod = p.getProduct();
				Integer val = mockmap.get(prod);
				if (val == null) {
					val = 0;
				}
				mockmap.put(prod, ++val);
			}
		}

		return mockmap;

	}

	@Override
	@RolesAllowed(MapPermission.S_VIEW)
	public Place findPlace(EventMap e, int x, int y) {
		return placeFacade.find(e, x, y);
	}

	/**
	 * Reserve the place for user. This reservation will timeout after a while
	 * buy() method should be called after this when buying place;
	 * 
	 * @param place
	 *            place to be reserved
	 * @param user
	 *            User for whom the place should be reserved.
	 * @return true when successfull. On any error false.
	 */
	@Override
	@RolesAllowed(MapPermission.S_BUY_PLACES)
	public boolean reservePlace(Place place, EventUser user) {
		place = placeFacade.find(place.getId());
		user = eventUserFacade.find(user.getId());
		boolean ret = false;
		if (place.isBuyable() && !place.isTaken()) {
			place.setCurrentUser(user);
			place.setReleaseTime(Calendar.getInstance());
			place.getReleaseTime().add(Calendar.MINUTE, RESERVE_MINUTES);

			// Create timeout service to timeout the reserved place in
			// RESERVE_MINUTES
			boolean foundTimeout = false;
			for (Timer t : ts.getTimers()) {
				if (t.getInfo().equals(PLACE_RESERVE_TIMEOUTER)) {
					foundTimeout = true;
				}
			}
			if (!foundTimeout) {
				logger.info("Place timeout calculator not started. Starting new.");
				ts.createTimer(new Date(), 1000 * 60, PLACE_RESERVE_TIMEOUTER);
			}
			ret = true;
		}
		return ret;
	}

	@Timeout
	public void checkTimedOutPlaces(Timer timer) {
		// logger.debug("Checking Timed out places at {}", new Date());
		placeFacade.timeoutPlaces();
	}

	//
	// @Override
	// public void releaseUsersPlaces(User user) throws
	// PermissionDeniedException {
	// if (user == null) {
	// user = permbean.getCurrentUser();
	// } else if (!permbean.isCurrentUser(user)) {
	// permbean.fatalPermission(MapPermission.MANAGE_OTHERS,
	// "Not enough rights to release users ", user, " places");
	// }
	// logger.debug("timeouting places");
	// placeFacade.releasePlaces(permbean.getCurrentUser());
	// }

	@Override
	@RolesAllowed({ MapPermission.S_BUY_PLACES, MapPermission.S_MANAGE_OTHERS })
	public PlaceGroup buySelectedPlaces(EventUser user) throws BortalCatchableException {
		if (user == null) {
			user = permbean.getCurrentUser();
		} else {
			if (!user.equals(permbean.getCurrentUser()) && !permbean.hasPermission(MapPermission.MANAGE_OTHERS)) {
				loggerbean.logMessage(SecurityLogType.permissionDenied, permbean.getCurrentUser(), "Can not buy places for user " + user);
				throw new EJBAccessException("Not enough permissions to buy place");
			}
			user = eventUserFacade.reload(user);
		}
		LanEvent event = eventBean.getCurrentEvent();

		List<Place> places = placeFacade.findUsersReservations(event, user);
		if (places.isEmpty()) {
			return null;
		}

		// PlaceGroup pg = pgbean.createPlaceGroup(user);

		BigDecimal totalprice = addAndCalcPrice(user, null);
		BigDecimal balance = user.getAccountBalance();
		if (balance.compareTo(totalprice) < 0 && !permbean.hasPermission(MapPermission.MANAGE_OTHERS)) {
			logger.info("User {} Could not buy things because account balance {} is too low for purchase {}", new Object[] { user, balance, totalprice });
			return null;
		}

		for (Entry<Product, Integer> line : getPlaceProductcount(places).entrySet()) {
			productPBean.createAccountEvent(line.getKey(), new BigDecimal(line.getValue()), user, Calendar.getInstance());
		}

		PlaceGroup pg = new PlaceGroup(event, Calendar.getInstance(), Calendar.getInstance(), true);
		pg.setCreator(user);
		pgfacade.create(pg);
		// user.getPlaceGroups().add(pg);
		userfacade.flush();

		boolean associatedToPlace = isUserMember(user, places.get(0).getProduct());

		for (Place p : places) {
			if (!p.isReservedFor(user)) {
				throw new BortalCatchableException("Trying to buy place not reserved for that user");
			}
			logger.info("Buying place {} for user {}", p.getName(), user.getUser().getLogin());
			GroupMembership gm = buy(p, pg);
			if (!associatedToPlace)
			{
				logger.info("Associating buyer {} to place {}", user, gm);
				associatedToPlace = true;
				gm.setUser(user);
			}

		}

		// adding account event does funny stuff. evicting helps...
		userfacade.evict();

		return pg;
	}

	// This method should not be available in the local bean client
	public void lockPlaceProduct(EventUser user, Product prod, BigDecimal quantity) {

		// BigDecimal loop = BigDecimal.ZERO;
		LanEvent event = eventBean.getCurrentEvent();
		PlaceGroup pg = new PlaceGroup(event, Calendar.getInstance(), Calendar.getInstance(), true);
		pg.setCreator(user);
		pgfacade.create(pg);
		boolean associatedToPlace = isUserMember(user, prod);

		// If user is not yet associated to this type of product, find it out...

		for (int i = 0; i < quantity.intValue(); ++i)
		{
			Place freePlace = null;

			if (prod.getProductFlags().contains(ProductFlag.CREATE_NEW_PLACE_WHEN_BOUGHT))
			{
				freePlace = new Place();
				freePlace.setProduct(prod);
				freePlace.setProvidesRole(prod.getProvides());
				placeFacade.create(freePlace);
			} else if (prod.getPlaces() != null)
			{
				for (Place p : prod.getPlaces()) {
					if (!p.isTaken()) {
						freePlace = p;
						break;
					}
				}
			}
			if (freePlace == null) {
				throw new EJBException("Could find a place to be reserved....");
			}
			GroupMembership gm = buy(freePlace, pg);
			if (!associatedToPlace)
			{
				logger.info("Associating buyer {} to place {}", user, gm);
				associatedToPlace = true;
				gm.setUser(user);
			}
		}

		// user.getPlaceGroups().add(pg);
	}

	private static boolean isUserMember(EventUser user, Product prod) {
		boolean ret = false;
		for (GroupMembership gm : user.getGroupMemberships()) {
			if (prod.equals(gm.getPlaceReservation().getProduct())) {
				ret = true;
				break;
			}
		}
		return ret;
	}

	private GroupMembership buy(Place p, PlaceGroup pg) {
		p.setGroup(pg);
		p.setReleaseTime(null);
		// Current user temporarily used at place reservation. When buying
		// release field for its original use ( show who is sitting here ).
		p.setCurrentUser(null);
		GroupMembership membership = new GroupMembership(pg, p, gmemfacade.createInviteToken());
		pg.getMembers().add(membership);
		p.setPlaceReserver(membership);
		if (pg.getPlaces() == null) {
			pg.setPlaces(new ArrayList<Place>());
		}
		if (!pg.getPlaces().contains(p))
		{
			pg.getPlaces().add(p);
		}
		return membership;

	}

	@Override
	@RolesAllowed(MapPermission.S_MANAGE_MAPS)
	public int setBuyable(EventMap map, String like, boolean b) {
		return placeFacade.setBuyable(map, like, b);
	}

	// @Override
	// @RolesAllowed("MAP/READ")
	// public Place find(EventPk id) {
	// return placeFacade.find(id);
	// }

	// @Override
	// public void checkMemberships() {
	// List<Place> all = placeFacade.findAll(eventBean.getCurrentEvent());
	// for (Place p : all) {
	// if (p.getGroup() != null && p.getPlaceReserver() == null) {
	// LanEvent event = eventBean.getCurrentEvent();
	// String token = gmemfacade.createInviteToken(event);
	//
	// GroupMembership gm = new GroupMembership(event, p.getGroup(), p, token);
	// p.getGroup().getMembers().add(gm);
	// p.setPlaceReserver(gm);
	//
	// }
	//
	// }
	//
	// }

	// @Override
	// @RolesAllowed("SHOP/EXECUTE")
	// public Place lockPlace(User user, Place place) throws
	// PermissionDeniedException {
	// if (place.isTaken()) {
	// logger.warn("Place {} is already taken", place);
	// // throw new PermissionDeniedException(secubean,
	// // permbean.getCurrentUser(), "Place already taken!");
	// return null;
	// }
	//
	// LanEvent ev = eventBean.getCurrentEvent();
	// PlaceGroup pg = new PlaceGroup(ev, Calendar.getInstance(),
	// Calendar.getInstance(), true);
	// pg.setCreator(user);
	//
	// user.getPlaceGroups().add(pg);
	//
	// place.reserve(user);
	// place.buy(pg);
	//
	// GroupMembership newgm = new GroupMembership(ev, pg, place,
	// gmemfacade.createInviteToken(ev));
	//
	// pg.getMembers().add(newgm);
	//
	// boolean foundGm = false;
	// for (GroupMembership gm : user.getGroupMemberships()) {
	// logger.debug("Checking users gm:s found: {}", gm);
	// if (gm.getId().getEventId().equals(ev.getId())) {
	// foundGm = true;
	// break;
	// }
	// }
	// logger.debug("Foundgm {}", foundGm);
	// if (!foundGm) {
	// logger.debug("Membership not found. associating");
	// newgm.setUser(user);
	// user.getGroupMemberships().add(newgm);
	//
	// userbean.mergeChanges(user);
	// }
	// pgfacade.create(pg);
	// place = placeFacade.merge(place);
	//
	// return place;
	// }

	/**
	 * Release reservation from user
	 * 
	 * @param place
	 *            The place to be released
	 * @return true when successfull, on any erroro false.
	 */
	@Override
	@RolesAllowed({ MapPermission.S_RELEASE_PLACE, MapPermission.S_MANAGE_OTHERS })
	public boolean releasePlace(Place place) {
		place = placeFacade.find(place.getId());
		EventUser user = permbean.getCurrentUser();
		if (place.getGroup() != null || place.getCurrentUser() == null || (!permbean.hasPermission(MapPermission.MANAGE_OTHERS) && !place.getCurrentUser().equals(user))) {
			return false;
		}
		place.setCurrentUser(null);
		place.setReleaseTime(null);

		return true;

	}

	@Override
	@RolesAllowed(MapPermission.S_MANAGE_MAPS)
	public Place find(int placeId) {
		return placeFacade.find(placeId);
	}

	@Override
	@RolesAllowed(MapPermission.S_BUY_PLACES)
	public void unbuyPlace(Place place) {
		place = placeFacade.find(place.getId());
		if (place.getGroup() != null) {
			place.getGroup().getPlaces().remove(place);
			place.setGroup(null);
		}
	}

}