From e21be3aea31959219aafc4e28d983bafa95cde0a Mon Sep 17 00:00:00 2001 From: WillemDalton Date: Mon, 6 Oct 2025 10:25:23 -0400 Subject: moved some menu logic over to the search subystem, added a new query class --- .../model/course_search/CurrentSearchQuery.java | 63 ++++++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 src/main/java/design/model/course_search/CurrentSearchQuery.java (limited to 'src/main/java/design/model/course_search/CurrentSearchQuery.java') 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..45364f4 --- /dev/null +++ b/src/main/java/design/model/course_search/CurrentSearchQuery.java @@ -0,0 +1,63 @@ +package design.model.course_search; + +import java.util.ArrayList; +import java.util.List; + +import design.persistence.MasterDatabase; + +/* + * Represents the state of our current search. + */ +public class CurrentSearchQuery { + public static final CurrentSearchQuery INSTANCE = new CurrentSearchQuery(); + + + private CourseList query; + MasterDatabase db = MasterDatabase.INSTANCE; + private final List filters = new ArrayList(); + + public void initialize() + { + query = db.getCourseList(); + } + + public void addFilter(CourseSorter filter) + { + filters.add(filter); + } + + public void clearFilters() + { + filters.clear(); + } + + public String printFilters() + { + String filterResult = ""; + + if(filters.size() == 0) + { + return "nothing"; + } + + for( CourseSorter f : filters) + { + filterResult += f.toString() + " --> "; + } + + filterResult = filterResult.substring(0, filterResult.length() - 5); + filterResult += "\n"; + + return filterResult; + } + + public List getFilters() + { + return filters; + } + + public CourseList getQueryResult() + { + return query; + } +} -- cgit v1.2.3 From 9843e29a51bb6c21b21567b147c1ad301291ec85 Mon Sep 17 00:00:00 2001 From: WillemDalton Date: Mon, 6 Oct 2025 17:06:42 -0400 Subject: more progress on getting searching to work --- .../model/course_search/CurrentSearchQuery.java | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) (limited to 'src/main/java/design/model/course_search/CurrentSearchQuery.java') diff --git a/src/main/java/design/model/course_search/CurrentSearchQuery.java b/src/main/java/design/model/course_search/CurrentSearchQuery.java index 45364f4..1f8c8ba 100644 --- a/src/main/java/design/model/course_search/CurrentSearchQuery.java +++ b/src/main/java/design/model/course_search/CurrentSearchQuery.java @@ -2,6 +2,7 @@ package design.model.course_search; import java.util.ArrayList; import java.util.List; +import java.util.stream.Collectors; import design.persistence.MasterDatabase; @@ -16,21 +17,26 @@ public class CurrentSearchQuery { MasterDatabase db = MasterDatabase.INSTANCE; private final List filters = new ArrayList(); + + // initialize the query to the master DB public void initialize() { 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 ( this is for the model checking used filters ) public String printFilters() { String filterResult = ""; @@ -51,13 +57,28 @@ public class CurrentSearchQuery { return filterResult; } + // get all the filters public List getFilters() { return filters; } + // get our current query. public CourseList getQueryResult() { return query; } + + public CourseList search(String[] searchQuery) + { + List courses = query.getCourses(); + + courses = courses.stream() + .filter(s -> s.toString().toLowerCase().contains(searchQuery[0].toLowerCase())) + .collect(Collectors.toList()); + + query.setCourses(courses); + + return query; + } } -- cgit v1.2.3 From 09f5536f3e21d910e79daf49a67e9e98e9554751 Mon Sep 17 00:00:00 2001 From: WillemDalton Date: Mon, 6 Oct 2025 18:01:55 -0400 Subject: finished searching just need to order by our sorting strategies. --- .../model/course_search/CurrentSearchQuery.java | 26 +++++++++------------- 1 file changed, 11 insertions(+), 15 deletions(-) (limited to 'src/main/java/design/model/course_search/CurrentSearchQuery.java') diff --git a/src/main/java/design/model/course_search/CurrentSearchQuery.java b/src/main/java/design/model/course_search/CurrentSearchQuery.java index 1f8c8ba..0a492b3 100644 --- a/src/main/java/design/model/course_search/CurrentSearchQuery.java +++ b/src/main/java/design/model/course_search/CurrentSearchQuery.java @@ -13,17 +13,10 @@ public class CurrentSearchQuery { public static final CurrentSearchQuery INSTANCE = new CurrentSearchQuery(); - private CourseList query; MasterDatabase db = MasterDatabase.INSTANCE; + private CourseList query = db.getCourseList(); private final List filters = new ArrayList(); - - // initialize the query to the master DB - public void initialize() - { - query = db.getCourseList(); - } - // add a new filter public void addFilter(CourseSorter filter) { @@ -41,6 +34,7 @@ public class CurrentSearchQuery { { String filterResult = ""; + // no filters? let the user know. if(filters.size() == 0) { return "nothing"; @@ -51,7 +45,8 @@ public class CurrentSearchQuery { filterResult += f.toString() + " --> "; } - filterResult = filterResult.substring(0, filterResult.length() - 5); + // very silly way of removing the last arrow from our filter list. it's kind of dumb but it works fine. + filterResult = filterResult.substring(0, filterResult.length() - 5); filterResult += "\n"; return filterResult; @@ -69,16 +64,17 @@ public class CurrentSearchQuery { return query; } - public CourseList search(String[] searchQuery) + public void search(String searchQuery) { - List courses = query.getCourses(); + List courses; - courses = courses.stream() - .filter(s -> s.toString().toLowerCase().contains(searchQuery[0].toLowerCase())) + // compare to our search query. + courses = query.getCourses().stream() + .filter(s -> s != null && s.toString().toLowerCase().contains(searchQuery)) .collect(Collectors.toList()); - query.setCourses(courses); + // TO DO: Filter this based on our current filters, then return it! - return query; + query.setCourses(courses); } } -- cgit v1.2.3 From a697cdcd21092119208d59209da2127b2ad02477 Mon Sep 17 00:00:00 2001 From: WillemDalton Date: Mon, 6 Oct 2025 22:50:40 -0400 Subject: working on course filtering --- .../model/course_search/CurrentSearchQuery.java | 24 ++++++++++++++-------- 1 file changed, 15 insertions(+), 9 deletions(-) (limited to 'src/main/java/design/model/course_search/CurrentSearchQuery.java') diff --git a/src/main/java/design/model/course_search/CurrentSearchQuery.java b/src/main/java/design/model/course_search/CurrentSearchQuery.java index 0a492b3..3916f0a 100644 --- a/src/main/java/design/model/course_search/CurrentSearchQuery.java +++ b/src/main/java/design/model/course_search/CurrentSearchQuery.java @@ -64,17 +64,23 @@ public class CurrentSearchQuery { return query; } - public void search(String searchQuery) + public void search(String searchQuery) { - List courses; + List courses = db.getCourseList().getCourses().stream() + .filter(s -> s != null && s.toString().toLowerCase().contains(searchQuery.toLowerCase())) + .collect(Collectors.toList()); - // compare to our search query. - courses = query.getCourses().stream() - .filter(s -> s != null && s.toString().toLowerCase().contains(searchQuery)) - .collect(Collectors.toList()); + // Start with filtered base + CourseList current = new CourseList(); + current.setCourses(courses); - // TO DO: Filter this based on our current filters, then return it! - - query.setCourses(courses); + // Sequentially apply filters + for (CourseSorter filter : filters) + { + current.setSorter(filter); + current = current.groupByCurrentSorter(); // regroup after each + } + + query = current; } } -- cgit v1.2.3 From db1ede10a6547b51ffed71dc86d73f3a6c8af129 Mon Sep 17 00:00:00 2001 From: WillemDalton Date: Tue, 7 Oct 2025 09:10:05 -0400 Subject: added some comments, allows users to add courses to profile, fixed displaying course lists --- .../model/course_search/CurrentSearchQuery.java | 30 ++++++++++------------ 1 file changed, 14 insertions(+), 16 deletions(-) (limited to 'src/main/java/design/model/course_search/CurrentSearchQuery.java') diff --git a/src/main/java/design/model/course_search/CurrentSearchQuery.java b/src/main/java/design/model/course_search/CurrentSearchQuery.java index 3916f0a..c00eb86 100644 --- a/src/main/java/design/model/course_search/CurrentSearchQuery.java +++ b/src/main/java/design/model/course_search/CurrentSearchQuery.java @@ -12,11 +12,19 @@ import design.persistence.MasterDatabase; 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 filters = new ArrayList(); + + // reset the query + public void reset() + { + query = db.getCourseList(); + clearFilters(); + } + // add a new filter public void addFilter(CourseSorter filter) { @@ -29,7 +37,7 @@ public class CurrentSearchQuery { filters.clear(); } - // print out the filters ( this is for the model checking used filters ) + // print out the filters we're currently using and the order public String printFilters() { String filterResult = ""; @@ -45,7 +53,7 @@ public class CurrentSearchQuery { filterResult += f.toString() + " --> "; } - // very silly way of removing the last arrow from our filter list. it's kind of dumb but it works fine. + // remove last arrow and add padding filterResult = filterResult.substring(0, filterResult.length() - 5); filterResult += "\n"; @@ -66,21 +74,11 @@ public class CurrentSearchQuery { public void search(String searchQuery) { + // only grab courses which fit our search List courses = db.getCourseList().getCourses().stream() - .filter(s -> s != null && s.toString().toLowerCase().contains(searchQuery.toLowerCase())) + .filter(s -> s.toString().toLowerCase().contains(searchQuery.toLowerCase())) .collect(Collectors.toList()); - // Start with filtered base - CourseList current = new CourseList(); - current.setCourses(courses); - - // Sequentially apply filters - for (CourseSorter filter : filters) - { - current.setSorter(filter); - current = current.groupByCurrentSorter(); // regroup after each - } - - query = current; + query.setCourses(courses); } } -- cgit v1.2.3 From 2ef38d86d8b207bc0dad6e3c6b7780abc6f6e82b Mon Sep 17 00:00:00 2001 From: WillemDalton Date: Wed, 8 Oct 2025 21:49:21 -0400 Subject: finished multi filtering --- .../model/course_search/CurrentSearchQuery.java | 77 +++++++++++++++++++++- 1 file changed, 74 insertions(+), 3 deletions(-) (limited to 'src/main/java/design/model/course_search/CurrentSearchQuery.java') diff --git a/src/main/java/design/model/course_search/CurrentSearchQuery.java b/src/main/java/design/model/course_search/CurrentSearchQuery.java index c00eb86..e1f52ce 100644 --- a/src/main/java/design/model/course_search/CurrentSearchQuery.java +++ b/src/main/java/design/model/course_search/CurrentSearchQuery.java @@ -17,12 +17,10 @@ public class CurrentSearchQuery { private CourseList query = db.getCourseList(); private final List filters = new ArrayList(); - // reset the query public void reset() { query = db.getCourseList(); - clearFilters(); } // add a new filter @@ -79,6 +77,79 @@ public class CurrentSearchQuery { .filter(s -> s.toString().toLowerCase().contains(searchQuery.toLowerCase())) .collect(Collectors.toList()); - query.setCourses(courses); + // 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 filters, List 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 applyFiltersRecursive(List courses, List 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 result = new ArrayList<>(); + + // courses with an equal value. + List 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 group, List 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; + } } -- cgit v1.2.3 From ddcfcf82baf737e183ec7b00edeee26894516c58 Mon Sep 17 00:00:00 2001 From: sowgro Date: Thu, 9 Oct 2025 08:06:56 -0400 Subject: fix formatting --- .../model/course_search/CurrentSearchQuery.java | 75 +++++++++------------- 1 file changed, 29 insertions(+), 46 deletions(-) (limited to 'src/main/java/design/model/course_search/CurrentSearchQuery.java') diff --git a/src/main/java/design/model/course_search/CurrentSearchQuery.java b/src/main/java/design/model/course_search/CurrentSearchQuery.java index e1f52ce..999dfcb 100644 --- a/src/main/java/design/model/course_search/CurrentSearchQuery.java +++ b/src/main/java/design/model/course_search/CurrentSearchQuery.java @@ -1,81 +1,72 @@ package design.model.course_search; +import design.persistence.MasterDatabase; + import java.util.ArrayList; import java.util.List; import java.util.stream.Collectors; -import design.persistence.MasterDatabase; - -/* +/* * 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 filters = new ArrayList(); // reset the query - public void reset() - { + public void reset() { query = db.getCourseList(); } // add a new filter - public void addFilter(CourseSorter filter) - { + public void addFilter(CourseSorter filter) { filters.add(filter); } // clear the filters - public void clearFilters() - { + public void clearFilters() { filters.clear(); } // print out the filters we're currently using and the order - public String printFilters() - { + public String printFilters() { String filterResult = ""; // no filters? let the user know. - if(filters.size() == 0) - { + if (filters.size() == 0) { return "nothing"; } - for( CourseSorter f : filters) - { + for (CourseSorter f : filters) { filterResult += f.toString() + " --> "; } // remove last arrow and add padding - filterResult = filterResult.substring(0, filterResult.length() - 5); + filterResult = filterResult.substring(0, filterResult.length() - 5); filterResult += "\n"; return filterResult; } // get all the filters - public List getFilters() - { + public List getFilters() { return filters; } // get our current query. - public CourseList getQueryResult() - { + public CourseList getQueryResult() { return query; } - public void search(String searchQuery) - { + public void search(String searchQuery) { // only grab courses which fit our search List courses = db.getCourseList().getCourses().stream() - .filter(s -> s.toString().toLowerCase().contains(searchQuery.toLowerCase())) - .collect(Collectors.toList()); + .filter(s -> s.toString().toLowerCase().contains(searchQuery.toLowerCase())) + .collect(Collectors.toList()); // and now, we filter it! CourseList filtered = applyFilters(filters, courses); @@ -83,19 +74,16 @@ public class CurrentSearchQuery { } // to apply our filters we need to traverse the tree and make new grouping as we go. - public CourseList applyFilters(List filters, List coursesToFilter) - { + public CourseList applyFilters(List filters, List 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 applyFiltersRecursive(List courses, List 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) - { + private List applyFiltersRecursive(List courses, List 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; } @@ -112,17 +100,14 @@ public class CurrentSearchQuery { ICourse prev = null; // run through the courses, if - for (ICourse c : courses) - { + 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)) - { + * 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()) - { + if (!currentGroup.isEmpty()) { result.add(makeGroup(currentGroup, filters, level)); currentGroup = new ArrayList<>(); } @@ -133,8 +118,7 @@ public class CurrentSearchQuery { } // handle the last group. - if (!currentGroup.isEmpty()) - { + if (!currentGroup.isEmpty()) { result.add(makeGroup(currentGroup, filters, level)); } @@ -142,8 +126,7 @@ public class CurrentSearchQuery { } // make a CourseList group, a sublist of a group, and filter it. - private ICourse makeGroup(List group, List filters, int level) - { + private ICourse makeGroup(List group, List filters, int level) { // base case, group only has one course in it (already sorted) if (group.size() == 1) return group.get(0); @@ -151,5 +134,5 @@ public class CurrentSearchQuery { CourseList subList = new CourseList(); subList.setCourses(applyFiltersRecursive(group, filters, level + 1)); return subList; - } + } } -- cgit v1.2.3