PlaceBean.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.
 *
 */
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package fi.codecrew.moya.beans;

import java.io.ByteArrayOutputStream;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
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 fi.codecrew.moya.exceptions.PlaceAlreadyTakenException;
import fi.codecrew.moya.facade.*;
import fi.codecrew.moya.model.*;

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

import com.pdfjet.CoreFont;
import com.pdfjet.PDF;
import com.pdfjet.Page;
import com.pdfjet.TextLine;

import fi.codecrew.moya.enums.apps.MapPermission;
import fi.codecrew.moya.enums.apps.SpecialPermission;
import fi.codecrew.moya.exceptions.BortalCatchableException;
import fi.codecrew.moya.utilities.moyamessage.MoyaEventType;

/**
 * @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 Logger logger = LoggerFactory.getLogger(PlaceBean.class);


	@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 PlaceGroupFacade pgfacade;
	@EJB
	private ProductPBean productPBean;

	@EJB
	private BarcodeBeanLocal barcodeBean;
	@EJB
	private EventMapFacade eventMapFacade;
	@EJB
	private PlaceSlotFacade placeSlotFacade;

	@EJB
	private BillFacade billFacade;

	@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;
	 * <p>
	 * 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
	/** Use place slots */
	@Deprecated
	public BigDecimal getTotalReservationPrice(Place newPlace) {
		return addAndCalcPrice(permbean.getCurrentUser(), newPlace);
	}

	@RolesAllowed(MapPermission.S_MANAGE_OTHERS)
	@Override
	/** Use place slots */
	@Deprecated
	public BigDecimal getTotalReservationPrice(EventUser user, Place newPlace) {
		return addAndCalcPrice(user, newPlace);

	}

	/**
	 * Use place slots
	 */
	@Deprecated()
	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 = Bill.BILL_SCALED_ZERO_PRICE;

		Date now = new Date();
		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, user));
			}
		}
		return total.setScale(Bill.BILL_PRICE_SCALE, RoundingMode.HALF_UP);
	}

	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.reload(place);
		user = eventUserFacade.reload(user);
		boolean ret = false;

		// when admin click's place, he reserves it -> just ignore it
		if (!place.isTaken() || (permbean.hasPermission(MapPermission.MANAGE_OTHERS) && permbean.getCurrentUser().equals(place.getCurrentUser()))) {
			if (place.isBuyable() || permbean.hasPermission(MapPermission.MANAGE_OTHERS)) {

				if (place.getProduct().getProductFlags().contains(ProductFlag.PREPAID_CREDIT)) {
					logger.warn("Reserving place {} with Prepaid credit!", place);
					BigDecimal balance = user.getAccountBalance();
					BigDecimal price = getTotalReservationPrice(user, place);

					boolean canReserve = (price.compareTo(balance) <= 0);
					logger.debug("Balance {}, price {}", balance, price);

					if (!canReserve && !permbean.hasPermission(MapPermission.MANAGE_OTHERS)) {
						logger.debug("Did not have enought credits to reserve place! required {} , got {}", price, balance);
						return false;
					}
				} else {
					List<PlaceSlot> slots = placeSlotFacade.findFreePlaceSlotsForProduct(user, place.getProduct());
					if (slots != null && !slots.isEmpty()) {
						logger.info("Found free slots {} for user {}", Arrays.asList(slots.toArray()), user);
						PlaceSlot slot = slots.get(0);
						logger.warn("Reserving place {} with placeslot {}", place, slot);
						slot.setPlace(place);
						slot.setUsed(new Date());
					} else if (!permbean.hasPermission(MapPermission.MANAGE_OTHERS)) { // we still can reserve places to other people
						logger.warn("Not enough slots to reserve place {}", place);
						// Not enough slots to reserve place
						return false;
					}
				}

				if (!place.isBuyable()) {
					place.setBuyable(true);
				}

				place.setCurrentUser(user);
				place.setReserveTime(Calendar.getInstance());

				ret = true;
			}
		}
		return ret;
	}


	@Override
	@RolesAllowed({MapPermission.S_BUY_PLACES, MapPermission.S_MANAGE_OTHERS})
	public PlaceGroup buySelectedPlaces(EventUser user) throws BortalCatchableException {
		return buyOrReserveSelectedPlaces(user, true);
	}

	@Override
	@RolesAllowed({MapPermission.S_BUY_PLACES, MapPermission.S_MANAGE_OTHERS})
	public PlaceGroup buySelectedPlaces(List<Place> selectedPlaces, EventUser user) throws BortalCatchableException {
		return buyOrReserveSelectedPlaces(user, selectedPlaces, true);
	}

	@Override
	@RolesAllowed({MapPermission.S_MANAGE_OTHERS})
	public PlaceGroup reserveSelectedPlaces(EventUser eventuser) throws BortalCatchableException {
		return buyOrReserveSelectedPlaces(eventuser, false);
	}


	private PlaceGroup buyOrReserveSelectedPlaces(EventUser user, boolean createAccountevents) throws BortalCatchableException {
		return buyOrReserveSelectedPlaces(user, null, createAccountevents);
	}


	/**
	 * Reserves places and creates accountevents for the places.
	 */
	private PlaceGroup buyOrReserveSelectedPlaces(EventUser user, List<Place> selectedPlaces, boolean createAccountevents) throws BortalCatchableException {
		if (user == null) {
			user = permbean.getCurrentUser();
		} else {
			if (!user.equals(permbean.getCurrentUser()) && !permbean.hasPermission(MapPermission.MANAGE_OTHERS)) {
				loggerbean.sendMessage(MoyaEventType.PLACE_ERROR, 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 (selectedPlaces != null) {
			List<Place> newPlaces = new ArrayList<>();
			for (Place p : selectedPlaces) {
				if (!p.isReservedFor(permbean.getCurrentUser()) && p.isTaken())
					continue;

				p = placeFacade.reload(p); // persist teh shit
				newPlaces.add(p);
			}

			places = newPlaces;
		}

		if (places.isEmpty()) {
			return null;
		}

		// Check wether we should reserve places via credit or plcaeslot
		boolean placePrepaidcredit = places.get(0).getProduct().getProductFlags().contains(ProductFlag.PREPAID_CREDIT);
		// PlaceGroup pg = pgbean.createPlaceGroup(user);
		if (placePrepaidcredit && createAccountevents) {
			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, new Date());
			}
		}
		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());
		StringBuilder logSb = new StringBuilder();
		logSb.append("User Locked ").append(places.size()).append(" places: ");

		for (Place p : places) {

			if (!p.isReservedFor(user)) {
				// if you can mange others, you can give your (or free) place to another user
				if (!permbean.hasPermission(MapPermission.MANAGE_OTHERS) || (!p.isReservedFor(permbean.getCurrentUser()) && p.isTaken())) {
					throw new BortalCatchableException("Trying to buy place not reserved for that user");
				}
			}
			logger.info("Buying place {} for user {}", p.getName(), user.getUser().getLogin());
			logSb.append(p.getName()).append(", ");

			GroupMembership gm = buy(p, pg);
			if (!associatedToPlace) {
				logger.info("Associating buyer {} to place {}", user, gm);
				associatedToPlace = true;
				gm.setUser(user);
				if (user.getGroupMemberships() == null) {
					user.setGroupMemberships(new ArrayList<GroupMembership>());
				}
				user.getGroupMemberships().add(gm);
			}

		}
		loggerbean.sendMessage(MoyaEventType.PLACE_ACTION, permbean.getCurrentUser(), logSb.toString());

		// 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());
				freePlace.setName("-");
				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 not 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);
				if (user.getGroupMemberships() == null) {
					user.setGroupMemberships(new ArrayList<GroupMembership>());
				}
				user.getGroupMemberships().add(gm);
			}
		}

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

	private static boolean isUserMember(EventUser user, Product prod) {
		boolean ret = false;
		if (user.getGroupMemberships() != null) {
			for (GroupMembership gm : user.getGroupMemberships()) {

				if (gm.getPlaceReservation() != null && prod.equals(gm.getPlaceReservation().getProduct())) {
					ret = true;
					break;
				}
			}
		}

		return ret;
	}

	private GroupMembership buy(Place p, PlaceGroup pg) {
		p.setGroup(pg);

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

	/**
	 * Release reservation from user
	 *
	 * @param place The place to be released
	 * @return true when successfull, on any erroro false.
	 */
	@Override
	@RolesAllowed({MapPermission.S_BUY_PLACES, MapPermission.S_MANAGE_OTHERS})
	public boolean releasePlace(Place place) {
		place = placeFacade.reload(place);
		return releasePlacePriv(place) != null;
	}

	/**
	 * User release place
	 *
	 * @param place The place to be released
	 * @return true when successfull, on any erroro false.
	 */
	@Override
	@RolesAllowed({MapPermission.S_BUY_PLACES, MapPermission.S_MANAGE_OTHERS})
	public boolean userReleasePlace(Place place) {
		place = placeFacade.reload(place);
		PlaceSlot s = releasePlacePriv(place);

		return (s == null || s.getUsed() == null);
	}

	private PlaceSlot releasePlacePriv(Place place) {

		if (place.getGroup() != null) {
			place.getGroup().getPlaces().remove(place);
		}
		place.setGroup(null);
		place.setCurrentUser(null);
		place.setReserveTime(null);

		if (place.getPlaceReserver() != null) {
			place.getPlaceReserver().setPlaceReservation(null);
			place.setPlaceReserver(null);
		}

		PlaceSlot slot = placeSlotFacade.findSlotForPlace(place);

		// remove also slot from place
		if (slot != null) {
			slot.setPlace(null);
			slot.setUsed(null);
			place.setReserverSlot(null);
		}

		return slot;
	}

	public GroupMembership removeGroupMembership(Place place) {
		GroupMembership res = place.getPlaceReserver();
		if (res != null) {

			if (res.getPlaceGroup().getMembers() != null) {
				res.getPlaceGroup().getMembers().remove(res);
			}

			if (res.getUser() != null && res.getUser().getGroupMemberships() != null) {
				res.getUser().getGroupMemberships().remove(res);
			}
			place.setPlaceReserver(null);

			gmemfacade.remove(res);
		}
		return res;

	}

	@Override
	@RolesAllowed(MapPermission.S_VIEW)
	public Place find(int placeId) {
		Place ret = placeFacade.find(placeId);

		// Check that place belongs to this event before returning it.
		if (ret.getProduct() != null) {
			if (eventBean.getCurrentEvent().equals(ret.getProduct().getEvent())) {
				return ret;
			}
			return null;
		}

		if (ret.getMap() != null) {
			if (eventBean.getCurrentEvent().equals(ret.getMap().getEvent())) {
				return ret;
			}
		}
		return null;
	}

	@Override
	@RolesAllowed(MapPermission.S_MANAGE_OTHERS)
	public Place unbuyPlace(Place place) {
		place = placeFacade.reload(place);
		removeGroupMembership(place);
		releasePlacePriv(place);

		return place;
	}

	@Override
	@RolesAllowed(MapPermission.S_MANAGE_MAPS)
	public List<GroupMembership> matchGroupMembershipsByInviteToken(String token) {
		List<GroupMembership> gms = gmemfacade.matchByToken(token);
		return gms;
	}

	@Override
	public GroupMembership findGroupMembershipsByToken(String token) {
		return gmemfacade.findByToken(token);
	}

	private byte[] generatePlacesPdf(float width, float height, double font1, double font2, List<Place> places) throws Exception {
		ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

		PDF pdf = new PDF(outputStream);
		pdf.setTitle("Place");

		float pointInMillim = (25.4f / 72.0f); // 1 point is 1/72 inches. 1 inch
		// = 25.4mm
		float pagex = width / pointInMillim;
		float pagey = height / pointInMillim;

		for (Place place : places) {
			Page page = new Page(pdf, new float[]{pagex, pagey});

			// place code
			com.pdfjet.Font font = new com.pdfjet.Font(pdf, CoreFont.HELVETICA);
			font.setSize(font1);

			TextLine textLine = new TextLine(font);
			textLine.setText(place.getName());
			textLine.setPosition(5, 15);
			textLine.setColor(new int[]{0, 0, 0});
			textLine.drawOn(page);

			double currentX = 42;

			// nick
			if (place.getPlaceReserver() != null && place.getPlaceReserver().getUser() != null) {
				font = new com.pdfjet.Font(pdf, CoreFont.HELVETICA);
				font.setSize(font2);

				textLine = new TextLine(font);
				textLine.setText(place.getPlaceReserver().getUser().getNick());
				textLine.setPosition(currentX, 15);
				textLine.setColor(new int[]{0, 0, 0});
				textLine.drawOn(page);
			}

			// place hex code
			font = new com.pdfjet.Font(pdf, CoreFont.HELVETICA);
			font.setSize(font2);

			textLine = new TextLine(font);
			textLine.setText(barcodeBean.getPlaceTextCode(place));
			textLine.setPosition(currentX, (pagey / 2) + font1);
			textLine.setColor(new int[]{0, 0, 0});
			textLine.drawOn(page);

		}

		pdf.flush();
		outputStream.close();

		return outputStream.toByteArray();
	}

	@Override
	public byte[] generatePlacesPdf(float width, float height, double font1, double font2) {
		try {
			List<Place> places = placeFacade.findAll(eventBean.getCurrentEvent());
			Collections.sort(places);

			logger.info("sorting places etc.");

			return generatePlacesPdf(width, height, font1, font1, places);
		} catch (Exception e) {
			logger.error("Exception from place pdf generation.", e);

			throw new RuntimeException(e);
		}
	}

	@Override
	public Long selectablePlaceCount(EventMap map) {

		return placeFacade.countSelectable(map);
	}

	@Override
	public EventMap findMap(Integer mapId) {
		return eventMapFacade.find(mapId);
	}

	@Override
	public Long availablePlaceCount(EventMap map) {
		return placeFacade.countAvailable(map);
	}

	@Override
	public EventMap getActiveMap() {
		LanEvent event = eventBean.getCurrentEvent();
		logger.info("Current event: {}, maps {}", event, event.getEventMaps());
		for (EventMap map : event.getEventMaps()) {
			logger.info("Checking active map {}, is active {}", map, map.isActive());
			if (map.isActive()) {
				return map;
			}
		}
		return null;
	}

	@Override
	public List<EventMap> getMaps() {
		return eventMapFacade.getMaps();
	}

	@Override
	public List<PlaceSlot> getFreePlaceslots(EventUser user, Product product) {
		user = eventUserFacade.reload(user);
		if (!permbean.isCurrentUser(user) && !permbean.hasPermission(MapPermission.MANAGE_OTHERS))
			throw new EJBAccessException("User " + permbean.getCurrentUser() + "tried to fetch free places for user " + user);

		return placeSlotFacade.findFreePlaceSlotsForProduct(user, product);
	}

	@Override
	public List<Place> findPlacePrintlistForUser(EventUser user) {
		// TODO: get from placefacade. Sometimes it's easier to think loops then facadequeries

		boolean printOnlyOwn = eventBean.getPropertyBoolean(LanEventPropertyKey.PLACECODE_PRINT_ONLY_OWN);

		List<GroupMembership> gmems = gmemfacade.findMemberOrCreator(user);

		List<Place> places = new ArrayList<>();
		for (GroupMembership gm : gmems) {

			if (gm.getPlaceReservation() != null) {

				// places with no user belongs to creator
				if (gm.getUser() == null || !printOnlyOwn) {
					places.add(gm.getPlaceReservation());
				} else if (user.equals(gm.getUser())) {
					places.add(gm.getPlaceReservation());
				}

			}
		}

		return places;

	}

	@Override
	public List<Product> getMapProducts(EventMap map) {
		return placeFacade.getMapProducts(map);
	}

	@Override
	public List<PlaceSlot> getFreePlaceslots(EventUser user, EventMap map) {
		user = eventUserFacade.reload(user);
		if (!permbean.isCurrentUser(user) && !permbean.hasPermission(MapPermission.MANAGE_OTHERS))
			throw new EJBAccessException("User " + permbean.getCurrentUser() + "tried to fetch free places for user " + user);

		return placeSlotFacade.findFreePlaceSlots(user, map);
	}

	@Override
	public List<PlaceSlot> getPlaceslots(EventUser user) {

		if (!permbean.isCurrentUser(user) && !permbean.hasPermission(MapPermission.MANAGE_OTHERS)) {
			throw new EJBAccessException("User " + permbean.getCurrentUser() + "tried to get slots for user " + user);
		}
		return placeSlotFacade.finForUser(user);
	}

	@Override
	public boolean lockSlot(PlaceSlot row) {
		row = placeSlotFacade.reload(row);
		if (row.getPlace() == null && row.getUsed() == null) {
			row.setUsed(new Date());
		} else {
			return false;
		}
		return true;
	}

	@Override
	public boolean releaseSlot(PlaceSlot row) {
		row = placeSlotFacade.reload(row);
		if (row.getPlace() == null && row.getUsed() != null) {
			row.setUsed(null);
		} else {
			return false;
		}
		return true;
	}

	@Override
	public List<EventMap> getOrganisationsMaps() {
		return eventMapFacade.findOrganisationMaps();
	}

	@RolesAllowed(MapPermission.S_MANAGE_MAPS)
	public EventMap copyMap(EventMap src, EventMap dst) {
		src = eventMapFacade.reload(src);
		dst = eventMapFacade.reload(dst);
		if (dst.getPlaces() != null && !dst.getPlaces().isEmpty()) {
			throw new EJBException("Destination can not have existing places!");
		}
		Map<Product, Product> prodmapping = new HashMap<>();
		dst.setPlaces(new ArrayList<>());
		for (Place p : src.getPlaces()) {
			Place np = new Place(p, dst);
			Product product = prodmapping.get(p.getProduct());
			if (product == null) {
				product = new Product(p.getProduct(), dst.getEvent());
				productBean.create(product);
				prodmapping.put(p.getProduct(), product);
			}
			np.setProduct(product);
			dst.getPlaces().add(np);
			placeFacade.create(np);
		}

		dst.setActive(true);
		dst.setHeight(src.getHeight());
		dst.setWidth(src.getWidth());
		dst.setMapData(src.getMapData());
		dst.setMimeType(src.getMimeType());
		//	dst.setName("Copy of " + src.getName());
		dst.setNotes(src.getNotes());

		return dst;
	}

	@Override
	public Place findByCode(String code) {
		LanEvent event = eventBean.getCurrentEvent();
		return placeFacade.findByCode(code, event);
	}

	@Override
	public List<Place> findAllForEvent() {
		LanEvent event = eventBean.getCurrentEvent();
		List<Place> ret = placeFacade.findAll(event);
		return ret;
	}

	@Override
	public boolean isUnlockedPlaces(EventUser user) {
		List<Place> places = placeFacade.findUsersReservations(user.getEvent(), user);

		for (Place p : places) {
			if (p.isReservedFor(user)) {
				return true;
			}
		}

		return false;
	}

	/**
	 * Allow user to move their places around.
	 */
	@Override
	public void movePlaces(HashMap<Place, Place> change) {
		EventUser user = permbean.getCurrentUser();
		boolean manageOthers = permbean.hasPermission(MapPermission.MANAGE_OTHERS);

		for (Entry<Place, Place> s : change.entrySet()) {
			Place src = placeFacade.reload(s.getKey());
			Place dst = placeFacade.reload(s.getValue());

			if (!src.getProduct().equals(dst.getProduct())) {
				throw new EJBException("src and dst product  types differ for {}, {}" + src + " " + dst);
			}

			if (!manageOthers && !user.equals(src.getCurrentUser())
				&& (src.getGroup() == null || !user.equals(src.getGroup().getCreator()))) {
				throw new EJBAccessException("Trying to move places for another user without permissions!");
			}
			if (!dst.isBuyable() || dst.isTaken()) {
				throw new PlaceAlreadyTakenException(dst);
			}

			// Store values we want to store to the destination place
			PlaceGroup grp = src.getGroup();
			GroupMembership gmem = src.getPlaceReserver();
			EventUser currentUser = src.getCurrentUser();

			PlaceSlot srcSlot = releasePlacePriv(src);

			if (srcSlot != null) {
				// this place was reserved via a slot...
				srcSlot.setPlace(dst);
				dst.setReserverSlot(srcSlot);
				srcSlot.setUsed(new Date());
			}

			dst.setCurrentUser(currentUser);

			if (gmem != null) {
				dst.setPlaceReserver(gmem);
				gmem.setPlaceReservation(dst);
			}

			dst.setGroup(grp);
			if (grp != null) {
				grp.getPlaces().add(dst);
			}
		}

	}

}