TournamentBean.java

package fi.codecrew.moya.beans;

import java.util.List;

import javax.ejb.EJB;
import javax.ejb.LocalBean;
import javax.ejb.Stateless;

import fi.codecrew.moya.enums.TournamentStatus;
import fi.codecrew.moya.enums.TournamentTeamMemberRole;
import fi.codecrew.moya.facade.EventUserFacade;
import fi.codecrew.moya.facade.TournamentFacade;
import fi.codecrew.moya.facade.TournamentGameFacade;
import fi.codecrew.moya.facade.TournamentParticipantFacade;
import fi.codecrew.moya.facade.TournamentRuleFacade;
import fi.codecrew.moya.facade.UserFacade;
import fi.codecrew.moya.model.EventUser;
import fi.codecrew.moya.model.Tournament;
import fi.codecrew.moya.model.TournamentGame;
import fi.codecrew.moya.model.TournamentParticipant;
import fi.codecrew.moya.model.TournamentRule;
import fi.codecrew.moya.model.TournamentTeamMember;
import fi.codecrew.moya.model.User;

/**
 * Session Bean implementation class TournamentBean
 */
@Stateless
@LocalBean
public class TournamentBean implements TournamentBeanLocal {

	@EJB private TournamentRuleFacade tournamentRuleFacade;
	@EJB private TournamentGameFacade tournamentGameFacade;
	@EJB private TournamentFacade tournamentFacade;
	@EJB private TournamentParticipantFacade tournamentParticipantFacade;
	@EJB private EventUserFacade eventUserFacade;
	@EJB private EventBean eventBean;
	
    /**
     * Default constructor. 
     */
    public TournamentBean() {
        // TODO Auto-generated constructor stub
    }
    
    @Override
    public List<TournamentRule> getRulesByGame(TournamentGame tg) {
    	return tournamentRuleFacade.getRulesByGame(tg);
    }
    
    @Override
    public List<TournamentGame> getGames() {
    	return tournamentGameFacade.getGames();
    }
    
    @Override
    public TournamentGame createGame(TournamentGame tg) {
    	return tournamentGameFacade.create(tg);
    }
    
    @Override
    public TournamentRule createRule(TournamentRule tr) {
    	return tournamentRuleFacade.create(tr);
    }

	@Override
	public TournamentGame findGame(Integer id) {
		return tournamentGameFacade.find(id);
	}

	@Override
	public TournamentRule findRule(Integer id) {
		return tournamentRuleFacade.find(id);
	}

	@Override
	public void createTournament(Tournament tournament) {
		tournamentFacade.create(tournament);
	}
	
	@Override
	public List<Tournament> getTournamentsInStatus(TournamentStatus status) {
		return tournamentFacade.getTournamentsInStatus(status);
	}
	
	@Override
	public List<Tournament> getActiveTournaments() {
		return tournamentFacade.getTournamentsNotInStatus(TournamentStatus.COMPLETED);
	}

	@Override
	public Tournament getTournamentById(Integer tournamentId) {
		return tournamentFacade.find(tournamentId);
	}

	@Override
	public void editTournament(Tournament tournament) {
		tournamentFacade.merge(tournament);
	}

	@Override
	public void deleteTournament(Tournament tournament) {
		tournament = tournamentFacade.merge(tournament);
		tournamentFacade.remove(tournament);
	}

	@Override
	public void createParticipation(TournamentParticipant tournamentParticipant) throws Exception {
		Tournament t = tournamentFacade.find(tournamentParticipant.getTournament().getId());
		
		// Assert participant size is smaller than max
		if(t.getParticipants().size() < t.getMaxParticipants()) {
			TournamentTeamMember capt = null;
			for(TournamentTeamMember ttm : tournamentParticipant.getTeamMembers()) if(ttm.getRole() == TournamentTeamMemberRole.CAPTAIN) capt=ttm;
			
			// Assert team has a captain
			if(capt != null) {
				
				// Assert team has the correct number of players for a match
				if(tournamentParticipant.getTeamMembers().size() >= tournamentParticipant.getTournament().getPlayersPerTeam()) {
					tournamentParticipant = tournamentParticipantFacade.create(tournamentParticipant);
					t.getParticipants().add(tournamentParticipant);
				} else {
					throw new Exception("tournament.not_enough_players");
				}
			} else {
				throw new Exception("tournament.no_captain");
			}
		} else {
			throw new Exception("tournament.participation_full");
		}
	}

	@Override
	public boolean hasParticipations(EventUser currentUser, Tournament tournament) {
		for(TournamentParticipant tp : tournament.getParticipants()) {
			for(TournamentTeamMember tm : tp.getTeamMembers()) {
				EventUser eu = tm.getEventUser();
				System.out.println(eu.getNick());
				if(eu.equals(currentUser)) {
					return true;
				}
			}
		}
		
		return false;
	}
	
	@Override
	public EventUser findAvailablePlayerForTournamentByLogin(Tournament t, String login) throws Exception {
		EventUser u = eventUserFacade.findByLogin(login);
		if(u != null) {
			if(!hasParticipations(u,t))
				return u;
			else
				throw new Exception("tournaments.participation_already_exists");
		} else {
			throw new Exception("tournaments.participated_user_not_found");
		}
	}
}