ProductBean.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.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

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

import fi.codecrew.moya.facade.*;
import fi.codecrew.moya.model.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import fi.codecrew.moya.bortal.views.BillSummary;
import fi.codecrew.moya.enums.apps.ShopPermission;
import fi.codecrew.moya.enums.apps.SpecialPermission;
import fi.codecrew.moya.enums.apps.UserPermission;
import fi.codecrew.moya.utilities.moyamessage.MoyaEventType;

/**
 * Session Bean implementation class ProductBean
 */
@Stateless
@LocalBean
@DeclareRoles({
		ShopPermission.S_LIST_ALL_PRODUCTS,
		ShopPermission.S_LIST_USERPRODUCTS,
		ShopPermission.S_MANAGE_PRODUCTS,
		ShopPermission.S_SHOP_PRODUCTS,
		ShopPermission.S_SHOP_TO_OTHERS,

		UserPermission.S_VIEW_ACCOUNTEVENTS,
		SpecialPermission.S_USER,

})
public class ProductBean implements ProductBeanLocal {

	private static final String DEFAULT_CREDIT_PRODCT = "Automagic Credit product";

	@EJB
	private ProductFacade productFacade;

	@EJB
	private InventoryEventFacade ieFacade;

	@EJB
	private EventBeanLocal eventBean;

	@EJB
	private AccountEventFacade accounteventfacade;
	@EJB
	private DiscountFacade discountfacade;
	@EJB
	private UserFacade userFacade;

	@EJB
	private PermissionBeanLocal permbean;
	@EJB
	private EventUserFacade eventUserFacade;
	@EJB
	private UserBeanLocal userbean;

	@EJB
	private BillBeanLocal billbean;

	@EJB
	private EventBeanLocal eventbean;
	@EJB
	private BillLineFacade billLineFacade;

	@EJB
	private ProductPBean productPBean;

	@EJB
	private LoggingBeanLocal loggingbean;

	@EJB
	private PlaceBean placebean;

	@EJB
	private DiscountBean discountBean;

	@EJB
	private CardTemplateBean cardTemplateBean;

	@EJB
	private PlaceFacade placeFacade;
	@EJB
	private EventMapFacade mapfacade;

	@EJB
	private GroupMembershipFacade gmfacade;

	@EJB
	private PlaceSlotFacade slotfacade;

	@EJB
	private ProductOptionGroupFacade productOptionGroupFacade;

	@EJB
	private ProductOptionFacade productOptionFacade;

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

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

	@Override
	@RolesAllowed(ShopPermission.S_LIST_USERPRODUCTS)
	public List<Product> listUserShoppableProducts() {
		List<Product> ret = productFacade.findProductsByFlag(ProductFlag.USER_SHOPPABLE);
		Iterator<Product> i = ret.iterator();
		while (i.hasNext()) {
			Product p = i.next();
			if (p.getShopRequiredRole() != null && !(userbean.isUserInRole(permbean.getCurrentUser(), p.getShopRequiredRole().getId()))) {
				i.remove();
			}
		}
		return ret;
	}

	@Override
	@RolesAllowed(ShopPermission.S_MANAGE_PRODUCTS)
	public void create(Product prod) {
		LanEvent event = eventBean.getCurrentEvent();
		prod.setEvent(event);
		productFacade.create(prod);

	}

	@Override
	@RolesAllowed(ShopPermission.S_LIST_ALL_PRODUCTS)
	public List<Product> getProducts() {
		return productFacade.findAll();
	}

	@Override
	@RolesAllowed(ShopPermission.S_MANAGE_PRODUCTS)
	public Product mergeChanges(Product product) {
		return productFacade.merge(product);
	}

