OOP2 | Gitar

Refactor of Reservation related classes, mainly GUI

Author: Maarten 'Vngngdn' Vangeneugden
Date: Dec. 15, 2016, 10:33 p.m.
Hash: 70c4f4fde97168ddd55ad491ce96bd3731314269
Parent: 212ab469ae6defcc415d9558e2bf77a3bb06039f
Modified files: Challenge 6/MainWindow.java; Challenge 6/Reservation.java; Challenge 6/ReservationController.java; Challenge 6/ReservationView.java; Challenge 6/Window.java; Challenge 6/ontwerpkeuzes2.md

Challenge 6/MainWindow.java ¶

1 addition and 2 deletions.

View changes Hide changes

 * Main window for the hostel program.
 * This class creates some sort of "main menu screen". It displays a concise set
 * of buttons, that allow the user to reach all parts of the program's GUI.
 * To be called as soon as the program is started (Essentially from the Main
 * class).
 * @author Maarten Vangeneugden - 1438256
 */
public class MainWindow {

	private ReservationController reservationController;
	private RoomController roomController;
	
	public MainWindow(ReservationController reservationController, RoomController roomController) {
		this.reservationController = reservationController;
		this.roomController = roomController;

		Window window = new Window("Main menu");
		window.createButton("New reservation", "", "addReservation", this);
		window.createButton("Search screen", "", "openSearchView", this);
	}

	public void openSearchView() {
		SearchView sv = new SearchView(this.reservationController, this.roomController);
	}
	
	public void addReservation() {
		Reservation reservation = new Reservation(this.reservationController, this.roomController);
		ReservationView rv = new ReservationView(reservation, this.reservationController, this.roomController);
		ReservationView rv = new ReservationView(reservation, this.reservationController, this.roomController);

	}

}


Challenge 6/Reservation.java ¶

20 additions and 2 deletions.

View changes Hide changes

import java.util.HashSet;
import java.util.Date;

/**
 * Represents a reservation in a hostel.
 * Reservation is a simple class that allows one to store reservation
 * information, request it when necessary, and so on.
 * Certain methods are provided for interaction, which use contracts to assert
 * proper functioning.
 *
 * Note: There is a form of redundancy in this class.
 * Reservation holds a Set of Beds, and an integer, indicating the amount of
 * people that are in this Reservation.
 * Normally, the amount of people in the Reservation is determined by the amount
 * of reserved Beds, because the amount of Beds implied the amount of people to
 * facilitate.
 * Because of the design of this program, I've weighed the advantages and
 * disadvantages of holding this implication, of using a seperate member
 * explicitely indicating the amount of people.
 *
 * I've chosen the latter option. It scales better in terms of weird
 * afterthoughts ("I also want to make people sleep on the floor"), but being
 * explicit is also a tad easier to manage. It also allows the other classes to
 * be far more decoupled from Reservation (otherwise, they'd have to check for
 * errors every time themselves, hindering cohesiveness).
 *
 * To overcome the possible difference, I've made it so that, every time, the
 * relation between the values is changed (the people in the Reservation
 * changes, for example), the class automatically checks if the values are
 * corresponding. If they're not, a warning is printed to system.out.err,
 * informing about the fact that there's a discrepancy.
 *
 * I think that's the best way to overcome this problem.
 * @author Maarten Vangeneugden - 1438256
 */
public class Reservation {

	// Members
	private String groupName;
	private Date begin;
	private Date end;
	private Set<Bed> reservedBeds;
	private int people; // The amount of people in this Reservation
	private int reservationID;
	private String roomType; // Room type requested by group
	private Set<String> roomFacilities; // Requested room facilities
	private Set<Date> breakfastDays; // Set of days the group wants breakfast
	// Controllers
	private RoomController roomController;
	private ReservationController reservationController;

	/**
	 * Create a new Reservation.
	 * Be aware about the limitations of a Reservation: it's not the
	 * Reservation's duty to check whether the provided Beds are properly
	 * reserved; take care of this accordingly.
	 * 
	 * Some information is implicit. For example: The size of the set of
	 * reserved Beds implies the amount of people in the group; no breakfast
	 * days implies no breakfast, ...
	 * @param groupName The name of the group.
	 * @param people The amount of people that are reserving.
	 * @param begin The date that the Reservation begins.
	 * @param end The date that the Reservation ends.
	 * @param reservedBeds The set of Beds reserved and assigned to this
	 * Reservation.
	 * @param roomType The requested room type.
	 * @param roomFacilities The set of all requested room facilities.
	 * @param breakfastDays A set of all days that the group wants breakfast.
	 * @param reservationID An ID for this reservation, to differentiate from
	 * other Reservations.
	 * @pre No parameter must be a null pointer.
	 * @pre people must be a natural number, different from 0.
	 * @pre begin must come before end.
	 * @pre All dates in breakfastDays must fall between begin and end.
	 * @pre No string parameter may be empty.
	 * @post The amount of people in the Reservation is determined by the amount
	 * of reserved Beds.
	 * @throws NullPointerException if any parameter is a null pointer.
	 * @throws IllegalArgumentException if any of the other preconditions is not
	 * met.
	 */
	public Reservation(String groupName, int people, Date begin, Date end, Set<Bed> reservedBeds, String roomType, Set<String> roomFacilities) {
		// Contract validation:
		// Contract validation:
		if(people < 1) {
			throw IllegalArgumentException("The amount of people should be at least 1.");
		}
		if(!begin.before(end)) {
			throw IllegalArgumentException("The begin date occurs after the end date.");
		}
		if(groupName.isEmpty() || roomType.isEmpty()) {
			throw IllegalArgumentException("groupName and/or roomType were empty strings.");
		}
		for(String roomFacility: roomFacilities) {
			if(roomFacility.isEmpty()) {
				throw IllegalArgumentException("One of the room facilities was an empty string.");
			}
		}
		for(Date breakfastDay : breakfastDays) {
			if(breakfastDay.before(begin) || breakfastDay.after(end)) {
				throw IllegalArgumentException("One of the breakfast days occurs before/after the reservation period.");
			}
		}
		// Contract validated, execute constructor
		this.groupName = groupName;
		this.people = people;
		this.beginDate = begin;
		this.endDate = end;
		this.reservedBeds = reservedBeds;
		this.reservationID = reservationID;
		this.roomType = roomType;
		this.roomFacilities = roomFacilities;
		this.breakfastDays = breakfastDays
	}
	}
	
	/**
	 * Construct template Reservation.
	 * Use this constructor if you need to create an empty/new Reservation. 
	 * It omits the standard restrictions (for example, the group name will be
	 * empty) to accomodate for the expected usage of this Reservation.
	 */
	public Reservation() {
		this.groupName = "";
		this.people = 1;
		this.beginDate = new Date();
		this.endDate = new Date();
		this.reservedBeds = new HashSet<>();
		this.reservationID = 0;
		this.roomType = "";
		this.roomFacilities = new HashSet<>();
		this.breakfastDays = new HashSet<>();
	}

	/**
	 * Checks whether the amount of people corresponds with the reserved Beds.
	 * Call this method whenever a change in the amount of Beds, or the amount
	 * of people is made, or, whenever you need to assure consistency.
	 *
	 * It also prints a warning to system.out.err to inform about a discrepancy,
	 * should one be found.
	 *
	 * @return True if the counts are consistent, false otherwise.
	 */
	private boolean checkPeopleCountConsistency() {
		int people = this.getPeople();
		int beds = this.getReservedBeds().size();
		if(people != beds) {
			system.out.err("There's a discrepancy in the amount of people in Reservation"+
					this.reservationID +":");
			system.out.err("People: "+String.valueOf(people));
			system.out.err("Reserved Beds: "+String.valueOf(beds));
			return false;
		}
		return true;
	}

	/**
	 * Set the group name for this Reservation.
	 * @param groupName The new group name.
	 * @pre groupName mustn't be empty, or a null pointer.
	 * @post The group name is changed to the given name.
	 * @throws NullPointerException if groupName is a null pointer.
	 * @throws IllegalArgumentException if groupName is an empty String.
	 */
	public void setGroupName(String groupName) {
		if(groupName.isEmpty())
			throw IllegalArgumentException("groupName is an empty String.");
		this.groupName = groupName;
	}

	/**
	 * Retrieve the current group name.
	 * @return The group name of this Reservation.
	 */
	public String getGroupName() {
		return this.groupName;
	}

	/**
	 * Get amount of people in this Reservation.
	 * @post A warning will be printed to system.out.err if the amount of people
	 * is inconsistent with the amount of reserved Beds.
	 * @see Reservation.checkPeopleCountConsistency
	 * @return The amount of people in this Reservation.
	 */
	public int getPeople() {
		this.checkPeopleCountConsistency();
		return this.people;
	}

	/**
	 * Set the amount of people for this Reservation.
	 * Note that this method will not notify you if the new amount of people is
	 * equal to the previous amount.
	 * 
	 * This method will print
	 * @param people The new amount of people in this Reservation.
	 * @pre people must be at least 1.
	 * @post A warning will be printed to system.out.err if the amount of people
	 * is inconsistent with the amount of reserved Beds.
	 * @post The amount of people is changed to the given value.
	 * @throws IllegalArgumentException if people is less than 1.
	 */
	public void setPeople(int people) {
		if(people < 1) {
			throw IllegalArgumentException("people must be at least 1.");
		}
		this.people = people;
		this.checkPeopleCountConsistency();
	}
	/**
	 * Set the begin date for this Reservation.
	 * @param begin The new begin date.
	 * @pre begin mustn't be a null pointer.
	 * @pre begin must come strictly before the end date.
	 * @post The begin date is updated accordingly.
	 * @throws NullPointerException if begin is a null pointer.
	 * @throws IllegalArgumentException if begin comes after the end date.
	 */
	public void setBegin(Date begin) {
		if(!begin.before(this.getEnd()))
			throw IllegalArgumentException("begin comes after the end date.")
		this.begin = begin;
	}

	

	/**
	 * Set the end date for this Reservation.
	 * @param end The new end date.
	 * @pre end mustn't be a null pointer.
	 * @pre end must come strictly after the begin date.
	 * @post The end date is updated accordingly.
	 * @throws NullPointerException if end is a null pointer.
	 * @throws IllegalArgumentException if end comes after the end date.
	 */
	public Date getDate() {
		return date;
	}

	public void setReservedBeds(Set<Bed> reservedBeds) {
		this.reservedBeds = reservedBeds;
		this.checkPeopleCountConsistency();
	}

	public Set<Bed> getReservedBeds() {
		return reservedBeds;
		this.checkPeopleCountConsistency();
	}

	// TODO: Write documentation for all of these, even though it's all mostly
	// copy/pasting. pfffff
	public void setReservationID(int reservationID) {
		this.reservationID = reservationID;
	}

	public int getReservationID() {
		return reservationID;
	}

	public void setRoomType(String roomType) {
		this.roomType = roomType;
	}

	public String getRoomType() {
		return roomType;
	}

	public void setRoomFacilities(Set<String> roomFacilities) {
		this.roomFacilities = roomFacilities;
	}

	public Set<String> getRoomFacilities() {
		return roomFacilities;
	}

	/**
	 * Calculates the price of the Reservation, based on its current state.
	 * Price table:
	 * - 20/person/day
	 *   - 5 less in low season, 5 more in high season
	 * - 4/breakfast ordered
	 * - If room is fully booked by the group --> 10% discount
	 * @return The price in euros.
	 */
	public int getPrice() {
		int totalPrice = 0;
		// Jan - Apr: Mid
		// May - Aug: High
		// Sep - Dec: Low
		
		// Calculate bed prices
		int month = this.getDate().getMonth();
		int bedPrice = 20;
		if(month >=8) { // From September:
			bedPrice -= 5;
		} else if(month >=4) { // From May:
			bedPrice += 5;
		}
		totalPrice += (this.getReservedBeds().size() * this.getNights() * bedPrice);
		// Calculate price for breakfasts
		int breakfasts = this.getBreakfastDays().length;
		totalPrice += breakfasts * this.getReservedBeds().size();
		// Check if eligible for discount
		for(Room room: roomController.getRooms()) {
			Set<Bed> roomBeds = room.getBeds();
			if(roomBeds.containsAll(this.reservedBeds)) {
				double discount = (double)totalPrice * 0.1;
				totalPrice -= (int)discount;
			}
		}
		return totalPrice;
	}







	public void setBreakfastDays(int[] breakfastDays) {
		this.breakfastDays = breakfastDays;
	}
	public int[] getBreakfastDays() {
		return this.breakfastDays;
	}

}


Challenge 6/ReservationController.java ¶

9 additions and 12 deletions.

View changes Hide changes

import java.util.HashSet;
import java.util.Date;

/**
 * Controller class for the Reservations of this program.
 * Since this program handles a youth hostel, it's imperative that it holds a
 * number of Reservations.
 * 
 * ReservationController takes the responsibility of handling the addition,
 * cancelling, editing, ... of Reservations, and the related tasks inherent to
 * these responsibilities, such as reserving beds, generating IDs, ...
 * @author Maarten Vangeneugden - 1438256
 */
