ONLINE SHOE SHOPPING

A Project report submitted to

G.T.N ARTS COLLEGE (AUTONOMOUS)

DINDIGUL
In the partial fulfillment for the award of the degree of

BACHELOR OF INFORMATION TECHNOLOGY

Submitted by

A. NANTHESSWARAN (Reg.No:20UITB023)

C.ANAND KUMAR (Reg.No:20UITB002)

Under the guidance of

Mr. N. THAMBI RAJAN, M.Sc., M.Phil.,

Assistant Professor in Information Technology

DEPARTMENT OF INFORMATION TECHNOLOGY

G.T.N ARTS COLLEGE (AUTONOMOUS)

DINDIGUL – 624005

APRIL 2023
 G.T.N ARTS COLLEGE (AUTONOMOUS)

DINDIGUL – 624005

DEPARTMENT OF INFORMATION TECHNOLOGY

BONAFIDE CERTIFICATE

This is to certify that the project report entitled “ONLINE SHOE SHOPPING” is a bonafide
work done by G. BAVANA (Reg.No:19UCAB001) and
A. CLARA MARTINA (Reg.No:19UCAB003) in the partial fulfillment of the requirement
for the Degree of Bachelor of Computer Application during the year 2021 – 2022 and this
represents the original work of the candidates
Submitted for the viva – voce examination held on .

PROJECT GUIDE HEAD OF THE DEPARTMENT

P. AARTHY ( COMPUTER APPLICATION)

INTERNAL EXAMINAR EXTERNAL EXAMINAR

 DEPARTMENT OF COMPUTERAPPLICATION

G.T.N ARTS COLLEGE (AUTONOMOUS)

DECLARATION
This project report is originally prepared by us for the material fulfillment of our
degree and carried out under the guidance of Mrs. P. AARTHY, M.Sc. M.Phil.,
PGDCA., Assistant Professor in Computer Application, G.T.N ARTS COLLEGE
(AUTONOMOUS) for the partial fulfillment of Bachelor of Commerce with Computer
Application.

G. BAVANA A. CLARA MARTINA

(19UCAB001) (19UCAB003)

PLACE: DINDIGUL

DATE:
 ACKNOWLEDGEMENT

This project report is outcome of an individual work. We expressed our professional

gratitude to all the person who involved in this process.
We express our gratitude and sincere thanks to our Principal, Dr.P.
BALAGURUSAMY, M.A., M.ED., PGDCA., Ph.D., who is a man inspiring us with
distinct qualities and abilities. We show our grateful to him for providing us a conductive
atmosphere in laboratory.
We also thank our Vice Principal (SSC), Dr. U. NATRAJAN, Ph.D., who gave us
an opportunity for the training.
We express our sincere gratitude to Dr.M. SENTHILKUMR, M.Sc., M.PHIL.,
Ph.D., Assistant professor and Head department of computer application., Who
immediately helped in to develop the project successfully by giving necessary guidelines.
We express our sincere thanks to our guide Mrs. P. AARTHY, M.Sc., M.Phil.,
PGDCA., Assistant professor, department of bachelor computer application. For
showing his interest at every stage and his interest at every stage and his valuable suggestion
and having guided on right from the beginning of this project.
We extend our genuine thanks to all the teaching faculties of our department for the
precious guidance provided by them
We extend our gratitude to our parents for their financial support without which our
higher studies would have been only a dream.
 CONTENT
S.NO TITL PAGE.N
E O
1. Abstract 1
2. CHAPTER I
2
1.INTRODUCTION
3. CHAPTER II
2.SYSTEM
ANALYSIS 3

2.1 Existing System 3

2.2 Proposed System

4. CHAPTER III
3. FEASIBILITY STUDY

3.1 Economic Feasibility 5

5
3.2 Technical Feasibility
5
3.3 Operational Feasibility
5. CHAPTER IV
4. SYSTEM DESIGN
4.1 Input Design 6
6
4.2 Output Design
7
4.3 Dataflow Diagram
6. CHAPTER V
5. SYSTEM REQUIREMENTS
5.1 Hardware Requirements 12
5.2 Software Requirements 12
7. CHAPTER VI
6.1 Software Description 1
6.2 System Implementation 3
1
6.3 System Testing
6
6.4 Testing Levels 1
7
1
7
8. CHAPTER VII
7. MODULES
7.1 Project Description 21
7.2 Projects Screenshots 24
34
7.3 Coding
9. CHAPTER VIII
8.1 Conclusion 51
8.2 Future Enhancement 52
53
8.3 References
LIST OF FIGURES

FIG.N FIGURE NAME PAGE.N

O O
4.1 Zero Level DFD For Payment Management 9
4.2 1st Level Data Flow Diagram 10
4.3 2nd Level Data Flow Diagram 11
7.1 Dashboard 24
7.2 Student Fees 25
7.3 Student 26
7.4 Subjects 27
7.5 Exam Results 28
7.6 Class Attendance 29
7.7 Hostels 30
7.8 User Login 31
7.9 Bank Branch 32
7.10 Admin Login 33
LIST OF ABBREVATIONS

● SRS - System Requirement Specification

● DFD - Data Flow Diagram
● PHP - Hypertext Preprocessor
● CGI - Common Gateway Interface
● CLI - Command -Line Interface
● RDBMS - Relational Database Management System
● TB - Terabytes
● DTP - Distributed transaction processing
● ORT - Operational Readiness Testing
● OR & A - Operational Readiness and Assurance
ONLINE SHOE SHOPPING
 ABSTRACT

The Project on” Online Shoe Shopping” it is site to purchase, products

and many more. It would fulfill all requirement of latest products. It contains

all the functionally, Which is as follow: User Registration, Searching and

feedback. Internet is now a day’s become useful for everyone who use

theintemet , in addition to this; these project will give more use to all this to

this user.

The Main interface includes a top panel to select menu options such as

home, best sellers, user, shop, about, management, registration, login. Other

than shoe shopping this project consists of all the necessary modules which the

shopping needs. The main aim and objective are shop shopping but we have

