A MINI PROJECT REPORT

ON
MINDSCAPE RUMBLE

Submitted in the partial fulfilment of the requirements for the award of

BACHELOR OF TECHNOLOGY
IN
INFORMATION TECHNOLOGY

SUBMITTED BY

KRISHNA CHAITANYA J. AJAY KUMAR G. CHARAN

REDDY
21BK1A1250 21BK1A1247 21BK1A1238

Under the guidance of

Mr. A. Senthil Murugan

DEPARTMENT OF INFORMATION TECHNOLOGY

St. Peter’s Engineering College (UGC Autonomous)
Approved by AICTE, New Delhi, and NAAC with ‘A’ Grade,
Affiliated to JNTU, Hyderabad, Telangana
2021-2025

1
 CERTIFICATE

This is to certify that a Mini Project entitled “MINDSCAPE RUMBLE” is carried out by
KRISHNA CHAITANYA REDDY (21BK1A1250), J. AJAY KUMAR
(21BK1A1247), G. CHARAN (21BK1A1238), in partial fulfilment for the award of the
degree of Bachelor of Technology in INFORMATION TECHNOLOGY is a record of
bonafide work done by her/him under my supervision during the academic year 2024-2025

INTERNAL GUIDE HEAD OF THE DEPARTMENT

Mr. A. Senthil Murugan St. Peter’s Engineering College,
Assistant Professor Hyderabad
Department of CSE
St. Peter’s Engineering College,
Hyderabad

PROJECT COORDINATOR EXTERNAL EXAMINER

Mr. A. Senthil Murugan, M.E., (Ph.D)
Assistant Professor,
Department of CSE
St. Peters Engineering College,
Hyderabad

2
 DEPARTMENT OF INFORMATION TECHNOLOGY
ACKNOWLEDGEMENT

We sincerely express our deep sense of gratitude to Mr. A. Senthil Murugan Associate
Professor, Department of Computer science and Engineering, for his valuable guidance,
encouragement and cooperation during all phases of the project.
We are greatly indebted to our Project Coordinator for providing valuable advice, constructive
suggestions and encouragement without whom it would not been possible to complete this
project.
It is a great opportunity to render our sincere thanks to Head of the Department, Information
Technology for her timely guidance and highly interactive attitude which helped us a lot in
successful execution of the Project.
We are extremely thankful to our Principal Dr. K. SREE LATHA, who stood as an inspiration
behind this project and heartfelt for her endorsement and valuable suggestions.
We respect and thank our secretary, Sri. T.V. REDDY, for providing us an opportunity to do the
project work at St. PETER’S ENGINEERING COLLEGE and we are extremely thankful to
him for providing such a nice support and guidance which made us to complete the project.
We also acknowledge with a deep sense of reverence, our gratitude towards our parents, who
have always supported us morally as well as economically. We also express gratitude to all our
friends who have directly or indirectly helped us to complete this project work. We hope that we
can build upon the experience and knowledge that we have gained and make a valuable
contribution towards the growth of the society in coming future.

Krishna Chaitanya Reddy(21BK1A1250)

J. Ajay Kumar (21BK1A1247)
G. Charan (21BK1A1238)

3
 INSTITUTE VISION

To be a renowned Educational Institution that moulds Students into Skilled

Professionals fostering Technological Development, Research, and Entrepreneurship
meeting societal needs.

INSTITUTE MISSION

IM1 Making students knowledgeable in the field of core and applied areas of Engineering

to innovate Technological solutions to the problems in the Society.

IM2 Training the Students to impart the skills in cutting edge technologies, with the help of
relevant stakeholders.

IM3 Fostering a conducive ambiance that inculcates research attitude, identifying

promising fields for entrepreneurship with ethical, moral, and social responsibilities.

4
 DEPARTMENT OF INFORMATION TECHNOLOGY

DEPARTMENT VISION
To be a vibrant nodal center for Computer Science Engineering Education, Research that
make the students to contribute to technologies for IT, IT-Enabled Services; to involve in
innovative research on thrust areas off industry and academia; to establish start-ups
supporting major players in the industry.

DEPARTMENT MISSION

DM1: Emphasize project based learning by employing the state-of art technologies,
algorithms in software development for the problems in inter-disciplinary avenues.
DM2: Involve stakeholders to make the students industry ready with training in skill-
oriented computer application software.
DM3: Facilitate to learn the theoretical nuances of Computer Science, Computer
Engineering courses and motivate to carry out research in both core and applied areas of
CSE.

5
 DEPARTMENT OF INFORMATION TECHNOLOGY

Program Educational Objectives

• PEO1: Graduates will be able to excel as IT Professional with Proficiency in
understanding, analyzing and, applying designing for Information Technology
relevant problems.
• PEO2: Graduates will be able to pursue higher studies with good knowledge in core
areas of Information Technology and promote collaborative research
• PEO3: Graduates will be able to exhibit professionalism, teamwork, leadership skills
and exposure to current needs.
• PEO4: Graduates will be able to excel as entrepreneurs with the potential
knowledge to design software-based solutions for societal needs.

Program Outcomes

• PO: 1 ENGINEERING KNOWLEDGE Apply the knowledge of mathematics,

science, engineering fundamentals, and an engineering specialization to the solution of
complex engineering problems.
• PO: 2 PROBLEM ANALYSIS: Identify, formulate, research literature,
and analyze complex engineering problems reaching substantiated conclusions using
first principles of mathematics, natural sciences, and engineering sciences.
• PO: 3 DESIGN/DEVELOPMENT OF SOLUTIONS: Design solutions for
complex engineering problems and design system components or processes that
meet the specified needs with appropriate consideration for the public health and
safety, and the cultural, societal, and environmental considerations.
• PO: 4 CONDUCT INVESTIGATIONS OF COMPLEX PROBLEMS:
Use research-based knowledge and research methods including design of
experiments, analysis and interpretation of data, and synthesis of the information to
provide valid conclusions.
• PO: 5 MODERN TOOL USAGE: Create, select, and apply appropriate
techniques resources, and modern engineering and IT tools including

6
• PO: 6 THE ENGINEER AND SOCIETY: Apply reasoning informed by the
contextual knowledge to assess societal, health, safety, legal and cultural issues
and the consequent responsibilities relevant to the professional engineering
practice.
• PO: 7 ENVIRONMENT AND SUSTAINABILITY: Understand the impact of the
professional engineering solutions in societal and environmental contexts,
demonstrate the knowledge of, and need for sustainable development.
• PO: 8 ETHICS: Apply ethical principles and commit to professional ethics,
responsibilities, and norms of the engineering practice.
• PO: 9 INDIVIDUAL AND TEAM WORK: Function effectively as an individual,
and as a member or leader in diverse teams, and in multidisciplinary settings.
• PO:10 COMMUNICATION: Communicate effectively on complex
engineering activities with the engineering community and with society, such
as, being able to comprehend and write effective reports and design
documentation, make effective presentations, give and receive clear
instructions.
• PO: 11 PROJECT MANAGEMENT AND FINANCE: Demonstrate
knowledge and understanding of the engineering and management principles and
apply these to one’s own work, as a member and leader in a team, to manage
projects and in multidisciplinary environments.
• PO: 12 LIFE-LONG LEARNING: Recognize the need for, and have the
preparation and ability to engage in independent and life-long learning in the
broadest context of technological change.

Program Specific Outcomes

• PSO1: Competent in Emerging Trends: Apply software design and development

practices to create software applications in emerging areas such as Cloud computing,
Data Analytics, AI and Cyber Security.
• PSO2: Successful Career and Entrepreneurship: The ability to employ modern
computer languages in all the environments to create an innovative carrier
to be an entrepreneur and a zest for higher studies.

7
 DEPARTMENT OF INFORMATION TECHNOLOGY

