added kyle's changes to code

App/controllers/__init__.py

@@ -1,2 +1,12 @@
 from .user import *
-from .auth import *
+from .auth import *
+from .courses import *
+from .program import *
+from .staff import *
+from .student import *
+from .prerequistes import *
+from .programCourses import *
+from .studentCourseHistory import *
+from .coursePlanCourses import *
+from .coursesOfferedPerSem import *
+from .coursePlan import *

App/controllers/coursePlan.py

@@ -0,0 +1,274 @@
+from App.models import CoursePlan
+from App.database import db 
+from App.controllers import (
+    get_program_by_id, 
+    get_course_by_courseCode, 
+    get_credits, 
+    getPrereqCodes,
+    getCompletedCourses,
+    createPlanCourse,
+    deleteCourseFromCoursePlan,
+    get_allCore,
+    get_allFoun,
+    get_allElectives,
+    getCompletedCourseCodes,
+    convertToList,
+    get_all_OfferedCodes,
+    isCourseOffered,
+    programCourses_SortedbyRating,
+    programCourses_SortedbyHighestCredits,
+    get_all_courses_by_planid
+)
+
+
+def create_CoursePlan(id):
+    plan = CoursePlan(id)
+    db.session.add(plan)
+    db.session.commit()
+    return plan
+
+def getCoursePlan(studentid):
+    return CoursePlan.query.filter_by(studentId=studentid).first()
+
+def possessPrereqs(Student, course):
+    preqs = getPrereqCodes(course.courseName)
+    completed = getCompletedCourseCodes(Student.id)
+    for course in preqs:
+        if course not in completed:
+            return False
+
+    return True
+
+def addCourseToPlan(Student, courseCode):
+    course = get_course_by_courseCode(courseCode)
+    if course:
+        offered = isCourseOffered(courseCode)
+        if offered:
+            haveAllpreqs = possessPrereqs(Student, course)
+            if haveAllpreqs:
+                plan = getCoursePlan(Student.id)
+                if plan:
+                    createPlanCourse(plan.planId, courseCode)
+                    print("Course successfully added to course plan")
+                else:
+                    plan = create_CoursePlan(Student.id)
+                    createPlanCourse(plan.planId, courseCode)
+                    print("Plan successfully created and Course was successfully added to course plan")
+        else:
+            print("Course is not offered")
+    else:
+        print("Course does not exist")
+
+
+def removeCourse(Student, courseCode):
+    plan=getCoursePlan(Student.id)
+    if plan:
+        deleteCourseFromCoursePlan(plan.planid, courseCode)
+
+def getRemainingCourses(completed, required):
+    # Check if either 'completed' or 'required' is None
+    if completed is None or required is None:
+        return []  # Return an empty list or handle it in a way that makes sense for your application
+
+    completedCodes = []
+    for c in completed:
+        completedCodes.append(c.code)
+
+    remainingCodes = []
+    for r in required:
+        remainingCodes.append(r.code)
+
+
+    notCompleted = remainingCodes.copy()
+    for a in completedCodes:
+        if a in notCompleted:
+            notCompleted.remove(a)
+
+    return notCompleted
+
+
+def getRemainingCore(Student):
+    programme=get_program_by_id(Student.program_id)
+    remaining = []
+
+    if programme:
+        reqCore=get_allCore(programme.name)
+        completed = getCompletedCourses(Student.id)
+        remaining=getRemainingCourses(completed,reqCore)
+
+    return remaining
+
+
+def getRemainingFoun(Student):
+    programme = get_program_by_id(Student.program_id)
+    remaining =[]
+
+    if programme:
+        reqFoun = get_allFoun(programme.name)
+        completed = getCompletedCourses(Student.id)
+        remaining=getRemainingCourses(completed,reqFoun)
+
+    return remaining
+
+
+def getRemainingElec(Student):
+    programme = get_program_by_id(Student.program_id)  # Get the student's program
+    remaining = []
+
+    if programme:
+        reqElec = get_allElectives(programme.name)  # Use the instance method to get elective courses
+        completed = getCompletedCourses(Student.id)
+        remaining = getRemainingCourses(completed, reqElec)
+
+    return remaining
+
+
+def remElecCredits(Student):
+    programme = get_program_by_id(Student.program_id)  # Get the student's program
+    completedcourses = getCompletedCourseCodes(Student.id)
+    requiredCreds = 0
+
+    if programme:
+        requiredCreds = programme.elective_credits  # Access the elective_credits attribute
+        elective_courses = get_allElectives(programme.name)  # Use the instance method to get elective courses
+        electCodes = convertToList(elective_courses)
+        if electCodes:
+            for code in electCodes:
+                if code in completedcourses:
+                    c = get_course_by_courseCode(code)  # Get course
+                    if c:
+                        requiredCreds = requiredCreds - c.credits  # Subtract credits       
+    return requiredCreds
+
+
+def findAvailable(courseList):
+    listing=get_all_OfferedCodes()
+    available=[]
+
+    for code in courseList:
+        if code in listing:
+            available.append(code)
+
+    return available        #returns an array of course codes
+
+
+def checkPrereq(Student, recommnded):
+    validCourses=[]
+    for course in recommnded:
+        c = get_course_by_courseCode(course)
+        satisfied = possessPrereqs(Student, c)
+        if satisfied:
+            validCourses.append(c.courseCode)
+
+    return validCourses
+
+def getTopfive(list):
+    return list[:5]
+
+def prioritizeElectives(Student):
+    #get available electives
+    electives=findAvailable(getRemainingElec(Student))      
+    credits=remElecCredits(Student)
+    courses=[]
+
+    #select courses to satisfy the programme's credit requirements
+    for c in electives:     
+        if credits>0:
+            courses.append(c)
+            credits = credits - get_credits(c)
+
+    #merge available, required core and foundation courses
+    courses = courses + findAvailable(getRemainingCore(Student)) + findAvailable(getRemainingFoun(Student))
+
+    courses = checkPrereq(Student,courses)
+    return getTopfive(courses)
+
+
+def removeCoursesFromList(list1,list2):
+    newlist = list2.copy()
+    for a in list1:
+        if a in newlist:
+            newlist.remove(a)
+    return newlist
+
+
+def easyCourses(Student):
+    program = get_program_by_id(Student.program_id)
+    completed = getCompletedCourseCodes(Student.id)
+    codesSortedbyRating = programCourses_SortedbyRating(Student.program_id)
+
+    coursesToDo = removeCoursesFromList(completed, codesSortedbyRating)
+
+    elecCredits = remElecCredits(Student)
+
+    if elecCredits == 0:
+        allElectives = convertToList(get_allElectives(program.name))
+        coursesToDo = removeCoursesFromList(allElectives, coursesToDo)
+
+    coursesToDo = findAvailable(coursesToDo)
+
+    ableToDo = checkPrereq(Student, coursesToDo)
+    # for a in ableToDo:
+    #     print(a)
+
+    return getTopfive(ableToDo)
+
+
+def fastestGraduation(Student):
+    program = get_program_by_id(Student.program_id)
+    sortedCourses = programCourses_SortedbyHighestCredits(Student.program_id)
+    completed = getCompletedCourseCodes(Student.id)
+
+    coursesToDo = removeCoursesFromList(completed, sortedCourses)
+
+    elecCredits = remElecCredits(Student)
+
+    if elecCredits == 0:
+        allElectives = convertToList(get_allElectives(program.name))
+        coursesToDo = removeCoursesFromList(allElectives, coursesToDo)
+
+    coursesToDo = findAvailable(coursesToDo)
+    ableToDo = checkPrereq(Student, coursesToDo)
+
+    return getTopfive(ableToDo)
+
+def commandCall(Student, command):
+    courses = []
+
+    if command == "electives":
+        courses = prioritizeElectives(Student)
+
+    elif command == "easy":
+        courses = easyCourses(Student)
+
+    elif command == "fastest":
+        courses = fastestGraduation(Student)
+
+    else:
+        print("Invalid command")
+
+    return courses
+
+
+def generator(Student, command):
+    courses = []
+
+    plan = getCoursePlan(Student.id)
+
+    if plan is None:
+        plan = plan = create_CoursePlan(Student.id)
+
+
+    courses = commandCall(Student, command)
+
+    existingPlanCourses = get_all_courses_by_planid(plan.planId)
+
+    planCourses = []
+    for q in existingPlanCourses:
+        planCourses.append(q.code)
+
+    for c in courses: 
+        if c not in planCourses:
+            createPlanCourse(plan.planId, c)
+
+    return courses

