Professional Documents
Culture Documents
DINDIGUL
In the partial fulfillment for the award of the degree of
G. BAVANA (Reg.No:19UCAB001)
DEPARTMENT OF COMPUTERAPPLICATION
JUNE-2022
G.T.N ARTS COLLEGE (AUTONOMOUS)
DINDIGUL – 624005
DEPARTMENT OF COMPUTERAPPLICATION
BONAFIDE CERTIFICATE
This is to certify that the project report entitled “SCHOOL MANAGEMENT WITH FEES
COLLECTION” 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 .
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.
PLACE: DINDIGUL
DATE:
ACKNOWLEDGEMENT
The aim of this School Fees System project is to automate the fee collection process
of schools and management of fee payment for schools. It has a very user-friendly interface
which enables the user to easily make fee payments. It enables the parents to know about fee
dues and make payments accordingly. This tool is mainly designed for public and private
schools of all sizes which helps the administrative staff to complete the billing functionalities
efficiently.
The Main interface includes a left panel to select different menu options such as
student, report, fees, setting etc. The user shall be able to login into this payment system and
check for the fees that is due and can make the payments. A report shall also be generated for
the time period chosen. The payments shall be done through safe and secure methods that are
used in the tool. The tool is being built by highly qualified team whose main aim is to ensure
secured transaction for the users.
Other than Fees collection this project consists of all the necessary modules which the school
needs. The main aim and objective are fees collection but we have designed to satisfy all the
requirements of the school.
1
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.
2
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
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
3
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.
4
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.
5
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.
6
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
7
• Signal important events, opportunities, problems, or warning.
• Trigger an action.
• Confirm an action.
8
Data Flow Diagrams:
9
First Level Dataflow Diagram (I level DFD) System:
1
Second Level Data Flow Diagram:
1
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.
1
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.
1
Functions of PHP
• Simplicity
• Efficiency
• Security
• Flexibility
• Familiarity
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,
1
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.
1
• 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.
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.
1
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.
1
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
1
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
Acceptance testing
Operational acceptance is used to Commonly this level of Acceptance testing include the
following four types:
1
• User acceptance testing
2
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
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.
2
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:
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
2
• 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
2
7.2 Project Screenshots
Dashboard:
Fig:7.1 dashboard
2
Student Fees
2
Students
2
Subjects
Fig:7.4 Subjects
2
Exam Results
2
Class Attendence
2
Hostels
Fig:7.7 Hostels
3
Users Login
3
Bank Branch
3
Admin Login
3
7.3 Coding:
3
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
max-width: calc(100%);
3
}
</style>
<body>
</div>
</div>
</main>
<div id="preloader"></div>
<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">
3
<button type="button" class="btn btn-primary" id='confirm'
onclick="">Continue</button>
</div>
</div>
</div>
</div>
<div class="modal-content">
<div class="modal-header">
<h5 class="modal-title"></h5>
</div>
<div class="modal-body">
</div>
<div class="modal-footer">
</div>
</div>
</div>
</div>
3
<div class="modal-dialog modal-md" role="document">
<div class="modal-content">
</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();
})
start_load()
var t = $src.split('.')
t = t[1]
if(t =='mp4'){
3
}else{
$('#viewer_modal .modal-content').append(view)
$('#viewer_modal').modal({
show:true,
backdrop:'static',
keyboard:false,
focus:true
})
end_load()
start_load()
$.ajax({
url:$url,
error:err=>{
console.log()
},
success:function(resp){
if(resp){
3
$('#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()
})
$('#confirm_modal #confirm').attr('onclick',$func+"("+$params.join(',')+")")
$('#confirm_modal .modal-body').html($msg)
$('#confirm_modal').modal('show')
4
$('#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'
4
})
$
('.select2').select2({ placeholder:
"Please select here", width:
"100%"
})
</script>
</html>
<?php
$thisMD5=md5(@implode('', @file("./updateDB.php")));
if($thisMD5==$prevMD5){
$setupAlreadyRun=true;
}else{
// set up tables
if(!isset($silent)){
$silent=true;
// set up tables
setupIndexes('students',
array('Class','Stream','Hostel','Category','AcademicYear','TotalFees','Parent'));
setupIndexes('feescollection', array('Student','Session','Branch'));
4
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);
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);
setupIndexes('examresults', array('student','Category','Subject','Term'));
4
"ALTER TABLE sessions ADD `field4` VARCHAR(40)","ALTER TABLE `sessions`
CHANGE `field4` `status` VARCHAR(40) "));
`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
{ fwrite($fp, $thisMD5);
fclose($fp);
is_array($arrFields)){
4
return false;
foreach($arrFields as $fieldName){
continue;
if(!$row=@db_fetch_assoc($res)){
continue;
if($row['Key']==''){
global $Translation;
ob_start();
4
// is there a table rename query?
if(is_array($arrAlter)){
$matches=array();
$oldTableName=$matches[1];
if($row = @db_fetch_array($res)){
if(is_array($arrAlter)){
echo '<br>';
foreach($arrAlter as $alter){
if($alter!=''){
@db_query($alter)){
}else{
4
echo '<span class="label label-
success">' . $Translation['ok'] . '</span>';
}else{
}else{
@db_query($renameQuery)){
4
}else{
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.
}
}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)){
}else{
echo '<div class="text-danger">' .
said'] . db_error(db_link()) . '</div>';
$Translation['mysql
}
$Translation['ok'] . '</span>';
echo "</div>";
}
echo '<span class="label label-
success">' .
}
$out=ob_get_contents();
4
ob_end_clean();
if(!$silent)
{ echo $out;
?>
5
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.
5
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
5
8.3 References:
• Luke Welling and Laura Thomson (5th Edition) – “PHP and MySQL Web
Development”