Reference no: EM132873989 , Length: word count:2000

CTEC2906 Object Oriented Development - De Montfort University

Learning outcome 1: Design and develop applications with emphasis on quality, maintainability, correctness and robustness, enhancing their trustworthiness.
Learning outcome 2: Make effective use of the Java Software Development Kit Application Programming Interfaces

JavaFX Module Selection Tool GUI

The objective of this assessment is for you to demonstrate your ability to design and implement an OO system consisting of a set of Java classes, using advanced libraries within the Java SDK. In particular:
1. To study and correctly make use of a prebuilt student profile data model.
2. To build a suitable user interface using JavaFX 8 libraries.
3. To implement event handling procedures that provide a basis for an interactive and user-friendly system.
4. To adhere to standard principles of the Model-View-Controller (MVC) design pattern and appropriately decompose classes through abstraction and encapsulation.

JavaFX Module Selection GUI specification
A student profile captures the details of an individual second year undergraduate computing student and allows them to select their final year module options. There are compulsory modules that must be selected (depending on the course of study), and others that are only associated with certain courses. Modules either run in term 1 or 2, or all year long.

Your task is to build an interactive graphical user interface (GUI) that dynamically allows modules to be selected based on the chosen course of study, and then stores this information. The application should be user-friendly and contain appropriate validation to ensure only a legitimate selection of modules is made.

For this prototype, you are only required to use the data of two courses, Computer Science and Software Engineering. However, the system should be designed such that it would be relatively simple to add further courses and modules in the future.

The table overleaf shows all of the available modules, their credit amount, and whether they are an option or compulsory for Computer Science and Software Engineering students.
Computer Science students have 45 compulsory credits, whereas Software Engineering
students have 60 compulsory credits. Computer Science students can exclusively study IMAT3428.

In total 120 credits must be selected via any legitimate combination of modules, but crucially you may only select 60 credits per term. The yearlong compulsory module CTEC3451 contributes towards 15 credits in each term.

As an example, a Computer Science student would have by default 30 credits selected in term 1 and 15 credits in term 2 due to the mandatory nature of IMAT3423 and CTEC3451. This would mean they would need to select a further 30 credits of term 1 modules, and a further 45 credits in term 2. A Software Engineering student would be similar, but would additionally have the mandatory module CTEC3902 in term 2, therefore requiring an additional 30 credits worth of modules to be chosen in both term 1 and term 2.

In this case study, once students have successfully chosen a legitimate selection of modules as their first preference, they are then required to select 30 credits worth of reserve modules per term from those that remain, i.e. two term 1 modules and two term 2 modules. These reserve modules can then be used in the unlikely scenario of another module not running or being at full capacity for example.

Guidance on building the application

You are advised to thoroughly read this guidance and to continually refer to it as a means of helping you design and implement the JavaFX Module Selection Tool GUI application.

Please download ModuleSelectionTool.zip and extract the Java Project, then import it into Eclipse. You will note that it contains a template structure for you to work from including logical packages.

Application Loader

In the main package you have been given an ApplicationLoader that simply instantiates the model (i.e. StudentProfile) and view (i.e.
ModuleSelectionToolRootPane), and passes these to the controller (i.e.
ModuleSelectionToolController).

This should help you get started. You should clearly showcase the MVC design pattern throughout your implementation. You will be assessed on your ability to sensibly decouple these entities to make a maintainable and reusable solution.

The Model

You have been provided with the data model for this application - The model contains four classes - StudentProfile, Course, Module, and Name, and an enum Schedule.
• A Student Profile encapsulates a student name, p number, email, submission date, a Course of study, and a set of selected Modules, along with a set of reserved Modules.
• A Course has a name and a collection of all Modules available on that course.
• A Module has a code, name, credit amount, is either mandatory or not, and has a scheduled delivery of either term 1, term 2, or year long.
• A Name for a student is made up of a first name and a family name.

The model classes purposely have no javadoc comments, as you are required to study the source code in order to understand how to use them as the data model for your MVC application. You will not be assessed on writing javadoc for this assignment either.

For the vast majority of this assignment, you will not need to add any further code to the model and are advised to make use of existing methods wherever possible.

The View

In the view package you have been given a root pane, from which you can build your user interface. The GUI is made up of four forms, which should be separated onto different tabs. You have been given the first of these forms (placed onto a tab), along with a menu bar.
There are also some methods in these classes to help you get started. The overall GUI should include the following:

