UserBean.java

package fi.insomnia.bortal.beans;

import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
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.LocalBean;
import javax.ejb.Stateless;
import javax.imageio.ImageIO;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

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

import fi.insomnia.bortal.enums.apps.SpecialPermission;
import fi.insomnia.bortal.enums.apps.UserPermission;
import fi.insomnia.bortal.facade.EventUserFacade;
import fi.insomnia.bortal.facade.FeedbackFacade;
import fi.insomnia.bortal.facade.GroupMembershipFacade;
import fi.insomnia.bortal.facade.PlaceGroupFacade;
import fi.insomnia.bortal.facade.RoleFacade;
import fi.insomnia.bortal.facade.UserFacade;
import fi.insomnia.bortal.facade.UserImageFacade;
import fi.insomnia.bortal.model.EventUser;
import fi.insomnia.bortal.model.Feedback;
import fi.insomnia.bortal.model.GroupMembership;
import fi.insomnia.bortal.model.IUser;
import fi.insomnia.bortal.model.LanEvent;
import fi.insomnia.bortal.model.LanEventPropertyKey;
import fi.insomnia.bortal.model.PlaceGroup;
import fi.insomnia.bortal.model.Role;
import fi.insomnia.bortal.model.User;
import fi.insomnia.bortal.model.UserImage;
import fi.insomnia.bortal.util.MailMessage;
import fi.insomnia.bortal.util.UserSearchQuery;
import fi.insomnia.bortal.utilities.I18n;
import fi.insomnia.bortal.utilities.PasswordFunctions;
import fi.insomnia.bortal.utilities.SearchQuery;
import fi.insomnia.bortal.utilities.SearchResult;

@LocalBean
@Stateless
@DeclareRoles({
		UserPermission.S_VIEW_ALL,
		UserPermission.S_CREATE_NEW,
		UserPermission.S_INVITE_USERS,
		UserPermission.S_MODIFY,
		SpecialPermission.S_USER,
})
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 AccountEventBeanLocal acbean;

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

	@EJB
	private UserImageFacade imagefacade;

	@EJB
	private LoggingBeanLocal loggerbean;

	@EJB
	private RoleFacade rolefacade;
	@EJB
	private PlaceGroupFacade pgfacade;
	@EJB
	private FeedbackFacade feedbackFacade;

	@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.logMessage(SecurityLogType.permissionDenied, 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);

		return ret;
	}

	@Override
	public List<Role> findUsersRoles(EventUser u) {
		EventUser currusr = permbean.getCurrentUser();
		if (!currusr.equals(u) && !permbean.hasPermission(UserPermission.MODIFY)) {
			loggerbean.logMessage(SecurityLogType.permissionDenied, permbean.getCurrentUser(), "User tried to fetc another users roles: " + u);
			throw new EJBAccessException("Not enough rights to find roles");
		}

		return localFindUsersRoles(u);

	}

	public ArrayList<Role> localFindUsersRoles(EventUser u) {
		Set<Role> checkedRoles = new HashSet<Role>();
		if (u != null)
		{
			addRecursive(checkedRoles, rolefacade.findForUser(u));

			if (permbean.isLoggedIn()) {

				LanEvent event = eventBean.getCurrentEvent();
				// add roles from events default role.
				addRecursive(checkedRoles, event.getDefaultRole());

				// add roles from accountEvents of the user
				addRecursive(checkedRoles, acbean.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());
					}
				}
			}
		}
		return new ArrayList<Role>(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, byte[] image, String filename, String description) {

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

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

		UserImage userimage = null;

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

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

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

		return userimage;
	}

	@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.logMessage(SecurityLogType.permissionDenied, 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);
		// todo add barcode
		user.setEvent(eventBean.getCurrentEvent());
		// 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
	public boolean initPasswordReset(String username, String url) {

		User user = userFacade.findByLogin(username);
		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;
	}

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

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

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

	@Override
	@RolesAllowed(UserPermission.S_INVITE_USERS)
	public boolean invite(String invitemail, String url) {

		List<User> usercheck = userFacade.findByEmail(invitemail.trim());
		if (usercheck.size() > 0) {
			return false;
		}
		EventUser creator = permbean.getCurrentUser();
		LanEvent ev = eventBean.getCurrentEvent();
		PlaceGroup pg = new PlaceGroup(ev, Calendar.getInstance(), Calendar.getInstance(), false);
		pg.setCreator(creator);
		pg.setName("Invitebean");
		String token = PasswordFunctions.generateRandomString(30, PasswordFunctions.ALL_CHARS);
		pg.getMembers().add(new GroupMembership(pg, null, token));
		pgfacade.create(pg);

		MailMessage msg = new MailMessage();
		msg.setSubject(eventBean.getPropertyString(LanEventPropertyKey.INVITEMAIL_SUBJECT));
		msg.setMessage(MessageFormat.format(eventBean.getPropertyString(LanEventPropertyKey.INVITEMAIL_CONTENT), MessageFormat.format(url, token), creator.getUser().getWholeName()));
		msg.setToAddress(invitemail);
		utilbean.sendMail(msg);
		return true;
	}

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

	@Override
	@PermitAll
	public void createFromToken(EventUser user, String token) {
		GroupMembership gm = findToken(token);
		user.setEvent(eventBean.getCurrentEvent());
		gm.setUser(user);
		gm.setInviteAccepted(Calendar.getInstance());

		eventUserFacade.create(user);
	}

	// 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
	public boolean userExists(String login) {
		IUser usr = userFacade.findByLogin(login);
		return usr != null;
	}

	@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.logMessage(SecurityLogType.permissionDenied, 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) {
		if (user == null || user.getId() == null) {
			return null;
		}
		user = userFacade.find(user.getId());

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

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

	@Override
	public EventUser validateUser(String username, String password)
	{
		User user = userFacade.findByLogin(username);
		EventUser ret = null;
		if (user.checkPassword(password))
		{
			ret = this.getEventUser(user);
		}
		return ret;

	}

	@Override
	@RolesAllowed(UserPermission.S_VIEW_ALL)
	public EventUser getUserByBarcode(String barcode) {
		EventUser user = eventUserFacade.findByBarcode(barcode);
		return user;
	}

	@Override
	public SearchResult<User> getEventUsers(SearchQuery search) {
		if (search.getSearch() == null || search.getSearch().isEmpty())
		{
			throw new RuntimeException("You should be using getThisEventsUsers if not searching globally...");
			// return userFacade.searchEventUsers(search);
		} else {
			return userFacade.searchAllUsers(search);
		}

	}

	@Override
	public SearchResult<EventUser> getThisEventsUsers(UserSearchQuery searchQuery) {
		return eventUserFacade.searchEventUsers(searchQuery);
	}

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