	@Override
	public Product findCreditProduct() {
		List<Product> ret = productFacade.findProductsByPrice(BigDecimal.ONE.negate());
		Product retProd = null;
		if (ret == null || ret.isEmpty()) {
			retProd = new Product(eventBean.getCurrentEvent());
			retProd.setName(DEFAULT_CREDIT_PRODCT);
			retProd.setPrice(BigDecimal.ONE.negate());
			productFacade.create(retProd);
		} else {
			retProd = ret.get(0);
		}
		return retProd;
	}

	/**
	 * TODO: This is not enforced!!!
	 * 
	 * @param product
	 *            Product to find limits for
	 * @return How many products can still be bought. NULL if no limit.
	 */
	@Override
	public HashMap<Integer, BigDecimal> getProductLimit(Map<Integer, BigDecimal> prodCounts, EventUser user)
	{

		Set<Role> userroles = new HashSet<>(userbean.findUsersRoles(user));
		HashMap<Integer, BigDecimal> ret = new HashMap<>();
		for (Entry<Integer, BigDecimal> pc : prodCounts.entrySet())
		{

			Product prod = productFacade.find(pc.getKey());

			// if this is a place product and not a prepaid credit product and places are not created on the fly
			// get the available buyable places from database and check the number of unused places
			if (!prod.getProductFlags().contains(ProductFlag.PREPAID_CREDIT)
					&& !prod.getProductFlags().contains(ProductFlag.CREATE_NEW_PLACE_WHEN_BOUGHT)
					&& prod.getPlaces() != null
					&& !prod.getPlaces().isEmpty()) {

				Long selectableCount = placeFacade.countSelectable(prod);
				int unusedSlotcount = getUnusedSlotcount(prod);

				int freeCount = selectableCount.intValue() - unusedSlotcount;

				// logger.info("Prodlimit selectable {}, unused {}, free {}, prod {}", selectableCount, unusedSlots, freeCount, prod);
				ret.put(prod.getId(), BigDecimal.valueOf(freeCount));

			} else {
				BigDecimal lim = getPrivateProductLimit(prod, user, prodCounts, userroles);
				ret.put(prod.getId(), lim);
				// logger.info("Added product limit {} to {}", lim, prod);

			}
		}
		return ret;

	}

	/**
	 * How many unused slots there are for the product.
	 * 
	 * @param prod
	 * @return
	 */
	private int getUnusedSlotcount(Product prod)
	{
		// How many percent of places can be reserved from shop by one unpaid bill
		long unpaidSlotpercent = eventbean.getPropertyLong(LanEventPropertyKey.RESERVE_UNPAID_SLOT_PERCENT);

		int unusedSlotcount = 0;

		// If unpaid slot percent is 0 or 100, calculate directly from db.
		if (unpaidSlotpercent < 1 || unpaidSlotpercent > 99) {
			unusedSlotcount = slotfacade.findUnusedSlotsCount(prod, false).intValue();
		} else {
			// Calculate only 'unpaidSlotpercent' of total places to be reserver from one unpaid bill.
			// This is to try to reduce the possibility of abuse by creating a 1000 place bill
			// and obviously never intending to pay them.

			final List<PlaceSlot> unusedSlots = slotfacade.findUnusedSlots(prod, false);
			final Map<Integer, Integer> unpaidBills = new HashMap<>();
			int prodPlacecount = prod.getPlaces().size();

			for (PlaceSlot s : unusedSlots) {
				// If bill s paid (or there is no bill), calculate all slots
				if (s.getBill() == null || s.getBill().isPaid()) {
					++unusedSlotcount;
				} else {

					// If bill is paid, calculate only 'unpaidSlotpercent'% of slots 
					Integer billcnt = unpaidBills.get(s.getBill().getId());
					if (billcnt == null) {
						billcnt = 0;
					}

					if (billcnt * 100 / prodPlacecount < unpaidSlotpercent) {
						++unusedSlotcount;
					}
					unpaidBills.put(s.getBill().getId(), ++billcnt);
				}

			}
		}
		return unusedSlotcount;
	}