PROGRAM SPECIFIC OUTCOMES(PSO’S)

• PSO1: Competent in Emerging Trends: Apply software design and development practices

to create software applications in emerging areas such as Cloud computing, Data Analytics,

AI and Cyber Security.

• PSO2: Successful Career and Entrepreneurship: The ability to employ modern computer
languages in all the environments to create an innovative carrier to be an entrepreneur and
zest for higher studies.

8
 DECLARATION

We declare that a Mini Project entitled “MINDSCAPE RUMBLE” is an

Original Work submitted by the following group members who have actively
contributed and submitted in partial fulfilment for the award of degree in
“Bachelor of Technology in Information Technology”, at St. Peter’s
Engineering College, Hyderabad, and this project work has not been submitted
by me to any other college or university for the award of any kind of degree.

Batch No: 11
Program: B. Tech
Branch: Information Technology
Mini Project Title: MINDSCAPE RUMBLE
Date Submitted:

Name Roll Number Signature

KRISHNA CHAITANYA REDDY 21BK1A1250

J. AJAY KUMAR 21BK1A1247

G. CHARAN 21BK1A1238

9
 ABSTRACT

The Online Quiz Application is designed as a comprehensive and interactive platform that
aims to enhance the educational experience by providing engaging and flexible learning
opportunities. With the increasing shift towards online education and interactive content, this
application addresses the need for a streamlined, user-friendly quiz-taking experience across
various subjects. It offers a range of features designed to engage users, provide real-time
feedback, and track their performance, ensuring that learning is both effective and enjoyable.

The application supports multiple-choice quizzes, allowing users to test their knowledge on
various topics. Key features include User Authentication, where users create accounts to
access personalized quiz content; Quiz Management for administrators to create, update, and
manage quizzes; and Quiz Taking, where users receive instant feedback as they answer
questions, enhancing the learning experience. A Scoring and Progress Tracking system
calculates scores at the end of each quiz, tracking user progress over time and enabling review
of past attempts. Additionally, an optional Leaderboard feature encourages healthy
competition by displaying top performers, motivating users to engage more actively.

This project overcomes the limitations of existing quiz platforms, which often lack interactive
features, detailed feedback, and accessibility for self-paced learning. The proposed solution
creates an engaging environment where users can learn, track their progress, and receive
valuable insights, making it a versatile tool for educational institutions, trainers, and
individuals seeking a structured and effective way to test and improve their knowledge .

10
 TABLE OF CONTENTS

CONTENTS Page. No

1. INTRODUCTION 13

2. PROBLEM STATEMENT 14

3. LITERATURE SURVEY 15

4. EXISTING & PROPOSED SYSTEM 16-17

5. HARDWARE & SOFTWARE REQUIREMENTS 18

6. SOFTWARE DEVELOPMENT LIFECYCLE 19-21

7. UML DIAGRAMS 22-27

8. SYSTEM IMPLEMENTATION 28-30

9. SOURCE CODE 31-59

10. TESTING METHODOLOGIES 60-63

11. OUTPUT 64-69

12. FUTURE ENHANCEMENT 70

13. CONCLUSION 71
11
14. REFERENCES 72

12
 INTRODUCTION

In today’s digital age, the demand for interactive and flexible learning tools is higher than ever.
Traditional education methods are increasingly supplemented or replaced by online learning
platforms that allow users to study at their own pace and convenience. Among these platforms,
quiz applications play a significant role in assessing knowledge, reinforcing learning, and
enhancing student engagement. However, many existing quiz applications fall short in terms
user engagement, interactivity, and accessibility, often providing only basic, static quizzes
with limited feedback options.

The Online Quiz Application is designed to bridge these gaps by offering a comprehensive and
user-friendly platform that caters to diverse learning needs. It enables users to participate in
multiple-choice quizzes on various subjects, receive instant feedback, and track their progress
over time. The applications features are built with the aim of enhancing the learning experience
through gamification, such as leaderboards, badges to keep users motivated and engaged.

In addition, the platform offers a flexible and accessible environment that supports both
classroom-based and self-paced learning modes, ensuring compatibility with various devices,
including smartphones, tablets, and desktops. By leveraging modern technologies like React
Js for the user interface, the application provides a smooth and intuitive user experience,
making it easier for users to access and interact with content seamlessly.

Ultimately, the Online Quiz Application seeks to transform the way quizzes are used as
educational tools, promoting an engaging, interactive, and efficient learning experience for
users of all ages and educational backgrounds

13
 PROBLEM STATEMENT

Traditional quiz platforms often struggle to create a dynamic and engaging learning
experience. They frequently lack advanced interactive and gamified features, which are
essential for keeping users motivated and invested in their learning journey. Users are often
provided with only basic feedback on their performance, which fails to offer detailed
explanations or insights, making it difficult for learners to understand their mistakes or know
how to improve. Additionally, these platforms are often designed for traditional, classroom-
based environments, making them unsuitable for self-paced learning or difficult to access on
various devices such as smartphones and tablets. This highlights the need for a versatile and
interactive online quiz application that ensures an engaging learning experience, offers in-
depth feedback for continuous improvement, and provides robust support for multiple devices
and flexible learning settings.

Additionally, the design of these platforms often prioritizes traditional classroom settings
limiting support for self-paced, personalized learning environments and creating barriers for
users who want to access content seamlessly across devices such as smartphones, tablets, and
computers. This underscores the demand for a modern, AI-enhanced quiz application that not
only engages learners through gamification and adaptive content but also provides detailed
performance analysis and is fully accessible on a wide range of devices for a flexible and
effective educational experience.

14
 LITERATURE SURVEY

The development of online quiz applications has gained significant attention over recent years
due to the growing demand for digital learning tools that can enhance user engagement and
learning efficiency. This literature survey explores various existing systems, their strengths,
limitations, and the advancements in the field of online quizzes.

Traditional Quiz Applications:

• Traditional quiz platforms like Kahoot, Quizizz, and Google Forms have set the standard
for digital assessments in both classroom and remote learning environments. However,
they often lack features beyond basic question-and-answer formats. They provide limited
feedback mechanisms, usually displaying whether answers are correct or incorrect without
detailed explanations or personalized recommendations.

• The lack of gamification beyond simple scoring and ranking systems results in a short-
lived engagement for users. While platforms like Kahoot offer leaderboards, they do not
incorporate other motivational elements such as badges, levels, or rewards that could
enhance long-term user interest and retention.

Feedback and Performance Analytics:

• Studies indicate that immediate and detailed feedback is essential for effective learning.
Systems like Moodle and Blackboard offer quiz modules that include some form of
feedback, but these are often limited to static text or simple explanations. Research by
Hattie and Timperley (2007) suggests that personalized feedback that addresses specific
user mistakes and provides guidance for improvement is far more effective in enhancing
learning outcomes

• The proposed application, therefore, incorporates an advanced feedback system that not
only provides immediate responses but also includes detailed explanations for correct
and incorrect answers. Furthermore, it offers personalized insights and recommendations
based on user performance, which aligns with educational best practices.

15
 EXISTING SYSTEM

The existing online quiz platforms and systems are commonly used for educational
purposes, but they often have several limitations:
1. Limited Interactivity:
Many current systems lack engaging features like gamification, leaderboards, badges, or
levels, which are essential for maintaining user interest and motivation.
2. Basic Feedback Mechanism:
Existing platforms typically provide only basic feedback, such as marking answers as
correct or incorrect, without offering detailed explanations or personalized insights to help
users understand their mistakes.
3. Accessibility Issues:
These platforms are often designed primarily for classroom settings, with limited support
for self-paced learning. Furthermore, some systems are not optimized for use across
multiple devices like smartphones, tablets, and desktops, which restricts accessibility and
flexibility.
4. Limited Quiz Customization:
The ability to create and customize quizzes is often restricted, with predefined templates
and limited options for integrating multimedia elements like images, videos, and audio.
5. Lack of Progress Tracking:
Progress tracking in many existing systems is basic, typically showing only overall quiz
scores without providing users with detailed insights into their performance over time.
6. Minimal Gamification Elements:
Few existing platforms utilize gamification strategies beyond basic score tracking, which
limits their ability to engage and motivate users through interactive challenges and rewards.