designed to satisfy all the requirements of the online shopping.

 ACKNOWLEDGEMENT

I have efforts in this project, However, it would not have been possible without the

kind support and help of many individuals and organizations. I would like to extend my

sincere thanks to all of them

 Chapter I

1. Introduction
Fee collection and management are crucial tasks for all educational institutions. In the
earlier days, school office staff used to collect the fees manually from the students and
parents, providing printed receipts to each of the students after fee collection. It was tedious
and hectic work for the administrators to collect and manage fees. But in today’s world,
educational institutions started implementing cloud and mobile-based school management
software that made the process, smoother and much easier.
A fee management software is a task management system that automates fee
collection and receipt generation. It also automates entries into the school accounts that help
in reducing errors and eliminating duplicate data entries. The system supports both private
and public schools of all sizes. The school management system software that includes fee
management and accounts management modules can assist the school authorities in
automating and performing various finance-related tasks. Such tasks include fee collection,
customizing fee structure, setting discounts, tracking fraudulent transactions, adding fees,
improving the cash management process and much more. Using this software, you can easily
keep a real-time track of fee payments and other financial records. If you prefer to use a cloud
system, you can transfer student details and fees details to the cloud by a single click.
It is not a difficult task for a user to integrate the fee management module with other
modules of a school management software. Integrating fee management with other modules
provides a wider engagement for students and parents with the institution and improved
productivity for the school.
 Chapter II
2. System Analysis

System analysis is the overall analysis of the system before implementation and for
arriving at a precise solution. Careful analysis of a system before implementation prevents
post implementation problems that might arise due to bad analysis of the problem statements.
Thus, the necessity for systems analysis is justified. Analysis is the first crucial step, detailed
study of the various operations performed by a system and their relationships within and
outside of the system. Analysis is defining the boundaries of the system that will be followed
by design and implementation.
2.1 Existing system

The Existing system is the school administrator who has to maintain all the details of
the student manually in the books. Every time he wants to update the records of the students
need to search for the records in the books. Admin has to enter the details manually in the
books. Students cannot view the details and update if there are any system.
2.2 Proposed System
We are proposing an automated system using which the admin can store all details
about Student in to this site and he can export the details to excel. Instantly he can enter the
student roll number and get the details for editing, searching students. Fee details can be
added up to date and modify if required. Students can enter their personal details and view

the fee details.

Advantages:
1. Data can be accessed remotely
You can easily access the data from anywhere at any time using your device. Various
departments can transfer and import student data from devices located at multiple locations.
Automated reporting increases the revenue and productivity of an institution. It also helps in

eliminating errors that occur during the manual calculation.

2. Avoiding processing fees

Some banks provide corporate banking solutions for schools and other institutions that
help to avoid processing fees and other similar charges for online transactions. In such a way,
schools can save money by eliminating card payment processing charges. If an
institution is a non-profit organization, then that institution gets even better options to save
such charges.
3. A simple and safe fee payment system for parents
Online payment methods for collecting fees helps parents to easily make payment
through a single click and track the payments whenever they like. Parents can deposit fees
through secure payment gateways, using their mobile app as well as from a PC or any other
device. In this way, they can keep real-time tracking of their ward’s fee payment details.
4. Easy accounting
Utilizing fee management software for accounting purposes has really helped
educational institutions to save time and manage finance effectively. It assisted various
institutions to reduce paperwork and issue receipts through email, SMS etc. The fee
management system can generate student wise or class wise fee collection reports and
account-related reports that assists the finance management faculties to manage the accounts
smoothly.
Besides these advantages, a fee management system also offers numerous benefits
such as generating a fee structure, cancelling transactions, defining fee slabs for various
standards, defining fee discounts and much more.
 Chapter III

3. Feasibility Study
After doing the project Student fees payment system, study and analyzing all the
existing or required functionalities of the system, the next task is to do the feasibility study
for the project. All projects are feasible- given unlimited resources and infinite time.
Feasibility study includes consideration of all the possible ways to provide a solution
to given the problem. The proposed solution should satisfy all the requirements and should be
flexible enough so that future changes can be easily done based the future upcoming
requirements.
3.1 Economic Feasibility:
This is very important aspect to considered while developing a project. We decided
the technology based on minimum possible cost factor.
All hardware and software cost has to be borne by the organization.
Overall, we have estimated that the benefits of the organization is going to receive
from the proposed system will surely overcome the initial cost and the later on running cost
for system.
3.2 Technical Feasibility:
This includes the study of function, performance and constraints that may affect the
ability to achieve an acceptable system. For this feasibility study, we studied complete
functionality to be provided in the system, as described in the System Requirement
Specification (SRS), and checked if everything was possible using different type of frontend
and backend platforms.
3.3 Operational Feasibility
No doubt the proposed system is fully GUI based that is very user friendly and all
inputs to be taken all self-explanatory even to a layman. Besides, a proper training has been
conducted to let know the essence of the system to the users so that they feel comfortable to
the new system. As far our study is concerned the clients are comfortable and happy as the
system as cut down their loads and doing.
 Chapter IV

4. System Design
System design concentrates on moving from problems domain to solution domain.
This important phase is composed of several steps. It provides the understanding and
procedural details necessary for implementing the system recommended in the feasibility
study. Emphasis is on translating the performance requirements into design specification. The
design of any software involves mapping of the software requirements into functional
modules. Developing a real time application or any system utilities involves two processes.
The first process is to design the system to implements it. The second is to construct the
executable code.
Software has evolved from an intuitive art development on experience to a science,
each provides systematic techniques for the software definition. Software design is the first
step in the development phase of the software life cycle. Before design the system user
requirements have been identified, information has been gathered to verify the problems and
evaluate the existing system. A feasibility study has been conducted to review alternative
solution and provide cost and benefits justification. To overcome this proposed system is
recommended. At this point the design phase begins.
The process of the design involves conceiving and planning out in the mind and
making a drawing. In software design, there are three distinct activities: external design,
architectural design and detailed design are collectively referred to as internal design.
External design of software involves conceiving and planning out and specifying the
externally observable characteristics of software product.