	@Override
	public BigDecimal getProductLimit(Product product, EventUser user, Map<Integer, BigDecimal> prodCounts)
	{
		product = productFacade.reload(product);
		HashSet<Role> userroles = new HashSet<Role>(userbean.findUsersRoles(user));
		return getPrivateProductLimit(product, user, prodCounts, userroles);
	}

	/**
	 * Returns available products to be bought for the user.
	 * 
	 * @param product
	 * @param user
	 * @param prodCounts
	 * @param userroles
	 * @return Number of buyable products
	 */
	private BigDecimal getPrivateProductLimit(Product product, EventUser user, Map<Integer, BigDecimal> prodCounts, Set<Role> userroles)
	{
		BigDecimal ret = null;
		if (product != null && product.getProductLimits() != null)
		{

			for (ProductLimitation limit : product.getProductLimits())
			{
				BigDecimal currentCount = BigDecimal.ZERO;
				for (Product p : limit.getProducts())
				{
					currentCount = currentCount.add(prodCounts.get(p.getId()));
				}

				// logger.info("Got limit {} for product {}", limit, product);
				if (limit.getMatchingRoles() != null && !limit.getMatchingRoles().isEmpty())
				{
					boolean roleMatched = false;

					for (Role mr : limit.getMatchingRoles()) {
						if (userroles.contains(mr)) {
							roleMatched = true;
							break;
						}
					}
					if (!roleMatched) {
						continue;
					}
				}

				BigDecimal count = currentCount;

				switch (limit.getType())
				{
				case GLOBAL_BILLED: {
					BigDecimal globBillTot = BigDecimal.ZERO;
					for (Product p : limit.getProducts()) {
						BillSummary globBilledSummary = billLineFacade.getLineSummary(p, eventbean.getCurrentEvent());
						globBillTot = globBillTot.add(globBilledSummary.getActive());
					}
					count = count.add(globBillTot);
					ret = limit.getUpperLimit().subtract(count);
					break;
				}
				case GLOBAL_BILL_PAID:
					BigDecimal globBillPaid = BigDecimal.ZERO;
					for (Product p : limit.getProducts()) {
						BillSummary billPaidSummary = billLineFacade.getLineSummary(p, eventbean.getCurrentEvent());
						globBillPaid = globBillPaid.add(billPaidSummary.getPaid());
					}
					count = count.add(globBillPaid);
					ret = limit.getUpperLimit().subtract(count);
					break;
				case GLOBAL_ACCOUNTEVENTS:
					BigDecimal globalProductCount = accounteventfacade.getProductCount(limit.getProducts());
					if (globalProductCount != null) {
						count = count.add(globalProductCount);
					}
					ret = limit.getUpperLimit().subtract(count);
					break;
				case USER_ACCOUNTEVENTS:
					BigDecimal userProductCount = accounteventfacade.getProductCount(limit.getProducts(), user);
					if (userProductCount != null) {
						count = count.add(userProductCount);
					}
					ret = limit.getUpperLimit().subtract(count);
					break;
				case USER_BILLED:
					BigDecimal userBillTot = BigDecimal.ZERO;
					for (Product p : limit.getProducts()) {
						BillSummary userBilledSummary = billLineFacade.getLineSummary(p, eventbean.getCurrentEvent(), user);
						userBillTot = userBillTot.add(userBilledSummary.getActive());
					}
					count = count.add(userBillTot);
					ret = limit.getUpperLimit().subtract(count);
					break;
				case USER_BILL_PAID:
					BigDecimal userBillPaid = BigDecimal.ZERO;
					for (Product p : limit.getProducts()) {
						BillSummary userPaidSummary = billLineFacade.getLineSummary(p, eventbean.getCurrentEvent(), user);
						userBillPaid = userBillPaid.add(userPaidSummary.getPaid());
					}
					count = count.add(userBillPaid);
					ret = limit.getUpperLimit().subtract(count);
					break;

				default:
					break;

				}
				if (ret != null)
				{
					// logger.warn("breaking for value {}, product {}", ret,
					// product);
					break;
				}

			}

		}
		return ret;
	}