public class ReservationController {

	/* Rationale:
	 * Normally I'd put this as an interface (Set), but an interface does not
	 * inherit from Object, and thus, does not provide clone(). This is
	 * necessary, because otherwise, there's no point in having private
	 * members.
	 */
	private HashSet<Reservation> reservations; // Holds all Reservations
	private RoomController roomController;

	/**
	 * Creates the ReservationController.
	 * 
	 * WARNING: This program avoids the use of null pointers, but because of
	 * circular dependency issues, this class requires that the developer (which
	 * means YOU) set the RoomController reference member manually.
	 * Be advised that the setRoomController() method will not accept a null
	 * pointer.
	 *
	 * Once again: Set the RoomController reference manually ASAP. Failure to do
	 * so will cause this program to blow up. You've been warned.
	 * @see ReservationController.setRoomController
	 */
	public ReservationController() {
		this.reservations = new HashSet<>();
	}

	/**
	 * Returns a copy of all Reservations.
	 * Emphasis on "copy"; There is no setReservations() for a reason, using
	 * this to edit the pointer variable would omit the use of 'private'.
	 * @return A verbatim copy of all Reservations.
	 */
	@SuppressWarnings("unchecked")
	public Set<Reservation> getReservations() {
		return (HashSet<Reservation>)this.reservations.clone();
	}

	/**
	 * Generates a unique ID for a new Reservation.
	 * This method is to be called when a new Reservation is to be stored.
	 * As every Reservation carries an ID, this method searches for a unique
	 * one, and returns it.
	 * @return An integer, different from all other stored Reservation IDs.
	 */
	public int generateReservationID() {
		/* Small optimization idea:
		 * Instead of starting from 0, and incrementing until it's unique, it
		 * will take the amount of stored Reservations, and test that as an ID.
		 * This may still overlap (by removing an older Reservation), but may be
		 * much faster. Consider implemting and testing for effectiveness if
		 * generating an ID takes too long.
		 */
		int ID = 0;
		boolean isUnique = false;
		do {
			ID++;
			isUnique = true;
			for(Reservation reservation: this.reservations) {
				if(ID == reservation.getReservationID()) {
					isUnique = false;
				}
			}
		} while(!isUnique);
		// Test:
		for(Reservation reservation: this.reservations) {
			assert reservation.getReservationID() != ID : "Duplicate ID generated!";
		}
		return ID;
	}
	
	/** 
	 * Check if Reservation can be made.
	 * Call this method whenever you're planning on adding a new Reservation. It
	 * will check the provided requirements (Room facilities, for example), and
	 * return whether this Reservation can continue.
	 * @param reservation The Reservation to check for possible addition.
	 * @pre reservation mustn't be null.
	 * @throws NullPointerException if reservation is null.
	 * @return True if reservation can be added, False otherwise.
	 */
	public boolean checkReservation(Reservation reservation) {
		if(reservation == null) {
			throw NullPointerException("reservation was a null pointer.");
		}
		if(this.getRoomController().getQualifiedRooms(reservation).size() == 0) {
			return null;
	}

	/**
	 * Adds and confirms the reservation.
	 * By calling this method, the given reservation will be stored in the
	 * system, and the given room will be filled.
	 * You are to collect the necessary data, and assure yourself that all
	 * preconditions have been met.
	 * 
	 * The best way to accomplish this, is to only send 'sterile' Reservations
	 * as the first parameter. That is: Reservations without reserved Beds,
	 * without prior addition to the active Reservations, etc.
	 * NOTE: You must check for yourself if the Reservation can take place in
	 * this Room! If there are not enough Beds available, an exception will be
	 * thrown.
	 * @param reservation The Reservation to add.
	 * @param room The Room in which the people will reside.
	 * @pre room must have enough empty beds.
	 * @pre room must accomodate the Reservation's requirements.
	 * @pre No parameter must be null.
	 * @pre reservation mustn't already be stored in the active Reservations.
	 * @post reservation is stored in the active Reservations.
	 * @post The Beds in the provided Room are reserved for the Reservation's
	 * period.
	 * @throws IllegalArgumentException if the given Room can't fulfill the
	 * requirements of the Reservation, or occupants is less than 1.
	 * @throws NullPointerException if any parameter is a null pointer.
	 */
	public void addReservation(Reservation reservation, Room room) {
		// Contract validation. Null pointers are implicitely checked by calling
		// methods.
		if(occupants < 1)
			throw IllegalArgumentException("An invalid amount of occupants was given.");
		if(occupants > room.getEmptyBeds(reservation.getBegin(), reservation.getEnd()).size())
			throw IllegalArgumentException("The given Room has not enough empty Beds for the Reservation period.");
			throw IllegalArgumentException("The given Room has not enough empty Beds for the Reservation period.");
		if(!this.getRoomController().getQualifiedRooms(reservation).contains(room))
			throw IllegalArgumentException("The given Room cannot meet all requirements of the Reservation.");
		if(this.getReservations().contains(reservation))
			throw IllegalArgumentException("The given Reservation was already included in the active Reservations.");
		// Contract validated
		this.reservations.add(reservation);
		Set<Bed> beds
		for(int i=0; i<occupants; i++) {


		
		
		
		// TODO: Add reservation to the set, and add the reserved days to the
		// beds in the given room.
	}
		Set<Bed> reservedBeds = new HashSet<>();
		for(int i=0; i<reservation.getPeople(); i++) {
			beds[i].reservePeriod(reservation.getBegin(), reservation.getEnd());
			reservedBeds.add(beds[i]);
		}
		reservation.setReservedBeds(reservedBeds);
	}
	/**
	/**
	 * Cancels and removes the given Reservation.
	 * If you want to remove a Reservation, use this method, and provide the
	 * Reservation up for removal.
	 * This method will take care of related actions, such as releasing Beds.
	 * @param reservation The Reservation to be removed.
	 * @pre reservation mustn't be null.
	 * @pre reservation must be contained in the active Reservations.
	 * @post The Reservation is removed from the active Reservations.
	 * @post The Beds, previously reserved for this Reservation, are now
	 * released, and can be reserved for another Reservation.
	 * @throws NullPointerException if reservation is a null pointer.
	 * @throws IllegalArgumentException if reservation is not contained in the
	 * active Reservations.
	 */
	public void cancelReservation(Reservation reservation) {
		// Contract validation
		if(!this.getReservations().contains(reservation)) {
			throw IllegalArgumentException("The given Reservation was not contained in the active Reservations.");
		}
		if(reservation == null) {
			throw NullPointerException();
		}
		// Contract validated, execute method
		this.reservations.remove(reservation); // Remove from active Reservations
		for(Bed bed: reservation.getReservedBeds()) { // Release reserved Beds
			bed.removeReservationPeriod(reservation.getBegin(), reservation.getEnd());
		}
		// Asserting post conditions are met
		assert !this.getReservation().contains(reservation) : "The reservation is still part of the active Reservations.";
		for(Bed bed: reservation.getReservedBeds()) {
			assert bed.isFree(reservation.getBegin(), reservation.getEnd()) : "One or more of the Beds are still reserved.";
		}
	}

}


Challenge 6/ReservationView.java ¶

72 additions and 35 deletions.

View changes Hide changes

import java.util.Set;
import java.util.HashSet;
import java.util.Date;
/**
 * Creates a view screen that allows interaction with the reservation.
 * This window will place the reservation details in editable fields, so its
 * state can be adapted.
 * It then also adds a couple of buttons; add/update/cancel, with their
 * respective actions. These will then be passed to the ReservationController.
 * It will not allow to add/update a reservation if dates overlap, i.e. beds
 * can't be reserved for that period.
 * @author Maarten Vangeneugden - 1438256
 */
public class ReservationView {

	private Reservation reservation;
	private Window window;

	private ReservationController rc;
	private ReservationController rc;
	private RoomController roc;

	// GUI widgets:
	private JTextField nameField;
	private JTextField nameField;
	private JSpinner amountPeopleField;
	private JTextField dateField;
	private JSpinner durationField;
	private JRadioButton[] typeField;
	private JCheckBox showerField;
	private JCheckBox bathField;
	private JCheckBox minibarField;
	private JCheckBox aircoField;


