Skip to content

Mohamed Amine Chouaieb / WBT2425_team11

Go to a project
Commit fe6e0b0f by Mohamed Amine Chouaieb
Options

fixed admin page

parent c9a3b5c5
Expand all
Inline Side-by-side
Showing with 84 additions and 877 deletions
Practice7/react/next.config.mjs
/** @type {import('next').NextConfig} */
const nextConfig = {};
const nextConfig = {
output : 'export',
basePath: process.env.NEXT_PUBLIC_BASE_PATH || '',
distDir : 'build',
trailingSlash : true,
};
export default nextConfig;
uja_exams_app/backend/auth.py
......@@ -27,11 +27,16 @@ def get_password_hash(password):
# User authentication
def authenticate_user(db: Session, email: str, password: str):
print(f"Attempting to authenticate user: {email}") # Add this
user = db.query(models.User).filter(models.User.email == email).first()
if not user:
print(f"User not found: {email}") # Add this
return False
print(f"User found: {email}. Verifying password...") # Add this
if not verify_password(password, user.password):
print(f"Password verification failed for user: {email}") # Add this
return False
print(f"Password verified successfully for user: {email}") # Add this
return user
# Token functions
......@@ -65,20 +70,42 @@ async def get_current_user(token: str = Depends(oauth2_scheme), db: Session = De
raise credentials_exception
return user
# In auth.py
async def get_current_active_user(current_user: schemas.User = Depends(get_current_user)):
if current_user.status != schemas.UserStatus.approved:
# --- Add these lines ---
print(f"DEBUG: Checking status for user {current_user.email}.")
print(f"DEBUG: DB Status Value: '{current_user.status}', Type: {type(current_user.status)}")
print(f"DEBUG: Comparing against: '{schemas.UserStatus.approved}', Type: {type(schemas.UserStatus.approved)}")
# --- End of added lines ---
if current_user.status.value != schemas.UserStatus.approved:
print(f"DEBUG: Status check FAILED: '{current_user.status.value}' != '{schemas.UserStatus.approved.value}'") # Add this
raise HTTPException(status_code=400, detail="Inactive user")
print(f"DEBUG: Status check PASSED for user {current_user.email}") # Add this
return current_user
# Role-based authorization
# In auth.py
def get_admin_user(current_user: schemas.User = Depends(get_current_active_user)):
if current_user.role != schemas.UserRole.admin:
# --- Add these lines ---
print(f"DEBUG: Checking role for user {current_user.email}.")
print(f"DEBUG: DB Role Value: '{current_user.role}', Type: {type(current_user.role)}")
print(f"DEBUG: Comparing against: '{schemas.UserRole.admin}', Type: {type(schemas.UserRole.admin)}")
# --- End of added lines ---
if current_user.role.value != schemas.UserRole.admin:
print(f"DEBUG: Role check FAILED: '{current_user.role}' != '{schemas.UserRole.admin}'") # Add this
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="Not authorized"
)
print(f"DEBUG: Role check PASSED for user {current_user.email}") # Add this
return current_user
def get_professor_user(current_user: schemas.User = Depends(get_current_active_user)):
if current_user.role != schemas.UserRole.professor and current_user.role != schemas.UserRole.admin:
raise HTTPException(
......@@ -93,4 +120,4 @@ def get_student_user(current_user: schemas.User = Depends(get_current_active_use
status_code=status.HTTP_403_FORBIDDEN,
detail="Not authorized"
)
return current_user
return current_user
\ No newline at end of file
uja_exams_app/backend/tempCodeRunnerFile.py 0 → 100644
ke
\ No newline at end of file
uja_exams_app/backend/test.py 0 → 100644
from auth import (
get_password_hash,
authenticate_user,
create_access_token,
get_current_user,
get_current_active_user,
get_admin_user,
get_professor_user,
get_student_user,
ACCESS_TOKEN_EXPIRE_MINUTES
)
new_hash= get_password_hash("admin123")
print(new_hash)
\ No newline at end of file
uja_exams_app/database/init_db.sql
......@@ -77,7 +77,7 @@ CREATE TABLE IF NOT EXISTS user_requests (
-- Insert sample admin user
INSERT INTO users (email, password, role, status)
VALUES ('admin@ujaen.es', '$2b$12$1tJXSR/YKBEsvbRvuQC1qOQkgBCzpWzXaAkXSWCSEkM9GpzNBGjVK', 'admin', 'approved');
VALUES ('admin@ujaen.es', '$2b$12$ESnGdZ.c/GPYfYcsCbe5eeqdHCBpJq.Q7qE4vmJnJDwDgIY7PHDamPS', 'admin', 'approved');
-- Password is 'admin123' (hashed)
-- Insert sample professor users
......
uja_exams_app/database/schema.md
# UJA Exams Database Schema
## Overview
This document outlines the database schema for the UJA Exams web application. The schema is designed to support the application's requirements for user management, exam management, and grade tracking.
## Tables
### 1. Users
......
uja_exams_app/database/setup_db.sh deleted 100644 → 0
#!/bin/bash
# Initialize the database
echo "Creating UJA Exams database..."
sudo mysql -e "CREATE DATABASE IF NOT EXISTS uja_exams;"
sudo mysql -e "CREATE USER IF NOT EXISTS 'uja_user'@'localhost' IDENTIFIED BY 'uja_password';"
sudo mysql -e "GRANT ALL PRIVILEGES ON uja_exams.* TO 'uja_user'@'localhost';"
sudo mysql -e "FLUSH PRIVILEGES;"
# Import the database schema
echo "Importing database schema..."
sudo mysql uja_exams < /home/ubuntu/uja_exams_app/database/init_db.sql
echo "Database setup completed successfully!"
uja_exams_app/deployment/README.md deleted 100644 → 0
# UJA Exams Web Application
This is a web application for managing exams at UJA.
## Deployment Instructions
### Prerequisites
- Node.js (v14 or higher)
- Python 3.8 or higher
- MariaDB/MySQL
### Backend Setup
1. Navigate to the backend directory: `cd backend`
2. Create a virtual environment: `python3 -m venv venv`
3. Activate the virtual environment: `source venv/bin/activate`
4. Install dependencies: `pip install -r requirements.txt`
5. Start the backend server: `./start_backend.sh`
### Frontend Setup
1. Navigate to the frontend directory: `cd frontend`
2. Install dependencies: `npm install`
3. Start the frontend server: `./start_frontend.sh`
### Running the Application
You can run both backend and frontend servers simultaneously using the main deployment script:
```
./deploy.sh
```
### Accessing the Application
- Backend API: http://localhost:8000
- Frontend: http://localhost:3000
## User Roles
- Student: Can view and download exams, see grades
- Professor: Can upload exams, manage grades
- Admin: Can approve user registrations, manage all content
## Features
- User authentication with role-based access control
- Exam upload and management
- Grade tracking
- Admin approval workflow
uja_exams_app/deployment/backend/auth.py deleted 100644 → 0
from fastapi import Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer
from sqlalchemy.orm import Session
from datetime import datetime, timedelta
import jwt
from passlib.context import CryptContext
from typing import Optional
import models
import schemas
from database import get_db
# Security configuration
SECRET_KEY = "09d25e094faa6ca2556c818166b7a9563b93f7099f6f0f4caa6cf63b88e8d3e7"
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30
pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
# Password functions
def verify_password(plain_password, hashed_password):
return pwd_context.verify(plain_password, hashed_password)
def get_password_hash(password):
return pwd_context.hash(password)
# User authentication
def authenticate_user(db: Session, email: str, password: str):
user = db.query(models.User).filter(models.User.email == email).first()
if not user:
return False
if not verify_password(password, user.password):
return False
return user
# Token functions
def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
to_encode = data.copy()
if expires_delta:
expire = datetime.utcnow() + expires_delta
else:
expire = datetime.utcnow() + timedelta(minutes=15)
to_encode.update({"exp": expire})
encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
return encoded_jwt
# User dependency functions
async def get_current_user(token: str = Depends(oauth2_scheme), db: Session = Depends(get_db)):
credentials_exception = HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Could not validate credentials",
headers={"WWW-Authenticate": "Bearer"},
)
try:
payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
email: str = payload.get("sub")
if email is None:
raise credentials_exception
token_data = schemas.TokenData(email=email)
except jwt.PyJWTError:
raise credentials_exception
user = db.query(models.User).filter(models.User.email == token_data.email).first()
if user is None:
raise credentials_exception
return user
async def get_current_active_user(current_user: schemas.User = Depends(get_current_user)):
if current_user.status != schemas.UserStatus.approved:
raise HTTPException(status_code=400, detail="Inactive user")
return current_user
# Role-based authorization
def get_admin_user(current_user: schemas.User = Depends(get_current_active_user)):
if current_user.role != schemas.UserRole.admin:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="Not authorized"
)
return current_user
def get_professor_user(current_user: schemas.User = Depends(get_current_active_user)):
if current_user.role != schemas.UserRole.professor and current_user.role != schemas.UserRole.admin:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="Not authorized"
)
return current_user
def get_student_user(current_user: schemas.User = Depends(get_current_active_user)):
if current_user.role != schemas.UserRole.student:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="Not authorized"
)
return current_user
uja_exams_app/deployment/backend/crud.py deleted 100644 → 0
from sqlalchemy.orm import Session
from typing import List, Optional
from datetime import datetime
import models
import schemas
# User CRUD operations
def get_user(db: Session, user_id: int):
return db.query(models.User).filter(models.User.id == user_id).first()
def get_user_by_email(db: Session, email: str):
return db.query(models.User).filter(models.User.email == email).first()
def get_users(db: Session, skip: int = 0, limit: int = 100):
return db.query(models.User).offset(skip).limit(limit).all()
def create_user(db: Session, user: schemas.UserCreate, hashed_password: str):
db_user = models.User(
email=user.email,
password=hashed_password,
role=user.role,
status=models.UserStatus.pending
)
db.add(db_user)
db.commit()
db.refresh(db_user)
return db_user
def update_user(db: Session, user_id: int, user: schemas.UserUpdate):
db_user = db.query(models.User).filter(models.User.id == user_id).first()
if db_user:
if user.email:
db_user.email = user.email
if user.password:
db_user.password = user.password
if user.status:
db_user.status = user.status
db.commit()
db.refresh(db_user)
return db_user
# Exam CRUD operations
def get_exam(db: Session, exam_id: int):
return db.query(models.Exam).filter(models.Exam.id == exam_id).first()
def get_exams(db: Session, skip: int = 0, limit: int = 100):
return db.query(models.Exam).offset(skip).limit(limit).all()
def get_exams_by_professor(db: Session, professor_id: int, skip: int = 0, limit: int = 100):
return db.query(models.Exam).filter(models.Exam.professor_id == professor_id).offset(skip).limit(limit).all()
def create_exam(db: Session, exam: schemas.ExamCreate):
db_exam = models.Exam(**exam.dict())
db.add(db_exam)
db.commit()
db.refresh(db_exam)
return db_exam
def update_exam(db: Session, exam_id: int, exam: schemas.ExamUpdate):
db_exam = db.query(models.Exam).filter(models.Exam.id == exam_id).first()
if db_exam:
if exam.title:
db_exam.title = exam.title
if exam.description is not None:
db_exam.description = exam.description
db.commit()
db.refresh(db_exam)
return db_exam
def delete_exam(db: Session, exam_id: int):
db_exam = db.query(models.Exam).filter(models.Exam.id == exam_id).first()
if db_exam:
db.delete(db_exam)
db.commit()
return True
return False
# Grade CRUD operations
def get_grade(db: Session, grade_id: int):
return db.query(models.Grade).filter(models.Grade.id == grade_id).first()
def get_grades(db: Session, skip: int = 0, limit: int = 100):
return db.query(models.Grade).offset(skip).limit(limit).all()
def get_grades_by_student(db: Session, student_id: int, skip: int = 0, limit: int = 100):
return db.query(models.Grade).filter(models.Grade.student_id == student_id).offset(skip).limit(limit).all()
def get_grades_by_exam(db: Session, exam_id: int, skip: int = 0, limit: int = 100):
return db.query(models.Grade).filter(models.Grade.exam_id == exam_id).offset(skip).limit(limit).all()
def create_grade(db: Session, grade: schemas.GradeCreate):
db_grade = models.Grade(**grade.dict())
db.add(db_grade)
db.commit()
db.refresh(db_grade)
return db_grade
def update_grade(db: Session, grade_id: int, grade: schemas.GradeUpdate):
db_grade = db.query(models.Grade).filter(models.Grade.id == grade_id).first()
if db_grade:
if grade.grade is not None:
db_grade.grade = grade.grade
if grade.result_date:
db_grade.result_date = grade.result_date
db.commit()
db.refresh(db_grade)
return db_grade
# Rating CRUD operations
def get_rating(db: Session, rating_id: int):
return db.query(models.ExamRating).filter(models.ExamRating.id == rating_id).first()
def get_rating_by_student_exam(db: Session, student_id: int, exam_id: int):
return db.query(models.ExamRating).filter(
models.ExamRating.student_id == student_id,
models.ExamRating.exam_id == exam_id
).first()
def get_ratings_by_exam(db: Session, exam_id: int, skip: int = 0, limit: int = 100):
return db.query(models.ExamRating).filter(models.ExamRating.exam_id == exam_id).offset(skip).limit(limit).all()
def create_rating(db: Session, rating: schemas.RatingCreate):
db_rating = models.ExamRating(**rating.dict())
db.add(db_rating)
db.commit()
db.refresh(db_rating)
return db_rating
def update_rating(db: Session, student_id: int, exam_id: int, rating_value: float):
db_rating = get_rating_by_student_exam(db, student_id, exam_id)
if db_rating:
db_rating.rating = rating_value
db.commit()
db.refresh(db_rating)
return db_rating
return None
# Exchange CRUD operations
def get_exchange(db: Session, exchange_id: int):
return db.query(models.ExamExchange).filter(models.ExamExchange.id == exchange_id).first()
def get_exchanges_by_sender(db: Session, sender_id: int, skip: int = 0, limit: int = 100):
return db.query(models.ExamExchange).filter(models.ExamExchange.sender_id == sender_id).offset(skip).limit(limit).all()
def get_exchanges_by_receiver(db: Session, receiver_id: int, skip: int = 0, limit: int = 100):
return db.query(models.ExamExchange).filter(models.ExamExchange.receiver_id == receiver_id).offset(skip).limit(limit).all()
def create_exchange(db: Session, exchange: schemas.ExchangeCreate):
db_exchange = models.ExamExchange(**exchange.dict())
db.add(db_exchange)
db.commit()
db.refresh(db_exchange)
return db_exchange
def update_exchange_status(db: Session, exchange_id: int, status: schemas.RequestStatus):
db_exchange = db.query(models.ExamExchange).filter(models.ExamExchange.id == exchange_id).first()
if db_exchange:
db_exchange.status = status
db.commit()
db.refresh(db_exchange)
return db_exchange
# User Request CRUD operations
def get_request(db: Session, request_id: int):
return db.query(models.UserRequest).filter(models.UserRequest.id == request_id).first()
def get_request_by_user(db: Session, user_id: int):
return db.query(models.UserRequest).filter(models.UserRequest.user_id == user_id).first()
def get_requests(db: Session, skip: int = 0, limit: int = 100):
return db.query(models.UserRequest).offset(skip).limit(limit).all()
def get_pending_requests(db: Session, skip: int = 0, limit: int = 100):
return db.query(models.UserRequest).filter(
models.UserRequest.status == models.RequestStatus.pending
).offset(skip).limit(limit).all()
def create_request(db: Session, user_id: int):
db_request = models.UserRequest(user_id=user_id)
db.add(db_request)
db.commit()
db.refresh(db_request)
return db_request
def update_request_status(db: Session, request_id: int, status: schemas.RequestStatus):
db_request = db.query(models.UserRequest).filter(models.UserRequest.id == request_id).first()
if db_request:
db_request.status = status
db_request.response_date = datetime.now()
# Update user status based on request status
user = db.query(models.User).filter(models.User.id == db_request.user_id).first()
if status == schemas.RequestStatus.accepted:
user.status = models.UserStatus.approved
elif status == schemas.RequestStatus.rejected:
user.status = models.UserStatus.rejected
db.commit()
db.refresh(db_request)
return db_request
uja_exams_app/deployment/backend/database.py deleted 100644 → 0
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
# Database connection URL
SQLALCHEMY_DATABASE_URL = "mysql+pymysql://uja_user:uja_password@localhost/uja_exams"
# Create SQLAlchemy engine
engine = create_engine(SQLALCHEMY_DATABASE_URL)
# Create SessionLocal class
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
# Create Base class
Base = declarative_base()
# Dependency to get DB session
def get_db():
db = SessionLocal()
try:
yield db
finally:
db.close()
uja_exams_app/deployment/backend/models.py deleted 100644 → 0
from sqlalchemy import Boolean, Column, ForeignKey, Integer, String, Text, Float, Date, DateTime, Enum, UniqueConstraint
from sqlalchemy.orm import relationship
from sqlalchemy.sql import func
import enum
from database import Base
# Enum definitions
class UserRole(enum.Enum):
student = "student"
professor = "professor"
admin = "admin"
class UserStatus(enum.Enum):
pending = "pending"
approved = "approved"
rejected = "rejected"
class RequestStatus(enum.Enum):
pending = "pending"
accepted = "accepted"
rejected = "rejected"
# Model definitions
class User(Base):
__tablename__ = "users"
id = Column(Integer, primary_key=True, index=True)
email = Column(String(255), unique=True, index=True, nullable=False)
password = Column(String(255), nullable=False)
role = Column(Enum(UserRole), nullable=False)
status = Column(Enum(UserStatus), default=UserStatus.pending, nullable=False)
created_at = Column(DateTime, server_default=func.now())
updated_at = Column(DateTime, server_default=func.now(), onupdate=func.now())
# Relationships
exams = relationship("Exam", back_populates="professor")
grades = relationship("Grade", back_populates="student")
ratings = relationship("ExamRating", back_populates="student")
sent_exchanges = relationship("ExamExchange", foreign_keys="ExamExchange.sender_id", back_populates="sender")
received_exchanges = relationship("ExamExchange", foreign_keys="ExamExchange.receiver_id", back_populates="receiver")
request = relationship("UserRequest", back_populates="user", uselist=False)
class Exam(Base):
__tablename__ = "exams"
id = Column(Integer, primary_key=True, index=True)
title = Column(String(255), nullable=False)
description = Column(Text)
file_path = Column(String(255), nullable=False)
professor_id = Column(Integer, ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
created_at = Column(DateTime, server_default=func.now())
updated_at = Column(DateTime, server_default=func.now(), onupdate=func.now())
# Relationships
professor = relationship("User", back_populates="exams")
grades = relationship("Grade", back_populates="exam")
ratings = relationship("ExamRating", back_populates="exam")
exchanges = relationship("ExamExchange", back_populates="exam")
class Grade(Base):
__tablename__ = "grades"
id = Column(Integer, primary_key=True, index=True)
student_id = Column(Integer, ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
exam_id = Column(Integer, ForeignKey("exams.id", ondelete="CASCADE"), nullable=False)
grade = Column(Float(precision=5, decimal_return_scale=2), nullable=False)
result_date = Column(Date, nullable=False)
# Unique constraint
__table_args__ = (UniqueConstraint('student_id', 'exam_id', name='unique_student_exam'),)
# Relationships
student = relationship("User", back_populates="grades")
exam = relationship("Exam", back_populates="grades")
class ExamRating(Base):
__tablename__ = "exam_ratings"
id = Column(Integer, primary_key=True, index=True)
exam_id = Column(Integer, ForeignKey("exams.id", ondelete="CASCADE"), nullable=False)
student_id = Column(Integer, ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
rating = Column(Float(precision=2, decimal_return_scale=1), nullable=False)
created_at = Column(DateTime, server_default=func.now())
# Unique constraint
__table_args__ = (UniqueConstraint('student_id', 'exam_id', name='unique_student_exam_rating'),)
# Relationships
exam = relationship("Exam", back_populates="ratings")
student = relationship("User", back_populates="ratings")
class ExamExchange(Base):
__tablename__ = "exam_exchanges"
id = Column(Integer, primary_key=True, index=True)
sender_id = Column(Integer, ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
receiver_id = Column(Integer, ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
exam_id = Column(Integer, ForeignKey("exams.id", ondelete="CASCADE"), nullable=False)
status = Column(Enum(RequestStatus), default=RequestStatus.pending, nullable=False)
created_at = Column(DateTime, server_default=func.now())
updated_at = Column(DateTime, server_default=func.now(), onupdate=func.now())
# Relationships
sender = relationship("User", foreign_keys=[sender_id], back_populates="sent_exchanges")
receiver = relationship("User", foreign_keys=[receiver_id], back_populates="received_exchanges")
exam = relationship("Exam", back_populates="exchanges")
class UserRequest(Base):
__tablename__ = "user_requests"
id = Column(Integer, primary_key=True, index=True)
user_id = Column(Integer, ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
status = Column(Enum(RequestStatus), default=RequestStatus.pending, nullable=False)
request_date = Column(DateTime, server_default=func.now())
response_date = Column(DateTime, nullable=True)
# Relationships
user = relationship("User", back_populates="request")
uja_exams_app/deployment/backend/requirements.txt deleted 100644 → 0
annotated-types==0.7.0
anyio==4.9.0
click==8.1.8
exceptiongroup==1.2.2
fastapi==0.115.11
greenlet==3.1.1
h11==0.14.0
idna==3.10
pydantic==2.10.6
pydantic_core==2.27.2
PyMySQL==1.1.1
python-multipart==0.0.20
sniffio==1.3.1
SQLAlchemy==2.0.39
starlette==0.46.1
typing_extensions==4.12.2
uvicorn==0.34.0
uja_exams_app/deployment/backend/schemas.py deleted 100644 → 0
from pydantic import BaseModel, EmailStr, Field, validator
from typing import Optional, List
from datetime import datetime, date
from enum import Enum
# Enum definitions
class UserRole(str, Enum):
student = "student"
professor = "professor"
admin = "admin"
class UserStatus(str, Enum):
pending = "pending"
approved = "approved"
rejected = "rejected"
class RequestStatus(str, Enum):
pending = "pending"
accepted = "accepted"
rejected = "rejected"
# User schemas
class UserBase(BaseModel):
email: EmailStr
class UserCreate(UserBase):
password: str
role: UserRole
class UserUpdate(BaseModel):
email: Optional[EmailStr] = None
password: Optional[str] = None
status: Optional[UserStatus] = None
class UserInDB(UserBase):
id: int
role: UserRole
status: UserStatus
created_at: datetime
updated_at: datetime
class Config:
orm_mode = True
class User(UserInDB):
pass
# Exam schemas
class ExamBase(BaseModel):
title: str
description: Optional[str] = None
class ExamCreate(ExamBase):
file_path: str
professor_id: int
class ExamUpdate(BaseModel):
title: Optional[str] = None
description: Optional[str] = None
class ExamInDB(ExamBase):
id: int
file_path: str
professor_id: int
created_at: datetime
updated_at: datetime
class Config:
orm_mode = True
class Exam(ExamInDB):
average_rating: Optional[float] = None
# Grade schemas
class GradeBase(BaseModel):
student_id: int
exam_id: int
grade: float = Field(..., ge=0, le=100)
result_date: date
class GradeCreate(GradeBase):
pass
class GradeUpdate(BaseModel):
grade: Optional[float] = Field(None, ge=0, le=100)
result_date: Optional[date] = None
class GradeInDB(GradeBase):
id: int
class Config:
orm_mode = True
class Grade(GradeInDB):
exam: Optional[ExamBase] = None
# Rating schemas
class RatingBase(BaseModel):
exam_id: int
student_id: int
rating: float = Field(..., ge=0, le=5)
class RatingCreate(RatingBase):
pass
class RatingInDB(RatingBase):
id: int
created_at: datetime
class Config:
orm_mode = True
class Rating(RatingInDB):
pass
# Exchange schemas
class ExchangeBase(BaseModel):
sender_id: int
receiver_id: int
exam_id: int
class ExchangeCreate(ExchangeBase):
pass
class ExchangeUpdate(BaseModel):
status: RequestStatus
class ExchangeInDB(ExchangeBase):
id: int
status: RequestStatus
created_at: datetime
updated_at: datetime
class Config:
orm_mode = True
class Exchange(ExchangeInDB):
exam: Optional[ExamBase] = None
# User Request schemas
class UserRequestBase(BaseModel):
user_id: int
class UserRequestCreate(UserRequestBase):
pass
class UserRequestUpdate(BaseModel):
status: RequestStatus
class UserRequestInDB(UserRequestBase):
id: int
status: RequestStatus
request_date: datetime
response_date: Optional[datetime] = None
class Config:
orm_mode = True
class UserRequest(UserRequestInDB):
user: Optional[UserBase] = None
# Token schemas
class Token(BaseModel):
access_token: str
token_type: str
class TokenData(BaseModel):
email: Optional[str] = None
role: Optional[UserRole] = None
uja_exams_app/deployment/backend/start_backend.sh deleted 100644 → 0
#!/bin/bash
# Backend startup script for production
# Create virtual environment if it doesn't exist
if [ ! -d "venv" ]; then
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
else
source venv/bin/activate
fi
# Start the backend server
uvicorn main:app --host 0.0.0.0 --port 8000
uja_exams_app/deployment/deploy.sh deleted 100644 → 0
#!/bin/bash
# Main deployment script for UJA Exams web application
# Start the backend server
cd backend
./start_backend.sh &
BACKEND_PID=$!
# Wait for backend to start
echo "Waiting for backend to start..."
sleep 5
# Start the frontend server
cd ../frontend
./start_frontend.sh &
FRONTEND_PID=$!
echo "Both servers are running!"
echo "Backend PID: $BACKEND_PID"
echo "Frontend PID: $FRONTEND_PID"
echo "Press Ctrl+C to stop both servers"
# Wait for user to press Ctrl+C
trap "kill $BACKEND_PID $FRONTEND_PID; exit" INT
wait
uja_exams_app/deployment/frontend/asset-manifest.json deleted 100644 → 0
{
"files": {
"main.css": "/static/css/main.1ca9c762.css",
"main.js": "/static/js/main.d32f103b.js",
"static/js/453.8ab44547.chunk.js": "/static/js/453.8ab44547.chunk.js",
"index.html": "/index.html",
"main.1ca9c762.css.map": "/static/css/main.1ca9c762.css.map",
"main.d32f103b.js.map": "/static/js/main.d32f103b.js.map",
"453.8ab44547.chunk.js.map": "/static/js/453.8ab44547.chunk.js.map"
},
"entrypoints": [
"static/css/main.1ca9c762.css",
"static/js/main.d32f103b.js"
]
}
\ No newline at end of file
uja_exams_app/deployment/frontend/index.html deleted 100644 → 0
<!doctype html><html lang="en"><head><meta charset="utf-8"/><link rel="icon" href="/favicon.ico"/><meta name="viewport" content="width=device-width,initial-scale=1"/><meta name="theme-color" content="#000000"/><meta name="description" content="Web site created using create-react-app"/><link rel="apple-touch-icon" href="/logo192.png"/><link rel="manifest" href="/manifest.json"/><title>React App</title><script defer="defer" src="/static/js/main.d32f103b.js"></script><link href="/static/css/main.1ca9c762.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>
\ No newline at end of file
uja_exams_app/deployment/frontend/manifest.json deleted 100644 → 0
{
"short_name": "React App",
"name": "Create React App Sample",
"icons": [
{
"src": "favicon.ico",
"sizes": "64x64 32x32 24x24 16x16",
"type": "image/x-icon"
},
{
"src": "logo192.png",
"type": "image/png",
"sizes": "192x192"
},
{
"src": "logo512.png",
"type": "image/png",
"sizes": "512x512"
}
],
"start_url": ".",
"display": "standalone",
"theme_color": "#000000",
"background_color": "#ffffff"
}
uja_exams_app/deployment/frontend/package.json deleted 100644 → 0
{
"name": "uja-exams-frontend",
"version": "1.0.0",
"description": "UJA Exams Frontend Server",
"main": "server.js",
"scripts": {
"start": "node server.js"
},
"dependencies": {
"express": "^4.17.1"
}
}
uja_exams_app/deployment/frontend/robots.txt deleted 100644 → 0
# https://www.robotstxt.org/robotstxt.html
User-agent: *
Disallow:
uja_exams_app/deployment/frontend/server.js deleted 100644 → 0
const express = require('express');
const path = require('path');
const app = express();
// Serve static files
app.use(express.static(__dirname));
// Handle React routing, return all requests to React app
app.get('*', function(req, res) {
res.sendFile(path.join(__dirname, 'index.html'));
});
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
console.log(`Frontend server is running on port ${PORT}`);
});
uja_exams_app/deployment/frontend/start_frontend.sh deleted 100644 → 0
#!/bin/bash
# Frontend startup script for production
# Install dependencies if needed
if [ ! -d "node_modules" ]; then
npm install
fi
# Start the frontend server
npm start
uja_exams_app/deployment/frontend/static/js/453.8ab44547.chunk.js deleted 100644 → 0
"use strict";(self.webpackChunkfrontend=self.webpackChunkfrontend||[]).push([[453],{453:(e,t,n)=>{n.r(t),n.d(t,{getCLS:()=>y,getFCP:()=>g,getFID:()=>C,getLCP:()=>P,getTTFB:()=>D});var i,r,a,o,u=function(e,t){return{name:e,value:void 0===t?-1:t,delta:0,entries:[],id:"v2-".concat(Date.now(),"-").concat(Math.floor(8999999999999*Math.random())+1e12)}},c=function(e,t){try{if(PerformanceObserver.supportedEntryTypes.includes(e)){if("first-input"===e&&!("PerformanceEventTiming"in self))return;var n=new PerformanceObserver((function(e){return e.getEntries().map(t)}));return n.observe({type:e,buffered:!0}),n}}catch(e){}},f=function(e,t){var n=function n(i){"pagehide"!==i.type&&"hidden"!==document.visibilityState||(e(i),t&&(removeEventListener("visibilitychange",n,!0),removeEventListener("pagehide",n,!0)))};addEventListener("visibilitychange",n,!0),addEventListener("pagehide",n,!0)},s=function(e){addEventListener("pageshow",(function(t){t.persisted&&e(t)}),!0)},m=function(e,t,n){var i;return function(r){t.value>=0&&(r||n)&&(t.delta=t.value-(i||0),(t.delta||void 0===i)&&(i=t.value,e(t)))}},v=-1,d=function(){return"hidden"===document.visibilityState?0:1/0},p=function(){f((function(e){var t=e.timeStamp;v=t}),!0)},l=function(){return v<0&&(v=d(),p(),s((function(){setTimeout((function(){v=d(),p()}),0)}))),{get firstHiddenTime(){return v}}},g=function(e,t){var n,i=l(),r=u("FCP"),a=function(e){"first-contentful-paint"===e.name&&(f&&f.disconnect(),e.startTime<i.firstHiddenTime&&(r.value=e.startTime,r.entries.push(e),n(!0)))},o=window.performance&&performance.getEntriesByName&&performance.getEntriesByName("first-contentful-paint")[0],f=o?null:c("paint",a);(o||f)&&(n=m(e,r,t),o&&a(o),s((function(i){r=u("FCP"),n=m(e,r,t),requestAnimationFrame((function(){requestAnimationFrame((function(){r.value=performance.now()-i.timeStamp,n(!0)}))}))})))},h=!1,T=-1,y=function(e,t){h||(g((function(e){T=e.value})),h=!0);var n,i=function(t){T>-1&&e(t)},r=u("CLS",0),a=0,o=[],v=function(e){if(!e.hadRecentInput){var t=o[0],i=o[o.length-1];a&&e.startTime-i.startTime<1e3&&e.startTime-t.startTime<5e3?(a+=e.value,o.push(e)):(a=e.value,o=[e]),a>r.value&&(r.value=a,r.entries=o,n())}},d=c("layout-shift",v);d&&(n=m(i,r,t),f((function(){d.takeRecords().map(v),n(!0)})),s((function(){a=0,T=-1,r=u("CLS",0),n=m(i,r,t)})))},E={passive:!0,capture:!0},w=new Date,L=function(e,t){i||(i=t,r=e,a=new Date,F(removeEventListener),S())},S=function(){if(r>=0&&r<a-w){var e={entryType:"first-input",name:i.type,target:i.target,cancelable:i.cancelable,startTime:i.timeStamp,processingStart:i.timeStamp+r};o.forEach((function(t){t(e)})),o=[]}},b=function(e){if(e.cancelable){var t=(e.timeStamp>1e12?new Date:performance.now())-e.timeStamp;"pointerdown"==e.type?function(e,t){var n=function(){L(e,t),r()},i=function(){r()},r=function(){removeEventListener("pointerup",n,E),removeEventListener("pointercancel",i,E)};addEventListener("pointerup",n,E),addEventListener("pointercancel",i,E)}(t,e):L(t,e)}},F=function(e){["mousedown","keydown","touchstart","pointerdown"].forEach((function(t){return e(t,b,E)}))},C=function(e,t){var n,a=l(),v=u("FID"),d=function(e){e.startTime<a.firstHiddenTime&&(v.value=e.processingStart-e.startTime,v.entries.push(e),n(!0))},p=c("first-input",d);n=m(e,v,t),p&&f((function(){p.takeRecords().map(d),p.disconnect()}),!0),p&&s((function(){var a;v=u("FID"),n=m(e,v,t),o=[],r=-1,i=null,F(addEventListener),a=d,o.push(a),S()}))},k={},P=function(e,t){var n,i=l(),r=u("LCP"),a=function(e){var t=e.startTime;t<i.firstHiddenTime&&(r.value=t,r.entries.push(e),n())},o=c("largest-contentful-paint",a);if(o){n=m(e,r,t);var v=function(){k[r.id]||(o.takeRecords().map(a),o.disconnect(),k[r.id]=!0,n(!0))};["keydown","click"].forEach((function(e){addEventListener(e,v,{once:!0,capture:!0})})),f(v,!0),s((function(i){r=u("LCP"),n=m(e,r,t),requestAnimationFrame((function(){requestAnimationFrame((function(){r.value=performance.now()-i.timeStamp,k[r.id]=!0,n(!0)}))}))}))}},D=function(e){var t,n=u("TTFB");t=function(){try{var t=performance.getEntriesByType("navigation")[0]||function(){var e=performance.timing,t={entryType:"navigation",startTime:0};for(var n in e)"navigationStart"!==n&&"toJSON"!==n&&(t[n]=Math.max(e[n]-e.navigationStart,0));return t}();if(n.value=n.delta=t.responseStart,n.value<0||n.value>performance.now())return;n.entries=[t],e(n)}catch(e){}},"complete"===document.readyState?setTimeout(t,0):addEventListener("load",(function(){return setTimeout(t,0)}))}}}]);
//# sourceMappingURL=453.8ab44547.chunk.js.map
\ No newline at end of file
uja_exams_app/deployment/frontend/static/js/main.d32f103b.js deleted 100644 → 0
This diff could not be displayed because it is too large.
uja_exams_app/deployment/frontend/static/js/main.d32f103b.js.LICENSE.txt deleted 100644 → 0
/**
* @license React
* react-dom-client.production.js
*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
/**
* @license React
* react-dom.production.js
*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
/**
* @license React
* react-jsx-runtime.production.js
*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
/**
* @license React
* react.production.js
*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
/**
* @license React
* scheduler.production.js
*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
uja_exams_app/deployment/frontend/static/js/main.d32f103b.js.map deleted 100644 → 0
This diff could not be displayed because it is too large.
uja_exams_app/frontend/src/pages/AdminHome.js
......@@ -12,13 +12,10 @@ const AdminHome = () => {
const navigate = useNavigate();
useEffect(() => {
// Fetch exams data and pending requests
const fetchData = async () => {
try {
setIsLoading(true);
// This would be replaced with actual API calls
// const examsResponse = await axios.get('http://localhost:8000/exams/');
// const requestsResponse = await axios.get('http://localhost:8000/admin/requests/pending/count');
// Mock data for now
const mockExams = [
......@@ -70,7 +67,7 @@ const AdminHome = () => {
];
setExams(mockExams);
setPendingRequests(2); // Mock pending requests count
setPendingRequests(2);
} catch (error) {
console.error('Error fetching data:', error);
} finally {
......
uja_exams_app/frontend/src/pages/Login.js
......@@ -13,6 +13,23 @@ const Login = () => {
const { login, user } = useAuth();
const navigate = useNavigate();
React.useEffect(() => {
if (user) { // Check if the user state in context is updated
const userRole = user.role || '';
console.log("DEBUG: User context updated, role:", userRole);
if (userRole === 'student') {
navigate('/student');
} else if (userRole === 'professor') {
navigate('/professor');
} else if (userRole === 'admin') {
navigate('/admin');
} else {
console.error("DEBUG: Unknown user role for navigation:", userRole);
}
}
}, [user, navigate]);
const handleSubmit = async (e) => {
e.preventDefault();
setError('');
......
uja_exams_app/frontend/src/pages/PendingApproval.js
......@@ -15,7 +15,7 @@ const PendingApproval = () => {
<h1 className="pending-title">Account Pending Approval</h1>
<p className="pending-message">
Your account registration has been submitted and is waiting for administrator approval.
You will be notified once your account has been approved.
check later.
</p>
<div className="pending-actions">
<Link to="/login" className="auth-button">Back to Login</Link>
......
uja_exams_app/frontend/src/services/api.js
......@@ -2,7 +2,7 @@ import axios from 'axios';
// Create axios instance with base URL
const api = axios.create({
baseURL: 'http://localhost:8000',
baseURL: 'http://10.82.52.184:8000',
headers: {
'Content-Type': 'application/json',
},
......
uja_exams_app/frontend/src/services/services.js
......@@ -101,29 +101,32 @@ export const gradeService = {
export const adminService = {
// Get all user registration requests
getAllRequests: async (params = {}) => {
const response = await api.get('/admin/requests', { params });
// Change path from '/admin/requests' to '/requests/'
const response = await api.get('/requests/', { params });
return response.data;
},
// Approve user registration request
approveRequest: async (requestId) => {
const response = await api.post(`/admin/requests/${requestId}/approve`);
// Change path, method (POST to PUT), and send status in body
const response = await api.put(`/requests/${requestId}`, { status: 'accepted' });
return response.data;
},
// Reject user registration request
rejectRequest: async (requestId) => {
const response = await api.post(`/admin/requests/${requestId}/reject`);
// Change path, method (POST to PUT), and send status in body
const response = await api.put(`/requests/${requestId}`, { status: 'rejected' });
return response.data;
},
// Get all users
// Get all users (Assuming this matches backend, verify if needed)
getAllUsers: async (params = {}) => {
const response = await api.get('/admin/users', { params });
return response.data;
},
// Update user role
// Update user role (Assuming this matches backend, verify if needed)
updateUserRole: async (userId, role) => {
const response = await api.put(`/admin/users/${userId}/role`, { role });
return response.data;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or sign in to comment