	@Override
	public BigDecimal calculateTotal(Product product, BigDecimal quantity, Date date, EventUser user) {
		if (product == null || quantity == null) {
			throw new RuntimeException("Some parameter is null!");
		}
		BigDecimal total = product.getPrice();
		for (Discount d : discountBean.getActiveDiscountsByProduct(product, quantity, date, user)) {
			total = total.multiply(d.getPercentage());
		}
		return total.setScale(2, RoundingMode.HALF_UP).multiply(quantity);

	}

	// // TODO: alennukset lasketaan täällä. HUOMHUOM!!
	// @Override
	// public List<Discount> getActiveDiscounts(Product product, BigDecimal
	// quantity) {
	// ArrayList<Discount> ret = new ArrayList<Discount>();
	// for (Discount d : product.getDiscounts()) {
	// if (d.isActive() && quantity.compareTo(d.getAmountMax()) <= 0 &&
	// quantity.compareTo(d.getAmountMin()) >= 0) {
	// ret.add(d);
	// }
	// }
	// return ret;
	// }

	@Override
	public Product findById(int id) {
		Product ret = productFacade.find(id);
		if (ret != null && !ret.getEvent().equals(eventBean.getCurrentEvent())) {
			ret = null;
		}
		return ret;
	}

	@Override
	@RolesAllowed(ShopPermission.S_MANAGE_PRODUCTS)
	public List<Product> findForStaffshop() {
		return productFacade.findProductsWithNoFlag(ProductFlag.HIDE_FROM_INFOSHOP);
	}

	@RolesAllowed(ShopPermission.S_MANAGE_PRODUCTS)
	public List<Product> findProductsByFlag(ProductFlag... productFlags) {
		return productFacade.findProductsByFlag(productFlags);
	}

	@RolesAllowed(ShopPermission.S_MANAGE_PRODUCTS)
	@Override
	public Discount findDiscount(Integer discountid) {
		return discountfacade.find(discountid);
	}

	@Override
	@RolesAllowed(ShopPermission.S_MANAGE_PRODUCTS)
	public Discount save(Discount discount) {
		return discountfacade.merge(discount);
	}

	@Override
	public AccountEvent createAccountEvent(Product product, BigDecimal quantity, EventUser user) {
		user = eventUserFacade.reload(user);
		AccountEvent ret = productPBean.createAccountEvent(product, quantity, user, new Date());
		cardTemplateBean.checkPrintedCard(user);
		return ret;
	}

	@Override
	public AccountEvent createAccountEvent(Product product, BigDecimal overriddenUnitPrice, BigDecimal quantity, EventUser user) {
		user = eventUserFacade.reload(user);

		AccountEvent ret = productPBean.createAccountEvent(product, overriddenUnitPrice, quantity, user, new Date(), null);
		cardTemplateBean.checkPrintedCard(user);
		return ret;
	}

	@Override
	// @RolesAllowed(ShopPermission.S_LIST_ALL_PRODUCTS)
	public Product findByBarcode(String barcode) {
		return productFacade.findProductByBarcode(barcode);
	}

	@Override
	@RolesAllowed(ShopPermission.S_MANAGE_PRODUCTS)
	public void saveInventoryEvent(InventoryEvent ie) {
		logger.debug("Creating new Inventoryevent {}", ie);
		ieFacade.create(ie);
	}

	@Override
	@RolesAllowed(ShopPermission.S_MANAGE_PRODUCTS)
	public List<Product> findProductsForEvent() {
		return productFacade.findAll();
	}

	@Override
	public List<Product> findPlaceProducts() {

		ArrayList<Product> returnProducts = new ArrayList<Product>();

		for (Product product : findProductsForEvent()) {
			if (product.getPlaces() != null && product.getPlaces().size() > 0) {
				returnProducts.add(product);
			}
		}

		return returnProducts;
	}

