Implement student management features: add Student model, CRUD operations, and update certificate handling

Co-authored-by: Copilot <copilot@github.com>

Author: orabe

backend/app/crud.py

@@ -10,16 +10,39 @@ def generate_certificate_id(year: int) -> str:
 def get_certificate_by_public_id(db: Session, certificate_id: str):
     return db.query(models.Certificate).filter(models.Certificate.certificate_id == certificate_id).first()
 
+
+def get_student_by_id(db: Session, student_id: str):
+    return db.query(models.Student).filter(models.Student.student_id == student_id).first()
+
+
+def get_or_create_student(db: Session, student_id: str, student_name: str):
+    student = get_student_by_id(db, student_id)
+    if student:
+        if student_name and student.student_name != student_name:
+            student.student_name = student_name
+            db.commit()
+            db.refresh(student)
+        return student
+
+    student = models.Student(student_id=student_id, student_name=student_name)
+    db.add(student)
+    db.commit()
+    db.refresh(student)
+    return student
+
 def create_certificate(db: Session, cert_in: schemas.CertificateCreate):
     year = datetime.utcnow().year
 
+    get_or_create_student(db, cert_in.student_id, cert_in.student_name)
+
     while True:
         cert_id = generate_certificate_id(year)
         if not get_certificate_by_public_id(db, cert_id):
             break
 
     cert = models.Certificate(
         certificate_id=cert_id,
+        student_id=cert_in.student_id,
         student_name=cert_in.student_name,
         course_title=cert_in.course_title,
         completion_date=cert_in.completion_date,
@@ -55,3 +78,17 @@ def delete_certificate(db: Session, certificate_id: str):
     db.delete(cert)
     db.commit()
     return cert
+
+
+def delete_certificates_by_student_id(db: Session, student_id: str) -> int:
+    """Delete all certificates belonging to a given student_id. Returns number deleted."""
+    certs = db.query(models.Certificate).filter(models.Certificate.student_id == student_id).all()
+    if not certs:
+        return 0
+
+    count = len(certs)
+    for cert in certs:
+        db.delete(cert)
+
+    db.commit()
+    return count

backend/app/database.py

@@ -26,7 +26,7 @@
 
 
 def ensure_certificate_schema(bind=None):
-    """Create the certificates table and add any missing columns.
+    """Create the student and certificates tables and add any missing columns.
 
     This keeps older PostgreSQL/SQLite databases compatible when the
     certificate model gains new optional fields.
@@ -37,12 +37,28 @@ def ensure_certificate_schema(bind=None):
     Base.metadata.create_all(bind=target)
 
     inspector = inspect(target)
+    if "students" not in inspector.get_table_names():
+        return
+
     if "certificates" not in inspector.get_table_names():
         return
 
+    student_columns = {column["name"] for column in inspector.get_columns("students")}
     existing_columns = {column["name"] for column in inspector.get_columns("certificates")}
     missing_statements = []
 
+    if "student_id" not in student_columns:
+        missing_statements.append("ALTER TABLE students ADD COLUMN student_id VARCHAR")
+    if "student_name" not in student_columns:
+        missing_statements.append("ALTER TABLE students ADD COLUMN student_name VARCHAR")
+    if "created_at" not in student_columns:
+        missing_statements.append("ALTER TABLE students ADD COLUMN created_at TIMESTAMP")
+    if "updated_at" not in student_columns:
+        missing_statements.append("ALTER TABLE students ADD COLUMN updated_at TIMESTAMP")
+
+    if "student_id" not in existing_columns:
+        missing_statements.append("ALTER TABLE certificates ADD COLUMN student_id VARCHAR")
+
     if "attendance_percentage" not in existing_columns:
         missing_statements.append("ALTER TABLE certificates ADD COLUMN attendance_percentage INTEGER")
     if "assignment_completion_percentage" not in existing_columns:

backend/app/main.py

@@ -68,6 +68,7 @@ def verify_certificate(certificate_id: str, db: Session = Depends(get_db)):
     return {
         "status": "valid",
         "certificate_id": cert.certificate_id,
+        "student_id": cert.student_id,
         "student_name": cert.student_name,
         "course_title": cert.course_title,
         "course_link": cert.course_link,
@@ -95,20 +96,69 @@ def list_certificates(
     api_key: str = Depends(security.verify_api_key)
 ):
     certs = db.query(models.Certificate).all()
-    return certs
+    return [
+        {
+            "certificate_id": cert.certificate_id,
+            "student_id": cert.student_id,
+            "student_name": cert.student_name,
+            "course_title": cert.course_title,
+            "course_link": cert.course_link,
+            "completion_date": cert.completion_date,
+            "duration_hours": cert.duration_hours,
+            "attendance_percentage": cert.attendance_percentage,
+            "assignment_completion_percentage": cert.assignment_completion_percentage,
+            "course_level": cert.course_level,
+            "course_format": cert.course_format,
+            "instruction_language": cert.instruction_language,
+            "issuer": cert.issuer,
+            "instructor": cert.instructor,
+            "created_at": cert.created_at,
+            "updated_at": cert.updated_at,
+        }
+        for cert in certs
+    ]
 
 
-@app.delete("/admin/certificates/{certificate_id}", response_model=schemas.CertificateDeleteResponse)
-def delete_certificate(
-    certificate_id: str,
+@app.get("/admin/students/{student_id}", response_model=schemas.StudentLookupResponse)
+def get_student_by_student_id(
+    student_id: str,
     db: Session = Depends(get_db),
     api_key: str = Depends(security.verify_api_key)
 ):
-    cert = crud.delete_certificate(db, certificate_id)
-    if not cert:
-        raise HTTPException(status_code=404, detail="Certificate not found")
+    student = crud.get_student_by_id(db, student_id)
+    if not student:
+        raise HTTPException(status_code=404, detail="Student not found")
+
+    certificates = (
+        db.query(models.Certificate)
+        .filter(models.Certificate.student_id == student_id)
+        .order_by(models.Certificate.created_at.desc())
+        .all()
+    )
+
+    return {
+        "student": {
+            "student_id": student.student_id,
+            "student_name": student.student_name,
+            "created_at": student.created_at,
+            "updated_at": student.updated_at,
+        },
+        "certificates": certificates,
+    }
+
+
+@app.delete("/admin/certificates/student/{student_id}", response_model=schemas.CertificateDeleteResponse)
+def delete_certificates_for_student(
+    student_id: str,
+    db: Session = Depends(get_db),
+    api_key: str = Depends(security.verify_api_key)
+):
+    deleted_count = crud.delete_certificates_by_student_id(db, student_id)
+    if deleted_count == 0:
+        raise HTTPException(status_code=404, detail="No certificates found for student")
 
     return {
-        "message": "Certificate deleted",
-        "certificate_id": certificate_id,
+        "message": "Certificates deleted for student",
+        "student_id": student_id,
+        "deleted_count": deleted_count,
     }

backend/app/models.py

@@ -1,11 +1,20 @@
-from sqlalchemy import Column, Integer, String, DateTime
+from sqlalchemy import Column, Integer, String, DateTime, ForeignKey
+from sqlalchemy.orm import relationship
 from sqlalchemy.sql import func
 from .database import Base
 
+class Student(Base):
+    __tablename__ = "students"
+    student_id = Column(String, primary_key=True, index=True, nullable=False)
+    student_name = Column(String, nullable=False)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now(), server_default=func.now())
+
 class Certificate(Base):
     __tablename__ = "certificates"
     id = Column(Integer, primary_key=True, index=True)
     certificate_id = Column(String, unique=True, index=True, nullable=False)
+    student_id = Column(String, ForeignKey("students.student_id"), index=True, nullable=False)
     student_name = Column(String, nullable=False)
     course_title = Column(String, nullable=False)
     completion_date = Column(String, nullable=False)
@@ -19,6 +28,7 @@ class Certificate(Base):
 
     issuer = Column(String, default="MathCodeLab", nullable=False)
     instructor = Column(String, default="Mohammad Orabe", nullable=False)
+    student = relationship("Student")
     created_at = Column(DateTime(timezone=True), server_default=func.now())
     updated_at = Column(DateTime(timezone=True), onupdate=func.now(), server_default=func.now())
 

backend/app/schemas.py

@@ -2,6 +2,7 @@
 from typing import Optional
 
 class CertificateBase(BaseModel):
+    student_id: str
     student_name: str
     course_title: str
     completion_date: str
@@ -22,12 +23,24 @@ class CertificateOut(CertificateBase):
     certificate_id: str
     class Config:
         from_attributes = True
-    course_link: Optional[str] = None
+
+
+class StudentOut(BaseModel):
+    student_id: str
+    student_name: str
+    created_at: Optional[str] = None
+    updated_at: Optional[str] = None
+
+
+class StudentLookupResponse(BaseModel):
+    student: StudentOut
+    certificates: list[CertificateOut]
 
 class CertificateVerificationResponse(BaseModel):
     status: str
     certificate_id: str
     verification_url: Optional[str] = None
+    student_id: Optional[str] = None
     student_name: Optional[str] = None
     course_title: Optional[str] = None
     course_link: Optional[str] = None
@@ -46,6 +59,7 @@ class CertificateVerificationResponse(BaseModel):
 
 class CertificateDeleteResponse(BaseModel):
     message: str
-    certificate_id: str
+    student_id: str
+    deleted_count: int
 
 # Revocation support removed: no revoke schema

backend/scripts/create_certificate.py

@@ -1,7 +1,12 @@
 import sys
 import os
 from datetime import datetime
-sys.path.append(os.path.dirname(os.path.dirname(__file__)))
+from dotenv import load_dotenv
+
+PROJECT_ROOT = os.path.dirname(os.path.dirname(__file__))
+load_dotenv(os.path.join(PROJECT_ROOT, ".env"))
+sys.path.append(PROJECT_ROOT)
+
 from app import database, models, crud, schemas
 from sqlalchemy.orm import Session
 
@@ -39,6 +44,7 @@ def main():
     db = next(database.get_db())
     print("Enter certificate details:")
 
+    student_id = input("Student ID (primary key, e.g. STU-2026-001): ").strip()
     student_name = input("Student name: ")
     course_title = input("Course title: ")
     completion_date = prompt_date("Completion date (YYYY-MM-DD): ")
@@ -50,6 +56,7 @@ def main():
     instruction_language = input("Instruction language (e.g. English, German, Arabic): ") 
     course_link = input("Course link (optional, e.g. https://...): ").strip() or None
     cert_in = schemas.CertificateCreate(
+        student_id=student_id,
         student_name=student_name,
         course_title=course_title,
         completion_date=completion_date,
@@ -58,8 +65,7 @@ def main():
         assignment_completion_percentage=assignment_completion_percentage,
         course_level=course_level,
         course_format=course_format,
-        instruction_language=instruction_language
-        ,
+        instruction_language=instruction_language,
         course_link=course_link
     )
     cert = crud.create_certificate(db, cert_in)

backend/scripts/remove_certificate.py

@@ -0,0 +1,43 @@
+import argparse
+import os
+import sys
+
+from dotenv import load_dotenv
+from sqlalchemy.orm import Session
+
+PROJECT_ROOT = os.path.dirname(os.path.dirname(__file__))
+load_dotenv(os.path.join(PROJECT_ROOT, ".env"))
+sys.path.append(PROJECT_ROOT)
+
+from app import crud, database
+
+
+def remove_certificates_by_student(student_id: str):
+    database.ensure_certificate_schema()
+    db: Session = next(database.get_db())
+    try:
+        deleted_count = crud.delete_certificates_by_student_id(db, student_id)
+        if deleted_count == 0:
+            print(f"No certificates found for student_id: {student_id}")
+            return 1
+
+        print(f"Deleted {deleted_count} certificate(s) for student_id: {student_id}")
+        return 0
+    except Exception as exc:
+        print("Error while deleting certificates:")
+        print(exc)
+        return 1
+    finally:
+        db.close()
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Delete certificates by student_id (bulk)")
+    parser.add_argument("student_id", help="Student ID, e.g. S12345")
+    args = parser.parse_args()
+
+    raise SystemExit(remove_certificates_by_student(args.student_id.strip()))
+
+
+if __name__ == "__main__":
+    main()

backend/scripts/seed_demo_data.py

@@ -9,6 +9,7 @@ def seed():
     db = next(database.get_db())
     # Valid certificate
     cert1 = schemas.CertificateCreate(
+        student_id="STU-2026-001",
         student_name="Alice Example",
         course_title="Python Programming Basics",
         completion_date="2026-04-20",
@@ -17,6 +18,7 @@ def seed():
     c1 = crud.create_certificate(db, cert1)
     # Another demo certificate
     cert2 = schemas.CertificateCreate(
+        student_id="STU-2026-002",
         student_name="Bob Example",
         course_title="Data Science Intro",
         completion_date="2026-03-15",

backend/scripts/view_database.py

@@ -4,16 +4,18 @@
 from dotenv import load_dotenv
 from sqlalchemy.orm import Session
 
-sys.path.append(os.path.dirname(os.path.dirname(__file__)))
+PROJECT_ROOT = os.path.dirname(os.path.dirname(__file__))
+load_dotenv(os.path.join(PROJECT_ROOT, ".env"))
+sys.path.append(PROJECT_ROOT)
 
+from app import database
 from app.database import SessionLocal
 from app.models import Certificate
 
 
-load_dotenv()
-
-
 def view_database(limit: int = 50):
+	# Ensure missing optional columns are added before selecting all model fields.
+	database.ensure_certificate_schema()
 	db: Session = SessionLocal()
 	try:
 		certificates = (
@@ -32,6 +34,7 @@ def view_database(limit: int = 50):
 		for cert in certificates:
 			print("=" * 50)
 			print(f"Certificate ID : {cert.certificate_id}")
+			print(f"Student ID     : {cert.student_id}")
 			print(f"Student Name   : {cert.student_name}")
 			print(f"Course Title   : {cert.course_title}")
 			print(f"Completion Date: {cert.completion_date}")