UserBean.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.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.math.BigDecimal;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import javax.annotation.security.DeclareRoles;
import javax.annotation.security.PermitAll;
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.imageio.ImageIO;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import fi.codecrew.moya.enums.apps.MapPermission;

import org.apache.commons.codec.binary.Hex;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import fi.codecrew.moya.enums.CardState;
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.AccountEventFacade;
import fi.codecrew.moya.facade.ApprovalFacade;
import fi.codecrew.moya.facade.EventFacade;
import fi.codecrew.moya.facade.EventUserFacade;
import fi.codecrew.moya.facade.FeedbackFacade;
import fi.codecrew.moya.facade.GameIDFacade;
import fi.codecrew.moya.facade.GroupMembershipFacade;
import fi.codecrew.moya.facade.PlaceGroupFacade;
import fi.codecrew.moya.facade.PrintedCardFacade;
import fi.codecrew.moya.facade.ProductFacade;
import fi.codecrew.moya.facade.RoleFacade;
import fi.codecrew.moya.facade.UserApprovalFacade;
import fi.codecrew.moya.facade.UserFacade;
import fi.codecrew.moya.facade.UserImageFacade;
import fi.codecrew.moya.model.AccountEvent;
import fi.codecrew.moya.model.Approval;
import fi.codecrew.moya.model.EventUser;
import fi.codecrew.moya.model.Feedback;
import fi.codecrew.moya.model.GameID;
import fi.codecrew.moya.model.GroupMembership;
import fi.codecrew.moya.model.LanEvent;
import fi.codecrew.moya.model.LanEventPropertyKey;
import fi.codecrew.moya.model.PlaceGroup;
import fi.codecrew.moya.model.PrintedCard;
import fi.codecrew.moya.model.Product;
import fi.codecrew.moya.model.Role;
import fi.codecrew.moya.model.TournamentGame;
import fi.codecrew.moya.model.User;
import fi.codecrew.moya.model.UserApproval;
import fi.codecrew.moya.model.UserImage;
import fi.codecrew.moya.util.MailMessage;
import fi.codecrew.moya.util.UserSearchQuery;
import fi.codecrew.moya.utilities.I18n;
import fi.codecrew.moya.utilities.PasswordFunctions;
import fi.codecrew.moya.utilities.SearchQuery;
import fi.codecrew.moya.utilities.SearchResult;
import fi.codecrew.moya.utilities.moyamessage.MoyaEventType;

@LocalBean
@Stateless
@DeclareRoles({
		UserPermission.S_VIEW_ALL,
		UserPermission.S_CREATE_NEW,
		UserPermission.S_INVITE_USERS,
		UserPermission.S_MODIFY,
		SpecialPermission.S_USER,
		EventPermission.S_MANAGE_EVENT,
})
public class UserBean implements UserBeanLocal {

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

	/**
	 * Java EE container injektoi tämän luokkamuuttujan luokan luonnin
	 * yhteydessä.
	 */
	@EJB
	private UserFacade userFacade;

	@EJB
	private EventUserFacade eventUserFacade;

	@PersistenceContext
	private EntityManager em;

	@EJB
	private EventBeanLocal eventBean;

	@EJB
	private UserImageFacade userimagefacade;

	@EJB
	private UtilBeanLocal utilbean;

	@EJB
	private CardTemplateBeanLocal ctbean;

	@EJB
	private BarcodeBeanLocal barcodeBean;

	@EJB
	private PermissionBeanLocal permbean;
	@EJB
	private GroupMembershipFacade gmfacade;

	@EJB
	private UserImageFacade imagefacade;

	// changed bean to this bcause of loop
	@EJB
	private PrintedCardFacade printedcardfacade;

	@EJB
	private LoggingBeanLocal loggerbean;

	@EJB
	private RoleFacade rolefacade;
	@EJB
	private PlaceGroupFacade pgfacade;
	@EJB
	private FeedbackFacade feedbackFacade;
	@EJB
	private ApprovalFacade approvalFacade;
	@EJB
	private UserApprovalFacade userApprovalFacade;
	@EJB
	private GameIDFacade gameIDFacade;
	@EJB
	private ProductBeanLocal productbean;
	@EJB
	private ProductPBean productPrivateBean;
	@EJB
	private AccountEventFacade accountEventFacade;
	@EJB
	private EventFacade eventfacade;
	@EJB
	private ProductFacade productFacade;

	@Override
	@RolesAllowed(UserPermission.S_VIEW_ALL)
	public List<EventUser> getUsers() {

		List<EventUser> ret = eventUserFacade.findAll();
		return ret;
	}