	public ReservationView(Reservation reservation, ReservationController rc, RoomController roc) {
	 * Construct a window to edit a Reservation.
	 * This window presents its caller with the necessary tools to edit the
	 * given Reservation, and save it in the system.
	 *
	 * By sending it an empty Reservation, you can add a new Reservation to the
	 * system.
	 * This class is built in a way that allows it to be used for both creating
	 * new Reservations, and updating/changing existing Reservations.
	 * Existing Reservations can also be removed by clicking the appropriate
	 * button.
	 * @param reservation The Reservation that will be updated.
	 * @param rc The ReservationController class.
	 * @param roc The RoomController class.
	 * @pre No parameter may be a null pointer.
	 * @post A window is displayed with GUI widgets, which are filled in
	 * according to the state of reservation.
	 * @throws NullPointerException if any parameter is a null pointer.
	 */
	public ReservationView(Reservation reservation, ReservationController rc, RoomController roc) {
		this.rc = rc;
		if(rc == null || roc == null || reservation == null)
			throw NullPointerException("One or more of the given parameters is a null pointer.");
		// Contract validated
		this.rc = rc;
		this.roc = roc;

		this.reservation = reservation;
		this.window = new Window("Reservation screen");
		this.addFields();
	}

	public void setReservation(Reservation reservation) {
		this.reservation = reservation;
	}

	public Reservation getReservation() {
		return reservation;
	}

	private void addFields() {
	 * Add the necessary fields to the window.
	 * This method inspects the Reservation, and copies the included information
	 * to the widget's content.
	 */
	private void addFields() {
		this.window.createLabel("Group name");
		this.nameField = window.createTextField(this.reservation.getGroupName());
		this.window.createLabel("Amount of people");
		this.amountPeopleField = window.createSpinner(1, 20);
		// Formatting date for the date field:
		// Formatting date for the date field:
		this.window.createLabel("date");
		Date date = this.reservation.getDate();
		String day = String.valueOf(date.getDate());
		String month = String.valueOf(date.getMonth()+1);
		String year = String.valueOf(date.getYear()+1900);
		this.dateField = window.createTextField(day +" "+ month +" "+ year);
		this.window.createLabel("Duration");
		this.durationField = window.createSpinner(1, 355);
		String[] types = new String[3];
		types[0] = "Male";
		types[1] = "Female";
		types[2] = "Mixed";
		this.typeField = this.window.createRadioButtons(types);
		this.beginDateField = window.createTextField(this.reservation.getBegin().toString());
		this.window.createLabel("End date");
		this.endDateField = window.createTextField(this.reservation.getEnd().toString());
		String[] types = {"Male", "Female", "Mixed"};
		this.typeField = this.window.createRadioButtons(types);
		this.showerField = this.window.createCheckbox("Shower");
		// it is, and then already check the corresponding radio button.
		this.showerField = this.window.createCheckbox("Shower");
		this.bathField = this.window.createCheckbox("Bath");
		this.minibarField = this.window.createCheckbox("Minibar");
		this.aircoField = this.window.createCheckbox("Airco");


		this.window.createButton("Add/Update reservation", "", "addReservation", this);
		// check accordingly.
		this.window.createButton("Add/Update reservation", "", "addReservation", this);
		this.window.createButton("Cancel reservation", "", "cancelReservation", this);
	}
	}

	

	public void addReservation() {
	 * Start the addition of this Reservation to the system.
	 * This method will check the current fields, and update the Reservation
	 * with those values. In doing so, the validity of the values is checked
	 * (formatting, begin date before end date, ...).
	 * If everything is okay, the method will check if these changes are
	 * possible in the current system; are there enough empty beds?
	 *
	 * If everything is okay, the changes will be propagated to the
	 * Reservation's state, and (if it's a new Reservation) will be added to the
	 * system's active Reservations.
	 */
	public void addReservation() {
		// Collect all data from the fields
		String name = this.nameField.getText();
		String date = this.dateField.getText();
		// Extracting date data:
		String[] dateParts = date.split(" ");
		int day = Integer.parseInt(dateParts[0]);
		int month = Integer.parseInt(dateParts[1]);
		int year = Integer.parseInt(dateParts[2]);
		Date actualDate = new Date(day, month-1, year-1900);

		int amount = (Integer)this.amountPeopleField.getValue();
		int duration = (Integer)this.durationField.getValue();
		String type = "";
		try {
			beginDate = DataFormat.parse(this.beginDateField.getText());
			endDate = DataFormat.parse(this.endDateField.getText());
		}
		catch(ParseException e) {
			this.window.messageDialog("Not all date fields were properly formatted.");
			return;
		}
		int people = (Integer)this.amountPeopleField.getValue();
		String type = "";
		for(int i=0; i<this.typeField.length; i++) {
			if(this.typeField[i].isSelected()) {
				type = this.typeField[i].getText();
				break;
			}
		}
		Set<String> facilities = new HashSet<>();
		if(this.showerField.isSelected()) {
			facilities.add("Shower");
		}
		if(this.bathField.isSelected()) {
			facilities.add("Bath");
		}
		if(this.minibarField.isSelected()) {
			facilities.add("Minibar");
		}
		if(this.aircoField.isSelected()) {
			facilities.add("Airco");
		}

		Set<Room> possibleRooms = this.roc.getQualifiedRooms(actualDate, duration, type, facilities);
		if(possibleRooms.size() == 0) {

		//Set<Room> possibleRooms = this.roc.getQualifiedRooms(actualDate, duration, type, facilities);
		// TODO: Refactor upper method to work with the Reservation.
		// TODO: Implement all checks of valid data above this line!
		
		// Data validated; Try finding appropriate beds
		if(possibleRooms.size() == 0) {
			boolean tryAgain = this.window.confirmDialog("No rooms met the requirements! Would you like to continue and change the parameters?");
			if(!tryAgain) {
				// TODO close window
			}
		}
		else {
			// Determine end date:
			long beginDate = actualDate.getTime();
			long endDate = beginDate + (duration * 24 * 60 * 60 * 1000);
			Date actualEndDate = new Date(endDate);
			Room pickedRoom = null;
			for(Room room: possibleRooms) {
				if(room.getEmptyBeds(actualDate, actualEndDate).size() < room.getBeds().size()) {
					// First, fill the rooms that are partially filled.
					pickedRoom = room;
					break;
				}
			}
			if(pickedRoom == null) { // If still no room, pick an empty room
				for(Room room: possibleRooms) {
					if(room.getEmptyBeds(actualDate, actualEndDate).size() >= amount) {
						pickedRoom = room;
						break;
					}
				}
			}
			assert pickedRoom != null;
			// TODO: Set reservation fields here!
			this.rc.addReservation(reservation, pickedRoom);

			// Confirm and show price:
			int price = this.reservation.getPrice();
			this.window.confirmDialog("Reservation confirmed! Price: " +String.valueOf(price));
		}
		
	}
	public void cancelReservation() {
		// TODO: Close the window. That's all.
	public void removeReservation() {
		// TODO: Close the window. That's all.
	}
}


Challenge 6/Window.java ¶

26 additions and 0 deletions.

View changes Hide changes

 * Window.java - Module to create a new window with JSugar.
 * Copyright © 2016 Maarten "Vngngdn" Vangeneugden
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

/*
 * TODO list:
 * - JSlider (It's the same as the JSpinner, only longer. So an extra.)
 * - JTable (And a JScrollBar to accompany it) (extra, because of JList)
 * - JFileChooser (?)
 * DONE list:
 * - JLabel
 * - JText
 * - JButton
 * - JDialogBoxes (you know, everything dialog related)
 * - JCheckbox
 * - JRadioButton (properly grouping them has been taken care of as well)
 * - JSpinner
 * - JComboBox
 * - JList
 */

import javax.swing.*; // FIXME: Maybe namespacing it to "javax.swing;" is a better idea.
import java.util.NoSuchElementException;
import java.lang.reflect.Method;
import java.io.File;
/**

/**
 * Window class for the program.
 *
 * Window contains the necessary data and methods to present the user with what
 * he's familiar with as being a "window". To make it functional, the developer
 * can make use of a series of methods to add components to said window, remove
 * components, and so on.
 * Currently, Window also contains methods to show dialogs. This will be cleaned
 * in the near future.
 * @author Maarten Vangeneugden
 */
public class Window { // Must be public, in order to generate Javadoc.
	private JPanel panel; // The panel that contains all the components.
	private JFrame frame; // The "window" being presented to the user.

	/**
	 * Constructor of Window.
	 * By creating a new Window instance, this constructor will automatically
	 * start the initialization of the GUI. After doing so, the caller can
	 * start adding components to the window as pleased.
	 * @param title The title to be shown in the window's title bar.
	 */
	public Window(String title) {
		// Setting the UI style to the platform's UI style. Fuck Swing's,
		// really.
		try {
		UIManager.setLookAndFeel(
				UIManager.getSystemLookAndFeelClassName());
		} catch(Exception e) {
			e.printStackTrace();
		}

		if(title == null || title.equals("")) { // If the title was omitted:
			title = "JSugar";
		}
		this.panel = new JPanel();
		// TODO: The current title is "Hello world!" but that will become caller
		// defined soon.
		JFrame frame = new JFrame(title);
		// Makes it so that if the user clicks the X in the titlebar, the window
		// closes:
		frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); // XXX: Closes
		//ALL open windows!
		//frame.getContentPane().add(lblHelloWorld); // So you use a get() in order to set() data? #JavaWTF
		frame.setContentPane(this.panel); // Connecting the component panel to the window.
		// Makes the window fit to the necessary width and height, so it can show all "subcomponents".
		frame.pack(); 	
		frame.setVisible(true); // Makes the window visible to the user.
		this.frame = frame;
	}

	/**
	 * Resizes the window to fit all components.
	 * By calling this method, the window will evaluate the currently visible
	 * components, and resize itself so that all components become properly
	 * visible.
	 */
	private void updateWindow() {
		this.frame.pack();
	}

	/**
	 * A series of tests for method and class handling.
	 * When a caller presents certain methods with data concerning reflection,
	 * the Java classes you need to use for that are quite opaque, and don't
	 * offer much safety in any way.
	 * The solution therefore, is run some validation checks, but these take up
	 * a decent amount of space in terms of LoC.
	 * This method takes care of all that. Call this function whenever data
	 * needs to be validated.
	 * @param methodName The name of the method, as it is declared in object.
	 * @param object The class instance in where this method will be called.
	 * @return The method that could be derived from the supplied data, or null
	 * if that wasn't possible.
	 * @throws NullPointerException if either methodName or object are null
	 * pointers.
	 * @throws IllegalArgumentException if methodName is empty, or the method
	 * does not appear to be declared in the given object, or object is not a
	 * class.
	 */
	// All unchecked typecasts are safe, and the use of raw types is taken care
	// of.
	@SuppressWarnings({"unchecked","rawtypes"})
	private Method handleReflectionData(String methodName, Object object) {
		// Null pointer checking:
		if (methodName == null || object == null) {
			throw new NullPointerException("One or more of the given parameters are null pointers.");
		}

		// XXX: Some might say the next line should be in an else{} block. But
		// Scoping rules require that I'd then have to wrap the rest of the
		// method in the same else to use it.
		Class methodClass = object.getClass(); 
		if (methodName.equals("")) {
			throw new IllegalArgumentException("The given methodName was empty.");
		}
		Method method;
		try { // First: Look if there's a method without parameters.
			method = methodClass.getMethod(methodName, null);
		}
		catch (NoSuchMethodException exception) {
			try {
				// It's possible that the method requires an event parameter, so
				// check for that as well:
				Class<?>[] parameters = {java.awt.event.ActionEvent.class};
				method = methodClass.getMethod(methodName, parameters);
			}
			catch (NoSuchMethodException e) {
				throw new IllegalArgumentException("The given method does not appear in the given class. Be aware that the given method mustn't have any parameters, or only 1 parameter, which has to be of type java.awt.event.ActionEvent.");
			}
		}
		// At this stage, the given data has been validated, and we've been able
		// to retrieve the method itself.
		return method;
	}

	/**
	 * Creates a button in the GUI for interaction.
	 * This function offers a convenient way to create a button, that can be
	 * directly interacted with by the user. After creation, the button itself
	 * is returned to the caller, if he wishes to do something else with it.
	 * @param text The text that will be displayed in the button.
	 * @param action The action that will be returned to the action listener.
	 * @param methodName The name of the method that will be called when an
	 * action is triggered.
	 * @param triggerObject The object instance that contains the given method.
	 * This may only be a null pointer if triggerMethod is not an instance
	 * method.
	 * performed. This method may accept an ActionEvent parameter as its only
	 * parameter, or no parameters at all.
	 * @throws NullPointerException if triggerMethod is a null pointer, or
	 * the empty String was given.
	 * @throws IllegalArgumentException if triggerMethod has more than 1
	 * parameter, or the 1 required parameter is not of type ActionEvent.
	 * @return The button that was created.
	 * @see java.awt.event.ActionEvent
	 * @see java.lang.reflect.Method#invoke
	 */
	public JButton createButton(String text, String action, String methodName, Object triggerObject) {
		Method triggerMethod = this.handleReflectionData(methodName, triggerObject);

		// For starters, we first assert that the given parameters are valid:
		if (text == null) {
			text = "";
		}
		if (action == null) {
			action = "";
		}
		
		// When the method gets here, everything's been validated correctly.
		JButton button = new JButton(text);
		button.setActionCommand(action);
		button.addActionListener(
				new java.awt.event.ActionListener() {
					public void actionPerformed(java.awt.event.ActionEvent event) {
						try {
							triggerMethod.setAccessible(true);
							if (triggerMethod.getParameterTypes().length == 0) {
								// FIXME: Next line throws a warning?
								triggerMethod.invoke(triggerObject, null);
							}
							else {
								triggerMethod.invoke(triggerObject, new Object[]{event});
							}
						}
						catch (Exception useless) {
							/*
							 * XXX: Some info on why I don't just throw said
							 * Exception to the caller:
							 * Java has this awful language constraint, which
							 * forces every damn exception that isn't a subclass
							 * of RuntimeException, to be declared in the method
							 * declaration. This tends to infect all underlying
							 * methods as well, and all that for reasons I can't
							 * comprehend. In order to keep JSugar a simple and
							 * clean library, I'll rather just handle it here,
							 * and throw a RuntimeException with appropriate
							 * details.
							 */
							throw new IllegalArgumentException("triggerMethod is not accessible from this context.");
						}
					}
				});
		this.addComponent(button);
		return button;
	}

	/**
	 * Ask the user for input through a dialog box.
	 * This method presents the user with an input field, that can accept
	 * textual input. The method will return the given input after the user's
	 * clicked a button to send.
	 * @param text The text/question to be asked to the user.
	 * @return A String, equal to what the user entered.
	 * @throws NullPointerException if text is a null pointer.
	 */
	public String inputDialog(String text) {
		if (text == null) {
			throw new NullPointerException("The given text/question was a null pointer.");
		}
		return JOptionPane.showInputDialog(text);
	}

	/**
	 * Give the user a dialog box.
	 * This method can be used to provide a simple dialog to the user.
	 * This will show the user the given question, after which a boolean value
	 * is returned, holding the choice.
	 * @param text The text/question to be asked to the user.
	 * @return True if the user confirms, False if he denies.
	 * @throws NullPointerException if text is a null pointer.
	 */
	public boolean confirmDialog(String text) {
		if (text == null) {
			throw new NullPointerException("The given text/question was a null pointer.");
		}
		final int ACCEPTED = 0;
		//final int DENIED = 1; // Not used in the current context.
		int result = this.choiceDialog(text, new String[]{"Confirm", "Deny"});
		if (result == ACCEPTED) {
			return true;
		}
		else {
			return false;
		}
	}

	/**
	 * Give the user a choice dialog box.
	 * This method gives the user a simple dialog with predefined choices.
	 * These choices are to be provided by the caller in a simple array.
	 *
	 * Tip: This method works extremely well with arbitrary created choices.
	 * That is: if the outcome of the dialog is trivial (e.g. Only 1 choice),
	 * then that value is immediately returned.
	 * @param text The text/question to be asked to the user.
	 * @param choices An array of Strings, containing the choices the user can
	 * pick.
	 * @return The index value of the picked choice, or -1 if no choices were
	 * given.
	 * @throws NullPointerException if text is a null pointer.
	 */
	public int choiceDialog(String text, String[] choices) {
		if (text == null) {
			throw new NullPointerException("The given text/question was a null pointer.");
		}
		// First: handling the trivial cases:
		if (choices.length == 0) {
			return -1;
		}
		else if (choices.length == 1) {
			return 0;
		}
		int answer = JOptionPane.CLOSED_OPTION;
		// The dialog needs to be shown again until the user has made a possible
		// choice, i.e. Chickening out using the close button is not possible
		// (Because that returns CLOSED_OPTION).
		while (answer == JOptionPane.CLOSED_OPTION) {
				JOptionPane.showOptionDialog(
					null, // The parent component. May become the panel?
					text, // The text/question to describe the goal
					"Dialog", // The text in the title bar
					JOptionPane.DEFAULT_OPTION, // The kind of available options
					JOptionPane.QUESTION_MESSAGE, // The type of message
					null, // The icon to show
					choices, // The possible choices
					choices[0] // The standard choice
					);
		}
		return answer;
	}
		

	/**
	 * Creates a label in the GUI for interaction.
	 * This function offers a convenient way to create a label, that can be
	 * directly interacted with by the user. After creation, the label itself
	 * is returned to the caller, if he wishes to do something else with it.
	 * @param text The text that will be displayed in the label.
	 * @return The label that was created.
	 */
	public JLabel createLabel(String text) {
		JLabel label = new JLabel(text);
		this.addComponent(label);
		return label;
	}

	/**
	 * Adds a checkbox to the window.
	 * By providing a String, you can use this method to easily
	 * create a checkbox, and add it to the window. 
	 * @param text The text to put next to the checkbox.
	 * @return The checkbox that was created and added to the GUI.
	 */
	public JCheckBox createCheckbox(String text) {
		JCheckBox checkbox = new JCheckBox(text);
		this.addComponent(checkbox);
		return checkbox;
	}

	/**
	 * Adds radio buttons to the window.
	 * Given a list of Strings, this method will create the same amount of radio
	 * buttons.
	 *
	 * The radio buttons will silently be grouped in a ButtonGroup object,
	 * making them automatically disable each other, so only 1 radio button can
	 * be enabled. This ButtonGroup is immutable.
	 *
	 * If you need a mutable ButtonGroup, create your own, and use the 
	 * {@link #addComponent} method to add the radio buttons manually.
	 * @param text An array of Strings. The length of the array will determine
	 * the amount of radio buttons that will be created.
	 * @return An array of radio buttons, in the same order as text.
	 */
	public JRadioButton[] createRadioButtons(String text[]) {
		JRadioButton[] radioButtons = new JRadioButton[text.length];
		ButtonGroup buttonGroup = new ButtonGroup();
		for (int i=0; i<radioButtons.length; i++) {
			radioButtons[i] = new JRadioButton(text[i]);
			//radioButtons[i].setText(text[i]);
			buttonGroup.add(radioButtons[i]);
			this.addComponent(radioButtons[i]);
		}

		assert radioButtons.length == buttonGroup.getButtonCount() : "The amount of radio buttons ("+ radioButtons.length +") differs from the amount of buttons in buttonGroup ("+ buttonGroup.getButtonCount() +").";
		return radioButtons;
	}

	public JTextField createTextField(String text) {
		JTextField textField = new JTextField(text);
		this.addComponent(textField);
		return textField;
	}

	/**
	 * Adds a number spinner component to the GUI.
	 * This method allows the caller to create a so-called "spinner component"
	 * to the window. This spinner is an input box, in which only integers can
	 * be put.
	 *
	 * The caller can set a range, a start value, and a step size.
	 *
	 * The spinner created with this method may modify itself based on the
	 * parameters.
	 * For example: If the minimum and maximum value are equal, the spinner will
	 * be disabled.
	 *
	 * @param minimum The minimum value that can be selected.
	 * @param maximum The maximum value that can be selected.
	 * @param start The value that will initially be shown in the component.
	 * @param stepSize The step size when the user increases/decreases the
	 * value.
	 * @throws IllegalArgumentException if minimum is larger than maximum, 
	 * start is not in the range of the selectable values, or stepsize is not a
	 * natural number.
	 * @return The JSpinner that was added to the window.
	 */
	public JSpinner createSpinner(int minimum, int maximum, int start, int stepSize) {
		// As usual, we begin with checking the contract:
		if(minimum > maximum) {
			throw new IllegalArgumentException("The minimum value ("+ minimum +") was larger than the maximum value ("+ maximum +")");
		}
		// The "start ∉ [minimum, maximum]" is done by the SpinnerNumberModel
		// constructor, which will be constructed later.
		if(stepSize <= 0) { // stepSize ∉ ℕ¹ (In Belgium: ℕ₀)
			throw new IllegalArgumentException("The stepSize ("+ stepSize +") is not a natural number (excluding 0).");
		}
		// If the contract is valid, we can begin:
		/*
		 * I'd like to interject here, because this is a nice example of why
		 * JSugar was a good idea:
		 * If you want a spinner, you'll typically want an integer spinner. But
		 * in Swing, when you create a JSpinner, it creates a JSpinner, with a
		 * predefined 'SpinnerNumberModel' attached to it.
		 * It's this model you then have to extract from the created spinner, on
		 * which you need to apply the configuration.
		 * What you actually have to do, is create a SpinnerNumberModel
		 * yourself, put your settings on that, and then, create a JSpinner to
		 * which you give that SpinnerNumberModel.
		 * In essence: The entire Java framework is shit.
		 */
		SpinnerNumberModel spinnerSettings = new SpinnerNumberModel(
				start,
				minimum,
				maximum,
				stepSize
				);
		JSpinner spinner = new JSpinner(spinnerSettings);
		if(minimum == maximum) { // Trivial value is set already, --> disable.
			spinner.setEnabled(false);
		}
		this.addComponent(spinner);
		return spinner;
	}

	/**
	 * Adds a number spinner component to the GUI.
	 * This method allows the caller to create a so-called "spinner component"
	 * to the window. This spinner is an input box, in which only integers can
	 * be put.
	 * 
	 * Tip: This method is a convenience method, and works extremely well with
	 * arbitrary data.
	 * For example: The start value is automatically set to the minimal possible
	 * value, and the step size defaults to 1.
	 * If the minimum and maximum are equal, the component will be disabled, and
	 * thus, be locked on the only (trivially) possible value.
	 * If minimum is larger than maximum, the method will notify you of this,
	 * but also swap the values. So you can rest assured that the spinner will
	 * handle errors, but also, inform you about it.
	 * @param minimum The minimum value that can be selected.
	 * @param maximum The maximum value that can be selected.
	 * @return The JSpinner component that was added to the window.
	 */
	public JSpinner createSpinner(int minimum, int maximum) {
		// The disabling of equal values is done in the full createSpinner(), so
		// this is merely switching values if they need to be swapped.
		if(minimum > maximum) {
			System.err.println("minimum ("+ minimum +") was larger than maximum ("+ maximum +").");
			// FIXME: Consider whether it's appropriate to print a stacktrace
			// here, which may be convenient for debugging.
			
			// XXX: I know you don't need the help variable when swapping
			// integers, because you can also do basic arithmetics. Change it if
			// it causes too much eye burn for you.
			int swapValue = minimum;
			minimum = maximum;
			maximum = swapValue;
		}

		// Yeah, these 2 variables make you cringe huh, performance addicts?
		// Drown me in the tears of your useless performance-related opinions.
		int startValue = minimum;
		int stepSize = 1;
		return this.createSpinner(minimum, maximum, startValue, stepSize);
	}

	/**
	 * Adds a combobox to the GUI.
	 * Allows the caller to create a combobox by providing the values that
	 * should be put in it.
	 *
	 * This method can only be used for String values. If that is not what you
	 * need, consider creating your own combobox and adding it manually. Or, if
	 * you need a combobox for integers, consider {@link #createSpinner}.
	 *
	 * WARNING: {@link JComboBox#getSelectedItem} returns an object, not a
	 * String. You need to manually typecast this. This is a constraint of the
	 * Swing framework.
	 * @param items An array of Strings that will be put in the combobox.
	 * @throws NullPointerException if one of the values in items is a null
	 * pointer.
	 * @throws IllegalArgumentException if items is empty.
	 * @return The JCombobox that was added to the window.
	 */
	public JComboBox<String> addComboBox(String[] items) {
		// Contract validation:
		if(items.length == 0) {
			throw new IllegalArgumentException("The given array of items was empty.");
		}
		for(String item : items) {
			if(item == null) {
				throw new NullPointerException("One of the given Strings is a null pointer.");
			}
		}
		// Contract validated, create the component:
		JComboBox<String> comboBox = new JComboBox<String>(items);
		comboBox.setSelectedIndex(0);
		if(comboBox.getItemCount() == 1) { // Trivial selection
			comboBox.setEnabled(false);
		}
		this.addComponent(comboBox);
		return comboBox;
	}

	/**
	 * Creates a list of the given data, and adds it to the GUI.
	 * This will create a JList component, containing the given data. 
	 * To jar up your memory: A list in this context, is a component in which
	 * data of the same type is printed out. The user of said list, can then
	 * select a subset of these items.
	 *
	 * @see JList for a collection of possible operations.
	 * @param items The String items that will be put in the list.
	 * @throws NullPointerException if one of the values in items is a null
	 * pointer.
	 * @throws IllegalArgumentException if items is empty.
	 * @return A JList component, that was a added to the GUI.
	 */
	public JList createList(String[] items) {
		// Contract validation:
		if(items.length == 0) {
			throw new IllegalArgumentException("The given array of items was empty.");
		}
		for(String item : items) {
			if(item == null) {
				throw new NullPointerException("One of the given Strings is a null pointer.");
			}
		}
		// Contract validated, create the component:
		JList list = new JList(items);
		this.addComponent(list);
		return list;
	}

	/**
	 * Creates a table of the given data, and adds it to the GUI.
	 * This method allows you to create a table with sorting functionality in
	 * the GUI.
	 * This method relies on implications, deducted from the given data. That
	 * is, the length of the rows and columns is calculated by the longest
	 * length it can find in the nested array.
	 * To change the data, take a look at the JTable documentation.
	 *
	 * @see JTable for a collection of possible operations.
	 * @param items The String items that will be put in the list.
	 * @throws NullPointerException if one of the values in items is a null
	 * pointer.
	 * @throws IllegalArgumentException if items is empty, or the amount of
	 * column names does not correspond with the given amount of items.
	 * @return A JTable component, that was a added to the GUI.
	 */
	public JTable createTable(String[] columns, String[][] items) {
		// Contract validation:
		if(items.length == 0) {
			throw new IllegalArgumentException("The given array of items was empty.");
		}
		if(columns.length != items[0].length) {
			throw new IllegalArgumentException("The amount of columns does not correspond to the given amount of items.");
		}
		for(int i=0; i<items.length; i++) {
			if(items[i] == null) {
				throw new NullPointerException("One of the given Strings is a null pointer.");
			}
		}
		// Contract validated, create the component:
		// Deducting max length:
		int columnCount = columns.length;
		int rowCount = items.length;
		
		JTable table = new JTable(items, columns);
		this.addComponent(table);
		return table;
	}

	/**
	 * Adds the given component to the GUI.
	 * This method allows its caller to give a pre-made component, so that it
	 * can be added to the GUI. Even though its main use is for the Window class
	 * itself, the user of JSugar can also use it to create components himself,
	 * and then add them. As such, this method doesn't provide parameters for
	 * reflection/action triggering purposes.
	 * @param component The component to be added to the window.
	 * @throws NullPointerException if the given component is a null pointer.
	 */
	public void addComponent(JComponent component) {
		int originalSize = this.panel.getComponentCount();
		this.panel.add(component); // Throws the exception if null.
		this.updateWindow();

		assert originalSize == this.panel.getComponentCount()-1 : "A component was supposed to be added to the window, but the total amount of components was unchanged after the addition.";
	}

	/**
	 * Removes the given component from the GUI.
	 * This method allows its caller to remove a component from the GUI.
	 * @param component The component to be removed.
	 * @throws NoSuchElementException if the given component does not exist in
	 * the GUI.
	 * @throws NullPointerException if the given component is a null pointer.
	 */
	public void removeComponent(JComponent component) {
		int originalSize = this.panel.getComponentCount();
		this.panel.remove(component);
		int newSize = this.panel.getComponentCount();
		if (originalSize != newSize+1) {
			throw new NoSuchElementException("The given component does not exist in the GUI.");
		}
		this.updateWindow();
	}
	/**
	 * Prompts the user with a file chooser dialog.
	 * By calling this method, the user will be presented with a file chooser
	 * dialog, out of which a single file can be selected. If the selected file
	 * exists, a File object is returned, a null pointer if the user cancelled.
	 * @return A File object representing the file the user selected, or null
	 * otherwise.
	 */
	public File openFileChooserDialog() {
		JFileChooser fileDialog = new JFileChooser();
		fileDialog.setFileSelectionMode(JFileChooser.FILES_ONLY);

		int userResponse = fileDialog.showOpenDialog(this.panel);
		if(userResponse == JFileChooser.APPROVE_OPTION) {
			return fileDialog.getSelectedFile();
		}
		else {
			return null;
		}
	}
}
	/** Prompts the user with a message dialog.
	 * This method creates a dialog that is purely informative. As such, it
	 * only presents the user with the option to confirm it.
	 * @param text The text to be presented in the dialog box.
	 * @pre text mustn't be null or an empty string.
	 * @throws NullPointerException if text is a null pointer.
	 * @throws IllegalArgumentException if text is an empty string.
	 */
	public void messageDialog(String text) {
		if(text.isEmpty())
			throw IllegalArgumentException("text mustn't be an empty string.");
		JOptionPane.showMessageDialog(this.frame, text);
	}

	/**
	 * Closes this window.
	 * This method tells this Window's JFrame that a closing event has been
	 * fired.
	 * Use this method when you need to programatically close this window.
	 */
	public void close() {
		this.frame.dispatchEvent(new WindowEvent(this.frame, WindowEvent.WINDOW_CLOSING));
	}
}


Challenge 6/ontwerpkeuzes2.md ¶

3 additions and 0 deletions.

View changes Hide changes


## GRASP
Om zoveel mogelijk tegemoet te komen aan de GRASP-richtlijnen, heb ik volgende
ontwerpkeuzes toegepast voor de verschillende richtlijnen.

### High cohesion & Low coupling
- Veel classes zijn totaal van elkaar losgekoppeld. Een goed voorbeeld hiervan
  is Bed; Bed weet niet over dat er Reservaties bestaan, zelfs niet in welke
  Room het 'staat'.
- Als er toch gekoppeld moet worden, dan blijft dit tot een minimum beperkt; Een
  Room weet wel welke Bedden het heeft, maar niet hoe deze gebruikt worden, een
  Reservation weet wel welke Bedden voor hem gereserveerd zijn, maar heeft geen
  weet van welke kamer dat deze staat.