App/controllers/coursePlanCourses.py

@@ -0,0 +1,25 @@
+from App.models import CoursePlanCourses
+from App.database import db
+
+def createPlanCourse(planid, code):
+    course = CoursePlanCourses(planid, code)
+    db.session.add(course)
+    db.session.commit()
+
+def getCourseFromCoursePlan(planid, coursecode):
+    return CoursePlanCourses.query.filter_by(
+        planId = planid,
+        code = coursecode
+    ).first()
+
+def get_all_courses_by_planid(id):
+    return CoursePlanCourses.query.filter_by(planId=id).all()
+
+def deleteCourseFromCoursePlan(planid, coursecode):
+    course = getCourseFromCoursePlan(planid, coursecode)
+    if course:
+        db.session.delete(course)
+        db.session.commit()
+        print("Course succesfully removed from course plan")
+    else:
+        print("Course is not in Course Plan")

App/controllers/courses.py

@@ -0,0 +1,80 @@
+from App.models import Course, Prerequisites
+from App.controllers.prerequistes import (create_prereq, get_all_prerequisites)
+from App.database import db
+import json, csv
+
+def createPrerequistes(prereqs, courseName):
+    for prereq_code in prereqs:
+        prereq_course = Course.query.filter_by(courseCode=prereq_code).first()
+
+        if prereq_course:
+            create_prereq(prereq_code,courseName) 
+
+def create_course(code, name, rating, credits, prereqs):
+    already = get_course_by_courseCode(code)
+    if already is None:
+        course = Course(code, name, rating, credits)
+
+        if prereqs:
+            createPrerequistes(prereqs, name)
+
+        db.session.add(course)
+        db.session.commit()
+        return course
+    else:
+        return None
+
+
+def createCoursesfromFile(file_path):
+    try:
+        with open(file_path, 'r') as file:
+            csv_reader = csv.DictReader(file)
+            for row in csv_reader:
+                courseCode = row["courseCode"]
+                courseName = row["courseName"]
+                credits = int(row["numCredits"])
+                rating = int(row["rating"])
+                prerequisites_codes = row["preReqs"].split(',')
+
+                create_course(courseCode, courseName, rating, credits, prerequisites_codes)
+
+    except FileNotFoundError:
+        print("File not found.")
+
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return False
+
+    print("Courses added successfully.")
+
+def get_course_by_courseCode(code):
+    return Course.query.filter_by(courseCode=code).first()
+
+def courses_Sorted_byRating():
+    courses =  Course.query.order_by(Course.rating.asc()).all()
+    codes = []
+
+    for c in courses:
+        codes.append(c.courseCode)
+
+    return codes
+
+def courses_Sorted_byRating_Objects():
+    return Course.query.order_by(Course.rating.asc()).all()
+
+
+def get_prerequisites(code):
+    course = get_course_by_courseCode(code)
+    prereqs = get_all_prerequisites(course.courseName)
+    return prereqs
+
+def get_credits(code):
+    course = get_course_by_courseCode(code)
+    return course.credits if course else 0
+
+def get_ratings(code):
+    course = get_course_by_courseCode(code)
+    return course.rating if course else 0
+
+
+