	@Override
	@RolesAllowed(SpecialPermission.S_USER)
	public EventUser mergeChanges(EventUser user) {
		if (!permbean.isCurrentUser(user) && !permbean.hasPermission(UserPermission.MODIFY)) {
			loggerbean.sendMessage(MoyaEventType.USER_PERMISSION_VIOLATION, permbean.getCurrentUser(), "User tried to save another user: " + user);
			throw new EJBAccessException("Not enough rights to save user");
		}

		EventUser ret = eventUserFacade.merge(user);
		ctbean.checkPrintedCard(ret);
		// currentEventuser = null;
		return ret;
	}

	@Override
	public List<Role> findUsersRoles(EventUser u) {

		EventUser currusr = permbean.getCurrentUser();
		if (!currusr.equals(u) && !permbean.hasPermission(UserPermission.MODIFY)) {
			loggerbean.sendMessage(MoyaEventType.USER_PERMISSION_VIOLATION, permbean.getCurrentUser(), "User tried to fetc another users roles: " + u);
			throw new EJBAccessException("Not enough rights to find roles");
		}

		return new ArrayList<Role>(localFindUsersRoles(u));

	}

	// private EventUser currentEventuser;
	// private ArrayList<Role> currentEventuserRoles;

	// HUOMHUOM! Älä määrittele tätä UserBeanLocal interfacelle.
	// Käytä Viewien puolelta findUsersRoles joka tarkistaa käyttäjän oikeudet
	// ensin.
	public Set<Role> localFindUsersRoles(EventUser u) {
		// if (currentEventuser != null && u.equals(currentEventuser)) {
		// logger.debug("Returnin cached eventuserroles for user {}: {}",
		// currentEventuser, currentEventuserRoles);
		// return currentEventuserRoles;
		// }
		LanEvent event = eventBean.getCurrentEvent();

		Set<Role> checkedRoles = new HashSet<Role>();

		if (u != null)
		{
			addRecursive(checkedRoles, rolefacade.findForUser(u));

			if (permbean.isLoggedIn()) {

				// add roles from events default role.
				addRecursive(checkedRoles, event.getDefaultRole());
			}

			if (!u.isAnonymous()) {
				// add roles from accountEvents of the user
				addRecursive(checkedRoles, productbean.getRolesFromAccountEvents(u));

				for (GroupMembership member : gmfacade.findMemberships(u)) {
					if (member != null && member.getPlaceReservation() != null)
					{
						addRecursive(checkedRoles, member.getPlaceReservation().getProvidesRole());
						if (member.getPlaceReservation().getProduct() != null)
						{
							addRecursive(checkedRoles, member.getPlaceReservation().getProduct().getProvides());
						}
					}
				}
			}

		}
		// currentEventuser = u;
		// currentEventuserRoles = new ArrayList<Role>(checkedRoles);
		// logger.debug("Returning parsed eventUser roles for user {}:  {} ", u,
		// currentEventuserRoles);
		// return currentEventuserRoles;

		return checkedRoles;
	}

	private static void addRecursive(Set<Role> checkedRoles, Collection<Role> roles) {
		for (Role r : roles) {
			addRecursive(checkedRoles, r);
		}
	}

	private static void addRecursive(Set<Role> checkedRoles, Role role) {
		if (role == null || checkedRoles.contains(role)) {
			return;
		}
		checkedRoles.add(role);
		for (Role r : role.getParents()) {
			addRecursive(checkedRoles, r);
		}

	}

	@Override
	@RolesAllowed(SpecialPermission.S_USER)
	public UserImage uploadImage(EventUser user, String contentType, InputStream imagestream, String filename, String description) {

		user = eventUserFacade.reload(user);
		logger.debug("uploading image to userid {}", user);

		EventUser curruser = permbean.getCurrentUser();
		if (!curruser.equals(user) && !permbean.hasPermission(UserPermission.MODIFY)) {
			loggerbean.sendMessage(MoyaEventType.USER_PERMISSION_VIOLATION, curruser, "user tried to save picture for userid " + user + " without sufficient permissions!");
			throw new EJBAccessException("No permission to upload image as another user");
		}

		BufferedImage bimage;
		try {
			bimage = ImageIO.read(imagestream);
		} catch (IOException e) {
			throw new RuntimeException(e);
		}

		int maxImageWidth = 1000;
		int maxImageHeight = 1000;

		if (bimage.getWidth() > maxImageWidth || bimage.getHeight() > maxImageHeight) {

			int w = bimage.getWidth();
			int h = bimage.getHeight();

			if (w > h) {
				h = (int) (((double) h / (double) w) * (double) maxImageWidth);
				w = maxImageWidth;
			} else {
				w = (int) (((double) w / (double) h) * (double) maxImageHeight);
				h = maxImageHeight;
			}

			logger.info("scaling image to {} x {}", w, h);

			BufferedImage resized = new BufferedImage(w, h, bimage.getType());
			Graphics2D g = resized.createGraphics();
			g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
			g.drawImage(bimage, 0, 0, w, h, 0, 0, bimage.getWidth(), bimage.getHeight(), null);
			g.dispose();

			bimage = resized;
		}

		bimage = forceCrop(bimage);

		ByteArrayOutputStream naamaout = new ByteArrayOutputStream();
		try {
			ImageIO.write(bimage, "png", naamaout);
		} catch (IOException e) {
			throw new RuntimeException(e);
		}

		UserImage userimage = null;

		userimage = new UserImage(user.getUser());
		userimage.setMimeType(contentType);
		userimage.setImageData(naamaout.toByteArray());
		userimage.setName(filename);
		userimage.setDescription(description);

		user.getUser().getUserImageList().add(userimage);

		// setting uploaded image as the default.
		user.getUser().setCurrentImage(userimage);

		return userimage;
	}

