In Northeastern's documentation and in the degree audit, the two-letter semester designation for a class that branches both Summer 1 and Summer 2 ('S1' and 'S2') is 'SM'. Currently, the data definition uses 'SF'. This can and will inhibit compatibility with Northeastern services that make use of the two-letter semester designation system so it should be changed.

Semesters always belong to a year, years store the academic year num and hence semesters don't need to store them

Needs:

Sample .html file to test parsing on.

• double major, major-minor, combined major, single major.

JSON verifier to ensure JSONObject is properly formatted.

• ensures object has necessary attributes and types before parsing data.

Some work has already been done. The mockups need to be finalized and moved to the handoff page.

Support co-ops in a schedule. Probably just want to display a draggable "co-op" block in the sidebar that users can drag into the semester.

Currently, the parser is not able to handle a list of requirements associated with multiple courses of different genres. For example, if a course is required from an enumeration of courses, and that course can be part of multiple subjects (a CS capstone can be a DS course) the parser is not able to recognize that the DS course is part of this enumeration as well and there is not a current data representation for one.

For this:

• suggest a data representation for requiring courses for different subjects for an enumeration of courses
• implement such a data representation
• validate the data representation with testing, updating expected aspects of a degree audit to conform to this new course representation

For third-year students who've taken 16+ courses, it may be a lot easier to upload their degree audit, than manually enter in all the courses they've taken. However for a first-year, it would be super convenient to just select a major and enter the four or so courses they've taken. Additionally, this would provide an alternative to those with qualms against uploading their degree audit.

This would entail retrieving degree requirements from elsewhere, aka scraping the Northeastern catalog. For example, here are the chemical engineering degree requirements.

Once implemented, this could also serve to help SearchNEU. See the issue here.

Credit to Da-Jin:
"I'm starting to wonder if it would be easier for some students to just select their major and then enter which classes they've taken, rather than do the entire degree audit process. Someone in their third year would enjoy the convenience of extracting all 16+ classes they taken out of the degree audit, but for someone in their first/second semester, wouldn't that be more work than it's worth?"

Once designs are ready, implement functionality to add and remove a year from a schedule.

All duplicate courses get deleted if one course is delete. Fix this to only delete the one being deleted.

Edit: We should simply prevent duplicate courses in 1 semester lmao.

This issue is for changing the "requirement" objects produced by the HTML parser to provide more information about their specifics.

See issue #18 "Fix class list representation" for details about requirement enumerations with multiple subjects.

See issue #21 "add "type" property to requirements while parsing html" for details about adding a new property "type" to further specify what KIND of requirement the object represents.

This issue also covers additional requirement specifications that may be decided in the future, at the will of the authors.

Currently, we're using fetch to grab the plans and majors from the SearchNEU endpoint, where we really should be using a client like Relay or Apollo to do so. The GraphQL website describes why a client is good, here.

Here's a good article contrasting the two.

This concerns the part of the frontend that makes requests to the majors/plans, in frontend/src/utils/fetchMajorsAndPlans.ts.

This could be also added to the plan parser in backend/src/prereq_loader.ts.

Currently, the function that simplifies prerequisites based on courses already taken, takes a really long time to run. This is because every single time we call the function, we take time to parse all the completed courses, build up a hashmap containing all of them, and then parse the prerequisite object.

This would be a lot faster if the hashmap object only had to be build once for all of the prereqs, rather than built once for every function call.

The function is called filterAndSimplifyPrereqs in json_parser.js

Previously we did this in the sidebar by making the unfulfilled requirements red. We want to rethink this and come up with a better way of displaying the errors from our validation algorithm.

Style the login and signup pages according to the designs on figma.

Currently:

Was: functional, but not well organized.
Now: non-functional, but well organized.

Deliverable:

Make both functional and well organized.

Semester credits display as NaN in the plan when adding a course from the sidebar (or having preexisting courses from the sidebar). Currently reproducable on main.

For some reason when trying to drag a course fast out the sidebar, the course doesn't actually drag?

For different majors, there are different patterns of requirements.