4.1 Input Design

System design is the process of defining the architecture, components, modules,
interface, and data for a system to satisfy specified requirements. System design could be
seen as the application of systems theory to product development. There is some overlap with
the disciplines of systems analysis, systems architecture and system engineering.
Input design is the process of converting a user-oriented description of the inputs to a
computer-based business system into a programmer-oriented specification.
Input data were found to be available for establishing and maintaining master and
transaction files and for creating output records.
 The most suitable types of input media, for either off-line or on-line devices, where
selected after a study of alternative data capture techniques.
4.2 Input design considerations
The field length must be documented.
The sequence of field should match the sequence of the field on the source document.
The data format must be identified to the data entry operator. Design input
requirements must be comprehensive. Product complexity and the risk associated with its use
dictate the amount of details.
These specify what the product does, focusing on its operational capabilities and
processing of inputs and resultant outputs.
These specify how much or how well the product must perform, addressing such issues as
speed, strength, response times, accuracy, limits of operation, etc.
4.3 Output Design
A quality output is one, which meets the requirements of the end user and parents the
information clearly. In any system result of processing are communicated to the users and to
other system through outputs.
In output design it is determined how the information is to be displaced for immediate
need and also the hard copy output. It is the most important and direct source information to
the user. Efficient and intelligent output design improves the systems relationship to the help
user decision-making.
• Designing computer output should proceed in an organized, well thought out manner;
the right output must be developed while ensuring that each output element is
designed so that people will find the system can use easily and effectively. When
analysis design computer output, they should identify the specific output that is
needed to meet the requirements.
• Select methods for presenting information.

• Create document, report, or other formats that contain information produced by the
system.
The output form of an information system should accomplish one or more of the following

objectives.
• Convey information about past activities, current status or projections.
• Future
 • Signal important events, opportunities, problems, or warning.
• Trigger an action.
• Confirm an action.

4.4 Data flow Diagram

Data flow diagrams are used to graphically represent the flow of data in a business
information system. DFD describes the processes that are involved in a system to transfer
data from the input to the file storage and reports generation. Data flow diagrams can be
divided into logical and physical. The logical data flow diagram describes flow of data
through a system to perform certain functionality of a business. The physical data flow
diagram describes the implementation of the logical data flow.
DFD
Symbols Data
Flow
Arrows marking the movement of the data through the system indicate data flows. It
is the pipeline carrying packets of data from an identified point of origin to specific
destination.
Process
Bubbles or circles are used to indicate where incoming data flows are processed and
then transformed into outgoing data flows. The processes are numbered and named to
indicate the occurrence in the system flow.
External Entity
The rectangle indicates any source or destination of data. The entity can be a class of
people, an organization or even another system. The function of the external entity is to,
supply data to Receive data from the system. They have no interest in how to transform the
data.
Data Store
A data store denotes as open rectangles. It is observed that programs and subsystems
have complex interdependencies including flow of data, flow of control and interaction with
data stores. It is used to identify holding points.
 Data Flow Diagrams:

Zero Level DFD for Payment Management System:

Fig 4.1: Zero level DFD for payment management system

First Level Dataflow Diagram (I level DFD) System:

Fig 4.2: 1St level data flow diagram.

Second Level Data Flow Diagram:

Fig: 2nd level data flow diagram

 Chapter V

5. System Requirements

The hardware and software specification specifies the minimum hardware and
software required to run the project. The hardware configuration specified below is not by
any means the optimal hardware requirements. The software specifications given below is
just the minimum requirements, and the performance of the system may be slow on such

system.

5.1 Hardware Requirements

System : Pentium IV 2.4

Hard Disk : 40GB
Floppy Drive : 1.44MB
Monitor : 15 VGA color
Mouse : Logitech.
Keyboard : 110 keys enhanced
RAM : 256 MB
5.2 Software requirements
Operating System : Windows
Front End : PHP
Back End : MySQL.
 Chapter VI
6.1 Software
Description PHP
Hypertext preprocessor (php) is a server-side scripting language designed primarily
for web development but also used as a general-purpose language. Originally created by
Rasmus Lerdorf in 1994, the PHP reference implementation is now produced by the PHP
Development Team. PHP originally stood for personal home page, but it now stands for the
recursive acronym. PHP code may be embedded into HTML code, or it can be used in
combination with various web template systems, web content management systems and web
frameworks. PHP code is usually processed by a PHP interpreter implemented as a module in
the web server or as a Common Gateway Interface (CGI) executable. The web server
combines the results of the interpreted and executed PHP code, which may be any type of
data, including images, with the generated web page. PHP code may also be executed with a
command-line interface (CLI) and can be used to implement standalone graphical
applications. The standard PHP interpreted, powered by the Zend Engine, is free software
released under the PHP License.
PHP has been widely ported and can be deployed on most web servers on almost
every operating system and platform, free of charge. The PHP language evolved without a
written formal specification or standard until 2014, leaving evolved the canonical PHP
interpreter as a de facto standard. Since 2014 work has gone on to create a formal PHP
specification. PHP is a widely-used open source general-purpose scripting language that is
especially suited for web development and can be embedded into HTML. Instead of lots of
commands to output HTML, PHP pages contain HTML with embedded code that does
“something”. The PHP code is enclosed in special start and end processing instructions that
allow you to jump into and out of “PHP”. What distinguish PHP from something like client-
side JavaScript is that the code is executed on the server, generating HTML which is then
sent to the client. The client would receive the results of running that script, but cannot know
the underlying code. The web server is configured to process all your HTML files with PHP.
The best things in using PHP are that it is extremely simple for a newcomer, but offers many
advanced features for a professional programmer.
 Functions of PHP

• Generate dynamic page content

• Create, open, read, write, delete and close files on the server
• Collect from data
• Send and receive cookies
• Add, delete and modify data in your database
• Can be used to control user-access
• Can encrypt data
Characteristics of PHP
Five important characteristics make PHP' s practical possible