	private BufferedImage forceCrop(BufferedImage source) {
		int targetWidth, targetHeight;
		double targetRatio = CardPrintBean.ASPECT_RATIO; // x/y
		int sourceWidth = source.getWidth();
		int sourceHeight = source.getHeight();
		int sourceCenterX = sourceWidth / 2;
		int sourceCenterY = sourceHeight / 2;
		int sourceTop, sourceLeft, sourceRight, sourceBottom;

		double sourceRatio = (double) sourceWidth / (double) sourceHeight;
		if (sourceRatio > targetRatio) {
			// the pic is too wide - reduce width
			targetWidth = (int) ((double) sourceHeight * targetRatio);
			targetHeight = sourceHeight;

			// crop box coords - calculate left and right
			sourceLeft = sourceCenterX - (targetWidth / 2);
			sourceTop = 0;
			sourceRight = sourceCenterX + (targetWidth / 2);
			sourceBottom = sourceHeight;
		} else {
			// the pic is too tall - reduce height
			targetWidth = sourceWidth;
			targetHeight = (int) ((double) sourceWidth / targetRatio);

			// crop box coords - calculate top and bottom
			sourceLeft = 0;
			sourceTop = sourceCenterY - (targetHeight / 2);
			sourceRight = sourceWidth;
			sourceBottom = sourceCenterY + (targetHeight / 2);
		}

		BufferedImage cropped = new BufferedImage(targetWidth, targetHeight, source.getType());
		Graphics2D g = cropped.createGraphics();
		g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
		g.drawImage(source, 0, 0, targetWidth, targetHeight, sourceLeft, sourceTop, sourceRight, sourceBottom, null);
		g.dispose();

		return cropped;
	}

	@Override
	public UserImage findUserimageFORCE(Integer id)
	{
		return userimagefacade.find(id);
	}

	@Override
	public UserImage findUserImage(int id) {

		UserImage ret = null;
		if (id == 0 && permbean.isLoggedIn()) {
			ret = permbean.getCurrentUser().getUser().getCurrentImage();
		} else {
			ret = userimagefacade.find(id);
			if (ret != null && !permbean.isCurrentUser(ret.getUser()) && permbean.hasPermission(UserPermission.MODIFY)) {
				loggerbean.sendMessage(MoyaEventType.USER_INSUFFICIENT_PERMISSIONS, permbean.getCurrentUser(), "Not enough rights to access image id: ", id, " for user ", ret.getUser());
				throw new EJBAccessException("Not enough permissions to fetch image");
			}

		}
		return ret;
	}

	// @Override
	// public List<User> searchName(String name) {
	// return userFacade.searchForName(name);
	// }

	@Override
	@RolesAllowed(UserPermission.S_CREATE_NEW)
	public void createNewUser(EventUser user, String password) {

		user.getUser().resetPassword(password);
		user.setEvent(eventBean.getCurrentEvent());

		if (user.getLogin() == null || user.getLogin().trim().isEmpty()) {
			user.setLogin(user.getEmail());
		}

		// Tallennetaan olio kantaan...
		eventUserFacade.create(user);

		em.flush();
	}

	@Override
	public User findPasswordResetUser(Integer id, String hash) {
		User ret = null;
		if (id != null && hash != null && id > 0 && !hash.isEmpty()) {
			User user = userFacade.find(id);
			if (user != null && hash.equals(user.getConfirmHash())) {
				ret = user;
			}
		}
		return ret;
	}

	@Override
	public boolean resetPassword(User user, String password, String hash) {
		User nuser = userFacade.find(user.getId());
		if (user.equals(nuser) && hash.equals(nuser.getConfirmHash())) {
			logger.debug("Changing user {} password with confirmhash {}", user, hash);
			nuser.setConfirmHash(null);
			nuser.resetPassword(password);
			userFacade.merge(nuser);
			return true;
		}
		return false;
	}

    @Override
    @RolesAllowed(UserPermission.S_MODIFY)
    public boolean resetPassword(User user, String password) {
        logger.debug("Changing user {} password", user);
        user.resetPassword(password);
        userFacade.merge(user);
        return true;
    }

