CPP Blackbook - Merged PDF
CPP Blackbook - Merged PDF
A
PROJECT REPORT ON
“COLLEGE ERP SYSTEM”
Submitted to
Gramin Technical and Management Campus,
Vishnupuri, Nanded
In Partial Fulfilment of the Requirement for the Award of
Diploma In
Computer Engineering
Submitted by
Kranti Balaji Shinde
Shatakshi Uttam
Basarkar Under the
Guidance
Of
Mr. Honshette V. U.
431606 2021-2022
CERTIFICATE
This is certified that the project progress report entitled “Online
College ERP System” has been carried out by “Kranti Shinde,
Roll No.: 60[FS] and Shatakshi Basarkar Roll No.: 06[FS]”
under my guidance in partial fulfilment of award of diploma in
Computer Engineering of Maharashtra State Board Of Technical
Education, Mumbai during the academic year 2021-2022. To the
best my knowledge and belief this work has not been submitted
else- where for award of any degree or diploma.
Honshette Sir
(Guide)
Dept.of Comp.Engg
APPROVAL CERTIFICATE
ACKNOWLEDGEMENT
We could never have completed our project without the support and
assistance of many people. First and foremost, we would like to express
deepest gratitude to our project guide Miss. Dudhamle M.N. for his excellent
guidance, valuable suggestion and kind of encouragement in academics.
We would also like to thank Miss.Dudhmale M.N as they have given us
time to time information about the project. We are grateful for their help.
We are thankful to our HOD Miss. Dudhmale M.N. and Principal Dr. Pawar
V.S. for providing us this infrastructure and labs.
Last but not least we owe a debt to our parents who are silent guides in
our life. We are also thankful to all our friends for their encouragement and
support.
ABSTRACT
ERP College Management Module which is used by colleges to manage their daily
activities which include the management of Employees, Students Books and Library
Records, Parents details, Assignments, Admission Process, Results and Reports, Exams,
Events, Attendance, Timetable, Fees and Other Reports. It provides one-point access to
manage these wide range of activities both effectively. Managing a school, university
college or any educational institution without a perfect software solution in the present
times is painful, same in the case of any enterprises o business. Hence an appropriate
solution is required which can ensure the smooth functioning of the organization as a
whole, and with ERP college Management Module, this problem can simply be solved.
INDEX
1.1 Introduction 1
1.2 Aim 1
CHAPTER 1
INTRODUCTION
1.1 INTRODUCTION
The purpose is to design software for college database which contains up to date
or accurate information of the college. That should improve efficiency and flexibility of
college record management and to provide a common and or simple platform for
everyone to access the student’s information.
1.2 AIM
The main goal of the entire system is to provide a user-friendly interface and
powerful data system which make this system more useful. The College ERP system
computerizes all the details of the college system which are updated by admin only can
access by the students and faculties. ERP on college management system reduces the
most of the human work that are done earlier to managing the college system. Once the
details are entered into the system by the authorized person then there is no need for other
users to deal with separate section. Only a person that is having an administrative
authorization is enough to maintain all the reports and records of the system. The security
can also be provided as per the requirements. The main thing is that our system reduces
the human works at a great effort.
business. Hence an appropriate solution is required which can ensure the smooth
functioning of the organization as a whole, and with ERP college Management Module,
this problem can simply be solved.
This section includes the overall view of the project i.e., the basic problem definition and
the general overview of the problem which describes the problem in layman terms. It also
specifies the software used and the proposed solution strategy.
This section includes the Software and hardware requirements for the smooth running of
the application.
This section consists of the Software Development Life Cycle model. It also contains
technical diagrams like the Data Flow Diagram and the Entity Relationship diagram.
This section describes the different technologies used for the entire development process
of the Front-end as well as the Back-end development of the application.
This section has screenshots of all the implementation i.e., user interface and their
description.
This section has screenshots of all the implementation i.e., user interface and their
description.
CHAPTER 2
LITERATURE SURVEY
ERP is stands for Enterprise Resource Planning. Enterprise resource planning
(ERP) is business management software or a system which is typically used to manage
core departmental data of respective business. ERP provides an integrated view of
business processes, often in real-time, using common databases maintained by database
management systems. ERP system track business resources — raw materials, cash,
production capacity and the status of business commitments like: payroll, purchase
orders, and orders. The application that makes up the system share data across the various
departments (purchasing, accounting, sales, manufacturing etc.). That provides the core
data. ERP facilitates information flow between business function, and manages
connections to outside stakeholders. Every college has to maintain a management system
for various sections which may include performance analysis, attendance system, test
wise result, student information, fee structure, academic information, transport facility,
staff information and many more. Managing all these sections manually on paper
becomes very time consuming and complex tasks.
In such system there is high possibility of misplacement of collected data and data
redundancy in the form of paper records in order to overcome these drawbacks there is a
need to design and implement College ERP system where a college staff can track a
student profile in all aspects of academic course. College ERP system is an online web-
based system which implements a user friendly and attractive interface for college. The
aim for deployment and implementation of this system is to replace manual system of
colleges with an automated web-based system. This College ERP system also manages
data accurately and efficiently which is stored over a long period of time. College ERP
system provides single access point to all administrative system of colleges. In previous
systems all the departments are worked independently and separately. If anyone want to
access that data collectively then it is not possible with such systems. System study of
such system shows that all the booking was done manually on registers, which was
very complicated job.
Report generation of all records was also not possible in the existing system. Also, the
work of college was manually maintained and stored. All this data is maintained through
register or file system in the college. Current mode of working is based on manual system
in which the all the data is first received from respective personnel and then entered in
the registers or files. It is very complex job and time consuming also. The existing system
is also dependent on students, if the students are absent. Then performance of student will
be affected. Due to huge volume of data, a lot of problems are involved in maintaining,
updating and retrieving selected information.
This College ERP system also manages data accurately and efficiently which is
stored over a long period of time. College ERP system provides single access point to all
administrative system of colleges. In previous systems all the departments are worked
independently and separately. If anyone want to access that data collectively then it is not
possible with such systems. System study of such system shows that all the booking was
done manually on registers, which was very complicated job. Report generation of all
records was also not possible in the existing system. Also, the work of college was
manually maintained and stored. All this data is maintained through register or file
system in the college.
Collage ERP system is very time consuming and tedious job. The existing system
in depended on the pupil, is the pupil is not present. The achievement of the students will
be affected. Coz of lots of data many issues are involved in handling, updating and
collecting the desired data. Since the old system is totally handled manually, few of the
difficulties in the present system are as follows:
- ➢ Repetition of information.
➢ Problem in renewing the data.
➢ Non-integrated data.
➢ Lag in collecting data
CHAPTER 3
SCOPE OF THE
PROJECT
The purpose is to design software for college database which contains up to date
or accurate information of the college. That should improve efficiency and flexibility of
college record management and to provide a common and or simple platform for
everyone to access the student’s information
College information: Through this service one can access the complete
information about the college campus such as courses available, admission procedure,
placements, college events, achievements etc.
Student tracking: Any company or any organization that want to check the
summary about the student of the college, so that they will be able to choose the
particular students for their campus placement and for that purpose they will be given a
particular link through which they can access the information required.
Student attendance status: It gives the attendance status of students. Faculty will
update the attendance periodically and can be seen by students and parents.
Student’s performance in exams: This facility provides the performance of the student in
each exam which is conducted by university or college such as midterm performance.
Marks obtained by students in exams will be updated by faculties that can be access by
students and parents.
Exam Notification: This facility notifies students and parents about examination
schedule.
Events: It will give information about different events that will be conducted by
college time to time. Information about these events will be updated by administrator.
Online assignments: This service provides the facility to faculty to upload assignments and to
students to submit these assignments online.
Information about staff: It will help in maintaining complete information about
college faculty members such as their department, cadre, date of joining, salary, etc.
Administrator will register new faculties and remove their account when they leave the
college.
CHAPTER 4:
METHODLOGY
The system will be used by four people, which are Admin, Teacher, Librarian and
Student.
Admin can login using valid credentials and perform various task such as Adding a
Teacher, Student and Librarian and also can view them.
Admin can also add Time Table and Event details. System allows admin to view
book request received from librarian.
Teacher can login and perform various task such as add assignment, mark attendance,
upload result and view event.
Librarian can login and perform task such as adding a single or multiple books, view
added books, request a book, issue a book to students, return issued book from
student and view event.
Student can access the system by providing valid credentials access modules such as
viewing their own profile, view books, view time-table, assignments, result,
attendance and event.
Super admin is the root node who adds the colleges into the system with their details.
Also, can view/delete a college from the system.
Proposed system is easy to understand and user friendly too.
In that system admin who handle the data.
Admin can take information regarding fee detail.
This system is very easy to understand and user friendly.
Teacher, Student, Librarian are connected with each other on one system.
This system is saving the time for student and teacher too.
In this system user can connect any time whenever he/she wants.
This system is secure.
HTML and current maintainer of the CSS standards, has encouraged the use of CSS over
explicit presentational HTML since 1997.
4.3.2 CSS
Cascading Style Sheets (CSS) is a style sheet language used for describing the
presentation of a document written in a markup language like HTML.CSS is a
cornerstone technology of the World Wide Web, alongside HTML and JavaScript.CSS is
designed to enable the separation of presentation and content, including layout, colours,
and fonts. This separation can improve content accessibility, provide more flexibility and
control in the specification of presentation characteristics, enable multiple web pages to
share formatting by specifying the relevant CSS in a separate .CSS file, and reduce
complexity and repetition in the structural content.
CSS information can be provided from various sources. These sources can be the
web browser, the user and the author. The information from the author can be further
classified into inline, media type, importance, selector specificity, rule order, inheritance
and property definition. CSS style information can be in a separate document or it can be
embedded into an HTML document. Multiple style sheets can be imported. Different
styles can be applied depending on the output device being used; for example, the screen
version can be quite different from the printed version, so that authors can tailor the
presentation appropriately for each medium. The style sheet with the highest priority
controls the content display. Declarations not set in the highest priority source are passed
on to a source of lower priority, such as the user agent style. The process is called
cascading.
One of the goals of CSS is to allow users greater control over presentation.
Someone who finds red italic headings difficult to read may apply a different style sheet.
Depending on the browser and the web site, a user may choose from various style sheets
provided by the designers, or may remove all added styles and view the site using the
browser's default styling, or may override just the red italic heading style without altering
other attributes. The style sheet with the highest priority controls the content display.
Declarations not set in the highest priority source are passed on to a source of lower
priority, such as the user agent style. The process is called cascading.
4.3.3 JavaScript
JavaScript s a high-level, interpreted scripting language that conforms to the
ECMAScript specification. JavaScript has curly-bracket syntax, dynamic typing,
prototype-based object-orientation, and first-class functions. Alongside HTML and CSS,
JavaScript is one of the core technologies of the World Wide Web. JavaScript enables
interactive web pages and is an essential part of web applications. The vast majority of
websites use it, and major web browsers have a dedicated JavaScript engine to execute
it.as a multi-paradigm language, JavaScript supports event-driven, functional, and
imperative (including object-oriented and prototype-based) programming styles. It has
APIs for working with text, arrays, dates, regular expressions, and the DOM, but the
language itself does not include any I/O, such as networking, storage, or graphics
facilities. It relies upon the host environment in which it is embedded to provide these
features.
Initially only implemented client-side in web browsers, JavaScript engines are
now embedded in many other types of host software, including server-side in web servers
and databases, and in non-web programs such as word processors and PDF software, and
in runtime environments that make JavaScript available for writing mobile and desktop
applications, including desktop widgets.
The terms Vanilla JavaScript and Vanilla JS refer to JavaScript not extended by
any frameworks or additional libraries. Scripts written in Vanilla JS are plain JavaScript
code. Google’s Chrome extensions, Opera's extensions, Apple's Safari 5 extensions,
Apple's Dashboard Widgets, Microsoft's Gadgets, Yahoo! Widgets, Google Desktop
Gadgets, and Serenata Kilolo are implemented using JavaScript.
4.4.1 PHP
PHP is a server-side scripting language that is used to develop Static websites or
Dynamic websites or Web applications. PHP stands for Hypertext Pre-processor, that
earlier stood for Personal Home Pages. PHP scripts can only be interpreted on a server
that
has PHP installed. The client computers accessing the PHP scripts require a web browser
only. A PHP file contains PHP tags and ends with the extension ".php".
The term PHP is an acronym for PHP: Hypertext Pre-processor. PHP is a server-
side scripting language designed specifically for web development. PHP can be easily
embedded in HTML files and HTML codes can also be written in a PHP file. The thing
that differentiates PHP with client-side language like HTML is, PHP codes are executed
on the server whereas HTML codes are directly rendered on the browser.
PHP: Hypertext Pre-processor (or simply PHP) is a general-purpose programming
language originally designed for web development. It was originally created by Rasmus
Lerdorf in 1994.PHP code may be executed with a command line interface (CLI),
embedded into HTML code, or 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 a web server or as a Common Gateway
Interface (CGI) executable. The web server outputs the results of the interpreted and
executed PHP code, which may be any type of data, such as generated HTML code or
binary image data. PHP can be used for many programming tasks outside of the web
context, such as standalone graphical applications and robotic drone control.
4.4.2 MySQL
MySQL is an open-source relational database management system (RDBMS)
based on Structured Query Language (SQL). It is one part of the very popular LAMP
platform consisting of Linux, Apache, My SQL, and PHP. Currently My SQL is owned
by Oracle. My SQL database is available on most important OS platforms. It runs on
BSD Unix, Linux, Windows, or Mac OS. Wikipedia and YouTube use My SQL. These
sites manage millions of queries each day. My SQL comes in two versions: My SQL
server system and My SQL embedded system. MySQL is free and open-source software
under the terms of the GNU General Public License, and is also available under a
variety of proprietary licenses. MySQL was owned and sponsored
by the Swedish company MySQL AB, which was bought by Sun Microsystems (now
Oracle Corporation). In 2010, when Oracle acquired Sun, Widenius forked the
open- source MySQL project to create MariaDB.
RDBMS TERMINOLOGY
Before we proceed to explain MySQL database system, let's revise few definitions
related to database.
Database: A database is a collection of tables, with related data.
Table: A table is a matrix with data. A table in a database looks like a simple
spreadsheet.
Column: One column (data element) contains data of one and the same kind, for
example the column postcode.
Row: A row (= tuple, entry or record) is a group of related data, for example the
data of one subscription.
Redundancy: Storing data twice, redundantly to make the system faster.
Primary Key: A primary key is unique. A key value cannot occur twice in one
table. With a key, you can find at most one row.
Foreign Key: A foreign key is the linking pin between two tables.
Compound Key: A compound key (composite key) is a key that consists of
multiple columns, because one column is not sufficiently unique.
Index: An index in a database resembles an index at the back of a book.
Referential Integrity: Referential Integrity makes sure that a foreign key value
always points to an existing row.
CHAPTER 5
1.5.3 ER Diagram
The term implementation has different meanings ranging from the conversation of
a basic application to a complete replacement of a computer system. The procedures
however, are virtually the same. Implementation includes all those activities that take
place to convert from old system to new. The new system may be totally new replacing
an existing manual or automated system or it may be major modification to an existing
system. The method of implementation and time scale to be adopted is found out initially.
Proper implementation is essential to provide a reliable system to meet organization
requirement.
module in
isolation. Unit tests are typically written and run by software developers to ensure that code
meets its design and behaves as intended.
5.2.2 Benefits
The goal of unit testing is to isolate each part of the program and show that the
individual parts are correct. A unit test provides a strict, written contract that the piece of
code must satisfy. As a result, it affords several benefits.
1) Find problems early: Unit testing finds problems early in the development cycle.
In test-driven development (TDD), which is frequently used in both extreme
programming and scrum, unit tests are created before the code itself is written. When the
tests pass, that code is considered complete. The same unit tests are run against that
function frequently as the larger code base is developed either as the code is changed or
via an automated process with the build. If the unit tests fail, it is considered to be a bug
either in the changed code or the tests themselves. The unit tests then allow the location
of the fault or failure to be easily traced.
2) Facilitates Change: Unit testing allows the programmer to refactor code or upgrade
system libraries at a later date, and make sure the module still works correctly (e.g.,
in regression testing). The procedure is to write test cases for all functions and methods
so that whenever a change causes a fault, it can be quickly identified. Unit tests detect
changes which may break a design contract.
3) Simplifies Integration: Unit testing may reduce uncertainty in the units themselves
and can be used in a bottom-up testing style approach. By testing the parts of a program
first and then testing the sum of its parts, integration testing becomes much easier.
4) Documentation: Unit testing provides a sort of living documentation of the system.
Developers looking to learn what functionality is provided by a unit, and how to use it,
can look at the unit tests to gain a basic understanding of the unit's interface (API). Unit
test cases embody characteristics that are critical to the success of the unit. These
characteristics can indicate appropriate/inappropriate use of a unit as well as negative
behaviours that are to be trapped by the unit. A unit test case, in and of itself, documents
these critical characteristics, although many software development environments do not
rely solely upon code to document the product in development.
5.3.1 Purpose
The purpose of integration testing is to verify functional, performance, and
reliability requirements placed on major design items. These "design items", i.e.,
assemblages (or groups of units), are exercised through their interfaces using black-box
testing, success and error cases being simulated via appropriate parameter and data
inputs. Simulated usage of shared data areas and inter-process communication is tested
and individual subsystems are exercised through their input interface. Test cases are
constructed to test whether all the components within assemblages interact correctly, for
example across procedure calls or process activations, and this is done after testing
individual modules, i.e., unit testing. The overall idea is a "building block" approach, in
which verified assemblages are added to a verified base which is then used to support the
integration testing of further assemblages. Software integration testing is performed
according to the software development life cycle (SDLC) after module and functional
tests. The cross-dependencies for software integration testing are: schedule for integration
testing, strategy and selection of the tools used for integration, define the cyclomatic
complexity of the software and software architecture, reusability of modules and life-
cycle and versioning management. Some different types of integration testing are big-
bang, top- down, and bottom-up, mixed (sandwich) and risky-hardest. Other Integration
Patterns are: collaboration integration, backbone integration, layer integration, client-
server integration, distributed services integration and high-frequency integration. The
overall idea is a "building block" approach, in which verified assemblages are added to a
verified base which is then used to support the integration testing of further assemblages.
Malfunction – according to its specification the system does not meet its specified
functionality
Both verification and validation are related to the concepts of quality and of software quality
assurance. By themselves, verification and validation do not guarantee software quality;
planning, traceability, configuration management and other aspects of software
engineering are required. Within the modelling and simulation (M&S) community, the
definitions of verification, validation and accreditation are similar:
the unit, integration and system levels of the software testing process. Although
traditional testers tended to think of white-box testing as being done at the unit level, it is
used for integration and system testing more frequently today. It can test paths within a
unit, paths between units during integration, and between subsystems during a system–
level test. Though this method of test design can uncover many errors or problems, it has
the potential to miss unimplemented parts of the specification or missing requirements.
5.6.1 Levels
1) Unit testing:
White-box testing is done during unit testing to ensure that the code is working as
intended, before any integration happens with previously tested code. White-box testing
during unit testing catches any defects early on and aids in any defects that happen later
on after the code is integrated with the rest of the application and therefore prevents any
type of errors later on.
2) Integration testing:
White-box testing at this level are written to test the interactions of each interface
with each other. The Unit level testing made sure that each code was tested and working
accordingly in an isolated environment and integration examines the correctness of the
behaviour in an open environment through the use of white-box testing for any
interactions of interfaces that are known to the programmer.
3) Regression testing:
White-box testing during regression testing is the use of recycled white-box test
cases at the unit and integration testing levels.
5.6.2 Procedures
White-box testing's basic procedures involves the tester having a deep level of
understanding of the source code being tested. The programmer must have a deep
understanding of the application to know what kinds of test cases to create so that every
visible path is exercised for testing. Once the source code is understood then the source
code can be analysed for test cases to be created. These are the three basic steps that
white- box testing takes in order to create test cases:
5.6.3 Advantages
White-box testing is one of the two biggest testing methodologies used today. It has several
major advantages:
Side effects of having the knowledge of the source code is beneficial to thorough
testing.
Optimization of code by revealing hidden errors and being able to remove these
possible defects.
Gives the programmer introspection because developers carefully describe any
new implementation.
Provides traceability of tests from the source, allowing future changes to the
software to be easily captured in changes to the tests.
White box testing gives clear, engineering-based, rules for when to stop testing.
5.6.5 Disadvantages
Although white-box testing has great advantages, it is not perfect and contains some
disadvantages:
White-box testing brings complexity to testing because the tester must have
knowledge of the program, including being a programmer. White-box testing
requires a programmer with a high level of knowledge due to the complexity of
the level of testing that needs to be done.
On some occasions, it is not realistic to be able to test every single existing
condition of the application and some conditions will be untested.
The tests focus on the software as it exists, and missing functionality may not be
discovered.
5.7: SYSTEM TESTING
System testing of software or hardware is testing conducted on a complete, integrated
system to evaluate the system's compliance with its specified requirements. System
testing falls within the scope of black-box testing, and as such, should require no
knowledge of the inner design of the code or logic. As a rule, system testing takes, as its
input, all of the "integrated" software components that have passed integration testing and
also the software system itself integrated with any applicable hardware system(s). The
purpose of integration testing is to detect any inconsistencies between the software units
that are integrated together (called assemblages) or between any of the assemblages and
the hardware. System testing is a more limited type of testing; it seeks to detect defects
both within the "inter-assemblages" and also within the system as a whole.
System testing is performed on the entire system in the context of a Functional
Requirement Specification(s) (FRS) and/or a System Requirement Specification (SRS).
System testing tests not only the design, but also the behaviour and even the believed
expectations of the customer. It is also intended to test up to and beyond the bounds
defined in the software/hardware requirements specification(s).
CHAPTER 6
RESULT AND
APPLICATION
6.1 Project code:
Index.php
<?php
define('LARAVEL_START', microtime(true));
require DIR .'/../vendor/autoload.php';
$app = require_once DIR .'/../bootstrap/app.php';
$kernel = $app->make(Illuminate\Contracts\Http\Kernel::class);
$response = $kernel->handle(
$request = Illuminate\Http\Request::capture()
);
$response->send();
$kernel->terminate($request, $response);
FeePayDueChart.php
<?php
namespace App\Charts;
use ConsoleTVs\Charts\Classes\Chartjs\Chart;
class FeePayDueChart extends Chart
{
public function construct($a,$b)
{
parent:: construct();
$this->labels([$a, $b])
->title('Fee Compare')
->loaderColor('#46b8da')
->options([
'legend' =>
[ 'display' =>
true,
]
]);
}
}
FeeChart.php
<?php
namespace App\Charts;
use App\Models\Month;
use ConsoleTVs\Charts\Classes\Chartjs\Chart;
class FeesChart extends Chart
{
public function construct()
{
parent:: construct();
$months = Month::get()->pluck('title');
$this->labels($months)
->title('Fees Collection')
->loaderColor('#46b8da')
->options([
'legend' => [
'display' => true,
]
]);
}}
SalaryChart.php
<?php
namespace App\Charts;
use ConsoleTVs\Charts\Classes\Chartjs\Chart;
class SalaryChart extends Chart
{
public function construct()
{
parent:: construct();
$months = Month::get()->pluck('title');
$this->labels($months)
->title('Salary Pay')
->loaderColor('#FF6384')
->options([
'legend' => [
'display' => true,
] ]);
}}
SampleChart.php
<?php
namespace App\Charts;
use ConsoleTVs\Charts\Classes\Chartjs\Chart;
class SampleChart extends Chart{
public function construct()
{
parent:: construct();
$this->labels(['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August',
'September', 'October', 'November', 'December'])
->title('Fees Collection/Salary Pay')
->loaderColor('red')
->options([
'legend' => [
'display' => true,
]
]);
}
public function chart(){
$chart = new SampleChart;
// Additional logic depending on the chart approach
return view('dashboard.chart', ['chart' => $chart]);
}
}
TransactionsChart.php
<?php
namespace App\Charts;
use App\Models\Month;
use ConsoleTVs\Charts\Classes\Chartjs\Chart;
class TransactionChart extends Chart
{
public function construct()
{
parent:: construct();
$months = Month::get()->pluck('title');
$this->labels($months)
->title('Transaction')
->loaderColor('#FF6384')
->options([
'legend' => [
Kernal.php
<?php
namespace App\Console;
use Illuminate\Console\Scheduling\Schedule;
use Illuminate\Foundation\Console\Kernel as ConsoleKernel;
class Kernel extends ConsoleKernel
{
protected $commands = [
//Commands\SendSMSEmail::class, Commands\
BackupDatabaseCommand::class, Commands\
BirthdayWish::class, Commands\
BalanceFeesReminder::class, Commands\
LibraryClearance::class
];
protected function schedule(Schedule $schedule)
{
->cron('* * * * * *')
->withoutOverlapping();*/
$timeZone = getEnv('APP_TIMEZONE');
$schedule->command('command:birthdaywish')
->everyMinute()
->timezone($timeZone);
//Due Fee Reminder
$schedule->command('command:duefeereminder')
->monthly()
->timezone($timeZone);
//Library Clearance Reminder
$schedule->command('command:libraryclearance')
->daily()
->timezone($timeZone);
//Schedule Que Work
$schedule->command('queue:work --tries=18')
->everyFifteenMinutes()
->timezone($timeZone)
->withoutOverlapping();
}
protected function commands()
{
$this->load( DIR .'/Commands');
require base_path('routes/console.php');
}
}
Event.php
<?php
namespace App\Events;
use Illuminate\Broadcasting\Channel;
use Illuminate\Queue\SerializesModels;
use Illuminate\Broadcasting\PrivateChannel;
use Illuminate\Broadcasting\PresenceChannel;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
class Event{
Handler.php
<?php
namespace App\Exceptions;
use Mail;
use Exception;
use App\Mail\ExceptionOccured;
use Illuminate\Auth\AuthenticationException;
use Symfony\Component\Debug\Exception\FlattenException;
use Illuminate\Foundation\Exceptions\Handler as ExceptionHandler;
use Symfony\Component\Debug\ExceptionHandler as SymfonyExceptionHandler;
class Handler extends ExceptionHandler{
protected $dontReport = [
\Illuminate\Auth\AuthenticationException::class,
\Illuminate\Auth\Access\AuthorizationException::class,
\Symfony\Component\HttpKernel\Exception\HttpException::class,
\Illuminate\Database\Eloquent\ModelNotFoundException::class,
\Illuminate\Session\TokenMismatchException::class,
\Illuminate\Validation\ValidationException::class,
];
ViewHelperFacade.php
<?php
namespace App\Facades;
use Illuminate\Support\Facades\Facade;
class ViewHelperFacade extends Facade{
protected static function getFacadeAccessor() { return 'viewhelper'; }
}
Helper.php
<?php
if (env($key))
return env($key);
elseif ($value = configExistInDb($key))
return $value;
return $default;
}
function configExistInDb($key) {
$row = \App\Models\EmailSetting::first();
if (!$row)
return false;
else {
if (!$row->$key)
return false;
else
return $row->$key;
}
return false;
$env = file_get_contents(base_path() . '/.env');
$env = preg_split('/\s+/', $env);;
if($entry[0] == $key){
// If yes, overwrite it with the new one
$env[$env_key] = $key . "=" . $value;
} else {
// If not, keep the old one
$env[$env_key] = $env_value;
}
}
}
$env = implode("\n", $env);
file_put_contents(base_path() . '/.env', $env);
return true;
} else {
return false;
}
}*/
Assignment.php
<?php
namespace App\Models;
use Illuminate\Database\Eloquent\Model;
class Assignment extends BaseModel
{
Attendance.php
<?php
namespace App\Models;
use Illuminate\Database\Eloquent\Model;
class Attendance extends BaseModel
{
protected $fillable = ['created_by', 'last_updated_by', 'attendees_type', 'link_id',
'years_id','months_id',
'day_1','day_2','day_3','day_4','day_5','day_6','day_7','day_8','day_9','day_10','day_11','da
y_12','day_13',
'day_14','day_15','day_16','day_17','day_18','day_19','day_20','day_21','day_22','day_23','
day_24','day_25',
'day_26','day_27','day_28','day_29','day_30','day_31','status'];
}
Acadmicinfo.php
<?php
namespace App\Models;
use Illuminate\Database\Eloquent\Model;
class AcademicInfo extends Model
{
protected $fillable = ['created_by', 'last_updated_by', 'students_id', 'institution',
'board','pass_year','symbol_no',
'percentage', 'division_grade', 'major_subjects', 'remark', 'sorting_order','status'];
}
Bank.php
<?php
namespace App\Models;
use Illuminate\Database\Eloquent\Model;
class Bank extends BaseModel
{
protected $fillable = ['created_by', 'last_updated_by',
'bank_name','ac_name','ac_number','branch','status'];
public function bankTransaction()
{
return $this->hasMany(BankTransaction::class,'banks_id','id');
}
}
Bed.php
<?php
namespace App\Models;
use Illuminate\Database\Eloquent\Model;
class Bed extends BaseModel
{
protected $fillable = ['created_by', 'last_updated_by', 'hostels_id', 'rooms_id',
'bed_number', 'bed_status'];
Book.php
<?php
namespace App\Models;
use Illuminate\Database\Eloquent\Model;
class Book extends BaseModel
{
protected $fillable = ['created_by', 'last_updated_by', 'book_masters_id', 'book_code',
'book_status'];
public function bookMaster()
{
return $this->belongsTo(BookMaster::class, 'id');
}
public function bookStatus()
{
return $this->belongsTo(BookStatus::class, 'id');
}
public function libBookIssue()
{
return $this->hasMany(BookIssue::class, 'book_id');
}
}
Transaction.php
<?php
namespace App\Models;
use Illuminate\Database\Eloquent\Model;
class Transaction extends BaseModel
{
protected $fillable = ['created_by', 'last_updated_by', 'date', 'tr_head_id',
'dr_amount','cr_amount', 'description','status'];
public function trHead()
{
return $this->belongsTo(TransactionHead::class, 'id');
}
}
User.php
<?php
namespace App;
use App\Models\Roles;
use Illuminate\Notifications\Notifiable;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Zizaco\Entrust\Traits\EntrustUserTrait;
use OwenIt\Auditing\Auditable;
use OwenIt\Auditing\Contracts\Auditable as AuditableContract;
use OwenIt\Auditing\Contracts\UserResolver;
class User extends Authenticatable implements AuditableContract
{
use Notifiable;
use EntrustUserTrait;
use Auditable;
protected $fillable = [
'name', 'email', 'password','last_login_at','last_login_ip', 'profile_image',
'contact_number', 'address', 'role_id', 'hook_id', 'status'
];
protected $hidden =
[ 'password',
'remember_token',
];
public function userRole()
{
return $this->belongsToMany(Role::class);
}
public function getStatusAttribute($value)
{
return $value == 1?'active':'in-active';
}
public function setStatusAttribute($value)
{
$this->attributes['status'] = $value == 'active'?1:0;
}
public static function resolveId()
{
return Auth::check() ? Auth::user()->getAuthIdentifier() : null;
}
}
Addvalidation.php
<?php
namespace App\Http\Requests\Download;
use Illuminate\Foundation\Http\FormRequest;
class AddValidation extends FormRequest
{
public function authorize()
{
return true;
}
public function rules()
{
return [
'title' => 'required | unique:downloads,title','download_file' =>
'required|max:10000|mimes:pdf,doc,docx,ppt,xls,xlsx,jpeg,bmp,png',
];
}
public function messages()
{
return [
];
}
}
CreateApplication.php
<?php
namespace
Tests;
use Illuminate\Contracts\Console\Kernel;
trait CreatesApplication
{
public function createApplication()
{
$app = require DIR .'/../bootstrap/app.php';
$app->make(Kernel::class)->bootstrap();
return $app;
}
}
Result:
Admin login
Admin dashboard
Student registration
Staff registeration
Book
Exam
Hostel
Vehicle
CHAPTER 7
CONCLUSION & FUTURE SCOPE
CONCLUSION
Tittle of the project as College ERP System is the system that deals with the
issues related to a particular institution. It is the very useful to the student as well as the
faculties to easy access to finding the details. This project is successfully implemented
with all the features and modules of the college ERP system as per requirements. The
college ERP provides appropriate information to users based on their profiles and role in
the system. This project is designed keeping in view the day-to-day problems faced by a
college system.
Based on analysis, discussions and a review of previous chapters, the following
have been established. The College ERP System application is a desktop application
system with four main user levels namely Accounts Officers, Admissions Officers,
Lecturers, and Administrators. The systems is placed on a centralized server accessible
by all registered account holders by the administrator into the system (under a particular
user level) at all times. The system allows its data to be shared, so it’s installed on a
centralized server and run from client machines at any department. All the college details
are stored in a centralized database. The system ensures strong security and
confidentiality because of the tools, applications and methodologies that were employed
during the 101 design and development stages of the project. Username and password are
always required to grant access.
FUTURE SCOPE
This Project provides the detail structure of the college campus and its
departments. College ERP System synchronizes the working of all the departments. It
looks on all aspects of a college, its students, faculties, departments, marks, hostels,
attendance and other co – curricular activities. College ERP System is the easiest way to
manage all functionalities of a college, which facilitates colleges to maintain the
functionality related to college employees and their students