Learning Outcomes:

• Gain more confidence programming in Java.
• Design an object-oriented programming (OOP) solution to a problem.
• Apply OOP concepts such as inheritance, polymorphism, and encapsulation (information hiding).

Table of Contents

• Recommended Approach
• The Venue Hire System
• Files Provided
• Checkpoints
• OOP Requirements
• The Commands
• Tasks
  • Task 1 (Checkpoint #1)
  • Task 2 (Checkpoint #2)
  • Task 3 (Checkpoint #2)
• Marking Scheme
• Important Instructions

Recommended Approach

To make sure that your machine is properly set for doing the assignment (and all assignments in this course), refer to the FAQ on the course website.

Then it’s a matter of:

• Clone the GitHub repository.
• Use Visual Studio Code for doing the assignment.
• Use the graphical “Testing” view in Visual Studio Code to run the tests (details below).
• As a final check before submitting, use the Maven wrapper to check that everything compiles and the test cases pass (details below).

To help you get started, you might want to watch the following video:

Let’s begin!

The Venue Hire System

Venue hire systems can be complex. In this assignment, you will be asked to design and implement a simple venue hire system. The system will be able to store information about venues and their bookings.

The system you develop is one that the venue hire company will use to manage their venues and bookings. The system will be used by the venue hire company’s staff to:

• View details of all the venues,
• Create new venues,
• View details of all the bookings for a venue,
• Create new bookings for a venue,
• Add catering, music, and floral services to a booking,
• View the invoice for a booking.

Due to the venue hire company’s limited budget (it’s apparently tough being a venue hire company), we will only design for them a terminal-driven interface. This means that the system will be controlled by a menu system that will be displayed on the terminal. The menu will allow the staff member to select from a list of commands. The staff member will be able to select a command by typing its code, and any arguments it expects. Some commands require additional options, which are prompted by the system one at a time. The system will then execute the appropriate action.

The menu of commands will be displayed on the terminal as follows:

PRINT_VENUES    [no args]       Print details of all the venues
CREATE_VENUE    [4 arguments]   Create a new venue with the given <VENUE_NAME>, <VENUE_CODE>, <VENUE_CAPACITY>, and <HIRE_FEE>
SET_DATE        [1 argument]    Set the system's date to the specified date in DD/MM/YYYY format
PRINT_DATE      [no args]       Print the system's current date
MAKE_BOOKING    [no args]       Request a new booking
PRINT_BOOKINGS  [1 argument]    Print all bookings for the specified <VENUE_CODE>
ADD_CATERING    [1 argument]    Add catering service to the specified <BOOKING_REFERENCE>
ADD_MUSIC       [1 argument]    Add music service to the specified <BOOKING_REFERENCE>
ADD_FLORAL      [1 argument]    Add floral service to the specified <BOOKING_REFERENCE>
VIEW_INVOICE    [1 argument]    View full invoice details for the specified <BOOKING_REFERENCE>
HELP            [no args]       Print usage
EXIT            [no args]       Exit the application

You have been given an incomplete implementation of the system, with only the command line interface implemented. You need to implement the commands using Object-Oriented Programming!

Here’s the solution in action (for Task 1 only), to give you an idea of what you are expected to implement:

Files Provided

Below is a list of the files provided to you for this assignment. You should not modify any of the files provided to you, except for the VenueHireSystem.java file (where you will need to implement the logic for the commands), and the MainTest.java file (where you can add your own test cases if you wish).

src/main/java/nz/ac/auckland/se281/Main.java

This class implements the command line interface (CLI).

You should not modify this class.

src/main/java/nz/ac/auckland/se281/MessageCli.java

This class declares most of the messages of the system.

You should not modify this class, but you are encouraged to use it.

You are encouraged to refer to these messages in the code you write, as it will be easier for you to avoid spelling and formatting issues that might otherwise cause you to fail test cases.

There are two ways to use these messages in your code:

• Get the message so that you can print it yourself by calling the getMessage() method, or
• Request for the message to be printed directly by calling the printMessage() method.

You will notice that most of the messages have %s placeholders in their values. For example, have a look at the definition of the PROFILE_CREATED message:

public enum MessageCli {
	// ...
	VENUE_SUCCESSFULLY_CREATED("Successfully created venue '%s' (%s)."),
	// ...
}

There are two %s placeholders, which means this message expects you to pass two arguments when you want to getMessage() or printMessage() it.

For example, consider you want to construct the message "Successfully created venue 'Frugal Fiesta Hall' (FFH)."

If you want to get the message to print it yourself, you would do:

String message = MessageCli.VENUE_SUCCESSFULLY_CREATED.getMessage("Frugal Fiesta Hall", "FFH");  // get the message
System.out.println(message);  // print it yourself

But, of course, it will often be easier to just print the message directly:

MessageCli.VENUE_SUCCESSFULLY_CREATED.printMessage("Frugal Fiesta Hall", "FFH");  // print the message directly

Be sure to dedicate time to understand how this works, as it will be very useful to use and make your job easier. You should already be familiar with this concept from how printf() works in C.

src/main/java/nz/ac/auckland/se281/VenueHireSystem.java

This class declares the methods that are invoked by the command line interface (Main.java). This is where you need to start your coding.

You must NOT change the signature of the existing methods of this class (such as changing method names, parameters, and return types).

Of course, you can (and you should) add instance fields and new methods of your own.

If you need to instantiate/initialise fields of the VenueHireSystem instance, you can only use the provided zero-parameter constructor (public VenueHireSystem()). You should not create other constructors in the VenueHireSystem class, as they will not be used by the command line or test cases.

src/main/java/nz/ac/auckland/se281/BookingReferenceGenerator.java

This Java file contains the generateBookingReference() method, which you will need for Task 2 and Task 3 (you can safely ignore it for Task 1). This method generates a random booking reference, which is a string of 8 characters. You must use this method to generate booking references for your bookings, so that you get the correct output when you run the test cases.

Here is an example of how to use this method to get the next random booking reference, stored to a variable called bookingReference:

String bookingReference = BookingReferenceGenerator.generateBookingReference();

HUD14D8O
ZP4HRCZ4
28GJARMV
ISXW7L6G
ALR0TCXE
ZI0F2V54
GMIHMQQ6
EQF27GQA
ZFJY9VYJ
GO9LDOS9
5IF4ZESQ
DPDD57HZ
DL7F8EMO
B697W6RY
5NVRH0C4
D0VAYSI1
NFW6ML28
CX35JSRW
3AJV498R
CKDAXDL2

You should not modify anything in the BookingReferenceGenerator.java file.

You should also NOT use the reset() method. The reset() method is used by the testing framework to reset the random number generator to a known state between test cases, so that the test cases can be executed multiple times without the random number generator affecting the results.

src/main/java/nz/ac/auckland/se281/Types.java

This Java file contains the following enum types:

• CateringType
• FloralType

These enum types are used to represent the different types of catering and floral services that can be added to a booking. You will need to use these enum types in Task 3.

You should not modify anything in the Types.java file.

src/test/java/nz/ac/auckland/se281/MainTest.java

This Java file contains the JUnit test cases for this assignment. These test cases make sure that you have implemented most of the assignment correctly.

Making sure that your program passes all of the provided tests will not guarantee that you will get full marks for this assignment, but it will mean that you should get at least half of the marks for the parts that work according to those tests. In fact, we only provided to you half of the test cases that we will use for marking your assignment. You should also note that the test cases we will use for marking your assignment will use slightly different inputs, to ensure you are not hardcoding the expected outputs.

The way that these test cases work is the same as you have seen in the Hello GitHub assignment. You can run them in the same way, either using the Maven wrapper or the Test Runner for Java extension in VS Code.

Writing your own tests or extending the ones you have been given is strongly recommended. Add them inside MainTest.YourTests, which you can find at the bottom of the MainTest.java class. You also need to uncomment each Suite Class near the top of this file:

@RunWith(Suite.class)
@SuiteClasses({MainTest.Task1.class,
				// MainTest.Task2.class,
				// MainTest.Task3.class,
				// MainTest.YourTests.class, // <-- uncomment this line
})

You can easily write a test using the helper methods runCommands(), assertContains() and assertDoesNotContain(). (which are implemented by us—they are not standard JUnit).

First, with runCommands() you specify the commands to be executed (separated by a comma). Then, with assertContains(), you specify what is the text that you expect to see on the console after executing all the commands. For example, this test case checks that two new venues are correctly created and added into the system:

@Test
public void second_venue_saved() throws Exception {
	runCommands(
			CREATE_VENUE, "'Frugal Fiesta Hall'", "FFH", "80", "150", CREATE_VENUE, "'Comfy Corner Events Centre'",	"CCEC",	"120", "250",	PRINT_VENUES);

	assertContains("Successfully created venue 'Frugal Fiesta Hall' (FFH).");
	assertContains("Successfully created venue 'Comfy Corner Events Centre' (CCEC).");
	assertContains("There are two venues in the system:");
	assertContains("Frugal Fiesta Hall (FFH) - 80 people - $150 base hire fee");
	assertContains("Comfy Corner Events Centre (CCEC) - 120 people - $250 base hire fee");
}

Sometimes it is easier to follow the test case by forcing breaklines with // at the end of each line. For example, the previous test case could be written as:

@Test
public void second_venue_saved() throws Exception {
	runCommands( //
		CREATE_VENUE, "'Frugal Fiesta Hall'", "FFH", "80", "150", //
		CREATE_VENUE, "'Comfy Corner Events Centre'",	"CCEC",	"120", "250", //
		PRINT_VENUES //
	);
	assertContains("Successfully created venue 'Frugal Fiesta Hall' (FFH).");
	assertContains("Successfully created venue 'Comfy Corner Events Centre' (CCEC).");
	assertContains("There are two venues in the system:");
	assertContains("Frugal Fiesta Hall (FFH) - 80 people - $150 base hire fee");
	assertContains("Comfy Corner Events Centre (CCEC) - 120 people - $250 base hire fee");
}

This way, even if your IDE attempts to auto-format the code, it will not change the way the test case is laid out. It makes it easier in the second case to see we executed three commands (CREATE_VENUE, CREATE_VENUE, and PRINT_VENUES), and then we checked that the output contains the lines we would expect to see as a result of those commands executing.

While you can add as many tests as you want, we will not consider them when marking your assignment. Be aware that your code must still work with the original version of the MainTest.java file, where we will reuse the test cases initially provided to you (with slightly different values), while also adding new test cases not visible to you.

src/test/java/nz/ac/auckland/se281/CliTest.java

You should not modify this file.

This Java file is used by the testing framework.

Various “hidden” files

Note: We also provide additional “hidden” files (those starting with “.”). You would need to change the folder options to be able to see them. We provide a .gitignore file that specifies intentionally-untracked files that Git should ignore, and a .mvn folder containing the Maven wrapper. You should not change these files, and you should not delete them.

Checkpoints

To help you tackle this assignment, we have split it into two checkpoints (Task 1 and Tasks 2+3).

You will need to submit your code for each checkpoint to your GitHub repository before each checkpoint’s respective deadline. The due dates for each checkpoint are listed at the top of this page. Make sure that you have pushed your commits and that they appear in the remote GitHub repository before the deadline. Refer to the instructions at the bottom of this page (Final Submission on GitHub) for more information on how to submit your code.

Checkpoint #1

This checkpoint is about applying basic Java OOP concepts, such as:

• Using collections
• Using loops
• Using classes

Inside the MainTest.java file, you will find the relevant test cases for this checkpoint are contained within:

• The MainTest.Task1 class

Checkpoint #2

This checkpoint is about applying slightly more advanced OOP concepts:

• Using inheritance
• Using polymorphism
• Using abstract classes

Inside the MainTest.java file, you will find the relevant test cases for this checkpoint are contained within:

• The MainTest.Task2 class
• The MainTest.Task3 class

OOP Requirements

For this assignment, you should use the OOP concepts we covered in class. As such, you should not implement all your code inside the VenueHireSystem class. You should create appropriate classes. We are giving you complete freedom on how to do the OO design. You will decide how many and which Java classes to create.

Inheritance (Checkpoint #2)

You should make sure that you are using inheritance for Checkpoint #2. There, we will check for the following:

• Your code should have at least one abstract class, and
• Your code should have at least three (sub)classes that extend class(es) that you have created.

Note that not all the sub-classes necessarily need to extend the abstract class. It is up to you.

For example, you meet the requirement if you create an abstract class public abstract class A, a public class B, and if you have three (sub)classes public class C extends A, public class D extends B, and public class E extends B:

As another example, you meet the requirement if you create an abstract class public abstract class A, and if you have three (sub)classes public class B extends A, public class C extends A, and public class D extends A. You can of course, create more classes on top of these, depending on your OO design choices:

It goes without saying that just creating the classes is not sufficient. Your code has to make use of the classes.

The Commands

Before proceeding with the tasks, read the code provided to you and start to familiarise yourself with the command-line interface.

To run the application in VS Code in an interactive mode, run the Main class using the Maven wrapper through VS Code’s built-in terminal. If the terminal window is not open, you can open it by clicking on the Terminal menu, then New Terminal. Then type the following command:

./mvnw clean compile exec:java@run for Unix/Mac OS or .\mvnw.cmd clean compile exec:java@run for Windows

You should see the following output:

Now you can try some of the commands!

Try the HELP command to see the list of available commands:

You can also try the EXIT command to exit the system:

Only the HELP and EXIT commands are implemented for you. You will need to implement the rest of the commands.

Commands with no arguments

The following commands do not require any arguments:

PRINT_VENUES    [no args]       Print details of all the venues
PRINT_DATE      [no args]       Print the system's current date
MAKE_BOOKING    [no args]       Request a new booking
HELP            [no args]       Print usage
EXIT            [no args]       Exit the application

This means you can just type them in the command line, press Enter or Return, and they will be executed. For example, if you use the PRINT_VENUES command and press Enter or Return, you should see the following:

Obviously, nothing got printed since you need to implement the logic. But notice that no error was reported, since you did not add arguments (as the command expects).

If you were to use the PRINT_VENUES command followed by some arguments, you would get an error message:

This is because the command expects no arguments, but you provided some (in this case, added, extra, things).

Commands with arguments

The following commands require arguments:

CREATE_VENUE    [4 arguments]   Create a new venue with the given <VENUE_NAME>, <VENUE_CODE>, <VENUE_CAPACITY>, and <HIRE_FEE>
SET_DATE        [1 argument]    Set the system's date to the specified date in DD/MM/YYYY format
PRINT_BOOKINGS  [1 argument]    Print all bookings for the specified <VENUE_CODE>
ADD_CATERING    [1 argument]    Add catering service to the specified <BOOKING_REFERENCE>
ADD_MUSIC       [1 argument]    Add music service to the specified <BOOKING_REFERENCE>
ADD_FLORAL      [1 argument]    Add floral service to the specified <BOOKING_REFERENCE>
VIEW_INVOICE    [1 argument]    View full invoice details for the specified <BOOKING_REFERENCE>

This means you must provide the required number of arguments before pressing Enter or Return for them to be executed. For example, if you use the CREATE_VENUE command without arguments (or the wrong number of arguments) and press Enter or Return, you should see the following:

To use it correctly, you need to provide the correct number of arguments:

Obviously, nothing got printed since you need to implement the logic. But notice that no error was reported, since you provided four arguments (as the command expects).

Tasks

To guide you through the assignment, we have divided it into three tasks. Task 1 corresponds to Checkpoint #1, while Task 2 and Task 3 together correspond to Checkpoint #2.

For each task, we provide a number of test cases (in MainTest.java) that you can use to test your code.

Task 1 (Checkpoint #1) [Worth 6%]

Initial test results

As soon as you compile and run the tests, you will notice the following output…

With the Maven wrapper:

./mvnw clean compile test for Unix/Mac OS or .\mvnw.cmd clean compile test for Windows:

With the Test Runner for Java extension in VS Code:

From the left side of VS Code, click on the Testing icon:

You will then see all the test cases. You might need to expand to see them all:

In either case, the examples above are telling you that 8 test cases were run, none of them passed, and all of them failed. In the output, you will find more details on why the test cases failed.

Hint: Look at the numbering of the test cases to guide you in the recommended order to tackle them, in this case the first test case is T1_01_no_venues().

For example, let’s consider the first test case as shown in the terminal, for when you use the Maven wrapper:

The same information is present in the Test Runner for Java extension in VS Code. You can click on the red x () to see the details of the failed test:

The important message to read is:

java.lang.AssertionError: The test is expecting the following output in the console, but it was not there: 
 "There are no venues in the system. Please create a venue first."

This means that the test is expecting the output There are no venues in the system. Please create a venue first. to be printed in the console, but it was not there. This is because you have not implemented the logic for the PRINT_VENUES command yet.

Let’s try something. Go to the printVenues() method inside VenueHireSystem.java, and add the following code:

public void printVenues() {
	// TODO implement this method
	System.out.println("There are no venues in the system. Please create a venue first.");
}

Run your test again, and you should see the following:

Or, from the terminal, we see that now only 7 of the 8 tests are failing:

Now, of course the edit we did was a hack to demonstrate how the tests work. We will very soon have a non-empty list of venues, and this hard-coded print statement will cause all those other test cases to fail! We therefore need to implement the correct logic as described in the following sections.

Creating a new venue (CREATE_VENUE and PRINT_VENUES)

Task 1 will require you to implement (some of) the logic for the CREATE_VENUE and PRINT_VENUES commands.

The CREATE_VENUE command creates a new venue with the specified venue name, venue code, venue capacity, and venue hire fee (passed as arguments to the CREATE_VENUE command). If any invalid input is provided, an error message should be printed (details below).

The PRINT_VENUES command prints the details of all the venues in the system.

If there are no venues in the system, it prints just the following header:

There are no venues in the system. Please create a venue first.

If there is one venue in the system, it prints the following header and the one itemised venue:

There is one venue in the system:
  * Frugal Fiesta Hall (FFH) - 80 people - $150 base hire fee. Next available on %s

If the system has more than one venue (but less than 10 venues), it prints the following header and the itemised list of all venues. For example, assume there are two venues in the system:

There are two venues in the system:
  * Frugal Fiesta Hall (FFH) - 80 people - $150 base hire fee. Next available on
  * Comfy Corner Events Centre (CCEC) - 120 people - $250 base hire fee. Next available on

If the system has 10 (or more) venues, it prints the following header and the itemised list of all venues. For example, assume there are 10 venues in the system:

There are 10 venues in the system:
  ... // itemised lists the venues

So, if there were 13 venues, it would print There are 13 venues in the system: followed by the itemised list of all 13 venues.

Take note of the differences between the different cases above:

• In the first example, the quantity is “no”, “venues” is plural, and the sentence ends with a period (“.”)
• In the second example, it uses “is”, the quantity is a word, “venue” is singular, and the sentence ends with a colon (“:”)
• In the third example, it uses “are”, the quantity is a word, “venues” is plural, and the sentence ends with a colon (“:”)
• In the fourth example, it uses “are”, the quantity is a digit, “venues” is plural, and the sentence ends with a colon (“:”)

NUMBER_VENUES("There %s %s venue%s in the system:")

MessageCli.NUMBER_VENUES.getMessage("are", "two", "s");    // Using the getMessage() method
MessageCli.NUMBER_VENUES.printMessage("are", "two", "s");  // Using the printMessage() method

In addition to the header, if there is at least one venue in the system, the PRINT_VENUES should also print the following for every venue in the system:

 * <VENUE_NAME> (<VENUE_CODE>) - <VENUE_CAPACITY> people - $<VENUE_HIRE_FEE> base hire fee. Next available on %s

Hint: See the MessageCli.VENUE_ENTRY message template.

When a new venue is created, it should be added to the system. The arguments have the following requirements:

<VENUE_NAME>

• Cannot be empty (i.e., cannot be '' or ' ' or any other combination of spaces).
• You will notice the use of single quotes in the test cases. This is because the venue name can be a single word (in which case the single quotes are optional), or multiple words (in which case the single quotes are required). You don’t need to worry about this, as the code provided already handles this and gives you the full name regardless.

<VENUE_CODE>

• Must be unique across all other venue codes currently in the system.

<VENUE_CAPACITY>

• Must be a whole integer, positive, over zero, numeric/digits.

<HIRE_FEE>

• Must be a whole integer, positive, over zero, numeric/digits.

When a successful venue is created, a success message should be printed:

Successfully created venue '<VENUE_NAME>' (<VENUE_CODE>).

For example:

281-venue-hire> CREATE_VENUE 'Frugal Fiesta Hall' FFH 80 150
Successfully created venue 'Frugal Fiesta Hall' (FFH).

The format of this message is very strict. Make sure you check for an appropriate message template in MessageCli to help you.

If there was something wrong, then the above success message should not be printed. Instead, one of the following messages gets printed.

If the venue name is empty, then the following message gets printed:

281-venue-hire> CREATE_VENUE '' NA 80 150
Venue not created: venue name must not be empty.

If the venue code already exists, then the following message gets printed:

281-venue-hire> CREATE_VENUE 'Frugal Fiesta Hall' FFH 80 150
Successfully created venue 'Frugal Fiesta Hall' (FFH).
281-venue-hire> CREATE_VENUE 'Frugal Fiesta Hall' FFH 80 150
Venue not created: code 'FFH' is already used for 'Frugal Fiesta Hall'.

If the hire fee (or capacity) is not a number^†, then the following message gets printed:

281-venue-hire> CREATE_VENUE 'Frugal Fiesta Hall' FFH 80 fifty
Venue not created: hire fee must be a number.

^†For our purposes, something is a number only if it can be parsed with Integer.parseInt() (see the Java docs) or this YouTube video to learn how to parse a string into an integer).

If the capacity (or hire fee) is not a positive integer, then the following message gets printed:

281-venue-hire> CREATE_VENUE 'Frugal Fiesta Hall' FFH -1 150
Venue not created: capacity must be a positive number.

Once you have implemented all the logic for Task 1, you should see all your test cases pass:

Or, from the terminal view:

As explained at the end of this document, we only provide you with half the test cases from each task. So, even though you have passed all 8 test cases, there are 7 more hidden test cases that we will add to these for Task 1. So, make sure you have implemented all the logic, and read the requirements carefully.

Task 2 (Checkpoint #2) [Worth 6%]

Now that the system supports creating venues, it is time to manage those venues. This will include setting the system’s date, making bookings, updating the next available date, and printing bookings.

Go to the top of the MainTest.java file, and uncomment the following line:

@RunWith(Suite.class)
@SuiteClasses({
  MainTest.Task1.class,
  // MainTest.Task2.class, // <-- uncomment this line to get started on Task 2
  // MainTest.Task3.class,
  // MainTest.YourTests.class,
})

You will see 15 new test cases, all of which are failing. Follow the same process as Task 1 to get them all passing, and carefully read the requirements below so you consider scenarios where test cases are not provided.

Setting (and printing) the system’s date

Before we can make bookings, we need to set the system’s date. The SET_DATE command sets the system’s date to the specified date (provided in DD/MM/YYYY format) and prints a confirmation message, for example:

281-venue-hire> SET_DATE 26/02/2024
System date set to 26/02/2024.

You don’t have to worry about handling invalid dates, or dates specified in a different format. You can assume that the user will always type in a valid date in the correct format.

The PRINT_DATE command prints the system’s current date (assuming it was previously set with SET_DATE), for example:

281-venue-hire> SET_DATE 26/02/2024
System date set to 26/02/2024.
281-venue-hire> PRINT_DATE
Current system date is 26/02/2024.

If the system’s date has not been set, then the following message gets printed:

281-venue-hire> PRINT_DATE
Current system date is not set.

Making bookings

Now it’s time to actually make some bookings! But, understandably, a few conditions need to be met before we can make a booking. These conditions are:

• The system’s date must be set,
• There must be at least one venue in the system,
• The venue code must exist,
• The venue must be available on the specified date, and
• The booking date must not be in the past (today or later is OK in terms of the current system date).

If any of these conditions are not met, then the booking cannot be made. In this case, an error message should be printed, and the booking is not made.

The MAKE_BOOKING command makes a booking for the specified venue code and date, and prints a confirmation message.

However, you will notice that the MAKE_BOOKING command has zero arguments! This is because the required information will be prompted after the command is executed, and we call these “options”. These options will be prompted for by the system one at a time. For example:

281-venue-hire> MAKE_BOOKING
	Venue code: FFH
	Requested date in DD/MM/YYYY format: 26/02/2024
	Customer email: client001@email.com
	Number of attendees: 70

Collecting these options is handled for you. Once collected, they are placed into an array of strings (i.e., the String[] options parameter in the VenueHireSystem.makeBooking() method).

For the example above, the options array would contain the following:

options[0] = "FFH"
options[1] = "26/02/2024"
options[2] = "client001@email.com"
options[3] = "70"

public void makeBooking(String[] options) {
	for (int i = 0; i < options.length; i++) {
		String value = options[i];
		System.out.println("option " + i + " = " + value);
	}
}

String date = "26/02/2024";
String[] dateParts = date.split("/");

String day = dateParts[0];   // "26"
String month = dateParts[1]; // "02"
String year = dateParts[2];  // "2024"

To simplify the implementation for making bookings, you do not need to worry about validating the format of the options. For example, you do not need to worry about validating the date format, or the email format, or the number of attendees being a number, etc. You can assume that the user will always type in a correct format. In fact, this is done for you. We will always use valid option types for marking, and you only need to consider the explicitly mentioned scenarios.

When a booking is successfully made, a success message should be printed:

"Successfully created booking '<BOOKING_REFERENCE>' for '<VENUE_NAME>' on <BOOKING_DATE> for <NUMBER_OF_ATTENDEES> people."

For example:

281-venue-hire> SET_DATE 27/02/2024
System date set to 27/02/2024.
281-venue-hire> MAKE_BOOKING
	Venue code: GGG
	Requested date in DD/MM/YYYY format: 27/02/2024
	Customer email: client001@email.com
	Number of attendees: 230
Successfully created booking 'HUD14D8O' for 'Grand Gala Gardens' on 27/02/2024 for 230 people.

The above example shows a successful booking. The information provided should be stored with that booking.

Notice that the booking reference (HUD14D8O) was not provided as an option, and was instead auto-generated by the system. This is a randomly generated booking reference, and you should use the BookingReferenceGenerator.generateBookingReference() method to generate it. You do not need to worry about how this method works, just use it.

HUD14D8O
ZP4HRCZ4
28GJARMV
ISXW7L6G
ALR0TCXE
ZI0F2V54
GMIHMQQ6
EQF27GQA
ZFJY9VYJ
GO9LDOS9
5IF4ZESQ
DPDD57HZ
DL7F8EMO
B697W6RY
5NVRH0C4
D0VAYSI1
NFW6ML28
CX35JSRW
3AJV498R
CKDAXDL2

There are some cases when the options provided might not be ideal, but they aren’t enough to stop a booking from being made. This will be the case when the number of attendees is less than 25% of the venue capacity, or more than 100% of the venue capacity. In these cases, the booking will still be made, but the number of attendees will be adjusted to be 25% or 100% of the venue capacity, respectively. When this happens, the following message should be printed:

Number of attendees adjusted from <ORIGINAL_NUMBER_OF_ATTENDEES> to <NEW_NUMBER_OF_ATTENDEES>, as the venue capacity is <VENUE_CAPACITY>.

For example, when too few attendees are specified:

281-venue-hire> MAKE_BOOKING
	Venue code: GGG
	Requested date in DD/MM/YYYY format: 28/05/2024
	Customer email: client999@email.com
	Number of attendees: 20
Number of attendees adjusted from 20 to 65, as the venue capacity is 260.
Successfully created booking 'HUD14D8O' for 'Grand Gala Gardens' on 28/05/2024 for 65 people.

Similar thing when too many attendees are specified, the number of attendees is adjusted to be 100% of the venue capacity.

You don’t have to worry about rounding up or down. We won’t have test cases where 25% results in a decimal number, and we won’t have test cases where the venue capacity is less than 4 (since 25% of 4 is 1, and 100% of 4 is 4).

Below are scenarios where a booking should not be made, and an error message should be printed instead. This means your system should not print any success message, and the booking should not be stored when the list of bookings for a given venue is printed.

If the system’s date has not been set, then the following message gets printed:

Booking not made: system date not set. Set the date first.

If there are no venues in the system, then the following message gets printed:

Booking not made: there are no venues in the system. Create one first.

If the venue code does not exist, then the following message gets printed:

281-venue-hire> MAKE_BOOKING
	Venue code: FAKE
	Requested date in DD/MM/YYYY format: 02/06/2024
	Customer email: client001@email.com
	Number of attendees: 50
Booking not made: there is no venue with code 'FAKE'.

If the booking date is in the past, then the following message gets printed, regardless of whether the venue was available or not:

Booking not made: '01/01/2021' is in the past (system date is 01/05/2024).

Finally, given the time to prepare and clean venues between bookings, the system should ensure that only one booking can be made per day for a given venue. This means that if a booking is made for a given venue on a given date, then no other bookings can be made for that venue on that date. If a booking is attempted to be made for a given venue on a given date, but there is already a booking for that venue on that date, then the following message gets printed:

Booking not made: venue 'Grand Gala Gardens' is already booked on 27/02/2024.

Updating the next available date**

Once you’ve got your bookings working, you need to update the next available date for a given venue.

When a booking is made, the next available date for that venue should be updated. This is the date that is printed when printing the list of venues. For example, assume that the system date is 01/01/2024:

• If there are no bookings for the venue yet, then it’s next available date is 01/01/2024 (today).
• If a booking already exists for 01/01/2024 (today), then the next available date is 02/01/2024 (tomorrow).
• If a booking already exists for today and tomorrow, then the next available date is 03/01/2024.
• If there is one booking 01/01/2024 (today), and the next one is 5 days away, then the next available date is 02/01/2024 (tomorrow).

The next available date will also need updating when the system time changes. For example, assume that the system date is 01/01/2024:

• If the system date moves forward to 20/01/2024, and there are no bookings for the venue yet, then it’s next available date is 20/01/2024 (the new today).

This is all tested against the output from the PRINT_VENUES command. For example:

281-venue-hire> SET_DATE 03/02/2024
System date set to 03/02/2024.
281-venue-hire> PRINT_VENUES
There are 10 venues in the system:
  * Frugal Fiesta Hall (FFH) - 80 people - $250 base hire fee. Next available on 03/02/2024
  * Comfy Corner Events Centre (CCEC) - 120 people - $500 base hire fee. Next available on 03/02/2024
	...

Printing bookings

Now that we can make bookings, we need to be able to print them.

The PRINT_BOOKINGS command prints all the bookings for a given venue (past and future bookings). It first prints the header that includes the venue name, and then prints the list of bookings for that venue along with their booking reference and event date. For example:

281-venue-hire> PRINT_BOOKINGS GGG
Bookings for 'Grand Gala Gardens':
  * 'HUD14D8O' on 27/03/2024
  * 'ZP4HRCZ4' on 28/05/2024

If there are no bookings for the specified venue (but the venue exists), then the same header is printed but with the following note below the header:

Bookings for 'Grand Gala Gardens':
  * No bookings for 'Grand Gala Gardens'.

If the venue code does not exist, then the following message gets printed:

281-venue-hire> PRINT_BOOKINGS ABC
Nothing to print: there is no venue with code 'ABC'.

If there are no venues in the system, then it suffices to print the same message as the venue code not existing. You do not need to worry about printing a different message for when there are no venues in the system.

Task 3 (Checkpoint #2) [Worth 6%]

Now that the system supports making bookings, it is time to manage those bookings. This will include adding services to a booking, and viewing invoices.

Go to the top of the MainTest.java file, and uncomment the following line:

@RunWith(Suite.class)
@SuiteClasses({
	MainTest.Task1.class,	
	MainTest.Task2.class,
	// MainTest.Task3.class, // <-- uncomment this line to get started on Task 3
	// MainTest.YourTests.class,
})

You will see 15 new test cases, all of which are failing. Follow the same process as Task 1 and Task 2 to get them all passing, and carefully read the requirements below so you consider scenarios where test cases are not provided.

Services

The currently-supported services include Catering, Music, and Floral. Each service has a different cost, and can be added to a booking.

When a service is added, it is added to a specific booking. A booking might have multiple services. To add a service, you need to specify the booking reference (which was generated when the booking was made).

When adding a service, the only check is that the booking reference exists. It doesn’t matter if there are venues or not, as the main check is that the actual booking reference exists (and it might not exist since there are no bookings in the system at all). In the case that the booking reference does not exist, a message gets printed for the service type (e.g., Catering, Music, or Floral), along with the booking reference that was provided. For example:

Catering service not added: there is no booking with reference 'HUD14D8O' in the system.

The impact of adding a service to the booking ultimately affects the cost of that booking (more on that below).

To make it easier, you do not need to worry about error checking the input in terms of validity of options for the services. Assume that the user will always enter the correct format for options when adding a service. In fact, this is done for you and you should be using the enums provided (see the CateringType and FloralType enums declared in the Types class).

Adding Catering services to a booking

The ADD_CATERING command adds a catering service to a booking. The booking reference is provided as an argument to the command, while the catering type is prompted for after the command is executed.

Here’s an example of the message that gets printed when a catering service is added to a booking:

281-venue-hire> ADD_CATERING HUD14D8O
	Select type (B/L/D/X/BL/LD/BLD): B
Successfully added Catering (Breakfast) service to booking 'HUD14D8O'.

For the catering services, you will need to use the CateringType enum declared in the Types class. It is used to represent the different types of catering services that can be added to a booking, and a value will be provided to you in the addCateringService() method in the VenueHireSystem class.

This enum has the following values:

• BREAKFAST: Breakfast, costing $15 per person
• LUNCH: Lunch, costing $20 per person
• DINNER: Dinner, costing $30 per person
• DRINKS: Drinks, costing $10 per person
• TWO_COURSE_BL: Two Course (Breakfast+Lunch), costing $45 per person
• TWO_COURSE_LD: Two Course (Lunch+Dinner), costing $60 per person
• THREE_COURSE: Three Course, costing $75 per person

// Example variable
CateringType cateringType = Types.CateringType.BREAKFAST;

// Get the name of the catering type
String cateringTypeName = cateringType.getName();

// Get the cost of the catering type
int cateringTypeCost = cateringType.getCostPerPerson();

Adding Music services to a booking

The ADD_MUSIC command adds a music service to a booking. The booking reference is provided as an argument to the command. There are no options to select from, as there is only one music service available.

Here’s an example of the message that gets printed when a music service is added to a booking:

281-venue-hire> ADD_MUSIC HUD14D8O
Successfully added Music service to booking 'HUD14D8O'.

All music services cost $500, and there is only one music service available.

Adding Floral services to a booking

The ADD_FLORAL command adds a floral service to a booking. The booking reference is provided as an argument to the command, while the user is prompted to upgrade to deluxe floral after the command is executed.

Here’s an example of the message that gets printed when a floral service is added to a booking:

281-venue-hire> ADD_FLORAL HUD14D8O
	Upgrade to deluxe? (y/n): n
Successfully added Floral (Standard) service to booking 'HUD14D8O'.

For the floral services, you will need to use the FloralType enum declared in the Types class. It is used to represent the two types of floral services that can be added to a booking, and a value will be provided to you in the addServiceFloral() method in the VenueHireSystem class.

This enum has the following values:

• STANDARD: Standard, costing $550
• DELUXE: Deluxe, costing $1000

// Example variable
FloralType floralType = Types.FloralType.STANDARD;

// Get the name of the floral type
String floralTypeName = floralType.getName();

// Get the cost of the floral type
int floralTypeCost = floralType.getCost();

Viewing invoices

Now that we can add services to bookings, we need to be able to view the invoices for those bookings. This will allow us to print and send the invoices to the clients (of course you don’t have to implement that last part!).

The VIEW_INVOICE command prints the full invoice details of a specific Booking, including the services, number of attendees being charged, the total cost, booking reference, client’s email, etc.

Here’s an example invoice:

281-venue-hire> VIEW_INVOICE ZP4HRCZ4

===============================================================
                          INVOICE
           -------------------------------------

Booking Reference: #ZP4HRCZ4

Booking Details:
Customer Email: client001@email.com
Date of Booking: 26/02/2024

Event Details:
Party Date: 28/07/2024
Number of Guests: 150
Venue: Refined Radiance Venue

Cost Breakdown:
  * Venue hire - $500
  * Catering (Two Course Breakfast/Lunch) - $6750
  * Floral (Deluxe) - $1000
Total Amount: $8250

Thank you for choosing 281 Venue Hire!
For any inquiries, please contact support@281venuehire.co.nz.
===============================================================

You’ll noticed there are two dates captured on the invoice:

• Date of Booking: This is the date that the booking was made (different from the date of the event). This is effectively the system date when the booking was made.
• Party Date: This is the date of the event (i.e., the date that the booking is for).

To help you print the invoice, have a look at the INVOICE_CONTENT_xxx values in the MessageCli class. These are the templates for the invoice, and you can use them to help you print the invoice:

• INVOICE_CONTENT_TOP_HALF
• INVOICE_CONTENT_VENUE_FEE
• INVOICE_CONTENT_CATERING_ENTRY
• INVOICE_CONTENT_MUSIC_ENTRY
• INVOICE_CONTENT_FLORAL_ENTRY
• INVOICE_CONTENT_BOTTOM_HALF

As you’ll notice, there’s quite a number of %s placeholders to be filled in for the invoice template.

Remember that catering costs are determined by the number of attendees (which is minimum 25% venue capacity, and maximum 100% venue capacity).

It doesn’t matter what order that you list of the various services, as long as the total cost is correct, and all the required elements are listed on the invoice.

Obviously, if the booking reference does not exist, then the following message gets printed:

Invoice not printed: there is no booking with reference 'ZP4HRCZ4' in the system.

Your Tests (optional)

You can add your own test cases in the MainTest.YourTests class, in a similar way to how the test cases are written in the MainTest.Task1, MainTest.Task2, and MainTest.Task3 classes.

These won’t be marked (in fact, they will be ignored during marking), but they are useful for you to test your code. Furthermore, knowing how to write test cases (and getting into the good habit of doing so) will help you write better code and gets you into the problem-solving mindset, which is extremely useful for your future career as an engineer.

Marking Scheme

Important Instructions

Please read the following information carefully before you begin your assignment.

@Test
public void testIsEven() {
  checkIfIsEven(2);
  assertContains("true");
}

public void checkIfIsEven(int number) {
  if (number == 2) {
    System.out.println("true");
  } else {
    System.out.println("false");
  }
}

@Test
public void testIsEven() {
  checkIfIsEven(280);
  assertContains("true");
}

email: "student@aucklanduni.ac.nz"
accessToken: "token-that-was-emailed-to-you"