  zijn deze vaak verplicht om van veel verschillende classes op de hoogte te
  zijn.

### Indirectie
- In plaats van functionaliteit toe te wijzen aan class X om met class Y te
  interageren, wordt er vaak gebruik gemaakt van een class Z, die deze
  verantwoordelijkheid op zich neemt.
- Dit wordt toegepast d.m.v. een MVC-structuur, waarin de \*Controller-classes
  als 'tussenpersoon' werken.
- Dit komt ook tegemoet aan de eigenschappen van Information Expertise.

### Creator
- Controllers staan ook in als zgn. Creators van de models die ze beheren. Ze
  voldoen dan ook aan de eigenschappen zoals
  [hier](https://en.wikipedia.org/wiki/GRASP_(object-oriented_design)#Creator)
  opgesomd wordt.


## SOLID

### Single Responsibility

## Algemene keuzes ter bevordering codekwaliteit

### Null pointers
Het valt misschien op dat ik doorheen mijn programma in veel contracten eis dat
geen enkele parameter een zgn. *null pointer* is.

Het gebruik van null pointers staat garant voor een overvloed aan moeilijk te
vinden bugs die (door het design van objectgeörienteerd programmeren) enorm diep
kunnen doorpropageren.

Ik maak er een kerntaak van dat, als er aan mijn programma gewerkt wordt, de
programmeur zichzelf steeds kan garanderen dat **alle** data die hij
ontvangt, valide data is.
Op deze manier valt er een hele last van de schouders van de programmeur; een
reeks fouten worden voorkomen, simpelweg door een strikt schema aan te houden.

Het controleren op null pointers wordt op 2 manieren gedaan:
- Gebruik van *methods* aanwezig in het gegeven type. Als de gegeven variabele
  een null pointer is, zal het programma direct crashen, en een
  NullPointerException geven.
- Expliciet testen of *var == null*. Wordt toegepast op parameters die direct
  als members opgeslagen dienen te worden.

Deze (contractuele) controle laat toe dat, mocht er een null pointer gebruikt
worden, het programma de programmeur hiervan direct op de hoogte stelt, en dit
op het laagst mogelijke niveau (namelijk de eerste method waar deze waarde
gebruikt wordt).

### Cloning
members 'private' maken (encapsuleren) is volledig nutteloos als men getters en
setters op deze members toepast; In Java worden references doorgegeven (m.u.v.
primitives), die de hele notie van encapsulatie voorbijgaan (bij sommige types).
Een voorbeeld hiervan is het privatiseren van een Set<T>-member: men kan daar
een 'getSet()'-method op plaatsen, en dan toch de inhoud van deze 'private'
aanpassen.

Ik heb geopteerd om, waar van toepassing, deze variabelen te 'clonen', om zo
exacte kopieën terug te geven.
Deze manier van werken brengt enkele voordelen teweeg:
- Zeer defensief programmeren; De ontwikkelaar kan geen members aanpassen als
  dat niet de bedoeling was
- Duidelijkheid code: getSet().clear() zal de member niet meer leegmaken. Om dat
  te doen, moet men gebruikmaken van de method die daarvoor bedoeld is:
  setSet(clearedSet)

### Inheritance
Overerving is een goed concept over het algemeen, maar **niet** in OOP.
De problemen omtrent impliciet gedrag en onnodige *state* zijn al te vaak
beschreven met OOP-inheritance.

Ik heb in mijn programma geen gebruik gemaakt van inheritance, exact omwille van
de problemen die het voortbrengt, zeker in termen van herbruikbaarheid en
robuustheid, wat toch zware vereisten waren voor deze opdracht.

Ik heb al mijn problemen makkelijk kunnen oplossen d.m.v. compositie.

### Benaming variabelen
Doorheen mijn programma maak ik heel veel gebruik van dezelfde benamingen.
Bijvoorbeeld: Een variabele van het type Reservation zal haast altijd
'reservation' heten, een Set van een bepaald type zal de naam van datzelfde type
dragen, in het meervoud, ...

Sommige programmeurs gebruiken liever afkortingen (bv. 'reservation' -->
'resv'), omdat dit sneller schrijft.

Naar mijn mening moet men bij deze werkwijze inleveren aan leesbaarheid, vooral
wanneer iemand die nog nooit met de code gewerkt heeft, dit programma moet
overnemen.

Daarnaast zorgt de consistentie van woordgebruik ervoor dat een andere
programmeur, doorheen het hele programma dezelfde context in zijn/haar gedachten
kan gebruiken.




------------------------------------------------------------ TODO
## Toepassing types/classes
Doorheen het programma heb ik getracht zoveel mogelijk gebruik te maken van
types/classes die
- Veelvoorkomend zijn in de Java STL (Zoals String, Set, List, ...)
- primitief zijn (ints, ...), omdat deze operatoren hebben en de code
  leesbaarder maken

Een goed voorbeeld hiervan zijn bv. de faciliteiten:
I.p.v. een aparte "Facility"-class te maken, heb ik de verschillende
faciliteiten voorgesteld door een simpele String. De voordelen van deze aanpak
zijn ook direct duidelijk:
- Betekenis is direct duidelijk; de faciliteit letterlijk in de code vernoemd
- Makkelijke interactie met GUI, die sowieso Strings vraagt voor bv. JLabel
- Uitbreidbaarheid wordt bekomen door simpelweg een nieuwe String te
  introduceren

## View en GUI
Werken met GUI's is vaak tijdrovend en veroorzaakt snel errors, zeker met bv.
anonieme methods, exceptions, ...
Alhoewel mijn programma grotendeels in een MVC-stijl is geschreven, maken de
view-classes (RegistrationView, SearchView, ...) achterliggend gebruik van een
zelfgemaakt framework om makkelijk vensters te maken.
Dit kleine framework is een persoonlijk hobbyproject dat ik JSugar noem.
Het biedt een heleboel voordelen, vergeleken met elk GUI-venster zelf opstellen:
- Vaak gebruikte GUI-widgets (zoals een label, textfield) worden aangemaakt en
  toegevoegd door slechts 1 method op te roepen
- JSugar maakt gebruik van reflectie om op een leesbare en uitbreidbare manier
  knoppen te activeren:
  public JButton createButton(String text, String action, String methodName, Object triggerObject)
  'methodName' is een simpele String, en 'triggerObject' is het object waar deze
  method moet worden opgeroepen.
- Automatische uitlijning van widgets
Voor meer informatie kunt u JSugar-readme.md raadplegen.

## java.util.Date

Doorheen het programma maak ik vaak gebruik van de Date-class uit de Java STL,
om de volgende redenen:
- Uitbreidbaarheid: Door overal eenzelfde type te gebruiken, is het gemakkelijk
  om nieuwe modules toe te voegen, zonder dat daarvoor abstractielagen etc.
  nodig zijn.
- Uniformiteit: Eenzelfde type uit de STL laat de ontwikkelaar toe om door het
  hele programma heen hetzelfde denkpatroon aan te houden; een
  Stringvoorstelling hier, een integer daar, ... veroorzaken problemen en bugs,
  die met deze class voorkomen worden.

## Bedden

Ik heb voor bedden een aparte class aangemaakt, omdat deze een bepaalde state
bijhouden, nml. wanneer ze gereserveerd zijn.


## Reservation
Voor de reservaties heb ik besloten om enkel die data bij te houden die inherent
gerelateerd is aan die reservatie:
- Enkel gereserveerde bedden i.p.v. gereserveerde kamers. Qua uitbreidbaarheid
  heeft dit tot gevolg dat men gemakkelijk kan uitbreiden naar reservaties,
  gespreid over verschillende kamers.


## ReservationView
Merk op hoe in ReservationView de data van de Reservation direct in de GUI wordt
geplaatst.
Dit staat toe om zeer gemakkelijk deze class te hergebruiken voor zowel het
**aanmaken** als het **updaten** van de reservatie.


1	1	import java.util.HashSet;
2	2	import java.util.Date;
3	3
4	4	/**
5	5	* Controller class for the Reservations of this program.
6	6	* Since this program handles a youth hostel, it's imperative that it holds a
7	7	* number of Reservations.
8	8	*
9	9	* ReservationController takes the responsibility of handling the addition,
10	10	* cancelling, editing, ... of Reservations, and the related tasks inherent to
11	11	* these responsibilities, such as reserving beds, generating IDs, ...
12	12	* @author Maarten Vangeneugden - 1438256
13	13	*/
14	14	public class ReservationController {
15	15
16	16	/* Rationale:
17	17	* Normally I'd put this as an interface (Set), but an interface does not
18	18	* inherit from Object, and thus, does not provide clone(). This is
19	19	* necessary, because otherwise, there's no point in having private
20	20	* members.
21	21	*/
22	22	private HashSet<Reservation> reservations; // Holds all Reservations
23	23	private RoomController roomController;
24	24
25	25	/**
26	26	* Creates the ReservationController.
27	27	*
28	28	* WARNING: This program avoids the use of null pointers, but because of
29	29	* circular dependency issues, this class requires that the developer (which
30	30	* means YOU) set the RoomController reference member manually.
31	31	* Be advised that the setRoomController() method will not accept a null
32	32	* pointer.
33	33	*
34	34	* Once again: Set the RoomController reference manually ASAP. Failure to do
35	35	* so will cause this program to blow up. You've been warned.
36	36	* @see ReservationController.setRoomController
37	37	*/
38	38	public ReservationController() {
39	39	this.reservations = new HashSet<>();
40	40	}
41	41
42	42	/**
43	43	* Returns a copy of all Reservations.
44	44	* Emphasis on "copy"; There is no setReservations() for a reason, using
45	45	* this to edit the pointer variable would omit the use of 'private'.
46	46	* @return A verbatim copy of all Reservations.
47	47	*/
48	48	@SuppressWarnings("unchecked")
49	49	public Set<Reservation> getReservations() {
50	50	return (HashSet<Reservation>)this.reservations.clone();
51	51	}
52	52
53	53	/**
54	54	* Generates a unique ID for a new Reservation.
55	55	* This method is to be called when a new Reservation is to be stored.
56	56	* As every Reservation carries an ID, this method searches for a unique
57	57	* one, and returns it.
58	58	* @return An integer, different from all other stored Reservation IDs.
59	59	*/
60	60	public int generateReservationID() {
61	61	/* Small optimization idea:
62	62	* Instead of starting from 0, and incrementing until it's unique, it
63	63	* will take the amount of stored Reservations, and test that as an ID.
64	64	* This may still overlap (by removing an older Reservation), but may be
65	65	* much faster. Consider implemting and testing for effectiveness if
66	66	* generating an ID takes too long.
67	67	*/
68	68	int ID = 0;
69	69	boolean isUnique = false;
70	70	do {
71	71	ID++;
72	72	isUnique = true;
73	73	for(Reservation reservation: this.reservations) {
74	74	if(ID == reservation.getReservationID()) {
75	75	isUnique = false;
76	76	}
77	77	}
78	78	} while(!isUnique);
79	79	// Test:
80	80	for(Reservation reservation: this.reservations) {
81	81	assert reservation.getReservationID() != ID : "Duplicate ID generated!";
82	82	}
83	83	return ID;
84	84	}
85	85
86	86	/**
87	87	* Check if Reservation can be made.
88	88	* Call this method whenever you're planning on adding a new Reservation. It
89	89	* will check the provided requirements (Room facilities, for example), and
90	90	* return whether this Reservation can continue.
91	91	* @param reservation The Reservation to check for possible addition.
92	92	* @pre reservation mustn't be null.
93	93	* @throws NullPointerException if reservation is null.
94	94	* @return True if reservation can be added, False otherwise.
95	95	*/
96	96	public boolean checkReservation(Reservation reservation) {
97	97	if(reservation == null) {
98	98	throw NullPointerException("reservation was a null pointer.");
99	99	}
100	100	if(this.getRoomController().getQualifiedRooms(reservation).size() == 0) {
101	101	return null;
102	102	}
103	103
104	104	/**
105	105	* Adds and confirms the reservation.
106	106	* By calling this method, the given reservation will be stored in the
107	107	* system, and the given room will be filled.
108	108	* You are to collect the necessary data, and assure yourself that all
109	109	* preconditions have been met.
110	110	*
111	111	* The best way to accomplish this, is to only send 'sterile' Reservations
112	112	* as the first parameter. That is: Reservations without reserved Beds,
113	113	* without prior addition to the active Reservations, etc.
114	114	* NOTE: You must check for yourself if the Reservation can take place in
115	115	* this Room! If there are not enough Beds available, an exception will be
116	116	* thrown.
117	117	* @param reservation The Reservation to add.
118	118	* @param room The Room in which the people will reside.
119	119	* @pre room must have enough empty beds.
120	120	* @pre room must accomodate the Reservation's requirements.
121	121	* @pre No parameter must be null.
122	122	* @pre reservation mustn't already be stored in the active Reservations.
123	123	* @post reservation is stored in the active Reservations.
124	124	* @post The Beds in the provided Room are reserved for the Reservation's
125	125	* period.
126	126	* @throws IllegalArgumentException if the given Room can't fulfill the
127	127	* requirements of the Reservation, or occupants is less than 1.
128	128	* @throws NullPointerException if any parameter is a null pointer.
129	129	*/
130	130	public void addReservation(Reservation reservation, Room room) {
131	131	// Contract validation. Null pointers are implicitely checked by calling
132	132	// methods.
133	133	if(occupants < 1)
134	-	throw IllegalArgumentException("An invalid amount of occupants was given.");
135	-	if(occupants > room.getEmptyBeds(reservation.getBegin(), reservation.getEnd()).size())
136	-	throw IllegalArgumentException("The given Room has not enough empty Beds for the Reservation period.");
+	134	throw IllegalArgumentException("The given Room has not enough empty Beds for the Reservation period.");
137	135	if(!this.getRoomController().getQualifiedRooms(reservation).contains(room))
138	136	throw IllegalArgumentException("The given Room cannot meet all requirements of the Reservation.");
139	137	if(this.getReservations().contains(reservation))
140	138	throw IllegalArgumentException("The given Reservation was already included in the active Reservations.");
141	139	// Contract validated
142	140	this.reservations.add(reservation);
143	141	Set<Bed> beds
144	-	for(int i=0; i<occupants; i++) {
145	-
146	-
147	-
148	-
149	-
150	-	// TODO: Add reservation to the set, and add the reserved days to the
151	-	// beds in the given room.
152	-	}
+	142	Set<Bed> reservedBeds = new HashSet<>();
+	143	for(int i=0; i<reservation.getPeople(); i++) {
+	144	beds[i].reservePeriod(reservation.getBegin(), reservation.getEnd());
+	145	reservedBeds.add(beds[i]);
+	146	}
+	147	reservation.setReservedBeds(reservedBeds);
+	148	}
153	149	/**
+	150	/**
154	151	* Cancels and removes the given Reservation.
155	152	* If you want to remove a Reservation, use this method, and provide the
156	153	* Reservation up for removal.
157	154	* This method will take care of related actions, such as releasing Beds.
158	155	* @param reservation The Reservation to be removed.
159	156	* @pre reservation mustn't be null.
160	157	* @pre reservation must be contained in the active Reservations.
161	158	* @post The Reservation is removed from the active Reservations.
162	159	* @post The Beds, previously reserved for this Reservation, are now
163	160	* released, and can be reserved for another Reservation.
164	161	* @throws NullPointerException if reservation is a null pointer.
165	162	* @throws IllegalArgumentException if reservation is not contained in the
166	163	* active Reservations.
167	164	*/
168	165	public void cancelReservation(Reservation reservation) {
169	166	// Contract validation
170	167	if(!this.getReservations().contains(reservation)) {
171	168	throw IllegalArgumentException("The given Reservation was not contained in the active Reservations.");
172	169	}
173	170	if(reservation == null) {
174	171	throw NullPointerException();
175	172	}
176	173	// Contract validated, execute method
177	174	this.reservations.remove(reservation); // Remove from active Reservations
178	175	for(Bed bed: reservation.getReservedBeds()) { // Release reserved Beds
179	176	bed.removeReservationPeriod(reservation.getBegin(), reservation.getEnd());
180	177	}
181	178	// Asserting post conditions are met
182	179	assert !this.getReservation().contains(reservation) : "The reservation is still part of the active Reservations.";
183	180	for(Bed bed: reservation.getReservedBeds()) {
184	181	assert bed.isFree(reservation.getBegin(), reservation.getEnd()) : "One or more of the Beds are still reserved.";
185	182	}
186	183	}
187	184
188	185	}
189	186

1	1
2	2	## GRASP
3	3	Om zoveel mogelijk tegemoet te komen aan de GRASP-richtlijnen, heb ik volgende
4	4	ontwerpkeuzes toegepast voor de verschillende richtlijnen.
5	5
6	6	### High cohesion & Low coupling
7	7	- Veel classes zijn totaal van elkaar losgekoppeld. Een goed voorbeeld hiervan
8	8	is Bed; Bed weet niet over dat er Reservaties bestaan, zelfs niet in welke
9	9	Room het 'staat'.
10	10	- Als er toch gekoppeld moet worden, dan blijft dit tot een minimum beperkt; Een
11	11	Room weet wel welke Bedden het heeft, maar niet hoe deze gebruikt worden, een
12	12	Reservation weet wel welke Bedden voor hem gereserveerd zijn, maar heeft geen
13	13	weet van welke kamer dat deze staat.
14	14
+	15	zijn deze vaak verplicht om van veel verschillende classes op de hoogte te
+	16	zijn.
+	17
15	18	### Indirectie
16	19	- In plaats van functionaliteit toe te wijzen aan class X om met class Y te
17	20	interageren, wordt er vaak gebruik gemaakt van een class Z, die deze
18	21	verantwoordelijkheid op zich neemt.
19	22	- Dit wordt toegepast d.m.v. een MVC-structuur, waarin de \*Controller-classes
20	23	als 'tussenpersoon' werken.
21	24	- Dit komt ook tegemoet aan de eigenschappen van Information Expertise.
22	25
23	26	### Creator
24	27	- Controllers staan ook in als zgn. Creators van de models die ze beheren. Ze
25	28	voldoen dan ook aan de eigenschappen zoals
26	29	[hier](https://en.wikipedia.org/wiki/GRASP_(object-oriented_design)#Creator)
27	30	opgesomd wordt.
28	31
29	32
30	33	## SOLID
31	34
32	35	### Single Responsibility
33	36
34	37	## Algemene keuzes ter bevordering codekwaliteit
35	38
36	39	### Null pointers
37	40	Het valt misschien op dat ik doorheen mijn programma in veel contracten eis dat
38	41	geen enkele parameter een zgn. null pointer is.
39	42
40	43	Het gebruik van null pointers staat garant voor een overvloed aan moeilijk te
41	44	vinden bugs die (door het design van objectgeörienteerd programmeren) enorm diep
42	45	kunnen doorpropageren.
43	46
44	47	Ik maak er een kerntaak van dat, als er aan mijn programma gewerkt wordt, de
45	48	programmeur zichzelf steeds kan garanderen dat alle data die hij
46	49	ontvangt, valide data is.
47	50	Op deze manier valt er een hele last van de schouders van de programmeur; een
48	51	reeks fouten worden voorkomen, simpelweg door een strikt schema aan te houden.
49	52
50	53	Het controleren op null pointers wordt op 2 manieren gedaan:
51	54	- Gebruik van methods aanwezig in het gegeven type. Als de gegeven variabele
52	55	een null pointer is, zal het programma direct crashen, en een
53	56	NullPointerException geven.
54	57	- Expliciet testen of var == null. Wordt toegepast op parameters die direct
55	58	als members opgeslagen dienen te worden.
56	59
57	60	Deze (contractuele) controle laat toe dat, mocht er een null pointer gebruikt
58	61	worden, het programma de programmeur hiervan direct op de hoogte stelt, en dit
59	62	op het laagst mogelijke niveau (namelijk de eerste method waar deze waarde
60	63	gebruikt wordt).
61	64
62	65	### Cloning
63	66	members 'private' maken (encapsuleren) is volledig nutteloos als men getters en
64	67	setters op deze members toepast; In Java worden references doorgegeven (m.u.v.
65	68	primitives), die de hele notie van encapsulatie voorbijgaan (bij sommige types).
66	69	Een voorbeeld hiervan is het privatiseren van een Set<T>-member: men kan daar
67	70	een 'getSet()'-method op plaatsen, en dan toch de inhoud van deze 'private'
68	71	aanpassen.
69	72
70	73	Ik heb geopteerd om, waar van toepassing, deze variabelen te 'clonen', om zo
71	74	exacte kopieën terug te geven.
72	75	Deze manier van werken brengt enkele voordelen teweeg:
73	76	- Zeer defensief programmeren; De ontwikkelaar kan geen members aanpassen als
74	77	dat niet de bedoeling was
75	78	- Duidelijkheid code: getSet().clear() zal de member niet meer leegmaken. Om dat
76	79	te doen, moet men gebruikmaken van de method die daarvoor bedoeld is:
77	80	setSet(clearedSet)
78	81
79	82	### Inheritance
80	83	Overerving is een goed concept over het algemeen, maar niet in OOP.
81	84	De problemen omtrent impliciet gedrag en onnodige state zijn al te vaak
82	85	beschreven met OOP-inheritance.
83	86
84	87	Ik heb in mijn programma geen gebruik gemaakt van inheritance, exact omwille van
85	88	de problemen die het voortbrengt, zeker in termen van herbruikbaarheid en
86	89	robuustheid, wat toch zware vereisten waren voor deze opdracht.
87	90
88	91	Ik heb al mijn problemen makkelijk kunnen oplossen d.m.v. compositie.
89	92
90	93	### Benaming variabelen
91	94	Doorheen mijn programma maak ik heel veel gebruik van dezelfde benamingen.
92	95	Bijvoorbeeld: Een variabele van het type Reservation zal haast altijd
93	96	'reservation' heten, een Set van een bepaald type zal de naam van datzelfde type
94	97	dragen, in het meervoud, ...
95	98
96	99	Sommige programmeurs gebruiken liever afkortingen (bv. 'reservation' -->
97	100	'resv'), omdat dit sneller schrijft.
98	101
99	102	Naar mijn mening moet men bij deze werkwijze inleveren aan leesbaarheid, vooral
100	103	wanneer iemand die nog nooit met de code gewerkt heeft, dit programma moet
101	104	overnemen.
102	105
103	106	Daarnaast zorgt de consistentie van woordgebruik ervoor dat een andere
104	107	programmeur, doorheen het hele programma dezelfde context in zijn/haar gedachten
105	108	kan gebruiken.
106	109
107	110
108	111
109	112
110	113	------------------------------------------------------------ TODO
111	114	## Toepassing types/classes
112	115	Doorheen het programma heb ik getracht zoveel mogelijk gebruik te maken van
113	116	types/classes die
114	117	- Veelvoorkomend zijn in de Java STL (Zoals String, Set, List, ...)
115	118	- primitief zijn (ints, ...), omdat deze operatoren hebben en de code
116	119	leesbaarder maken
117	120
118	121	Een goed voorbeeld hiervan zijn bv. de faciliteiten:
119	122	I.p.v. een aparte "Facility"-class te maken, heb ik de verschillende
120	123	faciliteiten voorgesteld door een simpele String. De voordelen van deze aanpak
121	124	zijn ook direct duidelijk:
122	125	- Betekenis is direct duidelijk; de faciliteit letterlijk in de code vernoemd
123	126	- Makkelijke interactie met GUI, die sowieso Strings vraagt voor bv. JLabel
124	127	- Uitbreidbaarheid wordt bekomen door simpelweg een nieuwe String te
125	128	introduceren
126	129
127	130	## View en GUI
128	131	Werken met GUI's is vaak tijdrovend en veroorzaakt snel errors, zeker met bv.
129	132	anonieme methods, exceptions, ...
130	133	Alhoewel mijn programma grotendeels in een MVC-stijl is geschreven, maken de
131	134	view-classes (RegistrationView, SearchView, ...) achterliggend gebruik van een
132	135	zelfgemaakt framework om makkelijk vensters te maken.
133	136	Dit kleine framework is een persoonlijk hobbyproject dat ik JSugar noem.
134	137	Het biedt een heleboel voordelen, vergeleken met elk GUI-venster zelf opstellen:
135	138	- Vaak gebruikte GUI-widgets (zoals een label, textfield) worden aangemaakt en
136	139	toegevoegd door slechts 1 method op te roepen
137	140	- JSugar maakt gebruik van reflectie om op een leesbare en uitbreidbare manier
138	141	knoppen te activeren:
139	142	public JButton createButton(String text, String action, String methodName, Object triggerObject)
140	143	'methodName' is een simpele String, en 'triggerObject' is het object waar deze
141	144	method moet worden opgeroepen.
142	145	- Automatische uitlijning van widgets
143	146	Voor meer informatie kunt u JSugar-readme.md raadplegen.
144	147
145	148	## java.util.Date
146	149
147	150	Doorheen het programma maak ik vaak gebruik van de Date-class uit de Java STL,
148	151	om de volgende redenen:
149	152	- Uitbreidbaarheid: Door overal eenzelfde type te gebruiken, is het gemakkelijk
150	153	om nieuwe modules toe te voegen, zonder dat daarvoor abstractielagen etc.
151	154	nodig zijn.
152	155	- Uniformiteit: Eenzelfde type uit de STL laat de ontwikkelaar toe om door het
153	156	hele programma heen hetzelfde denkpatroon aan te houden; een
154	157	Stringvoorstelling hier, een integer daar, ... veroorzaken problemen en bugs,
155	158	die met deze class voorkomen worden.
156	159
157	160	## Bedden
158	161
159	162	Ik heb voor bedden een aparte class aangemaakt, omdat deze een bepaalde state
160	163	bijhouden, nml. wanneer ze gereserveerd zijn.
161	164
162	165
163	166	## Reservation
164	167	Voor de reservaties heb ik besloten om enkel die data bij te houden die inherent
165	168	gerelateerd is aan die reservatie:
166	169	- Enkel gereserveerde bedden i.p.v. gereserveerde kamers. Qua uitbreidbaarheid
167	170	heeft dit tot gevolg dat men gemakkelijk kan uitbreiden naar reservaties,
168	171	gespreid over verschillende kamers.
169	172
170	173
171	174	## ReservationView
172	175	Merk op hoe in ReservationView de data van de Reservation direct in de GUI wordt
173	176	geplaatst.
174	177	Dit staat toe om zeer gemakkelijk deze class te hergebruiken voor zowel het
175	178	aanmaken als het updaten van de reservatie.
176	179

1	1	* Main window for the hostel program.
2	2	* This class creates some sort of "main menu screen". It displays a concise set
3	3	* of buttons, that allow the user to reach all parts of the program's GUI.
4	4	* To be called as soon as the program is started (Essentially from the Main
5	5	* class).
6	6	* @author Maarten Vangeneugden - 1438256
7	7	*/
8	8	public class MainWindow {
9	9
10	10	private ReservationController reservationController;
11	11	private RoomController roomController;
12	12
13	13	public MainWindow(ReservationController reservationController, RoomController roomController) {
14	14	this.reservationController = reservationController;
15	15	this.roomController = roomController;
16	16
17	17	Window window = new Window("Main menu");
18	18	window.createButton("New reservation", "", "addReservation", this);
19	19	window.createButton("Search screen", "", "openSearchView", this);
20	20	}
21	21
22	22	public void openSearchView() {
23	23	SearchView sv = new SearchView(this.reservationController, this.roomController);
24	24	}
25	25
26	26	public void addReservation() {
27	27	Reservation reservation = new Reservation(this.reservationController, this.roomController);
28	-	ReservationView rv = new ReservationView(reservation, this.reservationController, this.roomController);
+	28	ReservationView rv = new ReservationView(reservation, this.reservationController, this.roomController);
29	29
30	-	}
31	30
32	31	}
33	32

1	1	import java.util.HashSet;
2	2	import java.util.Date;
3	3
4	4	/**
5	5	* Represents a reservation in a hostel.
6	6	* Reservation is a simple class that allows one to store reservation
7	7	* information, request it when necessary, and so on.
8	8	* Certain methods are provided for interaction, which use contracts to assert
9	9	* proper functioning.
10	10	*
11	11	* Note: There is a form of redundancy in this class.
12	12	* Reservation holds a Set of Beds, and an integer, indicating the amount of
13	13	* people that are in this Reservation.
14	14	* Normally, the amount of people in the Reservation is determined by the amount
15	15	* of reserved Beds, because the amount of Beds implied the amount of people to
16	16	* facilitate.
17	17	* Because of the design of this program, I've weighed the advantages and
18	18	* disadvantages of holding this implication, of using a seperate member
19	19	* explicitely indicating the amount of people.
20	20	*
21	21	* I've chosen the latter option. It scales better in terms of weird
22	22	* afterthoughts ("I also want to make people sleep on the floor"), but being
23	23	* explicit is also a tad easier to manage. It also allows the other classes to
24	24	* be far more decoupled from Reservation (otherwise, they'd have to check for
25	25	* errors every time themselves, hindering cohesiveness).
26	26	*
27	27	* To overcome the possible difference, I've made it so that, every time, the
28	28	* relation between the values is changed (the people in the Reservation
29	29	* changes, for example), the class automatically checks if the values are
30	30	* corresponding. If they're not, a warning is printed to system.out.err,
31	31	* informing about the fact that there's a discrepancy.
32	32	*
33	33	* I think that's the best way to overcome this problem.
34	34	* @author Maarten Vangeneugden - 1438256
35	35	*/
36	36	public class Reservation {
37	37
38	38	// Members
39	39	private String groupName;
40	40	private Date begin;
41	41	private Date end;
42	42	private Set<Bed> reservedBeds;
43	43	private int people; // The amount of people in this Reservation
44	44	private int reservationID;
45	45	private String roomType; // Room type requested by group
46	46	private Set<String> roomFacilities; // Requested room facilities
47	47	private Set<Date> breakfastDays; // Set of days the group wants breakfast
48	48	// Controllers
49	49	private RoomController roomController;
50	50	private ReservationController reservationController;
51	51
52	52	/**
53	53	* Create a new Reservation.
54	54	* Be aware about the limitations of a Reservation: it's not the
55	55	* Reservation's duty to check whether the provided Beds are properly
56	56	* reserved; take care of this accordingly.
57	57	*
58	58	* Some information is implicit. For example: The size of the set of
59	59	* reserved Beds implies the amount of people in the group; no breakfast
60	60	* days implies no breakfast, ...
61	61	* @param groupName The name of the group.
62	62	* @param people The amount of people that are reserving.
63	63	* @param begin The date that the Reservation begins.
64	64	* @param end The date that the Reservation ends.
65	65	* @param reservedBeds The set of Beds reserved and assigned to this
66	66	* Reservation.
67	67	* @param roomType The requested room type.
68	68	* @param roomFacilities The set of all requested room facilities.
69	69	* @param breakfastDays A set of all days that the group wants breakfast.
70	70	* @param reservationID An ID for this reservation, to differentiate from
71	71	* other Reservations.
72	72	* @pre No parameter must be a null pointer.
73	73	* @pre people must be a natural number, different from 0.
74	74	* @pre begin must come before end.
75	75	* @pre All dates in breakfastDays must fall between begin and end.
76	76	* @pre No string parameter may be empty.
77	77	* @post The amount of people in the Reservation is determined by the amount
78	78	* of reserved Beds.
79	79	* @throws NullPointerException if any parameter is a null pointer.
80	80	* @throws IllegalArgumentException if any of the other preconditions is not
81	81	* met.
82	82	*/
83	83	public Reservation(String groupName, int people, Date begin, Date end, Set<Bed> reservedBeds, String roomType, Set<String> roomFacilities) {
84	-	// Contract validation:
+	84	// Contract validation:
85	85	if(people < 1) {
86	86	throw IllegalArgumentException("The amount of people should be at least 1.");
87	87	}
88	88	if(!begin.before(end)) {
89	89	throw IllegalArgumentException("The begin date occurs after the end date.");
90	90	}
91	91	if(groupName.isEmpty() \|\| roomType.isEmpty()) {
92	92	throw IllegalArgumentException("groupName and/or roomType were empty strings.");
93	93	}
94	94	for(String roomFacility: roomFacilities) {
95	95	if(roomFacility.isEmpty()) {
96	96	throw IllegalArgumentException("One of the room facilities was an empty string.");
97	97	}
98	98	}
99	99	for(Date breakfastDay : breakfastDays) {
100	100	if(breakfastDay.before(begin) \|\| breakfastDay.after(end)) {
101	101	throw IllegalArgumentException("One of the breakfast days occurs before/after the reservation period.");
102	102	}
103	103	}
104	104	// Contract validated, execute constructor
105	105	this.groupName = groupName;
106	106	this.people = people;
107	107	this.beginDate = begin;
108	108	this.endDate = end;
109	109	this.reservedBeds = reservedBeds;
110	110	this.reservationID = reservationID;
111	111	this.roomType = roomType;
112	112	this.roomFacilities = roomFacilities;
113	113	this.breakfastDays = breakfastDays
114	-	}
+	114	}
+	115
+	116	/**
+	117	* Construct template Reservation.
+	118	* Use this constructor if you need to create an empty/new Reservation.
+	119	* It omits the standard restrictions (for example, the group name will be
+	120	* empty) to accomodate for the expected usage of this Reservation.
+	121	*/
+	122	public Reservation() {
+	123	this.groupName = "";
+	124	this.people = 1;
+	125	this.beginDate = new Date();
+	126	this.endDate = new Date();
+	127	this.reservedBeds = new HashSet<>();
+	128	this.reservationID = 0;
+	129	this.roomType = "";
+	130	this.roomFacilities = new HashSet<>();
+	131	this.breakfastDays = new HashSet<>();
+	132	}
115	133
116	134	/**
117	135	* Checks whether the amount of people corresponds with the reserved Beds.
118	136	* Call this method whenever a change in the amount of Beds, or the amount
119	137	* of people is made, or, whenever you need to assure consistency.
120	138	*
121	139	* It also prints a warning to system.out.err to inform about a discrepancy,
122	140	* should one be found.
123	141	*
124	142	* @return True if the counts are consistent, false otherwise.
125	143	*/
126	144	private boolean checkPeopleCountConsistency() {
127	145	int people = this.getPeople();
128	146	int beds = this.getReservedBeds().size();
129	147	if(people != beds) {
130	148	system.out.err("There's a discrepancy in the amount of people in Reservation"+
131	149	this.reservationID +":");
132	150	system.out.err("People: "+String.valueOf(people));
133	151	system.out.err("Reserved Beds: "+String.valueOf(beds));
134	152	return false;
135	153	}
136	154	return true;
137	155	}
138	156
139	157	/**
140	158	* Set the group name for this Reservation.
141	159	* @param groupName The new group name.
142	160	* @pre groupName mustn't be empty, or a null pointer.
143	161	* @post The group name is changed to the given name.
144	162	* @throws NullPointerException if groupName is a null pointer.
145	163	* @throws IllegalArgumentException if groupName is an empty String.
146	164	*/
147	165	public void setGroupName(String groupName) {
148	166	if(groupName.isEmpty())
149	167	throw IllegalArgumentException("groupName is an empty String.");
150	168	this.groupName = groupName;
151	169	}
152	170
153	171	/**
154	172	* Retrieve the current group name.
155	173	* @return The group name of this Reservation.
156	174	*/
157	175	public String getGroupName() {
158	176	return this.groupName;
159	177	}
160	178
161	179	/**
162	180	* Get amount of people in this Reservation.
163	181	* @post A warning will be printed to system.out.err if the amount of people
164	182	* is inconsistent with the amount of reserved Beds.
165	183	* @see Reservation.checkPeopleCountConsistency
166	184	* @return The amount of people in this Reservation.
167	185	*/
168	186	public int getPeople() {
169	187	this.checkPeopleCountConsistency();
170	188	return this.people;
171	189	}
172	190
173	191	/**
174	192	* Set the amount of people for this Reservation.
175	193	* Note that this method will not notify you if the new amount of people is
176	194	* equal to the previous amount.
177	195	*
178	196	* This method will print
179	197	* @param people The new amount of people in this Reservation.
180	198	* @pre people must be at least 1.
181	199	* @post A warning will be printed to system.out.err if the amount of people
182	200	* is inconsistent with the amount of reserved Beds.
183	201	* @post The amount of people is changed to the given value.
184	202	* @throws IllegalArgumentException if people is less than 1.
185	203	*/
186	204	public void setPeople(int people) {
187	205	if(people < 1) {
188	206	throw IllegalArgumentException("people must be at least 1.");
189	207	}
190	208	this.people = people;
191	209	this.checkPeopleCountConsistency();
192	210	}
193	211	/**
194	212	* Set the begin date for this Reservation.
195	213	* @param begin The new begin date.
196	214	* @pre begin mustn't be a null pointer.
197	215	* @pre begin must come strictly before the end date.
198	216	* @post The begin date is updated accordingly.
199	217	* @throws NullPointerException if begin is a null pointer.
200	218	* @throws IllegalArgumentException if begin comes after the end date.
201	219	*/
202	220	public void setBegin(Date begin) {
203	221	if(!begin.before(this.getEnd()))
204	222	throw IllegalArgumentException("begin comes after the end date.")
205	223	this.begin = begin;
206	224	}
207	225
208	226
209	227
210	228	/**
211	229	* Set the end date for this Reservation.
212	230	* @param end The new end date.
213	231	* @pre end mustn't be a null pointer.
214	232	* @pre end must come strictly after the begin date.
215	233	* @post The end date is updated accordingly.
216	234	* @throws NullPointerException if end is a null pointer.
217	235	* @throws IllegalArgumentException if end comes after the end date.
218	236	*/
219	237	public Date getDate() {
220	238	return date;
221	239	}
222	240
223	241	public void setReservedBeds(Set<Bed> reservedBeds) {
224	242	this.reservedBeds = reservedBeds;
225	243	this.checkPeopleCountConsistency();
226	244	}
227	245
228	246	public Set<Bed> getReservedBeds() {
229	247	return reservedBeds;
230	248	this.checkPeopleCountConsistency();
231	249	}
232	250
233	251	// TODO: Write documentation for all of these, even though it's all mostly
234	252	// copy/pasting. pfffff
235	253	public void setReservationID(int reservationID) {
236	254	this.reservationID = reservationID;
237	255	}
238	256
239	257	public int getReservationID() {
240	258	return reservationID;
241	259	}
242	260
243	261	public void setRoomType(String roomType) {
244	262	this.roomType = roomType;
245	263	}
246	264
247	265	public String getRoomType() {
248	266	return roomType;
249	267	}
250	268
251	269	public void setRoomFacilities(Set<String> roomFacilities) {
252	270	this.roomFacilities = roomFacilities;
253	271	}
254	272
255	273	public Set<String> getRoomFacilities() {
256	274	return roomFacilities;
257	275	}
258	276
259	277	/**
260	278	* Calculates the price of the Reservation, based on its current state.
261	279	* Price table:
262	280	* - 20/person/day
263	281	* - 5 less in low season, 5 more in high season
264	282	* - 4/breakfast ordered
265	283	* - If room is fully booked by the group --> 10% discount
266	284	* @return The price in euros.
267	285	*/
268	286	public int getPrice() {
269	287	int totalPrice = 0;
270	288	// Jan - Apr: Mid
271	289	// May - Aug: High
272	290	// Sep - Dec: Low
273	291
274	292	// Calculate bed prices
275	293	int month = this.getDate().getMonth();
276	294	int bedPrice = 20;
277	295	if(month >=8) { // From September:
278	296	bedPrice -= 5;
279	297	} else if(month >=4) { // From May:
280	298	bedPrice += 5;
281	299	}
282	300	totalPrice += (this.getReservedBeds().size() * this.getNights() * bedPrice);
283	301	// Calculate price for breakfasts
284	302	int breakfasts = this.getBreakfastDays().length;
285	303	totalPrice += breakfasts * this.getReservedBeds().size();
286	304	// Check if eligible for discount
287	305	for(Room room: roomController.getRooms()) {
288	306	Set<Bed> roomBeds = room.getBeds();
289	307	if(roomBeds.containsAll(this.reservedBeds)) {
290	308	double discount = (double)totalPrice * 0.1;
291	309	totalPrice -= (int)discount;
292	310	}
293	311	}
294	312	return totalPrice;
295	313	}
296	314
297	315
298	316
299	317
300	318
301	319
302	320
303	321	public void setBreakfastDays(int[] breakfastDays) {
304	322	this.breakfastDays = breakfastDays;
305	323	}
306	324	public int[] getBreakfastDays() {
307	325	return this.breakfastDays;
308	326	}
309	327
310	328	}
311	329

1	1	import java.util.Set;
2	2	import java.util.HashSet;
3	3	import java.util.Date;
4	4	/**
5	5	* Creates a view screen that allows interaction with the reservation.
6	6	* This window will place the reservation details in editable fields, so its
7	7	* state can be adapted.
8	8	* It then also adds a couple of buttons; add/update/cancel, with their
9	9	* respective actions. These will then be passed to the ReservationController.
10	10	* It will not allow to add/update a reservation if dates overlap, i.e. beds
11	11	* can't be reserved for that period.
12	12	* @author Maarten Vangeneugden - 1438256
13	13	*/
14	14	public class ReservationView {
15	15
16	16	private Reservation reservation;
17	17	private Window window;
18	18
19	19	private ReservationController rc;
+	20	private ReservationController rc;
20	21	private RoomController roc;
21	22
22	23	// GUI widgets:
23	-	private JTextField nameField;
+	24	private JTextField nameField;
24	25	private JSpinner amountPeopleField;
25	26	private JTextField dateField;
26	27	private JSpinner durationField;
27	28	private JRadioButton[] typeField;
28	29	private JCheckBox showerField;
29	30	private JCheckBox bathField;
30	31	private JCheckBox minibarField;
31	32	private JCheckBox aircoField;
32	33
33	34
34	35	public ReservationView(Reservation reservation, ReservationController rc, RoomController roc) {
+	36	* Construct a window to edit a Reservation.
+	37	* This window presents its caller with the necessary tools to edit the
+	38	* given Reservation, and save it in the system.
+	39	*
+	40	* By sending it an empty Reservation, you can add a new Reservation to the
+	41	* system.
+	42	* This class is built in a way that allows it to be used for both creating
+	43	* new Reservations, and updating/changing existing Reservations.
+	44	* Existing Reservations can also be removed by clicking the appropriate
+	45	* button.
+	46	* @param reservation The Reservation that will be updated.
+	47	* @param rc The ReservationController class.
+	48	* @param roc The RoomController class.
+	49	* @pre No parameter may be a null pointer.
+	50	* @post A window is displayed with GUI widgets, which are filled in
+	51	* according to the state of reservation.
+	52	* @throws NullPointerException if any parameter is a null pointer.
+	53	*/
+	54	public ReservationView(Reservation reservation, ReservationController rc, RoomController roc) {
35	55	this.rc = rc;
+	56	if(rc == null \|\| roc == null \|\| reservation == null)
+	57	throw NullPointerException("One or more of the given parameters is a null pointer.");
+	58	// Contract validated
+	59	this.rc = rc;
36	60	this.roc = roc;
37	61
38	62	this.reservation = reservation;
39	63	this.window = new Window("Reservation screen");
40	64	this.addFields();
41	65	}
42	66
43	67	public void setReservation(Reservation reservation) {
44	68	this.reservation = reservation;
45	69	}
46	70
47	71	public Reservation getReservation() {
48	72	return reservation;
49	73	}
50	74
51	75	private void addFields() {
+	76	* Add the necessary fields to the window.
+	77	* This method inspects the Reservation, and copies the included information
+	78	* to the widget's content.
+	79	*/
+	80	private void addFields() {
52	81	this.window.createLabel("Group name");
53	82	this.nameField = window.createTextField(this.reservation.getGroupName());
54	83	this.window.createLabel("Amount of people");
55	84	this.amountPeopleField = window.createSpinner(1, 20);
56	-	// Formatting date for the date field:
+	85	// Formatting date for the date field:
57	86	this.window.createLabel("date");
58	-	Date date = this.reservation.getDate();
59	-	String day = String.valueOf(date.getDate());
60	-	String month = String.valueOf(date.getMonth()+1);
61	-	String year = String.valueOf(date.getYear()+1900);
62	-	this.dateField = window.createTextField(day +" "+ month +" "+ year);
63	-	this.window.createLabel("Duration");
64	-	this.durationField = window.createSpinner(1, 355);
65	-	String[] types = new String[3];
66	-	types[0] = "Male";
67	-	types[1] = "Female";
68	-	types[2] = "Mixed";
69	-	this.typeField = this.window.createRadioButtons(types);
+	87	this.beginDateField = window.createTextField(this.reservation.getBegin().toString());
+	88	this.window.createLabel("End date");
+	89	this.endDateField = window.createTextField(this.reservation.getEnd().toString());
+	90	String[] types = {"Male", "Female", "Mixed"};
+	91	this.typeField = this.window.createRadioButtons(types);
70	92	this.showerField = this.window.createCheckbox("Shower");
+	93	// it is, and then already check the corresponding radio button.
+	94	this.showerField = this.window.createCheckbox("Shower");
71	95	this.bathField = this.window.createCheckbox("Bath");
72	96	this.minibarField = this.window.createCheckbox("Minibar");
73	97	this.aircoField = this.window.createCheckbox("Airco");
74	98
75	-
76	-	this.window.createButton("Add/Update reservation", "", "addReservation", this);
+	99	// check accordingly.
+	100	this.window.createButton("Add/Update reservation", "", "addReservation", this);
77	101	this.window.createButton("Cancel reservation", "", "cancelReservation", this);
78	-	}
+	102	}
79	103
80	104
81	-
82	-	public void addReservation() {
+	105	* Start the addition of this Reservation to the system.
+	106	* This method will check the current fields, and update the Reservation
+	107	* with those values. In doing so, the validity of the values is checked
+	108	* (formatting, begin date before end date, ...).
+	109	* If everything is okay, the method will check if these changes are
+	110	* possible in the current system; are there enough empty beds?
+	111	*
+	112	* If everything is okay, the changes will be propagated to the
+	113	* Reservation's state, and (if it's a new Reservation) will be added to the
+	114	* system's active Reservations.
+	115	*/
+	116	public void addReservation() {
83	117	// Collect all data from the fields
84	118	String name = this.nameField.getText();
85	119	String date = this.dateField.getText();
86	-	// Extracting date data:
87	-	String[] dateParts = date.split(" ");
88	-	int day = Integer.parseInt(dateParts[0]);
89	-	int month = Integer.parseInt(dateParts[1]);
90	-	int year = Integer.parseInt(dateParts[2]);
91	-	Date actualDate = new Date(day, month-1, year-1900);
92	-
93	-	int amount = (Integer)this.amountPeopleField.getValue();
94	-	int duration = (Integer)this.durationField.getValue();
95	-	String type = "";
+	120	try {
+	121	beginDate = DataFormat.parse(this.beginDateField.getText());
+	122	endDate = DataFormat.parse(this.endDateField.getText());
+	123	}
+	124	catch(ParseException e) {
+	125	this.window.messageDialog("Not all date fields were properly formatted.");
+	126	return;
+	127	}
+	128	int people = (Integer)this.amountPeopleField.getValue();
+	129	String type = "";
96	130	for(int i=0; i<this.typeField.length; i++) {
97	131	if(this.typeField[i].isSelected()) {
98	132	type = this.typeField[i].getText();
99	133	break;
100	134	}
101	135	}
102	136	Set<String> facilities = new HashSet<>();
103	137	if(this.showerField.isSelected()) {
104	138	facilities.add("Shower");
105	139	}
106	140	if(this.bathField.isSelected()) {
107	141	facilities.add("Bath");
108	142	}
109	143	if(this.minibarField.isSelected()) {
110	144	facilities.add("Minibar");
111	145	}
112	146	if(this.aircoField.isSelected()) {
113	147	facilities.add("Airco");
114	148	}
115	149
116	150	Set<Room> possibleRooms = this.roc.getQualifiedRooms(actualDate, duration, type, facilities);
117	-	if(possibleRooms.size() == 0) {
+	151
+	152	//Set<Room> possibleRooms = this.roc.getQualifiedRooms(actualDate, duration, type, facilities);
+	153	// TODO: Refactor upper method to work with the Reservation.
+	154	// TODO: Implement all checks of valid data above this line!
+	155
+	156	// Data validated; Try finding appropriate beds
+	157	if(possibleRooms.size() == 0) {
118	158	boolean tryAgain = this.window.confirmDialog("No rooms met the requirements! Would you like to continue and change the parameters?");
119	159	if(!tryAgain) {
120	160	// TODO close window
121	161	}
122	162	}
123	163	else {
124	164	// Determine end date:
125	-	long beginDate = actualDate.getTime();
126	-	long endDate = beginDate + (duration * 24 * 60 * 60 * 1000);
127	-	Date actualEndDate = new Date(endDate);
128	-	Room pickedRoom = null;
129	165	for(Room room: possibleRooms) {
130	166	if(room.getEmptyBeds(actualDate, actualEndDate).size() < room.getBeds().size()) {
131	167	// First, fill the rooms that are partially filled.
132	168	pickedRoom = room;
133	169	break;
134	170	}
135	171	}
136	172	if(pickedRoom == null) { // If still no room, pick an empty room
137	173	for(Room room: possibleRooms) {
138	174	if(room.getEmptyBeds(actualDate, actualEndDate).size() >= amount) {
139	175	pickedRoom = room;
140	176	break;
141	177	}
142	178	}
143	179	}
144	180	assert pickedRoom != null;
145	181	// TODO: Set reservation fields here!
146	182	this.rc.addReservation(reservation, pickedRoom);
147	183
148	184	// Confirm and show price:
149	185	int price = this.reservation.getPrice();
150	186	this.window.confirmDialog("Reservation confirmed! Price: " +String.valueOf(price));
151	187	}
152	188
153	189	}
154	190	public void cancelReservation() {
155	-	// TODO: Close the window. That's all.
+	191	public void removeReservation() {
+	192	// TODO: Close the window. That's all.
156	193	}
157	194	}
158	195