Create Profile tab
Displays a combo box, pre-populated with the two aforementioned second year computing courses, and five text fields for inputting a student P number, first and last name, email, and the submission date. There is also a create profile button.

Select Modules tab
Should display two list views for unselected term 1 and term 2 modules (for the chosen course), and three further list views for selected year long, term 1 and term 2 modules (including compulsory modules). The accumulated term1 and term 2 credits for the current module selection should be displayed. There should be add and remove buttons for both term 1 and term 2 modules, and an overall reset and submit button.

Reserve Modules tab
Should display the remaining unselected modules for each term. Reserve modules should be chosen (using unselected/selected list views) for term 1, followed by term 2 (ideally using an Accordion control to only display one term at a time). There should be add and remove buttons for both term 1 and term 2 modules, as well as a confirm button for each term.

Overview Selection tab
Should display an overview of the student's details, selected modules and reserved modules based on their submitted profile and module selection from the previous three tabs. The information should be clear and well-presented across three separate text areas. There should also be a save overview button.

Your GUI also has a menu bar:

The Menu Bar
This Menu bar has two menus: File and Help. The File menu is made up of menu items: "Load Student Data", "Save Student Data" and "Exit". The Help menu is made up of a single menu item: "About".

Note: You are strongly advised to decompose the view by separating logical containers into their own top-level classes, enhancing reusability and abstraction. You will also need to provide suitable methods that allow relevant data to be accessed and modified within the view, adhering to principles of encapsulation and forming a clean public interface.

You can see the Sample GUI screenshots section at the end of this document to assist in visualising how the GUI should generally look and behave, although you may use this as a guide and be creative where applicable.

The Controller

The model and view have been decoupled by deploying a MVC architecture with a separate controller, which will contain the event handlers and general behaviour for this application. To help you get started with this you have been provided with a controller package containing the ModulSelectionToolController class. So far the controller initialises a reference to the view and model, along with its current subcontainers.

You will also notice a method within the controller class called generateAndReturnCourses, which populates an array of type Course with the required hardcoded module data. When you load the GUI, the "Create Profile" tab displays a combo box, populated with the two aforementioned computing courses. You will note the addCoursesToComboBox method undertakes this task.

Event Handling: The remaining key purpose of the controller is to define event handlers. To help you get started you have been given the exit handler along with an empty create student profile handler, which is attached to the create profile pane in the view.

See below details of what each event handler should broadly do. Note there are multiple add and remove handlers required across both the select and reserve modules tabs (please refer to Sample GUI Screenshots). It is also assumed you will consider appropriate validation to aid the behaviour of the application where relevant:
• Create Student Profile Handler - captures the details of the student and stores them within the data model (including their selected course). It should then dynamically populate the select modules tab with the initial unselected and (compulsory) selected modules based on the chosen course.
• Reset Handler - resets the selected modules tab to populate the initial unselected and (compulsory) selected modules based on the current chosen course.
• Add Handlers - removes the current selected module from the unselected modules list view and adds it to the selected (or reserved) modules list view (for a given term).
• Remove Handlers - removes the current selected module from the selected (or reserved) modules list view and adds it back to the unselected modules list view (for a given term).
• Submit Handler - captures the details of the selected modules and adds them into the data model. It should then dynamically populate the reserve modules tab with any remaining unselected term 1 and term 2 modules.
• Confirm Handlers - captures the details of the reserved modules for a given term and adds them into the data model. Once both terms have been confirmed an overview of the student's details, selected modules and reserved modules should appear dynamically on the overview selection tab.
• Save Overview Handler - save an overview of the student's details, as well as their selected and reserved modules in text format using a PrintWriter (or suitable alternative), choosing a custom representation.
• Save Profile Handler - save the student profile (data model) to a file in binary format using an ObjectOutputStream.

• Load Student Data Handler - restore the student profile (data model) from a file using an ObjectInputStream. You should also consider how best to bring the GUI (view) back to its previous state (at the point of saving).
• About Handler - trigger a popup window containing basic details of the application.
• Exit Handler - close the current window and terminate the application.

Note: Whilst you can use the hardcoded module data provided in the controller, a more advanced requirement of the application, would be to use a Scanner to dynamically load the course and module data into the application from a text file. This would allow for the input data to be more easily evolved in the future.

Attachment:- Object Oriented Development.rar