CardTemplateBean.java

package fi.codecrew.moya.beans;

import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
import java.util.Set;

import javax.annotation.security.DeclareRoles;
import javax.annotation.security.RolesAllowed;
import javax.ejb.EJB;
import javax.ejb.LocalBean;
import javax.ejb.Stateless;
import javax.imageio.ImageIO;

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

import fi.codecrew.moya.enums.CardState;
import fi.codecrew.moya.enums.apps.UserPermission;
import fi.codecrew.moya.facade.CardCodeFacade;
import fi.codecrew.moya.facade.CardObjectDataFacade;
import fi.codecrew.moya.facade.CardTemplateFacade;
import fi.codecrew.moya.facade.CardTextDataFacade;
import fi.codecrew.moya.facade.EventUserFacade;
import fi.codecrew.moya.facade.GroupMembershipFacade;
import fi.codecrew.moya.facade.LanEventPropertyFacade;
import fi.codecrew.moya.facade.PrintedCardFacade;
import fi.codecrew.moya.model.CardCode;
import fi.codecrew.moya.model.CardObjectData;
import fi.codecrew.moya.model.CardTemplate;
import fi.codecrew.moya.model.CardTextData;
import fi.codecrew.moya.model.EventUser;
import fi.codecrew.moya.model.GroupMembership;
import fi.codecrew.moya.model.LanEvent;
import fi.codecrew.moya.model.LanEventProperty;
import fi.codecrew.moya.model.LanEventPropertyKey;
import fi.codecrew.moya.model.PrintedCard;
import fi.codecrew.moya.model.Role;
import fi.codecrew.moya.util.MailMessage;

/**
 * Session Bean implementation class CardTemplateBean
 */
@Stateless
@LocalBean
@DeclareRoles({ UserPermission.S_WRITE_ROLES })
public class CardTemplateBean implements CardTemplateBeanLocal {

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

	/**
	 * Default constructor.
	 */
	public CardTemplateBean() {
		// TODO Auto-generated constructor stub
	}

	@EJB
	private CardTemplateFacade cdFacade;

	@EJB
	private EventBeanLocal eventBean;
	// @EJB
	// private UserBeanLocal userbean;
	@EJB
	private PrintedCardFacade printedcardfacade;
	@EJB
	private UtilBeanLocal mailbean;

	@EJB
	private EventUserFacade eventUserFacade;

	@EJB
	private UserBean userbean;

	@EJB
	private LanEventPropertyFacade eventPropertyFacade;
	@EJB
	private GroupMembershipFacade gmFacade;

	@EJB
	private CardTextDataFacade ctdFacade;

	@EJB
	private CardObjectDataFacade codFacade;
	
	@EJB
	private CardCodeFacade cardCodeFacade;



	// @Override
	// @RolesAllowed("USER_MANAGEMENT/WRITE")
	// public List<CardTemplate> findAll() {
	// return cdFacade.findAll(eventBean.getCurrentEvent());
	// }

	@Override
	@RolesAllowed(UserPermission.S_WRITE_ROLES)
	public void create(CardTemplate card) {

		LanEvent currEv = eventBean.getCurrentEvent();
		if (currEv.getCardTemplates() == null)
		{
			currEv.setCardTemplates(new ArrayList<CardTemplate>());
		}
		card.setEvent(currEv);
		currEv.getCardTemplates().add(card);
	}

	@Override
	@RolesAllowed(UserPermission.S_WRITE_ROLES)
	public CardTemplate find(Integer id) {
		return cdFacade.find(id);
	}

	@Override
	@RolesAllowed(UserPermission.S_WRITE_ROLES)
	public CardTextData findTextData(Integer id) {
		return ctdFacade.find(id);
	}

	@Override
	@RolesAllowed(UserPermission.S_WRITE_ROLES)
	public CardObjectData findObjectData(Integer id) {
		return codFacade.find(id);
	}

	@Override
	public void checkAllUsersCardRights() {
		for (EventUser u : eventUserFacade.findAll()) {
			checkPrintedCard(u);
		}
	}