• Simplicity
• Efficiency
• Security
• Flexibility
• Familiarity
MYSQL

MySQL is an open-source relational database management system (RDBMS). Its

name is a combination of “My”, the name co-founders Michael Widenius’s daughter, and
“SQL” the abbreviation for Structured Query Language. The MySQL development project
has made its source code available under the terms of the GNU General Public License, as
well as under a variety of proprietary agreements. MySQL was owned and sponsored by a
single for-profit firm, the Swedish company MySQL AB, now owned by oracle corporation.
For proprietary use, several paid editions are available, and offer additional functionality.
MySQL is a central component of the LAMP open-source web application software stack
(and other “AMP” stacks). LAMP is an acronym for &quotes; Linux, Apache, MySQL,

Perl/PHP/Python" applications that use the MySQL databa se include: TYP03, M0Dx,
Joomla, WordPress, phpBB, MyBB, and Drupal.
MySQL is also used in many high-profile, large-scale websites, including Google
(through not for search), Facebook, Twitter, Flickr, and You Tube. MySQL is written in c
and c++. Its SQL parser is written in yacc, but it uses a home-brewed lexical analyzer.
MySQL works on many system platforms, including AIX, BSDI, FreeBSD, HP-UX,
EComStation, i5/OS, IRIX, Linux, macOS, Microsoft Windows, NetBSD, Novell Netware,
OpenBSD, OpenSolaries, OS/2 Warp, QNX, Oracle Solaris, Symbian, SunOS, SCO Open
Server, SCO UnixWare, Sanos and Tru64. A port of MySQL to OpenVMS also exits.
MySQL is the most popular open source Relational SQL database management
system. MySQL is one of the best RDBMS beings used for developing web-based software
applications. MySQL is a fast, easy-to-use RDBMS being used for many small and big
business. MySQL is developed, marketed, and supported by MySQL AB, which is a Swedish
company.
MySQL is becoming so popular because of many good reasons:
• MySQL is released under an open-source license. So, you have nothing to pay to use
it.
• MySQL is a very powerful program in its own right. It handles a large subset of the
functionality of the most expensive and powerful database packages.
• MySQL uses a standard form of the well-known SQL data language.
• MySQL works on many operating systems and with many languages including PHP,
PERI, C, C++, JAVA, etc.
• MySQL works very quickly and works well even with large data sets.
• MySQL is very friendly to PHP, the most appreciated language for web development.

• MySQL supports large databases, up to 50 million rows or more in a table. The

default file size limit for a table is 4GB, but you can increase this (if your operating
system can handle it) to a theoretical limit of million terabytes (TB). MySQL is
customizable. The open-source GPL license allows programmers to modify the
MySQL software to fit their own specific environments.
Features

• A broad subset of ANSI SQL 99, as well as extensions.

• Cross procedures, using a procedural language that closely adheres to SQL/PSM.
• Triggers
• Cursors
• Updatable views

• Online DDL when using the InnoDB storage Engine.

• Information schema
• Performance Schema that collects and aggregates statistics about server execution and
query performance for monitoring purposes.
 • A set of SQL Mode options to control runtime behavior, including a strict mode to
better adhere to SQL standards.
• X/Open XA distributed transaction processing (DTP) support; two phase commits as
part of this, using the default InnoDB storage engine.
• Transactions with save points when using the default InnoDB Storage Engine.
• Cluster storage engine also supports transactions.
• ACID compliance when using InnoDB and NDB cluster storage engines.
• SSL support
• Query caching
• Sub-SELECTs (i.e. nested SELECTs)
• Built-in replication supports (i.e., master-master replication and master-slave
replication) with one master one master per slave, many slaves per master. Multi-
master replication is provided in MySQL cluster, and multi-master support can be
added to uncluttered configurations using Galera cluster.
• Embedded database library
• Unicode support
• Partitioned tables with pruning of partitions in optimizer
• Shared-nothing clustering through MySQL cluster
• Multiple storage engines, allowing one to choose the one that is most effective for
each table in the application.
• Native storage engines InnoDB, MyISAM, Merge, Memory (heap), federated,
Archive, csv, Blackhole, NDB cluster.
• Commit grouping, gathering multiple transactions from multiple connections together
to increase the numbers of commits per second.

6.2 System Implementation

Implementations is the stage in the project where the theoretical design is turned into
a working system. The implementation phase constructs, installs and operates the new
system. The most crucial stage in achieving a new successful system is that it will work
efficiently and effectively.
6.3 System
Testing Software
Testing:
Software testing is an investigation conducted to provide stakeholders with information about
the quality of the software product or service under test. Software testing can also provide an
objective, independent view of the software to allow the business to appreciate and
understand the risks of software implementation. Test techniques include the process of
executing a program or application with the intent of finding failures, and
verifying that the
software product is fit for use.
Software testing involves the execution of a software component or system component to
evaluate one or more properties of interest. In general, these properties indicate the extent to
which the component or system under test:
• meets the requirements that guided its design and development,
• responds correctly to all kinds of inputs,
• performs its functions within an acceptable time,
• is sufficiently usable,
• can be installed and run in its intended environments
• achieves the general result its stakeholder’s desire.
As the number of possible tests for even simple software components is practically infinite,
all software testing uses some strategy to select tests that are feasible for the available time
and resources. As a result, software testing typically, but not exclusively, attempts to execute
a program or application with the intent of finding failures  due to software faults.   The job of
testing is an iterative process as when one fault is fixed, it can illuminate other failures due to
deeper faults, or can even create new ones.

Software testing can provide objective, independent information about the quality of software
and risk of its failure to users or sponsors.
 Testing Approach
