A modern, feature-rich Django-based content management system (CMS) for educational institutions. Designed specifically for Fatima Convent Senior Secondary School, this application provides an intuitive platform for school administrators to manage and showcase school information, events, and multimedia content.
Features β’ Installation β’ Usage β’ Architecture β’ Contributing
- Overview
- Features
- Technology Stack
- Prerequisites
- Installation
- Configuration
- Usage
- Project Structure
- Database Models
- API Endpoints
- Troubleshooting
- Deployment
- Contributing
- License
- Support
The Fatima Convent Senior Secondary School Website is a comprehensive web application built with Django, enabling school administrators to manage and display:
- Dynamic Homepage with customizable banner slideshow
- Institutional Information including school history, mission, and principal details
- Media Gallery with organized photo and video content
- News & Updates for communicating important announcements
- Fee Structure information for students and parents
- Newsletter Subscription system for alumni engagement
- Admin Dashboard for easy content management without coding
This project demonstrates best practices in Django development, including proper model design, template hierarchy, and static file management.
- β Dynamic Banner Management - Admin-managed homepage banners with image support
- β About Section - Dedicated page for school history, principal profile, and institutional information
- β Gallery System - Categorized image and video gallery with media organization
- β Newsletter System - Email subscription functionality for alumni and interested parties
- β News Updates - Real-time updates and announcements management
- β Fee Structure - Display and manage school fee information
- β Django Admin Panel - Comprehensive admin interface for content management
- β Responsive Design - Mobile-friendly interface using Bootstrap 4+
- β Static Asset Management - Optimized CSS, JavaScript, and image handling
- β Database Migrations - Version-controlled database schema management
- β Media Upload Support - Easy image and video uploads with Django's media handling
- β SEO-Friendly - Structured URLs and semantic HTML templates
| Category | Technology |
|---|---|
| Backend | Python 3.x, Django 3.x+ |
| Database | SQLite3 (development), PostgreSQL (production) |
| Frontend | HTML5, CSS3, JavaScript (ES6+) |
| CSS Framework | Bootstrap 4+ |
| Icon Library | Font Awesome |
| JavaScript Libraries | jQuery, Owl Carousel, Masonry, Magnific Popup, ScrollReveal |
| Package Manager | pip |
| Version Control | Git |
Before you begin, ensure you have the following installed:
- Python 3.8 or higher - Download Python
- Git - Download Git
- pip - Usually comes with Python
- Virtual Environment - Built-in with Python (venv)
- OS: Windows, macOS, or Linux
- RAM: Minimum 512MB (1GB recommended)
- Disk Space: Minimum 500MB
- Browser: Modern browser with JavaScript enabled
git clone https://github.com/mrinmoy-hex/FCSS-WEB.git
cd FCSS-WEBIt's best practice to use a virtual environment to isolate project dependencies.
Windows (PowerShell):
python -m venv myenv
Set-ExecutionPolicy -Scope Process -ExecutionPolicy RemoteSigned
myenv\Scripts\Activate.ps1Windows (Command Prompt):
python -m venv myenv
myenv\Scripts\activate.batmacOS/Linux:
python3 -m venv myenv
source myenv/bin/activatepip install --upgrade pip
pip install -r requirements.txtThis installs all required packages including Django, Pillow (for image handling), and other dependencies specified in requirements.txt.
-
Database Setup:
python manage.py makemigrations python manage.py migrate
These commands create the SQLite database and apply all migrations.
-
Create Superuser Account:
python manage.py createsuperuser
You'll be prompted to enter username, email, and password. Use a secure password for production.
-
Collect Static Files (for production):
python manage.py collectstatic --noinput
This gathers all static files (CSS, JS, images) into
staticfiles/directory.
Edit SchoolApp/settings.py to customize:
# Key settings you may want to adjust:
DEBUG = True # Set to False in production
ALLOWED_HOSTS = ['localhost', '127.0.0.1'] # Add your domain
DATABASES = {...} # Database configuration
STATIC_URL = '/static/' # Static files URL
MEDIA_URL = '/media/' # Media files URLStart the development server with:
python manage.py runserverThe application will be available at:
- Frontend:
http://127.0.0.1:8000/ - Admin Panel:
http://127.0.0.1:8000/admin/
- Navigate to
http://127.0.0.1:8000/admin/ - Log in with your superuser credentials
- Manage content for:
- Banners - Homepage banner images and text
- About Section - School information and principal details
- Gallery - Photos and videos organized by category
- Newsletter Subscribers - Manage email subscriptions
- News Updates - Create and publish announcements
- Fee Structure - Maintain fee information
FCSS-WEB/
βββ App/ # Main Django application
β βββ migrations/ # Database migration files
β βββ models.py # Database models definition
β βββ views.py # View logic for rendering pages
β βββ urls.py # URL routing
β βββ admin.py # Django admin configuration
β βββ tests.py # Unit tests
β
βββ SchoolApp/ # Django project configuration
β βββ settings.py # Project settings
β βββ urls.py # Project-level URL routing
β βββ wsgi.py # WSGI application for deployment
β βββ asgi.py # ASGI application for async support
β
βββ templates/ # HTML templates
β βββ base.html # Base template (inherited by all pages)
β βββ index.html # Homepage
β βββ about.html # About page
β βββ gallery.html # Gallery page
β βββ contact.html # Contact page
β βββ fee_structure.html # Fee structure page
β βββ admin/ # Admin templates
β
βββ static/ # Static assets (CSS, JS, images)
β βββ css/ # Stylesheets
β βββ js/ # JavaScript files
β βββ images/ # Image assets
β βββ vendors/ # Third-party libraries
β
βββ media/ # User-uploaded content
β βββ banner_images/
β βββ about_images/
β βββ gallery_images/
β
βββ myenv/ # Virtual environment directory
βββ manage.py # Django management script
βββ requirements.txt # Python dependencies
βββ db.sqlite3 # SQLite database
βββ Procfile # Deployment configuration
βββ README.md # This file
Represents homepage banner content with images and text.
- title: String
- image: Image field
- description: Text
- created_at: DateTime
- updated_at: DateTimeStores school information, history, and principal details.
- title: String
- principal_name: String
- principal_image: Image field
- school_story: Text
- description: Text
- created_at: DateTime
- updated_at: DateTimeManages gallery photos and videos with categorization.
- category: String (choices-based)
- photo: Image field
- video: URL/Video field
- caption: String
- created_at: DateTime
- updated_at: DateTimeMaintains email subscription list.
- email: Email field (unique)
- subscribed_at: DateTime
- is_active: BooleanHandles news and announcements.
- title: String
- content: Text
- published_date: DateTime
- is_published: BooleanDisplays school fee information.
- class: String
- annual_fee: Decimal
- monthly_fee: Decimal
- description: Text| HTTP Method | Endpoint | Description |
|---|---|---|
| GET | / |
Homepage with banner slideshow |
| GET | /about/ |
About page with school information |
| GET | /gallery/ |
Gallery page with categorized media |
| GET | /contact/ |
Contact page |
| GET | /fee_structure/ |
Fee structure information |
| GET | /admin/ |
Admin dashboard |
Problem: Cannot find myenv\Scripts\Activate.ps1
Solution:
# Ensure you're in the project root directory
cd FCSS-WEB
# Recreate virtual environment
python -m venv myenvProblem: ModuleNotFoundError: No module named 'django'
Solution:
# Ensure virtual environment is activated
pip install -r requirements.txtProblem: django.db.utils.OperationalError
Solution:
# Reset migrations (development only!)
rm db.sqlite3
python manage.py makemigrations
python manage.py migrateProblem: CSS/JS not displaying in browser
Solution:
# Collect static files
python manage.py collectstatic --clear --noinput
# Ensure DEBUG = True in development
# Check STATIC_URL and STATIC_ROOT in settings.pyProblem: Address already in use
Solution:
# Use a different port
python manage.py runserver 8001
# Or kill the process using port 8000Problem: cannot be loaded because running scripts is disabled
Solution:
Set-ExecutionPolicy -Scope Process -ExecutionPolicy RemoteSigned- Set
DEBUG = Falsein settings.py - Configure
ALLOWED_HOSTSwith your domain - Use environment variables for sensitive data (database credentials, secret keys)
- Set up PostgreSQL database for production
- Configure static file serving (CDN or web server)
- Set up media file handling
- Enable HTTPS
- Configure email backend for newsletter functionality
- Set up regular database backups
- Use a production WSGI server (Gunicorn, uWSGI)
- Configure web server (Nginx, Apache)
This application can be deployed on:
- Heroku - See
Procfilefor configuration - PythonAnywhere
- DigitalOcean
- AWS EC2
- Azure App Service
- Self-hosted VPS
We welcome contributions from the community! Whether you're fixing bugs, adding features, or improving documentation, your help is appreciated.
-
Fork the Repository
# Click "Fork" on GitHub to create your own copy -
Clone Your Fork
git clone https://github.com/your-username/FCSS-WEB.git cd FCSS-WEB -
Create a Feature Branch
git checkout -b feature/your-feature-name # or git checkout -b bugfix/issue-description -
Make Your Changes
- Follow Django best practices
- Write clean, readable code
- Add comments for complex logic
- Update relevant documentation
-
Commit Your Changes
git commit -m "Add feature: Brief description of changes" -
Push to Your Fork
git push origin feature/your-feature-name
-
Open a Pull Request
- Go to the original repository
- Click "New Pull Request"
- Describe your changes in detail
- Reference any related issues
- Follow PEP 8 for Python code
- Use meaningful variable and function names
- Include docstrings for classes and functions
- Write unit tests for new features
- Update README.md if adding new features
- Keep commits atomic and well-documented
# Good example
def get_gallery_items(category=None):
"""
Retrieve gallery items, optionally filtered by category.
Args:
category (str, optional): Filter by category name
Returns:
QuerySet: Filtered gallery items
"""
queryset = GalleryItem.objects.all()
if category:
queryset = queryset.filter(category=category)
return querysetThis project is licensed under the MIT License - see the LICENSE file for details.
- β Use for commercial and private purposes
- β Modify the code
- β Distribute the software
- β Use it with restrictions
- Include the original copyright notice and license
- Provide a copy of the license
- Documentation: See Project Structure and Database Models
- Issues: GitHub Issues
- Discussions: GitHub Discussions
When reporting a bug, please include:
- Python version
- Django version
- Steps to reproduce
- Expected behavior
- Actual behavior
- Error traceback (if applicable)
- Screenshots (if applicable)
To suggest a new feature:
- Check if it's already been requested in Issues
- Create a new issue with the title "Feature Request: [Description]"
- Describe the feature and why it would be useful
Planned features and improvements:
- Student management system
- Online admission portal
- Class scheduling and timetable
- Assignment and homework submission
- Parent-teacher communication system
- Mobile application
- API documentation (Swagger/OpenAPI)
- Search functionality
- Multi-language support
- Analytics and reporting dashboard
Original Author: Mrinmoy and WIZARDOF-OZ
- Your Name - Contributions
- Django community for excellent framework and documentation
- Bootstrap team for responsive CSS framework
- Font Awesome for icon library
- All contributors and supporters of this project
Built with β€οΈ for Fatima Convent Senior Secondary School