16
 PROPOSED SYSTEM

The proposed Online Quiz Application aims to overcome the limitations of existing systems
by providing a more comprehensive, flexible, and engaging platform:

1. Enhanced Interactivity:
The application integrates gamification elements such as points, badges, leaderboards, and
time-bound challenges, making the learning experience engaging and motivating for users.
2. Detailed Feedback and Performance Insights:
Users receive instant feedback with explanations for correct and incorrect answers.
The system also provides personalized insights and recommendations, helping users
understand their performance and identify areas for improvement.
3. Accessibility and Flexibility:
The platform supports both classroom-based and self-paced learning modes, ensuring that
users can access the platform on various devices, including smartphones, tablets, and
desktops. This flexibility allows users to learn anytime, anywhere.
4. Comprehensive Quiz Customization:
The proposed system allows administrators to create and manage quizzes with diverse
question types and multimedia elements (images, videos, audio). This enables the design of
engaging and interactive assessments tailored to specific learning objectives.
5. Advanced Progress Tracking:
The application includes a robust progress tracking system that monitors user performance
over time, allowing them to review their past attempts, track their progress, and visualize
improvement.

17
 HARDWARE & SOFTWARE REQUIREMENTS

Software Requirements
1. Backend Development:
o Programming Language: Python 3.8 or above (for the backend server).
o Libraries and Frameworks:
▪ Django (for web server and REST API).

2. Frontend Development:
• Technologies:
o HTML, CSS, and JavaScript for the user interface.
o React.js (for web application development if using a React-based approach).
• Development Tools:
o VS Code or any modern code editor.
o Node.js (for using npm or yarn if you're including a build system for a
React application).
• Operating System:
o Compatible with Windows, macOS, or Linux.

Hardware Requirements
1. Minimum Requirements:
o Processor: Dual-core CPU (e.g., Intel i3 or AMD equivalent).
o RAM: 4 GB (for basic development).
o Storage: 2 GB free space (for installing dependencies or libraries ).
2. Recommended Requirements:
o Processor: Quad-core CPU (e.g., Intel i5 or AMD Ryzen 5).
o RAM: 8 GB or higher (smoother development).
o Storage: 5 GB or more (especially if using multiple servers or libraries).

18
 SOFTWARE DEVELOPMENT LIFE CYCLE (SDLC)

1. Planning
• Objective: Define the project goals, requirements, and scope.
• Activities:
o Identify project goals, such as providing a fun, interactive, and educational quiz
platform.
o Gather requirements, including features like user authentication, quiz management,
scoring, and leaderboard functionality.
• Establish a timeline and set milestones for each development phase.
• Deliverables: Project plan document with scope, objectives, and a timeline.

2. Requirements Analysis
• Objective: Specify functional and non-functional requirements in detail.
• Activities:
o List functional requirements, like quiz creation, real-time scoring, and personalized
feedback.
o Outline non-functional requirements, such as performance efficiency, cross- device
compatibility, and data security.
• Deliverables: Requirements specification document.

3. System Design
• Objective: Create a blueprint for the system architecture and design.
• Activities:
o Design the frontend using ReactJS, HTML, CSS, and JavaScript.
o Create a backend structure using Django for handling API requests, database
interactions, and user management.
o Plan data flow and establish a database schema for storing quizzes, scores, and user
details.
o Create wireframes/mockups for the user interface, detailing quiz navigation and
results display.
• Deliverables: System architecture diagrams, database design, and UI mockups.

4. Implementation
• Objective: Develop the system based on the design specifications.
• Activities:
o Backend Development: Implement features in Django, such as handling quiz data
and authentication.
19
 o Frontend Development: Develop the user interface for collecting user input
and displaying results.
o Integration: Connect the frontend with the backend using RESTful APIs.
• Deliverables: Functional code for the frontend and backend.

5. Testing
• Objective: Verify that the system works as intended and meets all requirements.
• Activities:
o Unit Testing: Validate individual components for correct
performance.
o Integration Testing: Ensure the frontend and backend work
seamlessly together.
o System Testing: Perform end-to-end testing to ensure that the entire system
functions correctly.
o Performance Testing: Check the system's responsiveness and stability under
different loads.
o User Acceptance Testing (UAT): Have potential users test the application to
validate usability and accuracy.
• Deliverables: Test reports, bug logs, and user feedback.

6. Deployment
• Objective: Deploy the system to a production environment, making it available for
end-users.
• Activities:
o Set up the production environment (web server, database, etc.).
o Deploy the backend and frontend components.
o Configure any necessary monitoring tools to track the system's performance and
usage.
• Deliverables: Live deployment of the application on a web server (e.g., cloud platform
like AWS or Azure).

7. Maintenance
• Objective: Ensure the system continues to operate effectively post-deployment.
• Activities:
o Monitor the system for any issues or performance degradation.
o Apply updates and patches as needed..
o Incorporate user feedback to add new features or improve existing functionality.
• Deliverables: Maintenance logs, updates, and patches.

20
SOFTWARE DEVELOPMENT LIFE CYCLE (WATER FALL MODEL)

21
UML DIAGRAMS

22
CLASS DIAGRAM

23
24
CONTEXT DIAGRAM

25
26
27
 SYSTEM IMPLEMENTATION

The system implementation phase of the Online Quiz Application involves transforming the
design into a fully functional system by developing and integrating the various components
and features. This phase ensures that all aspects of the application work together seamlessly,
providing a smooth user experience. The implementation process includes setting up the
front-end and back-end, integrating the database, testing the system, and deploying the
application. Below is a detailed breakdown of the system implementation steps:

1. Setting Up the Development Environment:

o The first step involves configuring the development environment, which includes
setting up tools and frameworks such as Django for the back-end and React for the
front-end. Required dependencies and libraries (e.g., Bootstrap for CSS styling,
Axios for API calls) are installed to ensure smooth development.

2. Front-End Implementation:
o The front-end of the application is developed using HTML, CSS, and JavaScript,
with React providing a dynamic and interactive user interface. Components such as
login forms, quiz pages, scoreboards, and dashboards are created to facilitate user
interaction.
o CSS and frameworks like Bootstrap are used to style the interface, ensuring a
responsive design that works across various devices and screen sizes. JavaScript and
React components handle the dynamic parts of the application, such as updating quiz
questions, showing feedback, and displaying real-time scores.

3. Back-End Implementation:
o The back-end is developed using Django, a Python-based web framework. Django
manages server-side logic, handles user authentication, processes quiz data, and
manages database interactions.
o Models are created to represent data structures like users, quizzes, questions, and
scores. Django’s built-in functionality for user authentication and session
management is used to implement secure login and registration features.

28
4. Database Integration:
o A relational database, such as SQLite or PostgreSQL, is integrated to store user
information, quiz data, and scores. Django’s Object-Relational Mapping (ORM)
system is used to create, read, update, and delete data efficiently.
o Database tables are designed to support different data entities such as users, quizzes,
quiz attempts, questions, and user performance statistics. Migrations are performed
to ensure database schema consistency throughout development.

5. API Development:
o RESTful APIs are developed using Django REST Framework to enable
communication between the front-end and back-end. These APIs handle user
requests like fetching quiz data, submitting answers, retrieving scores, and updating
user profiles.
o The APIs ensure secure and efficient data exchange, and they are tested for
performance and reliability to handle multiple user requests simultaneously.