	/**
	 * Checks users printed card roles and return the biggestCard
	 * 
	 * @throws PermissionDeniedException
	 */
	@Override
	public PrintedCard checkPrintedCard(EventUser user) {
		logger.info("Checking printed card");

		user = eventUserFacade.find(user.getId());

		LanEvent currEvent = eventBean.getCurrentEvent();
		List<PrintedCard> myCards = printedcardfacade.getCards(user);

		PrintedCard biggestCard = null;
		for (PrintedCard card : myCards) {
			if (card.getEnabled()) {
				if (biggestCard == null || biggestCard.getTemplate().getPower() < card.getTemplate().getPower()) {
					// The biggest card should be the only one enabled.
					if (biggestCard != null) {
						biggestCard.setEnabled(false);
					}
					biggestCard = card;
				}
			}
		}

		CardTemplate roleCard = getUsersCardtype(user);

		int existingPower = -999;
		int newPower = -999;
		if (roleCard != null) {
			newPower = roleCard.getPower();
		}
		if (biggestCard != null) {
			existingPower = biggestCard.getTemplate().getPower();
		}

		if (existingPower < newPower) {

			if (biggestCard != null) {
				biggestCard.setEnabled(false);
				// biggestCard = printedcardfacade.merge(biggestCard);
			}
			PrintedCard pc = new PrintedCard();
			pc.setEvent(currEvent);
			pc.setTemplate(roleCard);
			pc.setUser(user);

			user.getPrintedCards().add(pc);
			// printedcardfacade.create(pc);
			biggestCard = pc;
			logger.info("User {} has too little power old role {} New role {}", new Object[] { user.getUser().getLogin(), existingPower, newPower });
		} else if (existingPower > newPower) {
			MailMessage msg = new MailMessage();
			LanEventProperty value = eventPropertyFacade.find(eventBean.getCurrentEvent(), LanEventPropertyKey.ADMIN_MAIL);
			if (value != null && value.getTextvalue() != null && !value.getTextvalue().isEmpty())
			{

				msg.setFromAddress(value.getTextvalue());
				msg.setFromName("Lippukauppa");
				msg.setToAddress(value.getTextvalue());
				msg.setSubject("User " + user.getUser().getLogin() + " has too powerful card!");
				msg.setMessage("User ", user.getUser().getLogin(), "has too powerful card!\nCurrent power ", existingPower, ". Should be ", newPower, ". Card replaced with less power.\n\n-- \nLippukauppa");
				mailbean.sendMail(msg);
			}

			logger.info("User {} has too much power old role {} New role {}, old card revoked.", new Object[] { user.getUser().getLogin(), existingPower, newPower });

			biggestCard.setEnabled(false);
			return this.checkPrintedCard(user);
		} else {
			logger.info("User {} has power {} and roles has power {}", new Object[] { user.getUser().getLogin(), existingPower, newPower });
		}

		return biggestCard;
	}

	@Override
	@RolesAllowed(UserPermission.S_VIEW_ALL)
	public CardTemplate getUsersCardtype(EventUser user) {

		Set<Role> roles = userbean.localFindUsersRoles(user);
		// logger.info("Checking roles {} against {}", user, roles);
		CardTemplate greatestTemplate = null;
		for (Role listrole : roles) {
			// logger.info("Checking role {}", listrole);
			if (greatestTemplate == null || (listrole.getCardTemplate() != null && greatestTemplate.getPower() < listrole.getCardTemplate().getPower())) {
				greatestTemplate = listrole.getCardTemplate();
			}

		}
		return greatestTemplate;

	}

	// @Override
	// public PrintedCard setRfidUid(String tag, EventUser user) {
	// PrintedCard ct = checkPrintedCard(user);
	// return setRfidUid(tag, ct);
	// }

	// @Override
	// public PrintedCard setRfidUid(String tag, PrintedCard card) {
	// card.setRfidUid(tag);
	// return printedcardfacade.merge(card);
	// }

	@Override
	@RolesAllowed(UserPermission.S_WRITE_ROLES)
	public List<PrintedCard> findActiveCards() {
		return this.printedcardfacade.findAllEnabled(eventBean.getCurrentEvent());
	}

	@Override
	@RolesAllowed(UserPermission.S_WRITE_ROLES)
	public List<CardTextData> findCardTextDatas(CardTemplate template) {
		return this.ctdFacade.findAll(template);
	}

