EventUserFacade.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.facade;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.ejb.EJB;
import javax.ejb.LocalBean;
import javax.ejb.Stateless;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.From;
import javax.persistence.criteria.Root;
import javax.persistence.metamodel.SingularAttribute;

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

import fi.codecrew.moya.beans.EventBeanLocal;
import fi.codecrew.moya.enums.DatabaseHasCompare;
import fi.codecrew.moya.enums.DatabaseValueCompare;
import fi.codecrew.moya.facade.callbacks.EventLimiter;
import fi.codecrew.moya.facade.callbacks.EventUserAccountSaldoPredicate;
import fi.codecrew.moya.facade.callbacks.EventUserCardStateFilter;
import fi.codecrew.moya.facade.callbacks.EventUserPlacegroupPredicate;
import fi.codecrew.moya.facade.callbacks.EventUserRolefilter;
import fi.codecrew.moya.facade.callbacks.EventUserSearchPredicate;
import fi.codecrew.moya.facade.callbacks.EventuserToUserWrapper;
import fi.codecrew.moya.facade.callbacks.OrderCallback;
import fi.codecrew.moya.model.EventUser;
import fi.codecrew.moya.model.EventUser_;
import fi.codecrew.moya.model.LanEvent;
import fi.codecrew.moya.model.User;
import fi.codecrew.moya.model.User_;
import fi.codecrew.moya.util.UserSearchQuery;
import fi.codecrew.moya.utilities.SearchQuery.QuerySortOrder;
import fi.codecrew.moya.utilities.SearchResult;
import fi.codecrew.moya.utilities.jpa.FacadeCallback;

/**
 * Session Bean implementation class EventUserFacade
 */
@Stateless
@LocalBean
public class EventUserFacade extends IntegerPkGenericFacade<EventUser> {

	@EJB
	private EventBeanLocal eventBean;

	public EventUserFacade() {
		super(EventUser.class);
	}

	private final Map<Integer, Map<String, Integer>> logincache = new HashMap<Integer, Map<String, Integer>>();
	private static final Logger logger = LoggerFactory.getLogger(EventUserFacade.class);

	public EventUser findByLogin(final String login) {
		LanEvent event = eventBean.getCurrentEvent();
		EventUser ret;
		if ((ret = checkCache(login, event)) == null)
		{
			CriteriaBuilder cb = getEm().getCriteriaBuilder();
			CriteriaQuery<EventUser> cq = cb.createQuery(EventUser.class);
			Root<EventUser> root = cq.from(EventUser.class);
			cq.where(
					cb.equal(root.get(EventUser_.user).get(User_.login), login),
					cb.equal(root.get(EventUser_.event),
							event));

			ret = getSingleNullableResult(getEm().createQuery(cq));
			if (ret != null)
				logincache.get(event.getId()).put(ret.getLogin(), ret.getId());
		}
		return ret;
	}

	private EventUser checkCache(final String login, final LanEvent event) {
		if (!logincache.containsKey(event.getId()))
			logincache.put(event.getId(), new HashMap<String, Integer>());

		Integer euId = null;
		EventUser ret = null;
		if ((euId = logincache.get(event.getId()).get(login)) != null) {
			ret = this.find(euId);
		}
		return ret;

	}

	public EventUser find(User user) {
		return getOtherOrganisationsEventuser(user, eventBean.getCurrentEvent());
	}

	public EventUser getOtherOrganisationsEventuser(User user, LanEvent event)
	{
		EventUser ret = null;
		if ((ret = checkCache(user.getLogin(), event)) == null) {
			CriteriaBuilder cb = getEm().getCriteriaBuilder();
			CriteriaQuery<EventUser> cq = cb.createQuery(EventUser.class);
			Root<EventUser> root = cq.from(EventUser.class);
			cq.where(
					cb.equal(root.get(EventUser_.user), user),
					cb.equal(root.get(EventUser_.event), event));

			ret = getSingleNullableResult(getEm().createQuery(cq));
		}
		return ret;
	}

	public List<EventUser> findAll() {
		CriteriaBuilder cb = getEm().getCriteriaBuilder();
		CriteriaQuery<EventUser> cq = cb.createQuery(EventUser.class);
		Root<EventUser> root = cq.from(EventUser.class);
		cq.where(cb.equal(root.get(EventUser_.event), eventBean.getCurrentEvent()));
		return getEm().createQuery(cq).getResultList();
	}