6. Testing:
o Unit and integration tests are written to validate the functionality of individual
components and ensure that the application works as expected. Front-end testing
focuses on verifying user interactions, while back-end testing validates API
responses and database operations.
o User acceptance testing (UAT) is conducted to verify the application’s functionality
and usability, ensuring that it meets user requirements and provides a satisfactory
experience.

7. Deployment:
o Once development and testing are completed, the application is deployed to a server
or cloud platform (e.g., Heroku, AWS, or

DigitalOcean). Deployment configurations are set up to manage web server settings,

database connections, and static file handling.

29
 o Continuous Integration/Continuous Deployment (CI/CD) tools may be used to
automate deployment processes, ensuring that updates and bug fixes are quickly and
efficiently pushed to the live environment.\

8. Maintenance and Updates:

o Post-deployment, the system undergoes monitoring and maintenance to ensure
stability and performance. Bugs and issues reported by users are tracked, and updates
are rolled out to enhance features or fix problems.
o Feedback from users and analytics is used to plan future improvements, such as
adding new quiz features, implementing the leaderboard system, or enhancing the
feedback mechanism.

30
 SOURCE CODE

Index.py

# Generated by Django 3.0.5 on 2020-12-06 08:49

from django.conf import settings

from django.db import migrations, models
import django.db.models.deletion

class Migration(migrations.Migration):

initial = True

dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]

operations = [
migrations.CreateModel(
name='Student',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True,
serialize=False, verbose_name='ID')),
('profile_pic', models.ImageField(blank=True, null=True,
upload_to='profile_pic/Student/')),
('address', models.CharField(max_length=40)),
('mobile', models.CharField(max_length=20)),
('status', models.BooleanField(default=False)),
('user',
models.OneToOneField(on_delete=django.db.models.deletion.CASCADE,
to=settings.AUTH_USER_MODEL)),
],
),

31
Forms.py

from django import forms

from django.contrib.auth.models import User
from . import models

class ContactusForm(forms.Form):
Name = forms.CharField(max_length=30)
Email = forms.EmailField()
Message =
forms.CharField(max_length=500,widget=forms.Textarea(attrs={'rows': 3, 'cols':
30}))

class TeacherSalaryForm(forms.Form):
salary=forms.IntegerField()

class CourseForm(forms.ModelForm):
class Meta:
model=models.Course
fields=['course_name','question_number','total_marks']

class QuestionForm(forms.ModelForm):

#this will show dropdown str method course model is shown on html so
override it
#to_field_name this will fetch corresponding value user_id present in course
model and return it
courseID=forms.ModelChoiceField(queryset=models.Course.objects.all(),empty
_label="Course Name", to_field_name="id")
class Meta:
model=models.Question
fields=['marks','question','option1','option2','option3','option4','answer']
widgets = {
'question': forms.Textarea(attrs={'rows': 3, 'cols': 50})
32
 }

Models.py

from django.db import models

from student.models import Student

class Course(models.Model):
course_name = models.CharField(max_length=50)
question_number = models.PositiveIntegerField()
total_marks = models.PositiveIntegerField()
def str (self):
return self.course_name