Static, dynamic, and passive testing
Executing programmed code with a given set of test cases is referred to as dynamic testing.
There are many approaches available in software testing. Reviews, walkthroughs,
or inspections are referred to as static testing, whereas
Static testing is often implicit, like proofreading, plus when programming tools/text editors
check source code structure or compilers (pre-compilers) check syntax and data flow as static
program analysis. Dynamic testing takes place when the program itself is run. Dynamic
testing may begin before the program is 100% complete in order to test particular sections of
code and are applied to discrete functions or modules. Typical techniques for these are either
using stubs/drivers or execution from a debugger environment.
Static testing involves verification, whereas dynamic testing also involves validation.
Passive testing means verifying the system behavior without any interaction with the software
product. Contrary to active testing, testers do not provide any test data but look at system logs
and traces. They mine for patterns and specific behavior in order to make some kind of
decisions. This is related to offline runtime verification and log analysis.
6.4 Testing Levels:
Broadly speaking, there are at least three levels of testing: unit testing, integration
testing, and system testing. However, a fourth level, acceptance testing, may be included by
developers. This may be in the form of operational acceptance testing or be simple end-user
(beta) testing, testing to ensure the software meets functional expectations. Based on the
ISTQB Certified Test Foundation Level syllabus, test levels includes those four levels, and
the fourth level is named acceptance testing. Tests are frequently grouped into one of these
levels by where they are added in the software development process, or by the level of
specificity of the test.
Unit testing
Unit testing refers to tests that verify the functionality of a specific section of code, usually at
the function level. In an object-oriented environment, this is usually at the class level, and the
minimal unit tests include the constructors and destructors.
These types of tests are usually written by developers as they work on code (white-box style),
to ensure that the specific function is working as expected. One function might have multiple

tests, to catch corner cases or other branches in the code. Unit testing alone cannot verify the
functionality of a piece of software, but rather is used to ensure that the building blocks of the
software work independently from each other.
Unit testing is a software development process that involves a synchronized application of a
broad spectrum of defect prevention and detection strategies in order to reduce software
development risks, time, and costs. It is performed by the software developer or engineer
during the construction phase of the software development life cycle. Unit testing aims to
eliminate construction errors before code is promoted to additional testing; this strategy is
intended to increase the quality of the resulting software as well as the efficiency of the
overall development process.
Depending on the organization's expectations for software development, unit testing might
include static code analysis, data-flow analysis, metrics analysis, peer code reviews, code
coverage analysis and other software testing practices.
Integration testing
Integration testing is any type of software testing that seeks to verify the interfaces between
components against a software design. Software components may be integrated in an iterative
way or all together ("big bang"). Normally the former is considered a better practice since it
allows interface issues to be located more quickly and fixed.
Integration testing works to expose defects in the interfaces and interaction between
integrated components (modules). Progressively larger groups of tested software components
corresponding to elements of the architectural design are integrated and tested until the
software works as a system.
Integration tests usually involve a lot of code, and produce traces that are larger than those
produced by unit tests. This has an impact on the ease of localizing the fault when an
integration test fails. To overcome this issue, it has been proposed to automatically cut the
large tests in smaller pieces to improve fault localization.
System testing
System testing tests a completely integrated system to verify that the system meets its
requirements. For example, a system test might involve testing a login interface, then creating
and editing an entry, plus sending or printing results, followed by summary processing or

deletion (or archiving) of entries, then logoff.

Acceptance testing
Operational acceptance is used to Commonly this level of Acceptance testing include the
following four types:
• User acceptance testing

• Operational acceptance testing

• Contractual and regulatory acceptance testing

• Alpha and beta testing
User acceptance testing and Alpha and beta testing are described in the next testing types
section.
Conduct operational readiness (pre-release) of a product, service or system as part of a quality
management system. OAT is a common type of non-functional software testing, used mainly
in software development and software maintenance projects. This type of testing focuses on
the operational readiness of the system to be supported, or to become part of the production
environment. Hence, it is also known as operational readiness testing (ORT) or Operations
readiness and assurance (OR&A) testing. Functional testing within OAT is limited to those
tests that are required to verify the non-functional aspects of the system.
In addition, the software testing should ensure that the portability of the system, as well as
working as expected, does not also damage or partially corrupt its operating environment or
cause other processes within that environment to become inoperative.
Contractual acceptance testing is performed based on the contract's acceptance criteria
defined during the agreement of the contract, while regulatory acceptance testing is
performed based on the relevant regulations to the software product. Both of these two testing
can be performed by users or independent testers. Regulation acceptance testing sometimes
involves the regulatory agencies auditing the test results.
 Chapter VII
7. Modules
7.1 Project Description
1. Admin Dashboard
2. Student Fees
3. Payment
4. Master List
5. Courses and year
6. Students
7. Report
8. Payment Report
9. System setting
10. Users
1. Admin Dashboard
This is the center page for all access.
2. Student Fees:
This module represents the fees details of the student list. It includes ID number, EF
number, Name, Payable Fee, paid detail, balance amount and also, we can edit, delete and

view with particular format.

3. Payment:

This module represents Payment details of students list. It includes the details of date,
ID number, EF number, name, paid amount and also, we can easily edit, view and delete via
icons.

4. Master List:

This module has two particular menus. There are Courses & Fees and students. This
module is very useful for admin because of easy to know all student details in one menu.
5. Courses and Year:
This module shows the details of courses, description and total fee and also here we
can edit and delete the details of the students list as per norms.
6. Students:
This module show the details of the student's name and information. This information
includes the details of address, contact no, email ID and here also we can add, edit and delete
the details of student list.
7. Report:
In this session, have one particular menu. That is payment report.
8. Payment Report:
In this module represents the details of student's school fees payment report for every
month. We can easily edit and delete the details and also add.

9. System setting:

This system setting module represents the user's login detail.

10. Users:
This module represents the user’s login details. We can add and delete user login. And
also, it can easily maintain to admin.
Other Features which is added:
• Track enquiries & visitors log on the front office
• Create multiple academic sessions and manage courses, classes, batches, and subjects
• Manage day-to-day classes & Timetables
• Manage registration, pre-admission and admission process
• Add and manage students, teachers, and staffs. Know more about them with their
detailed informative profile
• Ability to promote and terminate students
• Record daily and subject wise attendance
• Build multi-level employee structures and manage it smoothly
• Create tasks with reminders and stay organized
• Manage fee, it’s allocation, concession & cancellation
• Print professional, great looking fee receipts
• Create multiple accounts and track transactions
• your own branding with pre-built themes and color options
• Installation Wizard to set Manage routes, vehicles, it’s documents, fuel & service
records
• Track day to day vehicle log
• Use powerful library management system to manage books. Filter & search books
with authors, publishers, subjects & topics
• Keep records of the books issued, return, late fee and penalty
• Give login access to students, parents, and staffs. Control their access using powerful
roles & permission control system
• Style the application to up the application
• To Do list, Notes, and Reports
7.2 Project Screenshots
Dashboard:

