diff options
Diffstat (limited to 'src/main/java')
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); } |