class Question(models.Model):
course=models.ForeignKey(Course,on_delete=models.CASCADE)
marks=models.PositiveIntegerField()
question=models.CharField(max_length=600)
option1=models.CharField(max_length=200)
option2=models.CharField(max_length=200)
option3=models.CharField(max_length=200)
option4=models.CharField(max_length=200)
cat=(('Option1','Option1'),('Option2','Option2'),('Option3','Option3'),('Option4','
Option4'))
answer=models.CharField(max_length=200,choices=cat)

class Result(models.Model):
student = models.ForeignKey(Student,on_delete=models.CASCADE)
exam = models.ForeignKey(Course,on_delete=models.CASCADE)
marks = models.PositiveIntegerField()
date = models.DateTimeField(auto_now=True)

33
 apps.py

from django.apps import AppConfig

class StudentConfig(AppConfig):
name = 'student'

forms.py

from django import forms

from django.contrib.auth.models import User
from . import models
from quiz import models as QMODEL

class StudentUserForm(forms.ModelForm):
class Meta:
model=User
fields=['first_name','last_name','username','password']
widgets = {
'password': forms.PasswordInput()
}

class StudentForm(forms.ModelForm):
class Meta:
model=models.Student
fields=['address','mobile','profile_pic']

from django import forms

from django.contrib.auth.models import User
from . import models

class TeacherUserForm(forms.ModelForm):
class Meta:
model=User
fields=['first_name','last_name','username','password']
widgets = {
'password': forms.PasswordInput()
}
34
class TeacherForm(forms.ModelForm):
class Meta:
model=models.Teacher
fields=['address','mobile','profile_pic']

models.py

from django.db import models

from django.contrib.auth.models import User

class Student(models.Model):
user=models.OneToOneField(User,on_delete=models.CASCADE)
profile_pic=
models.ImageField(upload_to='profile_pic/Student/',null=True,blank=True)
address = models.CharField(max_length=40)
mobile = models.CharField(max_length=20,null=False)

@property
def get_name(self):
return self.user.first_name+" "+self.user.last_name
@property
def get_instance(self):
return self
def str (self):
return self.user.first_name

from django.db import models

from django.contrib.auth.models import User

class Teacher(models.Model):
user=models.OneToOneField(User,on_delete=models.CASCADE)
profile_pic=
models.ImageField(upload_to='profile_pic/Teacher/',null=True,blank=True)
address = models.CharField(max_length=40)
mobile = models.CharField(max_length=20,null=False)
status= models.BooleanField(default=False)
35
 salary=models.PositiveIntegerField(null=True)
@property
def get_name(self):
return self.user.first_name+" "+self.user.last_name
@property
def get_instance(self):
return self
def str (self):
return self.user.first_name

urls.py

from django.urls import path

from student import views
from django.contrib.auth.views import LoginView

urlpatterns = [
path('studentclick', views.studentclick_view),
path('studentlogin',
LoginView.as_view(template_name='student/studentlogin.html'),name='studentlogi
n'),
path('studentsignup', views.student_signup_view,name='studentsignup'),
path('student-dashboard', views.student_dashboard_view,name='student-
dashboard'),
path('student-exam', views.student_exam_view,name='student-exam'),
path('take-exam/<int:pk>', views.take_exam_view,name='take-exam'),
path('start-exam/<int:pk>', views.start_exam_view,name='start-exam'),

path('calculate-marks', views.calculate_marks_view,name='calculate-marks'),
path('view-result', views.view_result_view,name='view-result'),
path('check-marks/<int:pk>', views.check_marks_view,name='check-marks'),
path('student-marks', views.student_marks_view,name='student-marks'),
]

from django.urls import path

from teacher import views
from django.contrib.auth.views import LoginView

36
urlpatterns = [
path('teacherclick', views.teacherclick_view),
path('teacherlogin',
LoginView.as_view(template_name='teacher/teacherlogin.html'),name='teacherlogi
n'),
path('teachersignup', views.teacher_signup_view,name='teachersignup'),
path('teacher-dashboard', views.teacher_dashboard_view,name='teacher-
dashboard'),
path('teacher-exam', views.teacher_exam_view,name='teacher-exam'),
path('teacher-add-exam', views.teacher_add_exam_view,name='teacher-add-exam'),
path('teacher-view-exam', views.teacher_view_exam_view,name='teacher-view-
exam'),
path('delete-exam/<int:pk>', views.delete_exam_view,name='delete-exam'),

path('teacher-question', views.teacher_question_view,name='teacher-question'),
path('teacher-add-question', views.teacher_add_question_view,name='teacher-add-
question'),
path('teacher-view-question', views.teacher_view_question_view,name='teacher-
view-question'),
path('see-question/<int:pk>', views.see_question_view,name='see-question'),
path('remove-question/<int:pk>', views.remove_question_view,name='remove-
question'),
]

37
Views.py

from django.shortcuts import render,redirect,reverse

from . import forms,models
from django.db.models import Sum
from django.contrib.auth.models import Group
from django.http import HttpResponseRedirect
from django.contrib.auth.decorators import login_required,user_passes_test
from django.conf import settings
from datetime import date, timedelta
from django.db.models import Q
from django.core.mail import send_mail
from teacher import models as TMODEL
from student import models as SMODEL
from teacher import forms as TFORM
from student import forms as SFORM
from django.contrib.auth.models import User

def home_view(request):
if request.user.is_authenticated:
return HttpResponseRedirect('afterlogin')
return render(request,'quiz/index.html')

def is_teacher(user):
return user.groups.filter(name='TEACHER').exists()

def is_student(user):
return user.groups.filter(name='STUDENT').exists()

def afterlogin_view(request):
if is_student(request.user):
return redirect('student/student-dashboard')

elif is_teacher(request.user):
38
 accountapproval=TMODEL.Teacher.objects.all().filter(user_id=request.user.i
d,status=True)
if accountapproval:
return redirect('teacher/teacher-dashboard')
else:
return render(request,'teacher/teacher_wait_for_approval.html')
else:
return redirect('admin-dashboard')

def adminclick_view(request):
if request.user.is_authenticated:
return HttpResponseRedirect('afterlogin')
return HttpResponseRedirect('adminlogin')

@login_required(login_url='adminlogin')
def admin_dashboard_view(request):
dict={
'total_student':SMODEL.Student.objects.all().count(),
'total_teacher':TMODEL.Teacher.objects.all().filter(status=True).count(),
'total_course':models.Course.objects.all().count(),
'total_question':models.Question.objects.all().count(),
}
return render(request,'quiz/admin_dashboard.html',context=dict)

@login_required(login_url='adminlogin')
def admin_teacher_view(request):
dict={
'total_teacher':TMODEL.Teacher.objects.all().filter(status=True).count(),
'pending_teacher':TMODEL.Teacher.objects.all().filter(status=False).count(),
'salary':TMODEL.Teacher.objects.all().filter(status=True).aggregate(Sum('salar
y'))['salary sum'],
}
return render(request,'quiz/admin_teacher.html',context=dict)

39
@login_required(login_url='adminlogin')
def admin_view_teacher_view(request):
teachers= TMODEL.Teacher.objects.all().filter(status=True)
return render(request,'quiz/admin_view_teacher.html',{'teachers':teachers})

@login_required(login_url='adminlogin')
def update_teacher_view(request,pk):
teacher=TMODEL.Teacher.objects.get(id=pk)
user=TMODEL.User.objects.get(id=teacher.user_id)
userForm=TFORM.TeacherUserForm(instance=user)
teacherForm=TFORM.TeacherForm(request.FILES,instance=teacher)
mydict={'userForm':userForm,'teacherForm':teacherForm}
if request.method=='POST':
userForm=TFORM.TeacherUserForm(request.POST,instance=user)
teacherForm=TFORM.TeacherForm(request.POST,request.FILES,instance=t
eacher)
if userForm.is_valid() and teacherForm.is_valid():
user=userForm.save()
user.set_password(user.password)
user.save()
teacherForm.save()
return redirect('admin-view-teacher')
return render(request,'quiz/update_teacher.html',context=mydict)

@login_required(login_url='adminlogin')
def delete_teacher_view(request,pk):
teacher=TMODEL.Teacher.objects.get(id=pk)
user=User.objects.get(id=teacher.user_id)
user.delete()
teacher.delete()
return HttpResponseRedirect('/admin-view-teacher')

40
@login_required(login_url='adminlogin')
def admin_view_pending_teacher_view(request):
teachers= TMODEL.Teacher.objects.all().filter(status=False)
return
render(request,'quiz/admin_view_pending_teacher.html',{'teachers':teachers})

@login_required(login_url='adminlogin')
def approve_teacher_view(request,pk):
teacherSalary=forms.TeacherSalaryForm()
if request.method=='POST':
teacherSalary=forms.TeacherSalaryForm(request.POST)
if teacherSalary.is_valid():
teacher=TMODEL.Teacher.objects.get(id=pk)
teacher.salary=teacherSalary.cleaned_data['salary']
teacher.status=True
teacher.save()
else:
print("form is invalid")
return HttpResponseRedirect('/admin-view-pending-teacher')
return render(request,'quiz/salary_form.html',{'teacherSalary':teacherSalary})

@login_required(login_url='adminlogin')
def reject_teacher_view(request,pk):
teacher=TMODEL.Teacher.objects.get(id=pk)
user=User.objects.get(id=teacher.user_id)
user.delete()
teacher.delete()
return HttpResponseRedirect('/admin-view-pending-teacher')

@login_required(login_url='adminlogin')
def admin_view_teacher_salary_view(request):
teachers= TMODEL.Teacher.objects.all().filter(status=True)
return
render(request,'quiz/admin_view_teacher_salary.html',{'teachers':teachers})

41
@login_required(login_url='adminlogin')
def admin_student_view(request):
dict={
'total_student':SMODEL.Student.objects.all().count(),
}
return render(request,'quiz/admin_student.html',context=dict)

@login_required(login_url='adminlogin')
def admin_view_student_view(request):
students= SMODEL.Student.objects.all()
return render(request,'quiz/admin_view_student.html',{'students':students})

@login_required(login_url='adminlogin')
def update_student_view(request,pk):
student=SMODEL.Student.objects.get(id=pk)
user=SMODEL.User.objects.get(id=student.user_id)
userForm=SFORM.StudentUserForm(instance=user)
studentForm=SFORM.StudentForm(request.FILES,instance=student)
mydict={'userForm':userForm,'studentForm':studentForm}
if request.method=='POST':
userForm=SFORM.StudentUserForm(request.POST,instance=user)
studentForm=SFORM.StudentForm(request.POST,request.FILES,instance=st
udent)
if userForm.is_valid() and studentForm.is_valid():
user=userForm.save()
user.set_password(user.password)
user.save()
studentForm.save()
return redirect('admin-view-student')
return render(request,'quiz/update_student.html',context=mydict)

42
@login_required(login_url='adminlogin')
def delete_student_view(request,pk):
student=SMODEL.Student.objects.get(id=pk)
user=User.objects.get(id=student.user_id)
user.delete()
student.delete()
return HttpResponseRedirect('/admin-view-student')

@login_required(login_url='adminlogin')
def admin_course_view(request):
return render(request,'quiz/admin_course.html')

@login_required(login_url='adminlogin')
def admin_add_course_view(request):
courseForm=forms.CourseForm()
if request.method=='POST':
courseForm=forms.CourseForm(request.POST)
if courseForm.is_valid():
courseForm.save()
else:
print("form is invalid")
return HttpResponseRedirect('/admin-view-course')
return render(request,'quiz/admin_add_course.html',{'courseForm':courseForm})

@login_required(login_url='adminlogin')
def admin_view_course_view(request):
courses = models.Course.objects.all()
return render(request,'quiz/admin_view_course.html',{'courses':courses})

@login_required(login_url='adminlogin')
def delete_course_view(request,pk):
course=models.Course.objects.get(id=pk)
course.delete()
return HttpResponseRedirect('/admin-view-course')

43
@login_required(login_url='adminlogin')
def admin_question_view(request):
return render(request,'quiz/admin_question.html')

@login_required(login_url='adminlogin')
def admin_add_question_view(request):
questionForm=forms.QuestionForm()
if request.method=='POST':
questionForm=forms.QuestionForm(request.POST)
if questionForm.is_valid():
question=questionForm.save(commit=False)
course=models.Course.objects.get(id=request.POST.get('courseID'))
question.course=course
question.save()
else:
print("form is invalid")
return HttpResponseRedirect('/admin-view-question')
return
render(request,'quiz/admin_add_question.html',{'questionForm':questionForm})

@login_required(login_url='adminlogin')
def admin_view_question_view(request):
courses= models.Course.objects.all()
return render(request,'quiz/admin_view_question.html',{'courses':courses})

@login_required(login_url='adminlogin')
def view_question_view(request,pk):
questions=models.Question.objects.all().filter(course_id=pk)
return render(request,'quiz/view_question.html',{'questions':questions})

@login_required(login_url='adminlogin')
def delete_question_view(request,pk):
question=models.Question.objects.get(id=pk)
question.delete()
44
 return HttpResponseRedirect('/admin-view-question')

@login_required(login_url='adminlogin')
def admin_view_student_marks_view(request):
students= SMODEL.Student.objects.all()
return
render(request,'quiz/admin_view_student_marks.html',{'students':students})

@login_required(login_url='adminlogin')
def admin_view_marks_view(request,pk):
courses = models.Course.objects.all()
response = render(request,'quiz/admin_view_marks.html',{'courses':courses})
response.set_cookie('student_id',str(pk))
return response

@login_required(login_url='adminlogin')
def admin_check_marks_view(request,pk):
course = models.Course.objects.get(id=pk)
student_id = request.COOKIES.get('student_id')
student= SMODEL.Student.objects.get(id=student_id)

results= models.Result.objects.all().filter(exam=course).filter(student=student)
return render(request,'quiz/admin_check_marks.html',{'results':results})

def aboutus_view(request):
return render(request,'quiz/aboutus.html')

def contactus_view(request):
sub = forms.ContactusForm()
if request.method == 'POST':
sub = forms.ContactusForm(request.POST)
if sub.is_valid():
45
 email = sub.cleaned_data['Email']
name=sub.cleaned_data['Name']
message = sub.cleaned_data['Message']
send_mail(str(name)+' ||
'+str(email),message,settings.EMAIL_HOST_USER,
settings.EMAIL_RECEIVING_USER, fail_silently = False)
return render(request, 'quiz/contactussuccess.html')
return render(request, 'quiz/contactus.html', {'form':sub})

views.py

from django.shortcuts import render,redirect,reverse

from . import forms,models
from django.db.models import Sum
from django.contrib.auth.models import Group
from django.http import HttpResponseRedirect
from django.contrib.auth.decorators import login_required,user_passes_test
from django.conf import settings
from datetime import date, timedelta
from django.db.models import Q
from django.core.mail import send_mail
from teacher import models as TMODEL
from student import models as SMODEL
from teacher import forms as TFORM
from student import forms as SFORM
from django.contrib.auth.models import User

def home_view(request):
if request.user.is_authenticated:
return HttpResponseRedirect('afterlogin')
return render(request,'quiz/index.html')

def is_teacher(user):
return user.groups.filter(name='TEACHER').exists()

def is_student(user):
46
 return user.groups.filter(name='STUDENT').exists()

def afterlogin_view(request):
if is_student(request.user):
return redirect('student/student-dashboard')

elif is_teacher(request.user):
accountapproval=TMODEL.Teacher.objects.all().filter(user_id=request.user.id
,status=True)
if accountapproval:
return redirect('teacher/teacher-dashboard')
else:
return render(request,'teacher/teacher_wait_for_approval.html')
else:
return redirect('admin-dashboard')

def adminclick_view(request):
if request.user.is_authenticated:
return HttpResponseRedirect('afterlogin')
return HttpResponseRedirect('adminlogin')

@login_required(login_url='adminlogin')
def admin_dashboard_view(request):
dict={
'total_student':SMODEL.Student.objects.all().count(),
'total_teacher':TMODEL.Teacher.objects.all().filter(status=True).count(),
'total_course':models.Course.objects.all().count(),
'total_question':models.Question.objects.all().count(),
}
return render(request,'quiz/admin_dashboard.html',context=dict)

@login_required(login_url='adminlogin')
def admin_teacher_view(request):
dict={
'total_teacher':TMODEL.Teacher.objects.all().filter(status=True).count(),
'pending_teacher':TMODEL.Teacher.objects.all().filter(status=False).count(),
'salary':TMODEL.Teacher.objects.all().filter(status=True).aggregate(Sum('salary'
))['salary sum'],
47
 }
return render(request,'quiz/admin_teacher.html',context=dict)

@login_required(login_url='adminlogin')
def admin_view_teacher_view(request):
teachers= TMODEL.Teacher.objects.all().filter(status=True)
return render(request,'quiz/admin_view_teacher.html',{'teachers':teachers})

@login_required(login_url='adminlogin')
def update_teacher_view(request,pk):
teacher=TMODEL.Teacher.objects.get(id=pk)
user=TMODEL.User.objects.get(id=teacher.user_id)
userForm=TFORM.TeacherUserForm(instance=user)
teacherForm=TFORM.TeacherForm(request.FILES,instance=teacher)
mydict={'userForm':userForm,'teacherForm':teacherForm}
if request.method=='POST':
userForm=TFORM.TeacherUserForm(request.POST,instance=user)
teacherForm=TFORM.TeacherForm(request.POST,request.FILES,instance=te
acher)
if userForm.is_valid() and teacherForm.is_valid():
user=userForm.save()
user.set_password(user.password)
user.save()
teacherForm.save()
return redirect('admin-view-teacher')
return render(request,'quiz/update_teacher.html',context=mydict)

@login_required(login_url='adminlogin')
def delete_teacher_view(request,pk):
teacher=TMODEL.Teacher.objects.get(id=pk)
user=User.objects.get(id=teacher.user_id)
user.delete()
teacher.delete()
return HttpResponseRedirect('/admin-view-teacher')

@login_required(login_url='adminlogin')
48
def admin_view_pending_teacher_view(request):
teachers= TMODEL.Teacher.objects.all().filter(status=False)
return
render(request,'quiz/admin_view_pending_teacher.html',{'teachers':teachers})

@login_required(login_url='adminlogin')
def approve_teacher_view(request,pk):
teacherSalary=forms.TeacherSalaryForm()
if request.method=='POST':
teacherSalary=forms.TeacherSalaryForm(request.POST)
if teacherSalary.is_valid():
teacher=TMODEL.Teacher.objects.get(id=pk)
teacher.salary=teacherSalary.cleaned_data['salary']
teacher.status=True
teacher.save()
else:
print("form is invalid")
return HttpResponseRedirect('/admin-view-pending-teacher')
return render(request,'quiz/salary_form.html',{'teacherSalary':teacherSalary})

@login_required(login_url='adminlogin')
def reject_teacher_view(request,pk):
teacher=TMODEL.Teacher.objects.get(id=pk)
user=User.objects.get(id=teacher.user_id)
user.delete()
teacher.delete()
return HttpResponseRedirect('/admin-view-pending-teacher')

@login_required(login_url='adminlogin')
def admin_view_teacher_salary_view(request):
teachers= TMODEL.Teacher.objects.all().filter(status=True)
return
render(request,'quiz/admin_view_teacher_salary.html',{'teachers':teachers})

@login_required(login_url='adminlogin')
def admin_student_view(request):
dict={
49
 'total_student':SMODEL.Student.objects.all().count(),
}
return render(request,'quiz/admin_student.html',context=dict)

@login_required(login_url='adminlogin')
def admin_view_student_view(request):
students= SMODEL.Student.objects.all()
return render(request,'quiz/admin_view_student.html',{'students':students})

@login_required(login_url='adminlogin')
def update_student_view(request,pk):
student=SMODEL.Student.objects.get(id=pk)
user=SMODEL.User.objects.get(id=student.user_id)
userForm=SFORM.StudentUserForm(instance=user)
studentForm=SFORM.StudentForm(request.FILES,instance=student)
mydict={'userForm':userForm,'studentForm':studentForm}
if request.method=='POST':
userForm=SFORM.StudentUserForm(request.POST,instance=user)
studentForm=SFORM.StudentForm(request.POST,request.FILES,instance=stu
dent)
if userForm.is_valid() and studentForm.is_valid():
user=userForm.save()
user.set_password(user.password)
user.save()
studentForm.save()
return redirect('admin-view-student')
return render(request,'quiz/update_student.html',context=mydict)

@login_required(login_url='adminlogin')
def delete_student_view(request,pk):
student=SMODEL.Student.objects.get(id=pk)
user=User.objects.get(id=student.user_id)
user.delete()
student.delete()
return HttpResponseRedirect('/admin-view-student')

@login_required(login_url='adminlogin')
50
def admin_course_view(request):
return render(request,'quiz/admin_course.html')

@login_required(login_url='adminlogin')
def admin_add_course_view(request):
courseForm=forms.CourseForm()
if request.method=='POST':
courseForm=forms.CourseForm(request.POST)
if courseForm.is_valid():
courseForm.save()
else:
print("form is invalid")
return HttpResponseRedirect('/admin-view-course')
return render(request,'quiz/admin_add_course.html',{'courseForm':courseForm})

@login_required(login_url='adminlogin')
def admin_view_course_view(request):
courses = models.Course.objects.all()
return render(request,'quiz/admin_view_course.html',{'courses':courses})

@login_required(login_url='adminlogin')
def delete_course_view(request,pk):
course=models.Course.objects.get(id=pk)
course.delete()
return HttpResponseRedirect('/admin-view-course')

@login_required(login_url='adminlogin')
def admin_question_view(request):
return render(request,'quiz/admin_question.html')

@login_required(login_url='adminlogin')
def admin_add_question_view(request):
questionForm=forms.QuestionForm()
if request.method=='POST':
questionForm=forms.QuestionForm(request.POST)
if questionForm.is_valid():
question=questionForm.save(commit=False)
course=models.Course.objects.get(id=request.POST.get('courseID'))
51
 question.course=course
question.save()
else:
print("form is invalid")
return HttpResponseRedirect('/admin-view-question')
return
render(request,'quiz/admin_add_question.html',{'questionForm':questionForm})

@login_required(login_url='adminlogin')
def admin_view_question_view(request):
courses= models.Course.objects.all()
return render(request,'quiz/admin_view_question.html',{'courses':courses})

@login_required(login_url='adminlogin')
def view_question_view(request,pk):
questions=models.Question.objects.all().filter(course_id=pk)
return render(request,'quiz/view_question.html',{'questions':questions})

@login_required(login_url='adminlogin')
def delete_question_view(request,pk):
question=models.Question.objects.get(id=pk)
question.delete()
return HttpResponseRedirect('/admin-view-question')

@login_required(login_url='adminlogin')
def admin_view_student_marks_view(request):
students= SMODEL.Student.objects.all()
return
render(request,'quiz/admin_view_student_marks.html',{'students':students})

@login_required(login_url='adminlogin')
def admin_view_marks_view(request,pk):
courses = models.Course.objects.all()
response = render(request,'quiz/admin_view_marks.html',{'courses':courses})
response.set_cookie('student_id',str(pk))
return response

@login_required(login_url='adminlogin')
def admin_check_marks_view(request,pk):
52
 course = models.Course.objects.get(id=pk)
student_id = request.COOKIES.get('student_id')
student= SMODEL.Student.objects.get(id=student_id)

results= models.Result.objects.all().filter(exam=course).filter(student=student)
return render(request,'quiz/admin_check_marks.html',{'results':results})

def aboutus_view(request):
return render(request,'quiz/aboutus.html')

def contactus_view(request):
sub = forms.ContactusForm()
if request.method == 'POST':
sub = forms.ContactusForm(request.POST)
if sub.is_valid():
email = sub.cleaned_data['Email']
name=sub.cleaned_data['Name']
message = sub.cleaned_data['Message']
send_mail(str(name)+' ||
'+str(email),message,settings.EMAIL_HOST_USER,
settings.EMAIL_RECEIVING_USER, fail_silently = False)
return render(request, 'quiz/contactussuccess.html')
return render(request, 'quiz/contactus.html', {'form':sub

53
 index.html

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-
width, initial- scale=1.0">
<title>Heart Disease Prediction</title>
min-height: 100vh;
}
.container {
background-color: white;
border-radius: 8px;
box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
padding: 20px;
max-width: 600px;
width: 100%;
}
h1 {
text-align: center;
color: #333;
margin-bottom: 20px;
}
form {
display: grid;
grid-template-columns: 1fr 1fr; /* Two columns */
gap: 20px; /* Space between items */
}
label {
margin-bottom: 8px;
color: #555;
54
 font-weight: bold;
}
input[type="number"] {
padding: 10px;
border-radius: 4px;
border: 1px solid #ddd;
font-size: 16px;
width: 100%;
}
/* Make the submit button span two columns */
input[type="submit"] {
padding: 12px;

background-color: #4CAF50;
color: white;
border: none;
border-radius: 4px;
font-size: 16px;
cursor: pointer;
grid-column: span 2; /* Make it span both columns */
transition: background-color 0.3s ease;
}
input[type="submit"]:hover {
background-color: #45a049;
}

text-align: center;
color: #333;
margin-bottom: 20px;
}
form {
display: grid;
grid-template-columns: 1fr 1fr; /* Two columns */
gap: 20px; /* Space between items */
}
55
 background-color: #4CAF50;
color: white;
border: none;
border-radius: 4px;
font-size: 16px;
cursor: pointer;
grid-column: span 2; /* Make it span both columns */
transition: background-color 0.3s ease;
}
input[type="submit"]:hover {
background-color: #45a049;
}
</style>
</head>
<body>
<div class="container">
<h1>Heart Disease Prediction</h1>
<form action="/predict" method="post">
<div>
<label>Age:</label>
<input type="number" name="age" required>
</div>
<div>
<label>Height (cm):</label>
<input type="number" name="height" required>
</div>
<div>
<label>Weight (kg):</label>
<input type="number" name="weight" required>
</div>
<div>
<label>Systolic blood pressure (ap_hi):</label>
<input type="number" name="ap_hi" required>
</div>
<div>
56
 <label>Diastolic blood pressure (ap_lo):</label>
<input type="number" name="ap_lo" required>
</div>
<div>
<label>Cholesterol (1: normal, 2: above normal, 3:
well above normal):</label>
<input type="number" name="cholesterol" required>
</div>
<div>
<label>Gluc (1: normal, 2: above normal, 3: well
above normal):</label>
<input type="number" name="gluc" required>
</div>
<div>
<label>Smoke (1: yes, 0: no):</label>
<input type="number" name="smoke" required>
</div>
<div>
<label>Alco (1: yes, 0: no):</label>
<input type="number" name="alco" required>
</div>
<div>
<label>Active (1: yes, 0: no):</label>
<input type="number" name="active" required>
</div>
<div>
<label>Gender (1: female, 2: male):</label>
<input type="number" name="gender" required>
</div>
<!-- Submit Button -->
<input type="submit" value="Predict">
</form>
</div>
</body>
</html>
57
 result.html

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Prediction Result</title>
<style>
body {
font-family: Arial, sans-serif;
background-color: #f7f7f7;
display: flex;
justify-content: center;
align-items: center;
height: 100vh;
margin: 0;
}
.container {
background-color: white;
border-radius: 8px;
box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
padding: 20px;
max-width: 400px;
text-align: center;
}
h1 {
color: #333;
}
p{
font-size: 18px;
color: #666;
margin: 20px 0;
}
a{
display: inline-block;
padding: 10px 20px;
background-color: #4CAF50;
58
 color: white;
border-radius: 4px;
text-decoration: none;
}
a:hover {
background-color: #45a049;
}
</style>
</head>
<body>
<div class="container">
<h1>Prediction Result</h1>
<p>Your heart disease prediction: <strong>{{ prediction }}</strong></p>
<a href="/">Go Back</a>
</div>
</body>
</html>

59
 TESTING METHODOLOGIES

SOFTWARE TESTING
Software testing is a critical element of software quality assurance and represents the
ultimate review of specification, design and code generation.
➢ Testing Objectives
● To ensure that during operation the system will perform as per specification.
● To make sure that system meets the user requirements during operation
● To make sure that during the operation, incorrect input, processing and
output will be detected
● To see that when correct inputs are fed to the system the outputs are correct
● To verify that the controls incorporated in the same system as intended
● Testing is a process of executing a program with the intent of finding an error
● A good test case is one that has a high probability of finding an as yet
undiscovered error.
The software developed has been tested successfully using the following testing
strategies and any errors that are encountered are corrected and again the part of the
program or the procedure or function is put to testing until all the errors are removed.
A successful test is one that uncovers an as yet undiscovered error.
Note that the result of the system testing will prove that the system is working correctly.
It will give confidence to system designer, users of the system, prevent frustration during
implementation process etc.,

60
TEST CASE DESIGN:

White box testing:

White box testing is a testing case design method that uses the control structure of the
procedure design to derive test cases. All independent paths in a module are exercised at
least once, all logical decisions are exercised at once, execute all loops at boundaries and
within their operational bounds exercise internal data structure to ensure their validity.

Black Box Testing:

Black Box Testing attempts to find errors in following areas or categories, incorrect or
missing functions, interface error, errors in data structures, performance error and
initialization and termination error. Here all the input data must match the data type to
become a valid entry. The following are the different tests at various levels.

Unit Testing:
Unit testing is essentially for the verification of the code produced during the coding phase
and the goal is to test the internal logic of the module/program. In the Generic code project,
the unit testing is done during the coding phase of data entry forms whether the functions
are working properly or not. In this phase all the drivers are tested whether they are rightly
connected or not.

61
 TEST CASES

1. Test Case: Data Preprocessing

• Objective: Ensure that the dataset is preprocessed correctly before training

the model.
• Steps:

1. Load the dataset (cardio_train.csv).

2. Drop irrelevant columns, such as 'id'.
3. Check for any missing values and handle them appropriately (e.g., impute
or drop).
4. Scale the features using Standard Scaler.
• Expected Results: The dataset should be cleaned, with all features scaled

and no missing values.

2. Test Case: Model Training
• Objective: Verify that the model is trained successfully with the given dataset.

• Steps:

1. Split the dataset into training and testing sets (e.g., 80-20 split).
2. Train the Random Forest model with the specified parameters.
3. Evaluate the training time and accuracy on the training set.
• Expected Results: The model should train without errors and achieve an

accuracy above a certain threshold (e.g., 70%).

3. Test Case: Prediction Functionality
• Objective: Ensure the model can make predictions based on user input.

• Steps:

1. Provide a sample input, including age, height, weight, blood

pressure, cholesterol, etc.
2. Use the model's predict() method to get a prediction.
• Expected Results: The output should indicate either "Disease" or "No

Disease" based on the input data.

4. Test Case: API Endpoint Testing
• Objective: Validate the backend API's ability to handle prediction requests.

• Steps:

1. Send a POST request to the /predict endpoint with a JSON payload

62
 containing user data.
2. Check if the response status code is 200 (OK).
3. Validate that the response contains the prediction result.
• Expected Results: The API should return a 200 status code and a valid

prediction.
5. Test Case: User Interface Form Submission
• Objective: Verify that the form on the frontend collects data and sends it

correctly to the backend.

• Steps:

1. Enter valid inputs for age, height, weight, blood pressure, cholesterol, etc., in
the form fields.
2. Submit the form and check if the backend receives the data correctly.
3. Verify that the prediction result is displayed on the result page.
• Expected Results: The form submission should be successful, and the

prediction should be displayed.

6. Test Case: Edge Cases for User Input
• Objective: Test how the system handles extreme or invalid inputs.

• Steps:

1. Enter negative values for age, height, or weight.

2. Submit incomplete data (e.g., missing one or more required fields).
3. Enter outlier values (e.g., extremely high blood pressure).
• Expected Results: The system should display appropriate error messages and

not proceed with invalid input.

63
OUTPUT

64
65
66
 \

67
68
69
 FUTURE ENHANCEMENTS

Implementation of an AI Leaderboard System:

• Develop a dynamic leaderboard that uses AI algorithms to analyze user performance trends.
The system will display top performers based on quiz scores and activity levels, motivating
users to participate more frequently. Customization options will allow users to view rankings
on daily, weekly, or monthly bases.

Detailed Feedback Mechanism:

• Create an AI-driven feedback system that provides users with explanations for both correct
and incorrect answers. By analyzing performance data, the system can offer personalized
recommendations, guiding users on specific areas for improvement.

AI-Powered Adaptive Quizzing:

• Integrate an AI engine that adapts quiz difficulty in real time based on individual user
performance. The system will assess the user’s strengths and weaknesses, providing easier
questions for those struggling and more challenging ones for high performers, ensuring a
tailored learning experience.

Mobile Application Development:

• Design a mobile app for both Android and iOS that leverages AI for enhanced user
experience. Features could include push notifications for new quizzes, AI-based reminders
for practice, and offline access to quizzes, allowing users to track scores and view progress
anytime, anywhere.

Multi-Language Support:
• Use AI-driven translation tools to offer quizzes in multiple languages, increasing
accessibility for a wider audience. Users can set their language preferences, and the system
can adapt quizzes to regional or cultural contexts, enhancing user engagement.

70
 CONCLUSION

The Online Quiz Application represents a significant advancement in the field of digital
education, providing a dynamic and interactive platform tailored to enhance learning
experiences through engaging quizzes, instant feedback, and personalized progress tracking.
By identifying and addressing the limitations of traditional quiz solutions, this application
fosters a flexible and accessible environment that caters to diverse learning styles, making it
suitable for students, educators, and organizations alike.

One of the standout features of the application is its emphasis on gamification, which
transforms the learning process into an engaging and enjoyable experience. By incorporating
elements such as points, badges, and a dynamic leaderboard, users are motivated to participate
actively and strive for improvement. The application encourages healthy competition among
peers, reinforcing knowledge retention and making learning a more social and rewarding
endeavor.

The platform’s customization options further enhance its usability, allowing educators to tailor
quizzes to meet specific learning objectives and adapt content to various educational contexts.
This adaptability ensures that the quizzes remain relevant and effective, whether used in a
classroom setting or for self-directed study. Instant feedback on quiz performance not only
helps users identify their strengths and weaknesses but also empowers them to take charge
of their learning journeys, thereby fostering a sense of autonomy and responsibility.

In conclusion, the Online Quiz Application is a valuable educational tool that not only supports
effective knowledge assessment and learning improvement but also adapts to the evolving
needs of users in a digital age. By continuously refining its features and addressing emerging
challenges, the application has the potential to significantly impact how knowledge is acquired
and assessed, paving the way for a more interactive and engaging learning environment .

71
 REFERENCES

• Django Software Foundation. (n.d.). Django Documentation. Retrieved from

https://www.djangoproject.com/

• React. (n.d.). React Documentation. Retrieved from

https://reactjs.org/docs/getting-started.html

• W3Schools. (n.d.). JavaScript Tutorial. Retrieved from

https://www.w3schools.com/js/
.
• Official documentation for Django (https://www.djangoproject.com/)

• Official documentation for React.js (https://reactjs.org/)

• Official documentation for SQLite (https://www.sqlite.org/)

72