Fig:7.1 dashboard
Student Fees

Fig:7.2 Student fees collection

Students

Fig:7.3 Student Interface

Subjects

Fig:7.4 Subjects
Exam Results

Fig:7.5 Exam Results

Class Attendence

Fig:7.6 Class Attendance

Hostels

Fig:7.7 Hostels
Users Login

Fig:7.8 Users Login Page

Bank Branch

Fig:7.9 Bank Branch

Admin Login

Fig:7.10 Admin Login Page

7.3 Coding:

<! DOCTYPE html>

<html long="en">

<? Php session start ();?>

<head>
<meta charset="utf-8">
<meta content="width=device-width, initial-scale=1.0" name="viewport">

<title><?php echo isset($_SESSION['system']['name']) ? $_SESSION['system']['name'] : ''

?></title>
<?php if(!
isset($_SESSION['login_id']))
header('location:login.php');
include('./header.php');
// include('./auth.php');
?>
</head>
<style>
body{
background: #80808045;
}
.modal-dialog.large
{ width: 80% !
important; max-width:
unset;
}
.modal-dialog.mid-large {
width: 50% !important;
max-width: unset;
}
#viewer_modal .btn-close {
 position: absolute;

z-index: 999999;

/*right: -4.5em;*/

background: unset;

color: white;

border: unset;

font-size: 27px;

top: 0;

#viewer_modal .modal-dialog {

width: 80%;

max-width: unset;

height: calc(90%);

max-height: unset;

#viewer_modal .modal-content {

background: black;

border: unset;

height: calc(100%);

display: flex;

align-items: center;

justify-content:

center;

#viewer_modal img,#viewer_modal

video{ max-height: calc(100%);

max-width: calc(100%);
 }

</style>

<body>

<?php include 'topbar.php' ?>

<?php include 'navbar.php' ?>

<div class="toast" id="alert_toast" role="alert" aria-live="assertive" aria-atomic="true">

<div class="toast-body text-white">

</div>

</div>

<main id="view-panel" >

<?php $page = isset($_GET['page']) ? $_GET['page'] :'home'; ?>

<?php include $page.'.php' ?>

</main>

<div id="preloader"></div>

<a href="#" class="back-to-top"><i class="icofont-simple-up"></i></a>

<div class="modal fade" id="confirm_modal" role='dialog'>

<div class="modal-dialog modal-md" role="document">

<div class="modal-content">

<div class="modal-header">

<h5 class="modal-title">Confirmation</h5>

</div>

<div class="modal-body">

<div id="delete_content"></div>

</div>

<div class="modal-footer">
 <button type="button" class="btn btn-primary" id='confirm'
onclick="">Continue</button>

<button type="button" class="btn btn-secondary" data-

dismiss="modal">Close</button>

</div>

</div>

</div>

</div>

<div class="modal fade" id="uni_modal" role='dialog'>

<div class="modal-dialog modal-md" role="document">

<div class="modal-content">

<div class="modal-header">

<h5 class="modal-title"></h5>

</div>

<div class="modal-body">

</div>

<div class="modal-footer">

<button type="button" class="btn btn-primary" id='submit' onclick="$('#uni_modal

form').submit()">Save</button>

<button type="button" class="btn btn-secondary" data-

dismiss="modal">Cancel</button>

</div>

</div>

</div>

</div>

<div class="modal fade" id="viewer_modal" role='dialog'>

 <div class="modal-dialog modal-md" role="document">

<div class="modal-content">

<button type="button" class="btn-close" data-dismiss="modal"><span class="fa fa-

times"></span></button>

<img src="" alt="">

</div>

</div>

</div>
</body>

<script>