	@Override
	@RolesAllowed(UserPermission.S_WRITE_ROLES)
	public List<CardObjectData> findCardObjectDatas(CardTemplate template) {
		return this.codFacade.findAll(template);
	}

	@RolesAllowed(UserPermission.S_WRITE_ROLES)
	@Override
	public CardTemplate save(CardTemplate card) {
		return cdFacade.merge(card);

	}

	@RolesAllowed(UserPermission.S_WRITE_ROLES)
	@Override
	public CardTextData save(CardTextData textData) {
		if (textData.getId() != null && textData.getId() != 0)
			return ctdFacade.merge(textData);
		else
			return ctdFacade.create(textData);
	}

	@RolesAllowed(UserPermission.S_WRITE_ROLES)
	@Override
	public CardObjectData save(CardObjectData objectData) {
		if (objectData.getId() != null && objectData.getId() != 0)
			return codFacade.merge(objectData);
		else
			return codFacade.create(objectData);
	}

	@Override
	public PrintedCard getCard(Integer id) {
		return printedcardfacade.find(id);
	}

	@Override
	public List<PrintedCard> getCards(EventUser user) {
		return printedcardfacade.getCards(user);
	}

	@Override
	public CardTemplate saveImage(CardTemplate cardTemplate, byte[] bytes) throws IOException {
		cardTemplate = cdFacade.find(cardTemplate.getId());

		BufferedImage base = ImageIO.read(new ByteArrayInputStream(bytes));
		ByteArrayOutputStream ostr = new ByteArrayOutputStream();
		ImageIO.write(base, "jpeg", ostr);

		cardTemplate.setImage(ostr.toByteArray());
		return cardTemplate;
	}

	@Override
	public List<CardTemplate> findAll() {
		return cdFacade.findAll();
	}

	// TODO: Laita takaisin kun rest-kutsut authaa. -- tuomari
	// @RolesAllowed(UserPermission.S_WRITE_ROLES)
	@Override
	public PrintedCard saveCard(PrintedCard card) {
		return printedcardfacade.merge(card);
	}

	@Override
	// TODO: Laita takaisin kun rest-kutsut authaa. -- tuomari
	// @RolesAllowed(UserPermission.S_WRITE_ROLES)
	public PrintedCard findCard(Integer id) {
		return printedcardfacade.find(id);
	}

	@Override
	public List<PrintedCard> getCardsByState(CardState... state) {
		return printedcardfacade.findByState(state);
	}

	@Override
	public PrintedCard setCardState(Integer cardId, CardState state) throws Exception {
		PrintedCard card = printedcardfacade.find(cardId);
		switch (state)
		{
		case PRINTED:
			card.setPrintCount(card.getPrintCount() + 1);
			card.setPrintTime(Calendar.getInstance());
			break;
		case PRINTING_IN_PROGRESS:
			if (card.getCardState().equals(CardState.PRINTING_IN_PROGRESS)
					|| card.getCardState().equals(CardState.PRINTED)) {
				String response = "Unable to change type to PRINTING_IN_PROGRESS value is already {}" + card.getCardState();
				logger.warn(response);
				throw new Exception(response);
			}
			break;
		default:
			break;
		}
		card.setCardState(state);

		return card;
	}

	
	
	
	
	
	@Override
	public EventUser giveCard(EventUser user, boolean markUserPlacesDelivered) {
		
		user = eventUserFacade.reload(user);

		PrintedCard card = checkPrintedCard(user);
		
		if (card.getCardState() != CardState.DELIVERED) {
			card.setCardState(CardState.DELIVERED);
		} else {
			logger.info("Not marking card to delivered: " + card.getCardState() + " : " + card.getId());
		}

		if (markUserPlacesDelivered) {
			for (GroupMembership membership : gmFacade.findMemberships(user)) {
				membership.setEnteredEvent(Calendar.getInstance());
				gmFacade.merge(membership);
			}
		}

		return user;
	}

	@Override
	public void removeCardCode(CardCode code) {
		code = cardCodeFacade.merge(code);
		
		if(code.getPrintedCard().getCardCodes().contains(code)) {
			code.getPrintedCard().getCardCodes().remove(code);
			cardCodeFacade.remove(code);
		}
	}	
	
	
}