The Course Selection System is a comprehensive web application designed for university students to manage their academic activities efficiently. Built using Django, Django REST Framework, and PostgreSQL, the system provides functionalities for course enrollment, academic tracking, faculty management, and administrative operations. The application is containerized using Docker to ensure easy deployment and scalability.

• Features
• Technology Stack
• Project Structure
• Installation
• Usage
• API Documentation
• Testing
• Deployment
• License
• Acknowledgements
• Contact

• Secure login and logout functionality with token-based authentication.
• Role-based access control for Students, Faculty, and Administrators.
• Password hashing and secure session management.

• View Available Courses: Students can browse courses offered in the current term.
• Enroll and Drop Courses: Seamless enrollment and dropping of courses within allowed periods.
• Course Load Management: Validation to prevent overloading beyond credit limits.

• Faculty Profiles: Administrators can create and manage faculty profiles.
• Course Assignment: Assign faculty members to specific courses.
• Communication: Faculty can communicate with enrolled students.

• Student Profiles: Detailed profiles including academic history and personal information.
• Academic Tracking: View enrolled courses, grades, and GPA calculation.
• Document Management: Upload and access important academic documents.

• Academic Terms: Administrators can create and manage terms.
• Course Offerings: Define courses available each term with schedules and capacities.
• Scheduling: Manage class times, exam schedules, and room assignments.

• Application for Emergency Drop: Students can apply with justifications.
• Approval Workflow: Requests are reviewed and approved by faculty and administrators.

• Appeal Submission: Students can submit grade appeals with supporting documents.
• Review Process: Faculty can review, comment, and make decisions on appeals.
• Notification System: Automated notifications for status updates.

• MinIO Integration: Secure storage and retrieval of academic documents.
• File Uploads: Supports various file types with size restrictions.
• Access Control: Permissions based on user roles and ownership.

• Students: Course enrollment, view grades, manage profiles.
• Faculty: Manage courses, enter grades, respond to appeals.
• Administrators: Full access to manage users, courses, terms, and system settings.

• Backend Framework: Django and Django REST Framework
• Database: PostgreSQL
• Containerization: Docker and Docker Compose
• Web Server: Nginx as a reverse proxy
• Storage: MinIO for object storage
• Authentication: Token-based authentication using Django's built-in mechanisms
• Version Control: Git

├── accounts/             # Handles user accounts and authentication
├── apply/                # Manages the course application process
├── college/              # Manages college-specific information
├── config/               # Configuration files and environment settings
├── course/               # Core functionality for course management
├── description/          # Project descriptions and documentation
├── nginx/                # Configuration for Nginx reverse proxy
├── shared/               # Shared resources and utilities
├── Dockerfile            # Dockerfile for building the application
├── docker-compose.yml    # Docker Compose configuration
├── manage.py             # Django management script
├── requirements.txt      # Python dependencies
├── .env                  # Environment variables
├── .gitignore            # Git ignore rules
├── LICENSE.md            # License information
└── README.md             # Project documentation (you're reading it!)

• Docker and Docker Compose installed on your machine.
• Git for version control.

1. Clone the Repository

   git clone https://github.com/yourusername/course-selection-system.git
   cd course-selection-system

2. Create Environment Variables

   • Copy the sample environment file and modify it according to your setup.

     cp .env.example .env

   • Update the .env file with your configurations.

3. Build and Run the Containers

   docker-compose up -d --build

4. Apply Migrations

   docker-compose exec web python manage.py migrate

5. Create Superuser (Admin Account)

   docker-compose exec web python manage.py createsuperuser

6. Collect Static Files

   docker-compose exec web python manage.py collectstatic --no-input

7. Access the Application

   • The application should now be running at http://localhost:8000/.
   • Access the admin panel at http://localhost:8000/admin/.

• Register and Login: Create an account or log in using your credentials.
• Browse Courses: View available courses for the current term.
• Enroll in Courses: Add desired courses to your schedule.
• Manage Enrollments: Drop courses or apply for emergency drops if needed.
• View Grades: Check your grades and academic progress.
• Submit Grade Appeals: If necessary, submit appeals for grade reviews.

• Login: Access your faculty account.
• Manage Courses: View and edit course information.
• Enter Grades: Submit grades for enrolled students.
• Respond to Appeals: Review and respond to grade appeals.

• Login: Access the admin dashboard.
• Manage Users: Create, update, or delete student and faculty accounts.
• Configure Terms: Set up academic terms and course offerings.
• Oversee Operations: Monitor system activities and handle administrative tasks.

• Swagger UI: Access the interactive API documentation at http://localhost:8000/swagger/.
• Endpoints: Detailed information about available endpoints for different user roles.
• Authentication: Use token-based authentication for secure API access.

• Unit Tests: Comprehensive tests are implemented for all major components.

docker-compose exec web python manage.py test

• Test Coverage: Generate coverage reports to ensure code quality.

• Docker Compose: Use the provided docker-compose.yml file configured for production.
• Environment Variables: Ensure all production variables are set in the .env file.
• Reverse Proxy: Nginx is configured to handle HTTPS and serve static files.

• CI Pipelines: Set up pipelines using tools like GitHub Actions, GitLab CI/CD, or Jenkins.
• Automated Testing: Tests are automatically run during the CI process.
• Automated Deployment: Successful builds can be deployed to production environments.

This project is licensed under the MIT License. See the LICENSE.md file for details.

• Django: High-level Python Web framework.
• Django REST Framework: Powerful toolkit for building Web APIs.
• PostgreSQL: Robust relational database system.
• Docker: Platform for developing, shipping, and running applications in containers.
• MinIO: High-performance, S3 compatible object storage.
• Nginx: High-performance HTTP server and reverse proxy.

For further details or inquiries:

• Project Maintainer: taha majlesi
• GitHub Repository: Course Selection System

Feel free to open an issue or submit a pull request if you have suggestions or improvements.

• Logging: The system implements comprehensive logging at various levels (DEBUG, INFO, WARNING, ERROR, CRITICAL).
• Error Handling: Custom error pages and messages for better user experience.

• Input Validation: All user inputs are validated to prevent SQL injection and XSS attacks.
• Secure Passwords: Passwords are hashed using strong algorithms.
• HTTPS Support: Configuration supports SSL/TLS for secure communication.

• Language Support: The application is built with internationalization in mind, supporting multiple languages.
• Translation: Easily add translations for different languages using Django's built-in i18n framework.

• Efficient Data Handling: API responses are paginated to handle large datasets efficiently.
• Filtering and Searching: Endpoints support filtering and searching for resources like courses and users.

• Code Documentation: Docstrings and comments are provided throughout the codebase.
• Developer Guide: Instructions for developers to contribute to the project are available in the CONTRIBUTING.md file.