    @Override
	public boolean initPasswordResetForUsername(String username, String url) {
		User user = userFacade.findByLogin(username);
		return initPasswordReset(user, url);
	}

	@Override
	public boolean initPasswordResetForEmail(String email, String url) {
		List<User> users = userFacade.findByEmail(email);
		logger.info("Got {} results for email: {}", users.size(), email);

		if (users.isEmpty()) {
			return false;
		}
		return initPasswordReset(users.get(0), url);
	}

	private boolean initPasswordReset(User user, String url)
	{
		String hash = PasswordFunctions.generateRandomString(25);
		logger.info("Initializing password sending: {}, hash: {}", user, hash);

		if (hash == null || hash.length() < 20 || user == null || user.getEmail() == null || user.getEmail().length() <= 5) {
			logger.info("Not sending email with params {} {}", new Object[] { user, hash });
			return false;
		}
		String path = MessageFormat.format(url, new Object[] { user.getId().toString(), hash });

		LanEvent event = eventBean.getCurrentEvent();
		MailMessage msg = new MailMessage();
		msg.setTo(user);
		msg.setSubject(I18n.get("passwordreset.mailSubject", event.getName()));
		msg.setMessage(I18n.get("passwordreset.mailBody", path));

		logger.info("sending mail! user {} hash {} path {}", new Object[] { user, hash, path });
		utilbean.sendMail(msg);
		user.setConfirmHash(hash);
		return true;
	}

	public PrintedCard rejectPrintedCard(PrintedCard card, MailMessage mail) {

		if (card != null) {

			card.setCardState(CardState.REJECTED);
			card = printedcardfacade.merge(card);
			logger.info("rejectPrintedCard(): Rejected card {}, state {}", card, card.getCardState());

			User user = null;
			if (card.getUser() != null && card.getUser().getUser() != null)
				user = card.getUser().getUser();

			LanEvent event = card.getEvent();

			if (mail != null) {
				if (!utilbean.sendMail(mail)) {
					logger.info("Sending mail failed");
				} else
					logger.info("Sending mail succeeded");
			} else {
				if (user == null)
					logger.info("user is null");
				if (event == null)
					logger.info("event is null");
			}
		}

		logger.info("returning card");

		return card;
	}

	// @Override
	// @RolesAllowed(UserPermission.S_VIEW_ALL)
	// public User findById(Integer id) {
	// return userFacade.find(id);
	// }

	// @Override
	// public long getUsersCount(String search) {
	// return userFacade.searchUserCount(search);
	// }

	@Override
	public boolean invite(String invitemail, String url, GroupMembership inviteGm) {
		invitemail = invitemail.trim();

		List<User> usercheck = userFacade.findByEmail(invitemail);
		if (usercheck.size() > 0 && inviteGm == null) {
			logger.info("Email already exists {}", invitemail);
			return false;
		}

		EventUser creator = permbean.getCurrentUser();
		LanEvent ev = eventBean.getCurrentEvent();

		String token = gmfacade.createInviteToken();

		PlaceGroup pg;
		if (inviteGm != null) {
			if (!permbean.hasPermission(MapPermission.MANAGE_OTHERS)) {
				if (inviteGm.getUser() != null && !permbean.isCurrentUser(inviteGm.getUser())) {
					throw new EJBAccessException("No permission to reinvite to that place");
				}

				if (inviteGm.getUser() == null && !permbean.isCurrentUser(inviteGm.getPlaceGroup().getCreator())) {
					throw new EJBAccessException("No permission to invite to that place");
				}
			}

			inviteGm.setInviteToken(token);
			inviteGm.setInviteEmail(invitemail);
			gmfacade.merge(inviteGm);
			pg = inviteGm.getPlaceGroup();
		} else {
			if (!permbean.hasPermission(UserPermission.INVITE_USERS)) {
				throw new EJBAccessException("No permission to invite other people");
			}

			pg = new PlaceGroup(ev, Calendar.getInstance(), Calendar.getInstance(), false);
			pg.setCreator(creator);
			pg.setName("Invite to " + invitemail);
			GroupMembership gm = new GroupMembership(pg, null, token);
			gm.setInviteEmail(invitemail);
			pg.getMembers().add(gm);
			pgfacade.create(pg);
		}

		MailMessage msg = new MailMessage();
		msg.setSubject(eventBean.getPropertyString(LanEventPropertyKey.INVITEMAIL_SUBJECT));
		String formatUrl = MessageFormat.format(url, token);
		logger.info("Sending invite url {}", formatUrl);
		msg.setMessage(MessageFormat.format(eventBean.getPropertyString(LanEventPropertyKey.INVITEMAIL_CONTENT), formatUrl, creator.getUser().getWholeName()));
		msg.setToAddress(invitemail);
		utilbean.sendMail(msg);
		return true;
	}