This issue proposes adding a "type" property to requirement objects, that would help specify the way that the requirement is meant to be completed.

For example a requirement with the "take one of the following" patterns could have the type "one-of", or "or", or ...

Another pattern is the "range except". This requirement specifies classes in a range from some number to another number, except some other union of courses. This can be seen in the new CS major requirements (with concentrations):

Adding this property to requirements is needed to suggest courses that could then fill those requirements, for the user to pick.

Any UX changes so that the app looks like it has just released and is being continuously worked on. Potentially some tooltips/popups to guide users through the app.

• Alpha UX cleanup
  • Displaying full course name in draggable courses
  • Hover on year to expand instead of show hide button
  • Feedback mechanism
    • Link to a google form

• Error boundary is remove in the migrating to react 18 PR since our current error boundary isn't compatible w react 18. Get it back up - easiest thing to do is just use the default react error boundary(we don't need another dependency).
• Style the error page with this design
• Liaise with Angela/Elaine to ensure that once implemented, technical implementation is up to design standards

Checklist for completion:

• Error boundary should display on any route that doesn't exist
• Error boundary should also be appropriately styled for mobile use

Update the existing mockups to add support for deleting a plan.

• Use the major validation algorithm to display validation errors in the sidebar

Things left to do:

• implement topological sort on created graph
• add functionality to deal with nested prerequisites when parsing the graph

• Dockerize the frontend and backend by adding 2 docker files
• Enable CD so that pushing to main gets auto deployed
  • For testing purpose try changing it to deploying when you push to your branch. If it works change it to "on push to main".

• Currently, we display "course not found" when a course is being fetched. We should display a loading state instead, "loading..." works.

We'll be working with @hankewyczz to add batch fetching courses.

We will review his PR and then update our search client to support batch fetching.

Context

• We're having performance issues with dnd when we render the sidebar.
• Specifically, dragging is slow.
• We found out that this is because of the amount of html content within a component.

Possible solutions

• Hide trash button + content that can be hidden in a draggable course. Only show it when necessary: on hover, like the previous app. THIS IS PROVEN TO HELP A LOT.

Other solutions if we still need improvement

• Virtualized lists to prevent all draggable courses to be a part of the dom
• Only allow one requirement section to be expanded at a time so that a massive requirement section doesn't bottleneck the performance

Needs to query the following from SearchNEU:

• courses with # within a certain range. Ex. CS 2500-9999
• prerequisites of a given course.
• all courses with a given NUPath

Potentially need to find:

• when courses are offered (perhaps inference based on past semesters?)

Deliverables:

• functions that will make the queries necessary
• functions that will parse resulting information to usable information.

The plan styling is broken right now in Safari (only one year displays, and takes up the entire screen vertically, show buttons are in the wrong place).

I'm greeted with a blank screen on both mobile and desktop (Firefox) when visiting the site.

Getting a 404 when trying to GET graduatenu.com.

• Some courses can be of many credits
• Example: https://searchneu.com/NEU/202330/classPage/ENTR/5000
  Shoutout to @AlpacaFur for catching this!

Achieve normalized output for different input degree audits for the HTML parser.

Perhaps printer-friendly?

It is possible for courses to have the same course number, subject, and term (the current definition of course sameness) but to be distinct courses - honors courses, for example. As such, a definition of sameness must also rely on the distinct name of the course during the term.

Deliverables:

• each in-progress or completed course requires a course name to be associated with it
• enforce constraint that course name alongside number, subject or term
• revise tests to reflect this constraint

Structuring the code is dependent on the application framework. Research needed for choosing a fitting framework.

Should have a meeting to discuss (a) what framework to use and (b) working on the frontend.

Plan parser does not work on the following plan of study:

plan

This is because there are 3 courses, and we only catch the first 2.

instead of leaving them lying around in ./, move them to somewhere like ./data or something.

We're looking for designs on displaying pre-req/co-req course errors, and credit overload semester errors.

Currently, infinite loops on me_audit.html. Prerequisite parsing needs to be converted to be short-circuiting.