	public SearchResult<EventUser> searchEventUsers(UserSearchQuery query) {
		ArrayList<FacadeCallback<EventUser>> callbacks = new ArrayList<FacadeCallback<EventUser>>();
		CriteriaBuilder cb = getEm().getCriteriaBuilder();

		CriteriaQuery<EventUser> listCQuery = cb.createQuery(EventUser.class);
		CriteriaQuery<Long> countCQuery = cb.createQuery(Long.class);

		if (query.getSort() != null)
		{
			boolean asc = false;
			if (query.getSortDirection() != null) {
				asc = QuerySortOrder.ASCENDING.equals(query.getSortDirection());
			}
			SingularAttribute<? super User, ?> sortfield = UserFacade.getUserField(query.getSort());
			logger.info("Sortig with {}, asc {} ", sortfield, asc);
			callbacks.add(new EventuserToUserWrapper(new OrderCallback<User>(asc, sortfield)));
		} else {
			callbacks.add(new OrderCallback<EventUser>(false, EventUser_.id));
		}

		callbacks.add(new EventLimiter(eventBean.getCurrentEvent()));

		if (query.getSearch() != null && !query.getSearch().isEmpty()) {
			callbacks.add(new EventUserSearchPredicate(query.getSearch(), UserFacade.getAttrlist()));
		}
		if (query.isPlaceAssoc()) {
			callbacks.add(new EventUserPlacegroupPredicate());
		}
		if (query.getFilterRoles() != null && !query.getFilterRoles().isEmpty()) {
			callbacks.add(new EventUserRolefilter(query.getFilterRoles()));
		}

		if (query.getHasCardState() != null && !query.getHasCardState().isEmpty()) {
			callbacks.add(new EventUserCardStateFilter(query.getHasCardState()));
		}

		if (query.getAccountSaldo() != null &&
				query.getAccountSaldoCompare() != null &&
				!DatabaseValueCompare.NONE.equals(query.getAccountSaldoCompare()))
		{
			callbacks.add(new EventUserAccountSaldoPredicate(query.getAccountSaldo(), query.getAccountSaldoCompare()));
		}
		if (query.getRequireImage() != null && !query.getRequireImage().equals(DatabaseHasCompare.NONE))
		{

		}

		From<?, EventUser> listRoot = searchCallbacks(listCQuery, callbacks, EventUser.class);
		From<?, EventUser> countRoot = searchCallbacks(countCQuery, callbacks, EventUser.class);

		listCQuery.select(listRoot);
		countCQuery.select(cb.count(countRoot));

		TypedQuery<Long> countQ = getEm().createQuery(countCQuery);
		TypedQuery<EventUser> listQ = getEm().createQuery(listCQuery);

		if (query.getPagesize() > 0) {
			listQ.setFirstResult(query.getPage() * query.getPagesize());
			listQ.setMaxResults(query.getPagesize());
		}
		return new SearchResult<EventUser>(listQ.getResultList(), countQ.getSingleResult());

	}

	// private Predicate addAcPredicate(CriteriaBuilder cb, UserSearchQuery
	// query, Root<AccountEvent> root) {
	// Expression<BigDecimal> sum =
	// cb.sum(cb.prod(root.get(AccountEvent_.unitPrice),
	// root.get(AccountEvent_.quantity)));
	// Predicate ret = null;
	// switch (query.getAccountSaldoCompare())
	// {
	// case EQ:
	// ret = cb.equal(sum, query.getAccountSaldo());
	// break;
	// case GE:
	// ret = cb.ge(sum, query.getAccountSaldo());
	// break;
	// case GT:
	// ret = cb.gt(sum, query.getAccountSaldo());
	// break;
	// case LE:
	// ret = cb.le(sum, query.getAccountSaldo());
	// break;
	// case LT:
	// ret = cb.lt(sum, query.getAccountSaldo());
	// break;
	// default:
	// throw new EJBException("Unknown account saldo comparer: " +
	// query.getAccountSaldoCompare());
	//
	// }
	// return ret;
	// }
	// public SearchResult<EventUser> searchUser(int page, int pagesize, String
	// sort, String search) {
	//
	// List<FacadeCallback<EventUser>> callbacks = new
	// ArrayList<FacadeCallback<EventUser>>();
	// if (sort == null || sort.isEmpty()) {
	// callbacks.add(new OrderCallback<EventUser>(false, EventUser_.id));
	// } else {
	// callbacks.add(new OrderCallback<EventUser>(false, sort));
	// }
	//
	// if (search == null || search.isEmpty()) {
	// callbacks.add(new EventUserEventlimiter(eventBean.getCurrentEvent()));
	// }
	// callbacks.add(new EventUserSearchCreator(search,
	// UserFacade.getAttrlist()));
	// return super.searcher(page, pagesize, callbacks);
	//
	// // return this.search(page, pagesize, query, NAMEFIELDS, sort);
	// }
	//
	// public class EventUserEventlimiter implements FacadeCallback<EventUser> {
	//
	// private LanEvent ev;
	//
	// public EventUserEventlimiter(LanEvent currentEvent) {
	// ev = currentEvent;
	// }
	//
	// @Override
	// public void exec(CriteriaBuilder cb, CriteriaQuery<?> cq, Path<EventUser>
	// root, List<Predicate> predicates) {
	// predicates.add(cb.equal(root.get(EventUser), ev));
	// }
	// }

}