	@Override
	public void cancelInvite(GroupMembership ship) {
		ship = gmfacade.merge(ship);
		ship.setInviteToken(gmfacade.createInviteToken());
		ship.setInviteEmail(null);
		ship.setInviteName(null);
	}

	@Override
	@PermitAll
	public GroupMembership findToken(String token) {
		return gmfacade.findByToken(token);
	}

	@Override
	@PermitAll
	public EventUser acceptInviteForExistingUser(String username, String password, String token) {
		GroupMembership gm = findToken(token);
		if (gm == null || ((gm.getUser() != null || gm.getInviteAccepted() != null) && gm.getPlaceReservation() == null)) {
			return null;
		}

		// it's nice to check password also
		EventUser eu = validateUser(username, password, true);

		if (eu == null)
			return null;

		loggerbean.sendMessage(MoyaEventType.INVITE_ACCEPTED, eu, "Ivite accepted by current user", gm, gm.getUser());

		gm.setUser(eu);
		gm.setInviteAccepted(Calendar.getInstance());

		gm.setInviteEmail(null);

		// change token, just in case
		gm.setInviteToken(gmfacade.createInviteToken());

		return eu;
	}

	@Override
	@PermitAll
	public boolean createFromInviteToken(EventUser user, String token) {
		if (user == null || user.getLogin() == null)
			return false;

		GroupMembership gm = findToken(token);

		// Check that invite has not already been accepted!
		if (gm == null || ((gm.getUser() != null || gm.getInviteAccepted() != null) && gm.getPlaceReservation() == null)) {
			return false;
		}
		user.setEvent(eventBean.getCurrentEvent());

		if (user.getLogin() == null || user.getLogin().trim().isEmpty()) {
			user.setLogin(user.getEmail());
		}

		gm.setUser(user);
		gm.setInviteAccepted(Calendar.getInstance());

		// change token, just in case
		gm.setInviteToken(gmfacade.createInviteToken());

		eventUserFacade.create(user);
		return true;
	}

	// private void jaiCrop()
	// {
	// SeekableStream seekableStream =
	// SeekableStream.wrapInputStream(naamastream, false);
	// PlanarImage naamaimage = JAI.create("Stream", seekableStream);
	//
	// // Origin point where you want to start cropping
	// Point p = new Point(150, 150);
	// // The size of the area that you want to crop
	// Dimension d = new Dimension(90, 70);
	// Rectangle r = new Rectangle(p, d);
	//
	// ParameterBlock pb = new ParameterBlock();
	// pb.addSource(naamaimage);
	//
	// pb.add((float) r.getX());
	// pb.add((float) r.getY());
	// pb.add((float) r.getWidth());
	// pb.add((float) r.getHeight());
	//
	// // Creates the cropped area
	// RenderedOp image = JAI.create("crop", pb);
	// }

	@Override
	public UserImage saveCroppedImage(UserImage currimage, int left, int top, int width, int height) throws IOException {
		currimage = imagefacade.find(currimage.getId());
		User user = currimage.getUser();
		logger.info("Current image {}, current user {}", currimage, user);

		user = userFacade.find(user.getId());
		ByteArrayInputStream naamastream = new ByteArrayInputStream(currimage.getImageData());
		BufferedImage face = ImageIO.read(naamastream);
		BufferedImage newface = face.getSubimage(left, top, width, height);
		ByteArrayOutputStream naamaout = new ByteArrayOutputStream();

		// JPG rikkoo asioita jos lähde ei ole JPG, tai muuten tunnettu
		// ilmeisesti alpha rikkoo asioita...
		ImageIO.write(newface, "png", naamaout);

		UserImage ret = new UserImage(user);
		ret.setMimeType("image/png");
		User curruser = permbean.getCurrentUser().getUser();
		ret.setDescription("Cropped by: [" + curruser.getId() + "] " + curruser.getWholeName() + " from image: " + currimage.getId());
		ret.setImageData(naamaout.toByteArray());
		// ret.setMimeType("image/jpeg");
		if (user.getUserImageList() == null)
		{
			user.setUserImageList(new ArrayList<UserImage>());
		}
		user.getUserImageList().add(ret);
		user.setCurrentImage(ret);

		return ret;

	}

	@Override
	@RolesAllowed(UserPermission.S_CREATE_NEW)
	public EventUser createNewUser(User usr) {
		EventUser evu = new EventUser(usr, eventBean.getCurrentEvent(), permbean.getCurrentUser());
		eventUserFacade.create(evu);
		return evu;
	}

	@Override
	@RolesAllowed(UserPermission.S_MODIFY_OWN_GAMEIDS)
	public void addGameID(TournamentGame game, String gameid) {
		EventUser u = permbean.getCurrentUser();

		GameID gid = new GameID();
		gid.setIdentifier(gameid);
		gid.setGame(game);
		gid.setUser(u);

		gameIDFacade.create(gid);

		u.getGameIDs().add(gid);
	}