window.start_load = function(){

$('body').prepend('<di id="preloader2"></di>')

window.end_load = function(){

$('#preloader2').fadeOut('fast', function() {

$(this).remove();

})

window.viewer_modal = function($src = ''){

start_load()

var t = $src.split('.')

t = t[1]

if(t =='mp4'){

var view = $("<video src='"+$src+"' controls autoplay></video>")

 }else{

var view = $("<img src='"+$src+"' />")

$('#viewer_modal .modal-content video,#viewer_modal .modal-content img').remove()

$('#viewer_modal .modal-content').append(view)

$('#viewer_modal').modal({

show:true,

backdrop:'static',

keyboard:false,

focus:true

})

end_load()

window.uni_modal = function($title = '' , $url='',$size=""){

start_load()

$.ajax({

url:$url,

error:err=>{

console.log()

alert("An error occured")

},

success:function(resp){

if(resp){
 $('#uni_modal .modal-title').html($title)

$('#uni_modal .modal-body').html(resp)

if($size != ''){

$('#uni_modal .modal-dialog').addClass($size)

}else{

$('#uni_modal .modal-dialog').removeAttr("class").addClass("modal-dialog
modal-md")

$('#uni_modal').modal({

show:true,

backdrop:'static',

keyboard:false,

focus:true

})

end_load()

})

window._conf = function($msg='',$func='',$params = []){

$('#confirm_modal #confirm').attr('onclick',$func+"("+$params.join(',')+")")

$('#confirm_modal .modal-body').html($msg)

$('#confirm_modal').modal('show')

window.alert_toast= function($msg = 'TEST',$bg = 'success'){

 $('#alert_toast').removeClass('bg-success')

$('#alert_toast').removeClass('bg-danger')

$('#alert_toast').removeClass('bg-info')

$('#alert_toast').removeClass('bg-warning')

if($bg == 'success')

$('#alert_toast').addClass('bg-success')

if($bg == 'danger')

$('#alert_toast').addClass('bg-danger')

if($bg == 'info')

$('#alert_toast').addClass('bg-info')

if($bg == 'warning')

$('#alert_toast').addClass('bg-warning')

$('#alert_toast .toast-body').html($msg)

$('#alert_toast').toast({delay:3000}).toast('show');

$(document).ready(function(){

$('#preloader').fadeOut('fast', function() {

$(this).remove();

})

})

('.datetimepicker').datetimepicker({ form

at:'Y/m/d H:i',

startDate: '+3d'
 })
$
('.select2').select2({ placeholder:
"Please select here", width:
"100%"
})
</script>
</html>

<?php

// check this file's MD5 to make sure it wasn't called before

$prevMD5=@implode('', @file(dirname( FILE ).'/setup.md5'));

$thisMD5=md5(@implode('', @file("./updateDB.php")));

if($thisMD5==$prevMD5){

$setupAlreadyRun=true;

}else{

// set up tables

if(!isset($silent)){

$silent=true;

// set up tables

setupTable('students', "create table if not exists `students` ( `id` INT unsigned

not null auto_increment , primary key (`id`), `FullName` VARCHAR(40) not null , `Gender`
VARCHAR(40) not null , `DOB` DATE not null , `Photo` VARCHAR(40) , `RegNo`
VARCHAR(40) not null , unique `RegNo_unique` (`RegNo`), `Class` INT unsigned not null
, `Stream` INT unsigned , `Hostel` INT unsigned , `DOJ` DATE not null , `Category` INT
unsigned , `AcademicYear` INT unsigned not null , `TotalFees` INT unsigned not null ,
`AdvanceFees` INT not null , `Balance` INT , `Parent` INT unsigned ) CHARSET utf8",
$silent, array( "ALTER TABLE students ADD `field17` VARCHAR(40)","ALTER TABLE
`students` CHANGE `field17` `Session` VARCHAR(40) "," ALTER TABLE `students`
CHANGE `Session` `Session` VARCHAR(40) not null "," ALTER TABLE `students`
CHANGE `Session` `Session` INT unsigned ","ALTER TABLE `students` DROP
`Session`"));

setupIndexes('students',
array('Class','Stream','Hostel','Category','AcademicYear','TotalFees','Parent'));

setupTable('feescollection', "create table if not exists `feescollection` ( `id`

INT unsigned not null auto_increment , primary key (`id`), `Student` INT unsigned not null ,
`Class` INT unsigned , `Session` INT unsigned not null , `PaidAmount` INT not null ,
`Balance` INT unsigned , `Branch` INT unsigned not null , `Date` DATE , `Remarks`
VARCHAR(40) ) CHARSET utf8", $silent);

setupIndexes('feescollection', array('Student','Session','Branch'));

setupTable('branch', "create table if not exists `branch` ( `id` INT unsigned

not null auto_increment , primary key (`id`), `Name` VARCHAR(40) not null ,
`AccountNumber` VARCHAR(40) not null ) CHARSET utf8", $silent);

setupTable('teachers', "create table if not exists `teachers` ( `id` INT unsigned

not null auto_increment , primary key (`id`), `Name` VARCHAR(40) not null , `Gender`
VARCHAR(40) not null , `Age` INT not null , `Phone` VARCHAR(40) not null , `Email`
VARCHAR(80) , `StaffNumber` INT not null ) CHARSET utf8", $silent);

setupTable('subjects', "create table if not exists `subjects` ( `id` INT unsigned

not null auto_increment , primary key (`id`), `Name` VARCHAR(40) not null ) CHARSET
utf8", $silent);

setupTable('classes', "create table if not exists `classes` ( `id` INT unsigned

not null auto_increment , primary key (`id`), `Name` VARCHAR(40) not null ) CHARSET
utf8", $silent);

setupTable('streams', "create table if not exists `streams` ( `id` INT unsigned

not null auto_increment , primary key (`id`), `Name` VARCHAR(40) not null ) CHARSET
utf8", $silent);
 setupTable('hostels', "create table if not exists `hostels` ( `id` INT unsigned
not null auto_increment , primary key (`id`), `Name` VARCHAR(40) not null , `Status`
VARCHAR(40) not null ) CHARSET utf8", $silent);

setupTable('timetable', "create table if not exists `timetable` ( `id` INT

unsigned not null auto_increment , primary key (`id`), `Time_Table` VARCHAR(40) not null
, `Class` INT unsigned not null , `Stream` INT unsigned ) CHARSET utf8", $silent);

setupIndexes('timetable', array('Class','Stream'));

setupTable('events', "create table if not exists `events` ( `id` INT unsigned not
null auto_increment , primary key (`id`), `Name` VARCHAR(40) not null , `Date` DATE not
null , `Details` TEXT not null ) CHARSET utf8", $silent);

setupTable('notices', "create table if not exists `notices` ( `id` INT unsigned

not null auto_increment , primary key (`id`), `Name` VARCHAR(40) not null , `Date` DATE
not null , `Details` TEXT not null , `Posted_By` VARCHAR(40) ) CHARSET utf8", $silent);

setupTable('examresults', "create table if not exists `examresults` ( `id` INT

unsigned not null auto_increment , primary key (`id`), `student` INT unsigned not null ,
`RegNo` INT unsigned , `Class` INT unsigned , `Stream` INT unsigned , `Category` INT
unsigned , `Subject` INT unsigned , `Marks` INT not null , `Term` INT unsigned not null ,
`AcademicYear` INT unsigned ) CHARSET utf8", $silent);

setupIndexes('examresults', array('student','Category','Subject','Term'));

setupTable('parents', "create table if not exists `parents` ( `id` INT unsigned

not null auto_increment , primary key (`id`), `Name` VARCHAR(40) not null , `Phone`
VARCHAR(40) not null , `Email` VARCHAR(80) , `HomeAddress` VARCHAR(40) )
CHARSET utf8", $silent);

setupTable('examcategories', "create table if not exists `examcategories` (

`id` INT unsigned not null auto_increment , primary key (`id`), `Name` VARCHAR(40) not
null ) CHARSET utf8", $silent);

setupTable('sessions', "create table if not exists `sessions` ( `id` INT unsigned

not null auto_increment , primary key (`id`), `Year` VARCHAR(40) not null , `Term`
VARCHAR(40) not null , `status` VARCHAR(40) ) CHARSET utf8", $silent, array(
"ALTER TABLE sessions ADD `field4` VARCHAR(40)","ALTER TABLE `sessions`
CHANGE `field4` `status` VARCHAR(40) "));

setupTable('studentcategories', "create table if not exists `studentcategories` (

`id` INT unsigned not null auto_increment , primary key (`id`), `Name` VARCHAR(40) not
null ) CHARSET utf8", $silent);

setupTable('classattendance', "create table if not exists `classattendance` (

`id` INT unsigned not null auto_increment , primary key (`id`), `Subject` INT unsigned not
null , `Student` INT unsigned not null , `RegNo` INT unsigned , `Class` INT unsigned ,
`Stream` INT unsigned , `Attended` VARCHAR(40) , `Date` DATE ) CHARSET utf8",
$silent);
setupIndexes('classattendance', array('Subject','Student'));
setupTable('schoolmoney', "create table if not exists `schoolmoney` (

`id`
INT unsigned not null auto_increment , primary key (`id`), `Class` INT unsigned not null ,
`Particulars` TEXT not null , `Total` DECIMAL(10,2) not null ) CHARSET utf8", $silent);

setupIndexes('schoolmoney', array('Class'));

// save MD5

if($fp=@fopen(dirname( FILE ).'/setup.md5', 'w'))

{ fwrite($fp, $thisMD5);

fclose($fp);

function setupIndexes($tableName, $arrFields){ if(!

is_array($arrFields)){
 return false;

foreach($arrFields as $fieldName){

if(!$res=@db_query("SHOW COLUMNS FROM `$tableName` like

'$fieldName'")){

continue;

if(!$row=@db_fetch_assoc($res)){

continue;

if($row['Key']==''){

@db_query("ALTER TABLE `$tableName` ADD INDEX

`$fieldName` (`$fieldName`)");

function setupTable($tableName, $createSQL='', $silent=true, $arrAlter=''){

global $Translation;

ob_start();

echo '<div style="padding: 5px; border-bottom:solid 1px silver; font-family:

verdana, arial; font-size: 10px;">';
 // is there a table rename query?

if(is_array($arrAlter)){

$matches=array();

if(preg_match("/ALTER TABLE `(.*)` RENAME `$tableName`/",

$arrAlter[0], $matches)){

$oldTableName=$matches[1];

if($res=@db_query("select count(1) from `$tableName`")){ // table already

exists

if($row = @db_fetch_array($res)){

echo str_replace("<TableName>", $tableName,

str_replace("<NumRecords>", $row[0],$Translation["table exists"]));

if(is_array($arrAlter)){

echo '<br>';

foreach($arrAlter as $alter){

if($alter!=''){

echo "$alter ... "; if(!

@db_query($alter)){

echo '<span class="label label-

danger">' . $Translation['failed'] . '</span>';

echo '<div class="text-danger">' .

$Translation['mysql said'] . ' ' . db_error(db_link()) . '</div>';

}else{
 echo '<span class="label label-
success">' . $Translation['ok'] . '</span>';

}else{

echo $Translation["table uptodate"];

}else{

echo str_replace("<TableName>", $tableName,

$Translation["couldnt count"]);

}else{ // given tableName doesn't exist

if($oldTableName!=''){ // if we have a table rename query

if($ro=@db_query("select count(1) from `$oldTableName`")){
// if old table exists, rename it.

$renameQuery=array_shift($arrAlter); // get and

remove rename query

echo "$renameQuery ... "; if(!

@db_query($renameQuery)){

echo '<span class="label label-danger">' .

$Translation['failed'] . '</span>';

echo '<div class="text-danger">' .

$Translation['mysql said'] . ' ' . db_error(db_link()) . '</div>';
 }else{

echo '<span class="label label-success">' .

$Translation['ok'] . '</span>';

if(is_array($arrAlter)) setupTable($tableName,
$createSQL, false, $arrAlter); // execute Alter queries on renamed table ...

}else{ // if old tableName doesn't exist (nor the new one since we're
here), then just create the table.

setupTable($tableName, $createSQL, false); // no Alter queries passed

}
}else{ // tableName doesn't exist and no rename, so just create the table
echo str_replace("<TableName>", $tableName,
$Translation["creating table"]);

if(!@db_query($createSQL)){

echo '<span class="label label-danger">' .

$Translation['failed'] . '</span>';
echo '<div class="text-danger">' .
$Translation['mysql
said'] . db_error(db_link()) . '</div>';

}else{

echo '<span class="label label-

success">' .
$Translation['ok'] . '</span>';

echo "</div>";

$out=ob_get_contents();
 ob_end_clean();

if(!$silent)

{ echo $out;

?>
 Chapter VIII

8.1 Conclusion:

Our project is only humble venture to satisfy the needs to manage their project work.
Several user-friendly coding has also adopted. This package shall prove to be a powerful
package in satisfying all the requirements of the school. The objective of software planning is
to provide a framework that enables the manger to make reasonable estimate made within a
limited time frame at the beginning of the software project and should be updated regularly as
the project progresses.
8.2 Future Enhancement

In near future, we are planning to fees are paid online mode. which helps for students and
parents. Let the admin can add new classes. Bank of question per subject Let teacher add
questions to the bank of question
8.3 References:

• Guderloy, Jorden BPB Publications (2000) – “Mastering SQL Server”

• Luke Welling and Laura Thomson (5th Edition) – “PHP and MySQL Web
Development”

• Roger S. Pressmen, T. Mc. GH. – software Engineering (Theoretical Approach)

• Thereon Willis wrox publications (2000) – “Beginning SQL Server”