programme code added

App/models/__init__.py

@@ -1 +1,14 @@
-from .user import *
+from .user import *
+from .staff import *
+from .student import *
+from .history import *
+from .historycourse import *
+from .course import *
+from .courseplan import *
+from .courseplancourse import *
+from .programme import *
+from .generator import *
+from .easygenerator import *
+from .fastgenerator import *
+from .manualgenerator import *
+from .maxelectivegenerator import *

App/models/course.py

@@ -0,0 +1,55 @@
+from App.database import db
+from enum import Enum
+
+class CourseType(Enum):
+    CORE = 'core'
+    ELECTIVE = 'elective'
+
+class Course(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    course_title = db.Column(db.String(255))
+    course_code = db.Column(db.String(20), unique=True)
+    credits = db.Column(db.Integer)
+    course_type = db.Column(db.Enum(CourseType))
+    dept = db.Column(db.String(50))
+
+    prerequisites = db.relationship('Course', secondary='course_prerequisite', primaryjoin='Course.id==course_prerequisite.c.course_id', secondaryjoin='Course.id==course_prerequisite.c.prerequisite_id', back_populates='successor_courses', lazy='dynamic')
+    anti_requisites = db.relationship('Course', secondary='course_antirequisite', primaryjoin='Course.id==course_antirequisite.c.course_id', secondaryjoin='Course.id==course_antirequisite.c.antirequisite_id', lazy='dynamic')
+    successor_courses = db.relationship('Course', secondary='course_prerequisite', primaryjoin='Course.id==course_prerequisite.c.prerequisite_id', secondaryjoin='Course.id==course_prerequisite.c.course_id', back_populates='prerequisites', lazy='dynamic')
+
+    def add_course_to_list(self, other_course, course_list):
+        if course_list == 'prerequisites':
+            if other_course not in self.prerequisites:
+                self.prerequisites.append(other_course)
+        elif course_list == 'anti_requisites':
+            if other_course not in self.anti_requisites:
+                self.anti_requisites.append(other_course)
+        elif course_list == 'successor_courses':
+            if other_course not in self.successor_courses:
+                self.successor_courses.append(other_course)
+        db.session.commit()
+        return getattr(self, course_list)
+
+    def remove_course_from_list(self, other_course, course_list):
+        if course_list == 'prerequisites':
+            if other_course in self.prerequisites:
+                self.prerequisites.remove(other_course)
+        elif course_list == 'anti_requisites':
+            if other_course in self.anti_requisites:
+                self.anti_requisites.remove(other_course)
+        elif course_list == 'successor_courses':
+            if other_course in self.successor_courses:
+                self.successor_courses.remove(other_course)
+        db.session.commit()
+        return getattr(self, course_list)
+
+
+course_prerequisite = db.Table('course_prerequisite',
+    db.Column('course_id', db.Integer, db.ForeignKey('course.id'), primary_key=True),
+    db.Column('prerequisite_id', db.Integer, db.ForeignKey('course.id'), primary_key=True)
+)
+
+course_antirequisite = db.Table('course_antirequisite',
+    db.Column('course_id', db.Integer, db.ForeignKey('course.id'), primary_key=True),
+    db.Column('antirequisite_id', db.Integer, db.ForeignKey('course.id'), primary_key=True)
+)

App/models/courseplan.py

@@ -0,0 +1,9 @@
+from App.database import db
+
+
+class CoursePlan(db.Model):
+    plan_id = db.Column(db.Integer, primary_key=True)
+    student_id = db.Column(db.Integer, db.ForeignKey('student.id'), nullable=False)
+    year = db.Column(db.Integer, default=db.func.current_date().year)
+    semester = db.Column(db.Integer)
+    courses = relationship('CoursePlanCourse', backref='course_plan', lazy=True)

App/models/courseplancourse.py

@@ -0,0 +1,7 @@
+class CoursePlanCourse(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    course_id = db.Column(db.Integer, db.ForeignKey('course.id'), nullable=False)
+    difficulty = db.Column(db.Integer)
+    semester_available = db.Column(db.Integer)
+    year = db.Column(db.Integer)
+    course_plan_id = db.Column(db.Integer, db.ForeignKey('course_plan.plan_id'), nullable=False)

App/models/history.py

@@ -0,0 +1,8 @@
+from App.database import db
+
+class History(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    year = db.Column(db.Integer)
+    semester = db.Column(db.Integer)
+    semester_courses = db.relationship('CourseHistory', backref='history', lazy=True)
+

App/models/historycourse.py

@@ -0,0 +1,10 @@
+from App.database import db
+
+class HistoryCourse(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    history_id = db.Column(db.Integer, db.ForeignKey('history.id'), nullable=False)
+    course_id = db.Column(db.Integer, db.ForeignKey('course.id'), nullable=False)
+    passed = db.Column(db.Boolean, default=False)
+
+    def course_passed(self):
+        return self.passed

App/models/programme.py

@@ -0,0 +1,18 @@
+from App.database import db
+
+class Programme(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    degree_name = db.Column(db.String(255))
+    courses = db.relationship('Course', secondary='programme_course', back_populates='programmes', lazy='dynamic')
+
+    def add_course(self, course):
+        if course not in self.courses:
+            self.courses.append(course)
+            db.session.commit()
+        return self
+
+    def remove_course(self, course):
+        if course in self.courses:
+            self.courses.remove(course)
+            db.session.commit()
+        return self

App/models/staff.py

@@ -0,0 +1,31 @@
+from App.database import db
+from App.models import Programme
+
+class Staff(User):
+    dept = db.Column(db.String(50))
+    faculty = db.Column(db.String(50))
+
+    def create_programme(self, name):
+        existing_programme = Programme.query.filter_by(degree_name=name).first()
+
+        if existing_programme:
+            return existing_programme
+        else:
+            new_programme = Programme(degree_name=name)
+            db.session.add(new_programme)
+            db.session.commit()
+            return new_programme
+
+        programme = Programme(degree_name=name)
+        db.session.add(programme)
+        db.session.commit()
+        return programme
+
+    def delete_programme(self, programme_id):
+        programme = Programme.query.get(programme_id)
+        if programme:
+            db.session.delete(programme)
+            db.session.commit()
+            return True
+        else:
+            return False

App/models/student.py

@@ -0,0 +1,25 @@
+from App.models import Programme, History, CoursePlan
+from App.database import db
+
+class Student(User):
+    programme_id = db.Column(db.Integer, db.ForeignKey('programme.id'))
+    programme = db.relationship('Programme', back_populates='students')
+    academic_history = db.relationship('History', backref='student', lazy=True)
+    academic_plan = db.relationship('CoursePlan', backref='student', lazy=True)
+
+    def enroll_in_programme(self, programme):
+        if self.programme:
+            return f"Error: {self.name} is already enrolled in the {self.programme.degree_name} programme."
+
+        self.programme = programme
+        db.session.commit()
+        return self.programme
+
+    def create_course_plan(self, programme, academic_history):  #tbis need work
+        course_plan = CoursePlan(student=self)
+        db.session.add(course_plan)
+        db.session.commit()
+        return course_plan
+
+    def view_course_plan(self):
+        return self.academic_plan

App/models/user.py

@@ -5,22 +5,35 @@
 class User(db.Model, UserMixin):
     id = db.Column(db.Integer, primary_key=True)
     username =  db.Column(db.String, nullable=False, unique=True)
-    password = db.Column(db.String(120), nullable=False)
+    password = db.Column(db.String(255), nullable=False)
+    name = db.Column(db.String(50), nullable=True)
 
-    def __init__(self, username, password):
+    def __init__(self, username, password, name=None):
         self.username = username
         self.set_password(password)
+        self.name = name
 
     def get_json(self):
-        return{
+        return {
             'id': self.id,
-            'username': self.username
+            'username': self.username,
+            'name': self.name
         }
 
+    def create_user(self, username, password): #IDK WHAT
+        existing_user = User.query.filter_by(username=username).first()
+        if existing_user:
+            return False
+
+        new_user = User(username=username, password=password, name=name)
+        db.session.add(new_user)
+        db.session.commit()
+        return True
+
     def set_password(self, password):
         """Create hashed password."""
         self.password = generate_password_hash(password, method='sha256')
-    
+
     def check_password(self, password):
         """Check hashed password."""
         return check_password_hash(self.password, password)