	@Override
	@RolesAllowed(UserPermission.S_MODIFY_OWN_GAMEIDS)
	public void removeGameIdById(Integer gameIdId) {
		GameID gi = gameIDFacade.find(gameIdId);

		// In the future we may edit other peoples' gameids, leave this as a
		// placeholder for now
		// At the very least it safeguards the situation if user gets another
		// users gameid in somehow..
		if (!permbean.isCurrentUser(gi.getEventUser())) {
			loggerbean.sendMessage(MoyaEventType.USER_INSUFFICIENT_PERMISSIONS, permbean.getCurrentUser(), "User tried to remove GameID from another user: ", gi.getEventUser());
			throw new EJBAccessException("Not enough rights to remove another users' GameIDs");
		}

		gi.getEventUser().getGameIDs().remove(gi);
		gameIDFacade.remove(gi);
	}

	@Override
	@RolesAllowed(UserPermission.S_VIEW_ALL_GAMEIDS)
	public GameID getGameIDByGameAndUser(TournamentGame tg, EventUser user) {
		return gameIDFacade.getGameIDByGame(tg, user);
	}

	@Override
	public boolean userExists(String login) {
		User usr = userFacade.findByLogin(login);
		return usr != null;
	}

	@Override
	public boolean userExistsByEmail(String email) {
		List<User> usr = userFacade.findByEmail(email);

		return (usr != null && usr.size() > 0);
	}

	@Override
	public EventUser findByEventUserId(Integer integer) {
		return eventUserFacade.find(integer);
	}

	@Override
	@RolesAllowed(SpecialPermission.S_USER)
	public EventUser mergeEventUserChanges(EventUser user) {
		if (!permbean.isCurrentUser(user) && !permbean.hasPermission(UserPermission.MODIFY)) {
			loggerbean.sendMessage(MoyaEventType.USER_INSUFFICIENT_PERMISSIONS, permbean.getCurrentUser(), "User tried to save another user: ", user);
			throw new EJBAccessException("Not enough rights to save user");
		}

		EventUser ret = eventUserFacade.merge(user);
		return ret;
	}

	@Override
	public EventUser getEventUser(User user, boolean create) {
		if (user == null || user.getId() == null) {
			return null;
		}
		user = userFacade.find(user.getId());

		EventUser ret = eventUserFacade.find(user);

		if (create && ret == null)
		{
			ret = new EventUser(user, eventBean.getCurrentEvent(), permbean.getCurrentUser());
			eventUserFacade.create(ret);
			eventUserFacade.flush();
			ret.setCreator(permbean.getCurrentUser());
		}

		return ret;
	}

	@Override
	public EventUser findByUserId(Integer userid, boolean createEventuser) {
		User user = userFacade.find(userid);
		EventUser ret = null;
		if (user != null) {
			ret = this.getEventUser(user, createEventuser);
		}
		return ret;
	}

	private EventUser validateUser(String username, String password, boolean createEventUser) {
		User user = userFacade.findByLogin(username);
		EventUser ret = null;
		if (user != null && user.checkPassword(password))
		{
			ret = this.getEventUser(user, createEventUser);
		}
		return ret;
	}

	@Override
	public EventUser validateUser(String username, String password)
	{
		return validateUser(username, password, false);
	}

	@Override
	@RolesAllowed(UserPermission.S_VIEW_ALL)
	public EventUser getUserByBarcode(String barcode) {
		PrintedCard tmpCard = barcodeBean.getPrintedCard(barcode);

		EventUser user = null;
		if (tmpCard == null) {
			user = barcodeBean.getUser(barcode);
		} else {
			user = tmpCard.getUser();
		}

		return user;
	}

	@Override
	@RolesAllowed(UserPermission.S_VIEW_ALL)
	public SearchResult<User> getUsers(SearchQuery search) {
		return userFacade.searchAllUsers(search);
	}

	@Override
	@RolesAllowed(UserPermission.S_VIEW_ALL)
	public SearchResult<EventUser> getThisEventsUsers(UserSearchQuery searchQuery) {
		SearchResult<EventUser> returnUsers = eventUserFacade.searchEventUsers(searchQuery);

		// search users by barcode, if found, return it first
		EventUser user = getUserByBarcode(searchQuery.getSearch());

		if (user != null) {
			List<EventUser> newSearchList = new ArrayList<EventUser>();

			newSearchList.add(user);

			newSearchList.addAll(returnUsers.getResults());

			returnUsers = new SearchResult<EventUser>(newSearchList, (long) newSearchList.size());

		} else if (searchQuery.isUsersWithUnusedCodes()) {
			List<EventUser> newSearchList = new ArrayList<EventUser>();
			List<GroupMembership> groupMembers = new ArrayList<GroupMembership>();
			groupMembers = gmfacade.findAllWithoutUser();

			for (GroupMembership member : groupMembers) {
				PlaceGroup group = member.getPlaceGroup();
				if (group != null && !newSearchList.contains(group.getCreator())) {
					newSearchList.add(group.getCreator());
				}
			}
			returnUsers = new SearchResult<EventUser>(newSearchList, (long) newSearchList.size());
		}

		return returnUsers;
	}

