Python Project Report
Python Project Report
Mini Project
Subject: Skill base Lab course: Python Programming
SE SEM-IV
A PROJECT REPORT ON
“File Tracking System”
by
The File Tracking System is a Python-based application designed to streamline and digitize the file approval
process in government engineering departments. It introduces a secure, role-based login system to ensure
proper access control and task delegation. The approval workflow follows a structured three-tier hierarchy
where files are initially reviewed by Assistant Engineers, then forwarded to Deputy Engineers, and finally
approved by Executive Engineers. This systematic process maintains the official chain of command and
promotes accountability at every level. The system offers several key benefits, including real-time tracking
of file status, a paperless and faster workflow, secure document storage, and transparent decision-making.
By reducing manual errors and administrative workload, the File Tracking System modernizes traditional
Traditional file management systems in government engineering departments are typically paper-based,
leading to slow processing, frequent misplacement of documents, and significant delays. The lack of
transparency in tracking file progress and the reliance on manual approvals contribute to administrative
inefficiencies. Moreover, without a centralized system, it becomes difficult to monitor who accessed or
approved a file, making record-keeping and accountability a challenge. To address these issues, this project
proposes the development of a digital File Tracking System using Python. The system offers secure, role-
based access for Admins and Employees and supports real-time file tracking through a structured three-
level approval hierarchy involving Assistant Engineers, Deputy Engineers, and Executive Engineers. This
digital workflow not only enhances transparency and accountability but also significantly reduces
paperwork, administrative overhead, and processing delays. With features like centralized monitoring,
automated approval logs, and secure document handling, the system aims to modernize traditional file
management, making the entire process faster, more reliable, and easier to audit.
Design/Methodology:
The File Tracking System is developed using a structured and modular approach, ensuring smooth
functionality, scalability, and ease of maintenance. The system is designed with a three-tier
architecture: Frontend (UI), Backend (Logic and APIs), and Database (Storage and Retrieval). It
includes distinct modules for login, file processing, and approval workflows.
3. Workflow Methodology:
1. Login Module: Authenticates users and redirects based on their role.
2. Dashboard Module: Displays relevant information such as assigned files, status, and pending
tasks.
3. File Upload & Assignment (Admin): Admin uploads files and assigns them to the first-level
reviewer.
4. Approval Chain:
▪ Files are reviewed by Assistant Engineer.
▪ Upon approval, forwarded to Deputy Engineer.
▪ Then, passed to Executive Engineer for final approval.
▪ At each step, status and timestamps are recorded.
5. Tracking & Logs: Every file’s status, reviewer, and approval time are logged and available in
real-time.
4. Development Methodology:
The system is developed using the Incremental Model:
• Phase 1: Set up basic login and role-based redirection.
• Phase 2: Implement file upload and assignment features.
• Phase 3: Add multi-level approval process.
• Phase 4: Integrate tracking, logs, and admin dashboard.
• Phase 5: Final testing, deployment, and user feedback loop.
5. Security Features:
• Password hashing for login credentials
• Session management for secure access
• Input validation to prevent SQL injection and form misuse
Figure:
Hardware Requirements:
Software Requirements:
• Operating System: Windows 10/11, macOS, or any Linux distribution (Ubuntu preferred for
production)
• Python Dependencies: Installed via requirements.txt, typically includes: Django, gunicorn (for
deployment), whitenoise (for static files)
• Web Server (for Deployment): Gunicorn (WSGI HTTP Server), Render (for hosting), GitHub
(code repository & CI/CD)
• Admin Panel: Comes with Django, with built-in password hashing + salting
# manage.py
#!/usr/bin/env python
"""Django's command-line utility for administrative tasks."""
import os
import sys
def main():
"""Run administrative tasks."""
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'file_tracking.settings')
try:
from django.core.management import execute_from_command_line
except ImportError as exc:
raise ImportError("Couldn't import Django. Are you sure it's installed?") from exc
execute_from_command_line(sys.argv)
if __name__ == '__main__':
main()
# settings.py
import os
from pathlib import Path
BASE_DIR = Path(__file__).resolve().parent.parent
SECRET_KEY = os.environ.get('SECRET_KEY', 'dev-secret-key')
DEBUG = True
ALLOWED_HOSTS = ['*']
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'app',
]
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'whitenoise.middleware.WhiteNoiseMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
ROOT_URLCONF = 'file_tracking.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [os.path.join(BASE_DIR, 'templates')],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
WSGI_APPLICATION = 'file_tracking.wsgi.application'
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': BASE_DIR / 'db.sqlite3',
}
}
AUTH_PASSWORD_VALIDATORS = [
{'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator'},
{'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator'},
{'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator'},
{'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator'},
]
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'Asia/Kolkata'
USE_I18N = True
USE_TZ = True
STATIC_URL = '/static/'
STATICFILES_DIRS = [os.path.join(BASE_DIR, 'static')]
STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles')
STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'
MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'
LOGIN_URL = 'login'
# urls.py
from django.urls import path
from . import views
urlpatterns = [
path('', views.home, name='home'),
path('about/', views.about, name='about'),
path('contact/', views.contact, name='contact'),
path('login/', views.user_login, name='login'),
path('logout/', views.user_logout, name='logout'),
path('admin/dashboard/', views.admin_dashboard, name='admin_dashboard'),
path('admin/add-employee/', views.add_employee, name='add_employee'),
path('admin/view-employees/', views.view_employees, name='view_employees'),
path('employee/dashboard/', views.employee_dashboard, name='employee_dashboard'),
path('employee/upload-file/', views.upload_file, name='upload_file'),
path('employee/view-requests/', views.view_requests, name='view_requests'),
path('employee/view-status/', views.view_status, name='view_status'),
path('employee/change-password/', views.change_password, name='change_password'),
path('employee/file/<int:file_id>/review/', views.approve_reject_file, name='approve_reject_file'),
]
# admin.py
from django.contrib import admin
from .models import EmployeeProfile, File, ApprovalHistory
@admin.register(EmployeeProfile)
class EmployeeProfileAdmin(admin.ModelAdmin):
list_display = ('user', 'designation', 'department', 'gender', 'mobile')
list_filter = ('designation', 'department', 'gender')
search_fields = ('user__username', 'user__email', 'user__first_name', 'user__last_name', 'department')
@admin.register(File)
class FileAdmin(admin.ModelAdmin):
list_display = ('title', 'uploaded_by', 'status', 'date_uploaded')
list_filter = ('status',)
search_fields = ('title', 'description', 'uploaded_by__username')
date_hierarchy = 'date_uploaded'
@admin.register(ApprovalHistory)
class ApprovalHistoryAdmin(admin.ModelAdmin):
list_display = ('file', 'approved_by', 'status', 'approved_at')
list_filter = ('status',)
search_fields = ('file__title', 'approved_by__username')
date_hierarchy = 'approved_at'
#app.py
from django.apps import AppConfig
class AppConfig(AppConfig):
default_auto_field = 'django.db.models.BigAutoField'
name = 'app'
#forms.py
from django import forms
from django.contrib.auth.models import User
from django.contrib.auth.forms import UserCreationForm, PasswordChangeForm
from .models import EmployeeProfile, File
class EmployeeCreationForm(forms.ModelForm):
name = forms.CharField(max_length=100)
email = forms.EmailField()
password = forms.CharField(widget=forms.PasswordInput())
class Meta:
model = EmployeeProfile
fields = ['gender', 'dob', 'designation', 'department', 'mobile']
widgets = {
'dob': forms.DateInput(attrs={'type': 'date'}),
}
All Profiles:
Gayatri 123456gg (assistant engineer)
Nikhil 123456ng (Deputy Engineer)
Umed 123456ui (Executive Engineer
Paul 123456pa(assistant engineer)
Anakin 123456dv(Deputy Engineer)
Eren 123456ey (Executive Engineer
#models.py
from django.db import models
from django.contrib.auth.models import User
from django.utils import timezone
class EmployeeProfile(models.Model):
GENDER_CHOICES = (
('M', 'Male'),
('F', 'Female'),
('O', 'Other'),
)
DESIGNATION_CHOICES = (
('assistant', 'Assistant Engineer'),
('deputy', 'Deputy Engineer'),
('executive', 'Executive Engineer'),
)
user = models.OneToOneField(User, on_delete=models.CASCADE, related_name='profile')
gender = models.CharField(max_length=1, choices=GENDER_CHOICES)
dob = models.DateField()
designation = models.CharField(max_length=20, choices=DESIGNATION_CHOICES)
department = models.CharField(max_length=100)
mobile = models.CharField(max_length=15)
def __str__(self):
return f"{self.user.get_full_name()} - {self.get_designation_display()}"
class File(models.Model):
STATUS_CHOICES = (
('pending_assistant', 'Pending Approval (Assistant)'),
('pending_deputy', 'Pending Approval (Deputy)'),
('pending_executive', 'Pending Approval (Executive)'),
('approved', 'Approved'),
('rejected', 'Rejected'),
)
title = models.CharField(max_length=200)
description = models.TextField()
file_upload = models.FileField(upload_to='files/')
uploaded_by = models.ForeignKey(User, on_delete=models.CASCADE,
related_name='uploaded_files')
status = models.CharField(max_length=20, choices=STATUS_CHOICES, default='pending_assistant')
current_reviewer = models.ForeignKey(User, on_delete=models.SET_NULL, null=True, blank=True,
related_name='files_to_review')
date_uploaded = models.DateTimeField(default=timezone.now)
def __str__(self):
return self.title
class ApprovalHistory(models.Model):
file = models.ForeignKey(File, on_delete=models.CASCADE, related_name='approvals')
approved_by = models.ForeignKey(User, on_delete=models.CASCADE)
approved_at = models.DateTimeField(default=timezone.now)
status = models.CharField(max_length=20, choices=(('approved', 'Approved'), ('rejected', 'Rejected')))
comments = models.TextField(blank=True, null=True)
def __str__(self):
return f"{self.file.title} - {self.status} by {self.approved_by.get_full_name()}"
#views.py
from django.shortcuts import render, redirect, get_object_or_404
from django.contrib.auth.decorators import login_required, user_passes_test
from django.contrib.auth import authenticate, login, logout
from django.contrib import messages
from django.contrib.auth.forms import AuthenticationForm
from django.contrib.auth.models import User
from django.db.models import Q
from .models import EmployeeProfile, File, ApprovalHistory
from .forms import EmployeeCreationForm, FileUploadForm, CustomPasswordChangeForm
def is_admin(user):
return user.is_superuser
def home(request):
return render(request, 'home.html')
def about(request):
return render(request, 'about.html')
def contact(request):
return render(request, 'contact.html')
def user_login(request):
if request.method == 'POST':
form = AuthenticationForm(request, data=request.POST)
if form.is_valid():
username = form.cleaned_data.get('username')
password = form.cleaned_data.get('password')
user = authenticate(username=username, password=password)
if user is not None:
login(request, user)
if user.is_superuser:
return redirect('admin_dashboard')
else:
return redirect('employee_dashboard')
else:
messages.error(request, "Invalid username or password.")
else:
messages.error(request, "Invalid username or password.")
else:
form = AuthenticationForm()
return render(request, 'login.html', {'form': form})
def user_logout(request):
logout(request)
return redirect('home')
# Admin views
@login_required
@user_passes_test(is_admin)
def admin_dashboard(request):
return render(request, 'admin/admin_home.html')
@login_required
@user_passes_test(is_admin)
def add_employee(request):
if request.method == 'POST':
form = EmployeeCreationForm(request.POST)
if form.is_valid():
form.save()
messages.success(request, "Employee added successfully!")
return redirect('view_employees')
else:
form = EmployeeCreationForm()
return render(request, 'admin/add_employee.html', {'form': form})
@login_required
@user_passes_test(is_admin)
def view_employees(request):
employees = EmployeeProfile.objects.all()
return render(request, 'admin/view_employees.html', {'employees': employees})
# Employee views
@login_required
def employee_dashboard(request):
if request.user.is_superuser:
return redirect('admin_dashboard')
return render(request, 'employee/dashboard.html')
@login_required
def upload_file(request):
if request.method == 'POST':
form = FileUploadForm(request.POST, request.FILES, user=request.user)
if form.is_valid():
form.save()
messages.success(request, "File uploaded successfully and sent for approval.")
return redirect('view_status')
else:
form = FileUploadForm()
return render(request, 'employee/upload_file.html', {'form': form})
@login_required
def view_requests(request):
user_profile = request.user.profile
@login_required
def view_status(request):
files = File.objects.filter(uploaded_by=request.user)
return render(request, 'employee/view_status.html', {'files': files})
@login_required
def change_password(request):
if request.method == 'POST':
form = CustomPasswordChangeForm(request.user, request.POST)
if form.is_valid():
form.save()
messages.success(request, "Your password was successfully updated!")
return redirect('employee_dashboard')
else:
messages.error(request, "Please correct the error below.")
else:
form = CustomPasswordChangeForm(request.user)
return render(request, 'employee/change_password.html', {'form': form})
@login_required
def approve_reject_file(request, file_id):
file = get_object_or_404(File, id=file_id)
if request.method == 'POST':
action = request.POST.get('action')
comments = request.POST.get('comments', '')
if action == 'reject':
file.status = 'rejected'
file.current_reviewer = None
file.save()
messages.success(request, "File has been rejected.")
return redirect('view_requests')
if user_profile.designation == 'assistant':
# Find a deputy engineer to review
deputy = User.objects.filter(
profile__designation='deputy',
profile__department=user_profile.department
).first()
if deputy:
file.status = 'pending_deputy'
file.current_reviewer = deputy
else:
messages.error(request, "No deputy engineer found to review this file.")
return redirect('view_requests')
if executive:
file.status = 'pending_executive'
file.current_reviewer = executive
else:
messages.error(request, "No executive engineer found to review this file.")
return redirect('view_requests')
file.save()
messages.success(request, "File has been approved and moved to the next stage.")
return redirect('view_requests')
The File Tracking System is a significant step forward in transforming traditional, paper-based workflows
into an efficient and transparent digital process within government engineering departments. Developed
using Python and Django, the system addresses major challenges faced by public sector offices, such as
delays, lack of transparency, misplacement of documents, and high administrative overhead.
Through its role-based authentication system, the application ensures that users (Admins and Engineers)
have access only to the features they need, safeguarding sensitive information and preventing
unauthorized file handling. By introducing a structured three-level approval hierarchy—Assistant
Engineer, Deputy Engineer, and Executive Engineer—the system enforces proper delegation and
accountability, replicating the real-world chain of command digitally.
The system’s modular architecture, built on the Django framework, supports clear separation of
concerns—handling user sessions, file uploads, role-based dashboards, and approval logs seamlessly. The
use of SQLite as the backend database ensures fast local development, while integration with deployment
platforms like Render and GitHub allows the system to be hosted and maintained reliably in production
environments. Furthermore, the inclusion of real-time file tracking and logging mechanisms adds an extra
layer of transparency and auditability.
Security is a cornerstone of the system, with features like password hashing, session validation, and input
sanitization implemented to protect data integrity. Additionally, the responsive frontend using HTML,
CSS, and Bootstrap makes the platform accessible across devices, enhancing user experience.
In conclusion, the File Tracking System not only reduces the reliance on physical paperwork but also
fosters a culture of digital efficiency, traceability, and transparency. It minimizes delays and errors while
providing a scalable solution for government departments aiming to modernize their internal workflows.
With future enhancements such as notifications, analytics, and document versioning, this system can
evolve into a comprehensive document lifecycle management platform suitable for any public sector
organization.
References: