Merge pull request #10 from RIT-SWEN-262/course-search

Course Search Menu

16 files changed, 490 insertions, 53 deletions

diff --git a/src/main/java/design/controller/userinput/menus/CourseSearch.java b/src/main/java/design/controller/userinput/menus/CourseSearch.java
new file mode 100644
index 0000000..019965c
--- /dev/null
+++ b/src/main/java/design/controller/userinput/menus/CourseSearch.java
@@ -0,0 +1,104 @@
+package design.controller.userinput.menus;
+
+import design.controller.userinput.Menu;
+import design.controller.userinput.MenuOption;
+import design.model.Course;
+import design.model.Golfer;
+import design.model.course_search.CourseList;
+import design.model.course_search.CurrentSearchQuery;
+import design.model.course_search.ICourse;
+import design.persistence.PersonalDatabase;
+import design.runtime.Session;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+/*
+ * The actual SEARCH feature of course searching.
+ */
+public class CourseSearch extends Menu {
+    CurrentSearchQuery query = CurrentSearchQuery.INSTANCE;
+    PersonalDatabase GolferDB = PersonalDatabase.INSTANCE;
+
+    @Override
+    public String getTitle() {
+        return "select course";
+    }
+
+    /*
+     * Prompt for input and search.
+     */
+    public void search() {
+        System.out.print("Enter search term (blank for all): ");
+        Scanner sc = new Scanner(System.in);
+        String searchTerm = sc.nextLine();
+
+        // search and present 
+        query.search(searchTerm);
+        this.present();
+
+        // reset the query after we're done.
+        query.reset();
+    }
+
+    /*
+     * Display the results of our search.
+     */
+    @Override
+    public List<MenuOption> getMenuOptions() {
+        var l = new ArrayList<MenuOption>();
+        List<ICourse> queryResult = query.getQueryResult().getCourses();
+
+        // 0 - return to main menu
+        l.add(new MenuOption("return to main menu", () -> new MainMenu().present()));
+
+        // if we find no results, let the user know.
+        if (queryResult.isEmpty()) {
+            System.out.println("\nNo matching courses found.\n");
+        }
+
+        // traverse the course list tree and add menu options for each leaf (course)
+        addCoursesRecursive(l, query.getQueryResult());
+        return l;
+    }
+
+
+    // recursively go through tree structure of courselist to make menu options.
+    // this is all for displaying the menu options, not the actual sorting. 
+    private void addCoursesRecursive(List<MenuOption> menuOptions, CourseList list) {
+        for (ICourse icourse : list.getCourses()) {
+            // if we find a leaf (course), display it as a menu option
+            if (icourse instanceof Course c) {
+                var name = String.format("%s, %s, Difficulty: %s, %s holes, %s total par",
+                        c.getName(), c.getLocation(), c.getDifficultyRating(), c.getHoleCount(), c.getTotalPar());
+                menuOptions.add(new MenuOption(name, () -> {
+                    Golfer currentGolfer = Session.getCurrentGolfer();
+                    if (currentGolfer == null) {
+                        // if we aren't logged in, notify the user.
+                        System.out.println("\n\n !!! log into a golfer account to add courses to your profile. !!! \n\n");
+                        new MainMenu().present();
+                        return;
+                    }
+
+                    // add the course, try to save to DB.
+                    currentGolfer.addCourse(c);
+                    try {
+                        GolferDB.updateGolfer(currentGolfer);
+                    } catch (IOException e) {
+                        e.printStackTrace(); // not sure if we should format this prettier for the user if the DB fails.
+                    }
+
+                    System.out.println("\n Course added to profile. \n");
+                    new MainMenu().present();
+                }
+                ));
+            }
+            // if not, we need to traverse another courselist
+            else if (icourse instanceof CourseList sublist) {
+                addCoursesRecursive(menuOptions, sublist);
+            }
+        }
+    }
+}
diff --git a/src/main/java/design/controller/userinput/menus/FiltersMenu.java b/src/main/java/design/controller/userinput/menus/FiltersMenu.java
new file mode 100644
index 0000000..9f2d8df
--- /dev/null
+++ b/src/main/java/design/controller/userinput/menus/FiltersMenu.java
@@ -0,0 +1,53 @@
+package design.controller.userinput.menus;
+
+import design.controller.userinput.Menu;
+import design.controller.userinput.MenuOption;
+import design.model.course_search.*;
+
+import java.util.List;
+
+import design.model.course_search.CurrentSearchQuery;
+
+/*
+ * Tracks the user's current filters on their search.
+ */
+public class FiltersMenu extends Menu {
+    CurrentSearchQuery query = CurrentSearchQuery.INSTANCE;
+
+    @Override
+    public String getTitle() {
+        return "filter menu";
+    }
+
+    /*
+     * Add a new filter to our filter list
+     */
+    public void addFilter(CourseSorter filter) {
+        CurrentSearchQuery.INSTANCE.addFilter(filter);
+        System.out.println("\nAdded filter.\n");
+        new SearchMenu().present();
+    }
+
+    /*
+     * clear all of our filters.
+     */
+    public void clearFilters() {
+        CurrentSearchQuery.INSTANCE.clearFilters();
+        System.out.println("\nCleared all filters.\n");
+        new SearchMenu().present();        
+    }
+
+    /*
+     * show our current filters.
+     */
+    @Override
+    public List<MenuOption> getMenuOptions() {
+
+        System.out.println("\nYou are filtering by ");
+        System.out.println(query.printFilters());
+
+        return List.of(
+                new MenuOption("return to search", () -> new SearchMenu().present())
+        );
+    }
+}
diff --git a/src/main/java/design/controller/userinput/menus/MainMenu.java b/src/main/java/design/controller/userinput/menus/MainMenu.java
index 1d6b72d..71a93b0 100644
--- a/src/main/java/design/controller/userinput/menus/MainMenu.java
+++ b/src/main/java/design/controller/userinput/menus/MainMenu.java
@@ -15,6 +15,7 @@ public class MainMenu extends Menu {
     public List<MenuOption> getMenuOptions() {
         return List.of(
                 new MenuOption("user settings...", () -> new UserSettings().present()),
+                new MenuOption("add course to profile...", () -> new SearchMenu().present()),
                 new MenuOption("statistics...", () -> new StatisticsMenu().present()),
                 new MenuOption("log round...", () -> new CourseSelectMenu().present()),
                 new MenuOption("quit", () -> {}));
diff --git a/src/main/java/design/controller/userinput/menus/SearchMenu.java b/src/main/java/design/controller/userinput/menus/SearchMenu.java
new file mode 100644
index 0000000..8b50265
--- /dev/null
+++ b/src/main/java/design/controller/userinput/menus/SearchMenu.java
@@ -0,0 +1,35 @@
+package design.controller.userinput.menus;
+
+import design.controller.userinput.Menu;
+import design.controller.userinput.MenuOption;
+import design.model.course_search.SortByDifficulty;
+import design.model.course_search.SortByHoles;
+import design.model.course_search.SortByLocation;
+import design.model.course_search.SortByPar;
+
+import java.util.List;
+
+/*
+ * The main control panel for course searching.
+ */
+public class SearchMenu extends Menu {
+
+    @Override
+    public String getTitle() {
+        return "search menu";
+    }
+
+    @Override
+    public List<MenuOption> getMenuOptions() {
+        return List.of(
+                new MenuOption("return to main menu", () -> new MainMenu().present()),
+                new MenuOption("search...", () -> new CourseSearch().search()),
+                new MenuOption("add difficulty filter...", () -> new FiltersMenu().addFilter(new SortByDifficulty())),
+                new MenuOption("add hole count filter...", () -> new FiltersMenu().addFilter(new SortByHoles())),
+                new MenuOption("add location filter...", () -> new FiltersMenu().addFilter(new SortByLocation())),
+                new MenuOption("add par filter...", () -> new FiltersMenu().addFilter(new SortByPar())),
+                new MenuOption("list filters", () -> new FiltersMenu().present()),
+                new MenuOption("clear all filters", () -> new FiltersMenu().clearFilters())
+        );
+    }
+}
diff --git a/src/main/java/design/model/Course.java b/src/main/java/design/model/Course.java
index f907622..c199563 100644
--- a/src/main/java/design/model/Course.java
+++ b/src/main/java/design/model/Course.java
@@ -1,5 +1,6 @@
 package design.model;
 
+import design.model.course_search.CourseList;
 import design.model.course_search.ICourse;
 
 import java.util.List;
@@ -23,32 +24,43 @@ public class Course implements ICourse {
         this.totalPar = totalPar;
         this.holes = holes;
     }
-
+    
     public int getId() {
         return id;
     }
-
+    
+    @Override
     public String getName() {
         return name;
     }
-
+    
+    @Override
     public float getDifficultyRating() {
         return difficultyRating;
     }
-
+    
+    @Override
     public String getLocation() {
         return location;
     }
-
+    
+    @Override   
     public int getHoleCount() {
         return holeCount;
     }
-
+    
+    @Override
     public int getTotalPar() {
         return totalPar;
     }
-
+    
+    @Override
     public List<Hole> getHoles() {
         return holes;
     }
+    
+    @Override
+    public String toString() {
+        return name + ", " + location + ", " + difficultyRating + ", " + holeCount + ", " + totalPar;
+    }
 }
diff --git a/src/main/java/design/model/course_search/CourseList.java b/src/main/java/design/model/course_search/CourseList.java
index 82648c2..c2411f7 100644
--- a/src/main/java/design/model/course_search/CourseList.java
+++ b/src/main/java/design/model/course_search/CourseList.java
@@ -1,10 +1,10 @@
 package design.model.course_search;
 
+import design.model.Hole;
+
 import java.util.ArrayList;
 import java.util.List;
 
-import design.model.*;
-
 /*
  * Defines a list of courses that can be sorted, added to or removed from.
  * Willem Dalton
@@ -13,56 +13,49 @@ public class CourseList implements ICourse {
     private CourseSorter sorter;
     private List<ICourse> courses;
 
-    public CourseList()
-    {
+    public CourseList() {
         courses = new ArrayList<>();
     }
 
     /*
      * Grab the list of courses
      */
-    public List<ICourse> getCourses()
-    {
+    public List<ICourse> getCourses() {
         return courses;
     }
 
     /*
      * Set the list of courses equal to an existing list
      */
-    public void setCourses(List<ICourse> courses)
-    {
+    public void setCourses(List<ICourse> courses) {
         this.courses = courses;
     }
 
     /*
-    * set the chosen sorting algorithm for the given list.
-    */
-    public void setSorter(CourseSorter courseSorter)
-    {
+     * set the chosen sorting algorithm for the given list.
+     */
+    public void setSorter(CourseSorter courseSorter) {
         sorter = courseSorter;
     }
 
     /*
      * Add a new course to the list.
      */
-    public void add(ICourse course)
-    {
+    public void add(ICourse course) {
         courses.add(course);
     }
 
     /*
-     * Remove a course from the list. 
+     * Remove a course from the list.
      */
-    public void remove(ICourse course)
-    {
+    public void remove(ICourse course) {
         courses.remove(course);
     }
 
     /*
      * Sort the list.
      */
-    public void sort()
-    {
+    public void sort() {
         sorter.sortCourses(courses);
     }
 
@@ -70,20 +63,37 @@ public class CourseList implements ICourse {
      * All overrides of the ICourse class. This is a drawback of the composite pattern, but it's pretty negligible here. return some dummy values.
      */
     @Override
-    public String getName() { return "Course List"; }
-    
+    public String getName() {
+        return "Course List";
+    }
+
+    @Override
+    public float getDifficultyRating() {
+        return 0;
+    }
+
     @Override
-    public float getDifficultyRating() { return 0; }
+    public String getLocation() {
+        return "";
+    }
 
     @Override
-    public String getLocation() { return ""; }
-    
+    public int getTotalPar() {
+        return 0;
+    }
+
     @Override
-    public int getTotalPar() { return 0; }
+    public int getHoleCount() {
+        return 0;
+    }
 
     @Override
-    public int getHoleCount() { return 0; }
+    public List<Hole> getHoles() {
+        return null;
+    }
 
     @Override
-    public List<Hole> getHoles() { return null; }
+    public String toString() {
+        return "Course List";
+    }
 }
diff --git a/src/main/java/design/model/course_search/CourseSorter.java b/src/main/java/design/model/course_search/CourseSorter.java
index 7549645..8b4d42c 100644
--- a/src/main/java/design/model/course_search/CourseSorter.java
+++ b/src/main/java/design/model/course_search/CourseSorter.java
@@ -8,4 +8,6 @@ import java.util.List;
  */
 public interface CourseSorter {
     public void sortCourses(List<ICourse> courses);
+    public String toString();
+    public boolean isEqual(ICourse a, ICourse b);
 }
\ No newline at end of file
diff --git a/src/main/java/design/model/course_search/CurrentSearchQuery.java b/src/main/java/design/model/course_search/CurrentSearchQuery.java
new file mode 100644
index 0000000..999dfcb
--- /dev/null
+++ b/src/main/java/design/model/course_search/CurrentSearchQuery.java
@@ -0,0 +1,138 @@
+package design.model.course_search;
+
+import design.persistence.MasterDatabase;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/*
+ * Represents the state of our current search.
+ */
+public class CurrentSearchQuery {
+    public static final CurrentSearchQuery INSTANCE = new CurrentSearchQuery();
+
+    // initialize our search with the master db data
+    MasterDatabase db = MasterDatabase.INSTANCE;
+    private CourseList query = db.getCourseList();
+    private final List<CourseSorter> filters = new ArrayList<CourseSorter>();
+
+    // reset the query
+    public void reset() {
+        query = db.getCourseList();
+    }
+
+    // add a new filter
+    public void addFilter(CourseSorter filter) {
+        filters.add(filter);
+    }
+
+    // clear the filters
+    public void clearFilters() {
+        filters.clear();
+    }
+
+    // print out the filters we're currently using and the order
+    public String printFilters() {
+        String filterResult = "";
+
+        // no filters? let the user know.
+        if (filters.size() == 0) {
+            return "nothing";
+        }
+
+        for (CourseSorter f : filters) {
+            filterResult += f.toString() + " --> ";
+        }
+
+        // remove last arrow and add padding
+        filterResult = filterResult.substring(0, filterResult.length() - 5);
+        filterResult += "\n";
+
+        return filterResult;
+    }
+
+    // get all the filters
+    public List<CourseSorter> getFilters() {
+        return filters;
+    }
+
+    // get our current query.
+    public CourseList getQueryResult() {
+        return query;
+    }
+
+    public void search(String searchQuery) {
+        // only grab courses which fit our search
+        List<ICourse> courses = db.getCourseList().getCourses().stream()
+                .filter(s -> s.toString().toLowerCase().contains(searchQuery.toLowerCase()))
+                .collect(Collectors.toList());
+
+        // and now, we filter it!
+        CourseList filtered = applyFilters(filters, courses);
+        query.setCourses(filtered.getCourses());
+    }
+
+    // to apply our filters we need to traverse the tree and make new grouping as we go. 
+    public CourseList applyFilters(List<CourseSorter> filters, List<ICourse> coursesToFilter) {
+        CourseList root = new CourseList();
+        root.setCourses(applyFiltersRecursive(coursesToFilter, filters, 0));
+        return root;
+    }
+
+    // the actual recursive part. Level is how many filters deep we are.
+    private List<ICourse> applyFiltersRecursive(List<ICourse> courses, List<CourseSorter> filters, int level) {
+        // base case. we have gone past all filters or theres only one course in this list. already sorted!
+        if (level >= filters.size() || courses.size() <= 1) {
+            return courses;
+        }
+
+        // grab out current sorting strategy for this level, and sort the courselist.
+        CourseSorter sorter = filters.get(level);
+        sorter.sortCourses(courses);
+
+        // the resulting sorted list, with new groupings
+        List<ICourse> result = new ArrayList<>();
+
+        // courses with an equal value.
+        List<ICourse> currentGroup = new ArrayList<>();
+
+        ICourse prev = null;
+
+        // run through the courses, if
+        for (ICourse c : courses) {
+            /* always add the first course to a new group. when iterating through courses, if we have to values that are equal, we need to add them into a group together.
+             * think about it this way. If we have [ 1, 2, 2, 2, 3, 4 ]. 1 is first, so its in it's own group. 2 /= 1, so 2 gets its own group.
+             * now do 2 again. we add it to the existing group 2. Same with the next 2. Now 3. 3 /= 2, so we put it in it's own group.
+             */
+            if (prev == null || !sorter.isEqual(prev, c)) {
+                // already a course in that group? we now have two equal values and so 
+                if (!currentGroup.isEmpty()) {
+                    result.add(makeGroup(currentGroup, filters, level));
+                    currentGroup = new ArrayList<>();
+                }
+            }
+
+            currentGroup.add(c);
+            prev = c;
+        }
+
+        // handle the last group.
+        if (!currentGroup.isEmpty()) {
+            result.add(makeGroup(currentGroup, filters, level));
+        }
+
+        return result;
+    }
+
+    // make a CourseList group, a sublist of a group, and filter it. 
+    private ICourse makeGroup(List<ICourse> group, List<CourseSorter> filters, int level) {
+        // base case, group only has one course in it (already sorted)
+        if (group.size() == 1) return group.get(0);
+
+        // group has more than 1 course in it, it needs to be sorted more if possible.
+        CourseList subList = new CourseList();
+        subList.setCourses(applyFiltersRecursive(group, filters, level + 1));
+        return subList;
+    }
+}
diff --git a/src/main/java/design/model/course_search/SortByDifficulty.java b/src/main/java/design/model/course_search/SortByDifficulty.java
index 8c3251c..b8a8aea 100644
--- a/src/main/java/design/model/course_search/SortByDifficulty.java
+++ b/src/main/java/design/model/course_search/SortByDifficulty.java
@@ -1,15 +1,26 @@
 package design.model.course_search;
 
-import java.util.List;
 import java.util.Comparator;
+import java.util.List;
 
 /*
  * Concrete strategy for sorting courses by their difficulty rating.
  * Willem Dalton
  */
 public class SortByDifficulty implements CourseSorter {
-    public void sortCourses(List<ICourse> courses)
-    {
-        courses.sort(Comparator.comparing(ICourse::getDifficultyRating));
+
+    @Override
+    public void sortCourses(List<ICourse> courses) {
+        courses.sort(Comparator.comparing(ICourse::getDifficultyRating).reversed()); // hardest to easiest
+    }
+
+    @Override
+    public boolean isEqual(ICourse a, ICourse b) {
+        return a.getDifficultyRating() == b.getDifficultyRating();
+    }
+
+    @Override
+    public String toString() {
+        return "Difficulty";
     }
 }
\ No newline at end of file
diff --git a/src/main/java/design/model/course_search/SortByHoles.java b/src/main/java/design/model/course_search/SortByHoles.java
index b1badab..1971e42 100644
--- a/src/main/java/design/model/course_search/SortByHoles.java
+++ b/src/main/java/design/model/course_search/SortByHoles.java
@@ -1,15 +1,27 @@
 package design.model.course_search;
 
-import java.util.List;
 import java.util.Comparator;
+import java.util.List;
 
 /*
  * Concrete strategy by sorting courses by their hole count (9 or 18)
  * Willem Dalton
  */
 public class SortByHoles implements CourseSorter {
-    public void sortCourses(List<ICourse> courses)
-    {
-        courses.sort(Comparator.comparing(ICourse::getHoleCount));
+
+    @Override
+    public void sortCourses(List<ICourse> courses) {
+        courses.sort(Comparator.comparing(ICourse::getHoleCount).reversed()); // highest par to lowest par
+    }
+
+    @Override
+    public boolean isEqual(ICourse a, ICourse b) {
+        return a.getHoleCount() == b.getHoleCount();
+    }
+
+    @Override
+    public String toString() {
+        return "Hole Count";
     }
-}
\ No newline at end of file
+
+}
diff --git a/src/main/java/design/model/course_search/SortByLocation.java b/src/main/java/design/model/course_search/SortByLocation.java
index 0d8a8d2..f748a51 100644
--- a/src/main/java/design/model/course_search/SortByLocation.java
+++ b/src/main/java/design/model/course_search/SortByLocation.java
@@ -1,15 +1,26 @@
 package design.model.course_search;
 
-import java.util.List;
 import java.util.Comparator;
+import java.util.List;
 
 /*
  * Concrete strategy for sorting courses by their location.
  * Willem Dalton
  */
 public class SortByLocation implements CourseSorter {
-    public void sortCourses(List<ICourse> courses)
-    {
+
+    @Override
+    public void sortCourses(List<ICourse> courses) {
         courses.sort(Comparator.comparing(ICourse::getLocation));
     }
+
+    @Override
+    public boolean isEqual(ICourse a, ICourse b) {
+        return a.getLocation().equals(b.getLocation());
+    }
+
+    @Override
+    public String toString() {
+        return "Location";
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/design/model/course_search/SortByName.java b/src/main/java/design/model/course_search/SortByName.java
index 2847d3e..68f2a72 100644
--- a/src/main/java/design/model/course_search/SortByName.java
+++ b/src/main/java/design/model/course_search/SortByName.java
@@ -1,15 +1,26 @@
 package design.model.course_search;
 
-import java.util.List;
 import java.util.Comparator;
+import java.util.List;
 
 /*
  * Concrete strategy for sorting courses base on their name.
  * Willem Dalton
  */
 public class SortByName implements CourseSorter {
-    public void sortCourses(List<ICourse> courses)
-    {
+
+    @Override
+    public void sortCourses(List<ICourse> courses) {
         courses.sort(Comparator.comparing(ICourse::getName));
     }
+
+    @Override
+    public boolean isEqual(ICourse a, ICourse b) {
+        return a.getName().equals(b.getName());
+    }
+
+    @Override
+    public String toString() {
+        return "Name";
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/design/model/course_search/SortByPar.java b/src/main/java/design/model/course_search/SortByPar.java
index 9a3eaf9..868b39d 100644
--- a/src/main/java/design/model/course_search/SortByPar.java
+++ b/src/main/java/design/model/course_search/SortByPar.java
@@ -1,15 +1,26 @@
 package design.model.course_search;
 
-import java.util.List;
 import java.util.Comparator;
+import java.util.List;
 
 /*
  * Concrete strategy for sorting courses based on their total par.
  * Willem Dalton
  */
 public class SortByPar implements CourseSorter {
-    public void sortCourses(List<ICourse> courses)
-    {
+
+    @Override
+    public void sortCourses(List<ICourse> courses) {
         courses.sort(Comparator.comparing(ICourse::getTotalPar));
     }
+
+    @Override
+    public boolean isEqual(ICourse a, ICourse b) {
+        return a.getTotalPar() == b.getTotalPar();
+    }
+
+    @Override
+    public String toString() {
+        return "Total Par";
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/design/persistence/CSVMasterDatabase.java b/src/main/java/design/persistence/CSVMasterDatabase.java
index fe89191..adbf759 100644
--- a/src/main/java/design/persistence/CSVMasterDatabase.java
+++ b/src/main/java/design/persistence/CSVMasterDatabase.java
@@ -16,6 +16,8 @@ import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 
+import design.model.course_search.*;
+
 public class CSVMasterDatabase implements MasterDatabase {
 
     private final List<Course> cache;
@@ -57,6 +59,28 @@ public class CSVMasterDatabase implements MasterDatabase {
         return cache.get(id);
     }
 
+    @Override
+    public CourseList getCourseList() {
+        CourseList courses = new CourseList();
+        for (Course c : cache)
+        {
+            courses.add(c);
+        }
+
+        return courses;
+    }
+
+    public CourseList getCourses(String s) {
+        CourseList courses = new CourseList();
+        for (Course c : cache)
+        {
+            if(c.getName().toLowerCase().contains(s.toLowerCase()))
+            courses.add(c);
+        }
+
+        return courses;
+    }
+
     private static class CourseDeserializer extends JsonDeserializer<Course> {
         int curID = 0;
 
diff --git a/src/main/java/design/persistence/JSONPersonalDatabase.java b/src/main/java/design/persistence/JSONPersonalDatabase.java
index b034680..3975d14 100644
--- a/src/main/java/design/persistence/JSONPersonalDatabase.java
+++ b/src/main/java/design/persistence/JSONPersonalDatabase.java
@@ -76,7 +76,7 @@ public class JSONPersonalDatabase implements PersonalDatabase {
 
     @Override
     public void addGolfer(Golfer golfer) throws IOException {
-        cache.put(golfer.getUsername(), golfer);
+        cache.putIfAbsent(golfer.getUsername(), golfer);
         save();
     }
 
diff --git a/src/main/java/design/persistence/MasterDatabase.java b/src/main/java/design/persistence/MasterDatabase.java
index ddc0434..3436ee0 100644
--- a/src/main/java/design/persistence/MasterDatabase.java
+++ b/src/main/java/design/persistence/MasterDatabase.java
@@ -1,10 +1,12 @@
 package design.persistence;
 
 import design.model.Course;
+import design.model.course_search.CourseList;
 
 public interface MasterDatabase {
     MasterDatabase INSTANCE = new CSVMasterDatabase("data/golf_courses_1000.csv");
 
     Course[] getCourses();
+    CourseList getCourseList(); // unique from courses as this is a composite of ICourses.
     Course getCourse(int id);
 }