	@Override
	@RolesAllowed(UserPermission.S_MODIFY_ACCOUNTEVENTS)
	public AccountEvent merge(AccountEvent account) {
		return accounteventfacade.merge(account);
	}

	@Override
	@RolesAllowed(UserPermission.S_MODIFY_ACCOUNTEVENTS)
	public EventUser delete(AccountEvent account) {

		AccountEvent acco = accounteventfacade.reload(account);
		EventUser ret = acco.getUser();
		ret.getAccountEvents().remove(acco);

		loggingbean.sendMessage(MoyaEventType.ACCOUNTEVENT_INFO, permbean.getCurrentUser(), "Deleting AccountEvent '", acco.getProduct().getName(), "' count: '", acco.getQuantity().toString(), "' unitprice: '", acco.getUnitPrice().toString(), "' accouser: '", acco.getUser().getUser().getLogin(), "'");
		acco.getProduct().getAccountEvents().remove(acco);
		acco.getUser().getAccountEvents().remove(acco);
		if (acco.getBill() != null) {
			acco.getBill().setAccountEvent(null);
		}

		accounteventfacade.remove(acco);
		return ret;
	}

	@Override
	public AccountEvent find(Integer id) {
		return accounteventfacade.find(id);
	}

	@Override
	public List<Role> getRolesFromAccountEvents(EventUser u) {
		return accounteventfacade.findProvidedRoles(eventBean.getCurrentEvent(), u);
	}


	@Override
	public List<AccountEvent> getDeliverableAccountEvents(EventUser user ) {

		List<AccountEvent> retlist = new ArrayList<>();
		for(AccountEvent ae : accounteventfacade.getAccountEvents(user)) {
			if(!ae.getProduct().isDeliverableProduct()) {
				continue;
			}

			// places are there already, so don't add them second time
			if(ae.getProduct().getPlaces() != null && !ae.getProduct().getPlaces().isEmpty()) {
				continue;
			}

			// TODO: pizzas also removed

			retlist.add(ae);
		}

		return retlist;
	}

	@Override
	public AccountEvent markDelivered(AccountEvent e, Calendar c) {
		e = accounteventfacade.reload(e);
		if (e.getDelivered() != null)
		{
			throw new EJBException("AccountEvent " + e + " already marked delivered!");
		}
		e.setDelivered(c);

		return e;
	}


	@Override
	public AccountEvent markUndelivered(AccountEvent e) {
		e = accounteventfacade.reload(e);

		e.setDelivered(null);

		return e;
	}

	@Override
	public List<Product> getPlaceProducts() {

		List<Product> allProducts = productFacade.findAll();

		List<Product> ticketProducts = new ArrayList<>();

		for (Product product : allProducts) {
			if (product.getProductFlags().contains(ProductFlag.RESERVE_PLACE_WHEN_BOUGHT)) {
				ticketProducts.add(product);
			} else if (product.getPlaces() != null && product.getPlaces().size() > 0) {
				ticketProducts.add(product);
			}

		}

		return ticketProducts;

		// TODO: fix this facade and use it
		//return placeFacade.getPlaceProducts();

	}

	@Override
	public ProductOption findOptionById(Integer id) {
		return productOptionFacade.find(id);
	}

	@Override
	public void deleteProductOptionGroup(ProductOptionGroup group) {

		ProductOptionGroup managedGroup = productOptionGroupFacade.reload(group);

		managedGroup.getProduct().getProductOptionGroups().remove(managedGroup);

		managedGroup.setDefaultOption(null);

		productOptionGroupFacade.remove(managedGroup);

	}

	@Override
	public Product reload(Product product) {
		return productFacade.reload(product);
	}

	@Override
	public Product delete(ProductDependency dep) {
		Product prod = productFacade.reload(dep.getDependant());
		prod.getProductDependencies().remove(dep);
		return prod;
	}


}