	@Override
	public void submitFeedback(String feedback) {
		Feedback fb = new Feedback();
		fb.setEvent(eventBean.getCurrentEvent());
		fb.setMessage(feedback);
		fb.setSender(permbean.getCurrentUser());
		fb.setTimestamp(Calendar.getInstance());
		feedbackFacade.create(fb);
	}

	@Override
	@RolesAllowed(SpecialPermission.S_SUPERADMIN)
	public List<Feedback> getFeedbacks() {
		return feedbackFacade.findAll();
	}

	@Override
	public UserApproval setUserApproval(EventUser user, String approvalName, boolean approvalValue, String notes) {
		if (!permbean.getCurrentUser().equals(user) && permbean.hasPermission(UserPermission.MODIFY))
			throw new EJBAccessException("Tried to set approval without permissions: " + approvalName + " to " + approvalValue + " with notes " + notes);

		Approval approval = approvalFacade.findOrCreate(approvalName);
		UserApproval ret = userApprovalFacade.findOrCreateApproval(user, approval);
		ret.setApprovalValue(approvalValue);
		ret.setNotes(notes);
		return ret;
	}

	@Override
	public boolean isUserInRole(EventUser user, Integer roleId) {
		Set<Role> roles = localFindUsersRoles(user);
		logger.info("CHecking user {} roleid {} from roles {}, roles size{}", new Object[] { user, roleId, roles, roles.size() });
		addRecursive(roles, eventBean.getCurrentEvent().getDefaultRole());

		for (Role r : roles) {
			if (roleId.equals(r.getId())) {
				logger.info("User {} found in role {}", user, roleId);
				return true;
			}
		}
		logger.info("User {} NOT found in role {}", user, roleId);
		return false;
	}

	@Override
	public User getUser(Integer id) {

		User ret = userFacade.find(id);
		if (!permbean.getCurrentUser().getUser().equals(ret) && !permbean.hasPermission(UserPermission.VIEW_ALL)) {
			throw new EJBAccessException("Tried to fetch user with id " + id + " from database without sufficient permissions");
		}

		return ret;
	}

	@Override
	@RolesAllowed(EventPermission.S_MANAGE_EVENT)
	public BigDecimal transferAccountSaldoFromPreviousEvent(List<User> users, LanEvent source)
	{

		if (source == null || users == null || users.isEmpty())
			return null;
		source = eventfacade.reload(source);
		LanEvent destination = eventBean.getCurrentEvent();
		if (!source.getOrganiser().equals(destination.getOrganiser())) {
			throw new EJBException("Trying to move credits between organisations!");
		}
		final Calendar time = Calendar.getInstance();
		final EventUser seller = permbean.getCurrentUser();

		final Product dstCredprod = productbean.findCreditProduct();
		final Product srcCredprod = productFacade.findProductsByPrice(BigDecimal.ONE.negate(), source).get(0);

		if (srcCredprod.getPrice().compareTo(dstCredprod.getPrice()) != 0) {
			throw new RuntimeException("Credit prices do not match! src " + srcCredprod.getPrice() + " dst " + dstCredprod.getPrice());
		}
		final BigDecimal creditPrice = srcCredprod.getPrice().negate();

		BigDecimal dstTotal = BigDecimal.ZERO;

		for (User user : users)
		{
			EventUser dstUser = eventUserFacade.find(user);
			EventUser srcUser = eventUserFacade.getOtherOrganisationsEventuser(dstUser.getUser(), source);

			// If source user does not exist, skip over.
			if (srcUser == null) {
				continue;
			}

			BigDecimal srcBalance = srcUser.getAccountBalance();
			if (srcBalance.compareTo(BigDecimal.ZERO) == 0) {
				continue;
			}
			BigDecimal count = srcBalance.divide(creditPrice);
			if (count.compareTo(BigDecimal.ZERO) < 0) {
				throw new EJBException("All users should have positive balance!. User with id: " + dstUser.getUser().getId() + " has negative balance!");
			}
			// Negative accountevent for source user
			AccountEvent srcacc = new AccountEvent(srcUser, srcCredprod, creditPrice, count.negate(), time);

			srcacc.setDescription("Credits transferred to: '" + destination.getName() + "'");
			srcacc.setSeller(seller);
			srcUser.addAccountevent(srcacc);
			accountEventFacade.create(srcacc);

			AccountEvent dstacc = new AccountEvent(dstUser, dstCredprod, creditPrice, count, time);
			dstacc.setDescription("Credits transferred from: '" + source.getName() + "'");
			dstacc.setSeller(seller);
			dstUser.addAccountevent(dstacc);
			accountEventFacade.create(dstacc);
			logger.info("Transferred {} credits with price {} for user {} from {} to {}",
					new Object[] { count, creditPrice, srcUser.getUser(), srcUser, dstUser });

			dstTotal = dstTotal.add(dstacc.getTotal());
		}
		return dstTotal;

	}

	@Override
	@RolesAllowed(EventPermission.S_MANAGE_EVENT)
	public EventUser getOtherEventsEventuser(User user, LanEvent event) {
		event = eventfacade.reload(event);
		if (!eventBean.getCurrentEvent().getOrganiser().equals(event.getOrganiser())) {
			throw new EJBAccessException("event must be organised by the organisation as this event.");
		}
		return eventUserFacade.getOtherOrganisationsEventuser(user, event);

	}

	@Override
	@RolesAllowed(EventPermission.S_MANAGE_EVENT)
	public String getAuthCode(EventUser user) {
		logger.info("getAuthCode()");
		String code = "";

		String hex = Integer.toHexString(user.getId());
		logger.info("Hex code {} for id {}", hex, user.getId());

		// padding hex string to 5 characters by adding Xs to the beginning
		if (hex.length() < 5) {
			logger.info("Padding hex ({}) with X.", hex.length());
			for (int i = 0; i < 5; i++) {
				if (hex.length() < 5) {
					hex = "X" + hex;
				}
				else
					break;
			}
		} else
			logger.info("Hex string too long ({}), no padding needed", hex.length());

		String hash = "";
		logger.info("Generating md5 hash from hex {}", hex);
		try {
			MessageDigest md = MessageDigest.getInstance("MD5");
			byte[] array = md.digest(hex.getBytes());
			hash = new String(Hex.encodeHex(array));
			logger.info("Hash {}", hash);
		} catch (NoSuchAlgorithmException ex) {
			logger.info("Catched exeption {}", ex.getMessage());
		}

		if (!hash.isEmpty() && hash.length() > 2) {
			// Generating code by concatenating hex string and first 3
			// characters from hash
			code = code.concat(hex);
			code = code.concat(hash.substring(0, 3));
			logger.info("Code for user is {}", code);
		} else
			logger.info("No code generated: hash.length() {}", hash.length());

		return code.toUpperCase();
	}

	@Override
	public String findUsernameByEmailUsername(String filter) {
		User user = userFacade.findByLogin(filter);

		List<User> users = userFacade.findByEmail(filter);

		if (users.size() == 1 && user != null) {
			if (user.equals(users.get(0)))
				return user.getLogin();

			return null;
		}

		if (user != null)
			return user.getLogin();

		if (users.size() == 1) {
			return users.get(0).getLogin();
		}

		return null;

	}

	@RolesAllowed(UserPermission.S_VIEW_ALL)
	public EventUser findEventuserByLogin(String username) {
		return eventUserFacade.findByLogin(username);
	}

    @Override
    @RolesAllowed(UserPermission.S_VIEW_ALL)
    public Boolean checkPassword(EventUser eventUser, String password) {
        if (eventUser != null) {
            return eventUser.checkPassword(password);
        }
        return null;
    }

	@PermitAll
	public EventUser findEventuserByLoginUnsecure(String username) {
		return eventUserFacade.findByLogin(username);
	}



    @Override
	@RolesAllowed(EventPermission.S_MANAGE_EVENT)
	public EventUser getUserByAuthcode(String authcode) {
		logger.info("getUser({})", authcode);
		EventUser user = null;

		if (authcode.length() == 8) {
			logger.info("authcode length is 8");
			// First 5 characters are the hex
			String paddedHex = authcode.substring(0, 5);
			logger.info("Padded hex {}", paddedHex);
			// Removing the padding characters
			String hex = paddedHex.replace("X", "");

			logger.info("Hex {}", hex);

			int id = 0;
			try {
				id = Integer.decode("0x" + hex.toLowerCase());
			} catch (NumberFormatException ex) {
				logger.info("NumberFormatException was thrown");
			}

			logger.info("Id {}", id);

			if (id != 0) {
				user = eventUserFacade.find(id);
			}
			if (user != null) {
				// Testing if the user is correct
				logger.info("User {} found with id {}", user, id);
				String testCode = getAuthCode(user);
				logger.info("Testcode {}", testCode);
				if (testCode == null || testCode.equals("") || !authcode.equals(testCode)) {
					user = null;
					logger.info("User set to null, test code not the same as user that was found.");
				}
			} else
				logger.info("User not found with id {}", id);
		} else
			logger.info("authcode length not 8!, length {}", authcode.length());

		return user;
	}

	
}