Tourist Management System

TOURIST MANAGEMENT SYSTEM
PROJECT REPORT
(LAB ON PROJECT)
Submitted in partial fulfilment of the requirements for the award of the degree of
BACHELOR OF COMPUTER APPLICATIONS
at the Bharathiar University
By
ANDREW PATRICK L KAVINKUMAR B
(Reg. No.:211CA103) (Reg. No.:21CA114)
ANISH M MANOJ V
(Reg. No.:211CA104) (Reg. No.: 211CA121)
ROSHAN A
(Reg. No.: 211CA132)
Under the Guidance of
V. YUVARAJ, M.C.A., M.Phil., (Ph.D.)

Assistant Professor
DEPARTMENT OF COMPUTER APPLICATIONS
Dr. N.G.P. ARTS AND SCIENCE COLLEGE

(An Autonomous Institution, Affiliated to Bharathiar University, Coimbatore)
Approved by Government of Tamil Nadu & Accredited by NAAC with A++Grade (3rd Cycle -3.64 CGPA)
Dr. N.G.P.-Kalapatti Road, Coimbatore-641 048, Tamil Nadu, India.
Website: www.drngpasc.ac.in Email: info@drngpasc.ac.in. Phone: +91-422-2369100

I I
NOVEMBER- 2023
DECLARATION
We, ANDREW PATRICK.L(Reg. No.:211CA103), KAVINKUMAR.B(Reg.

No.:21CA114), ANISH M(Reg. No.:211CA104), MANOJ V(Reg. No.:
211CA121),ROSHAN A(Reg. No.: 211CA132)hereby declare that the lab on project
report entitled "TOURIST MANAGEMENT SYSTEM" submitted in partial
fulfilment of the requirement for the award of the degree of Bachelor of Computer
Applications at the Bharathiar University is a record of original project work
done during the period of study(2021-24), under the guidance and supervision of
V.YUVARAJ M.C.A., M.Phil., (Ph.D.,) Assistant Professor, Department of
Computer Applications, Dr. N.G.P. Arts and Science College, Coimbatore – 48 and it
has not formed on the basis of award of any Degree/ Diploma/ Associateship/ Fellowship or
other similar title to any candidate of any university.
ANDREW PATRICK L KAVINKUMAR B

(Reg. No.:211CA103) (Reg. No.:21CA114)
ANISH M MANOJ V
(Reg. No.:211CA104) (Reg. No.: 211CA121)
ROSHAN A
(Reg. No.: 211CA132)
Place: Coimbatore
Date:
CERTIFICATE
This is to certify that the project, entitled "Tourist Management System"

submitted in partial fulfilment of the requirement for the award of the degree of
Bachelor of Computer Applications at the Bharathiar University is a record of
original project work done by ANDREW PATRICK.L(Reg.No.:211CA103),
ANISH.M(Reg.No.:211CA104),
KAVINKUMAR.B(Reg.No.:21CA114),MANOJ.V(Reg.No.:211CA121),ROSHAN.A(Reg.No.:
211CA132) during the period (2021-2024) during the period (2021-24) of their study in
Department of Computer Applications, Dr.N.G.P. Arts and Science College,Coimbatore-
48 under my supervision and guidance, and the project has not formed the basis for the award
of any Degree/ Diploma/ Associateship/ Fellowship or other similar title to any candidate of
any university.
(V. Yuvaraj) (Dr. R. Kousalya) (Prof. Dr. K. Ramamurthi)

Project Guide Head of the Department Principal
Place: Coimbatore
Date:
Viva-Voce Examination held on…………………………….
Internal Examiner
ACKNOWLEDGEMENT
This project was the most significant accomplishment in our life and it would
not have been possible without the blessing of God almighty and those who supported
and believed in our caliber.
We record a deep sense of gratitude to Dr. NALLA. G. PALANISWAMI, M.D,

AB (USA),Chairman, Dr.N.G.P Research and Educational Trust and Dr.THAVAMANI.D.
PALANISWAMI, M.D, AB (USA), Secretary, Dr. N.G.P. Arts and Science College,
Coimbatore for providing us an infrastructure facility to carry out project work
successfully.
We record our sincere thanks to Prof. Dr. K. RAMAMURTHI, M.Com., B.L.,

MBA., Ph.D., Principal, Dr. N.G.P. Arts and Science College, Coimbatore, for every
help he rendered before and during the project.
I would like to thank Dr. F. MARY MAGDALENE JANE, Dean, Faculty of

Computer Science for her constructive support throughout our project
We express our sincere thank to Dr. R. KOUSALYA, M.C.A., M.Phil., Ph.D.,

Professor and Head, Department of Computer Applications Dr. N.G.P. Arts and
Science College, Coimbatore for showing sustained interest and providing help
throughout the period of our work.
We would like to extend the sincere thanks to my guide V. YUVARAJ, M.C.A.,

M.Phil., (Ph.D.), Department of Computer Applications, Dr. N.G.P. Arts and Science
College, Coimbatore. We sincerely thank for her exemplary guidance and
encouragement.
We take this opportunity to acknowledge my sincere thanks to all the staff

members of the Department of Computer Science for their constant inspiration,
assistance and resourceful guidance for the completion of this project successfully.
We express our sincere thanks to our family and friends for their encouragement, love,
prayer, moral support, advice and sacrifice without which we would not have been able to pursue
the course of our study.
ABSTRACT
As the name specifies “TOURIST MANAGEMENT SYSTEM” is a web

application for managing tour booking.
Identification of the drawbacks of the existing system leads to the designing of

computerized system that will be compatible to the existing system with the system Which is
more user friendly and more GUI oriented. We can improve the efficiency of the system, thus
overcome the drawbacks of the existing system.
· Less human error
· Strength and strain of manual labour can be reduced
·High security
· Data redundancy can be avoided to some extent
· Data consistency
· Easy to handle
· Easy data updating
· Easy record keeping
· Backup data can be easily generated

TABLE OF CONTENTS
Chapter Number Contents Page No
1 INTRODUCTION
2 SYSTEM CONFIGURATION
2.1 Software Configuration
2.2 Hardware Configuration
2.3 Software Description
2.4 Languages Used
2.5 Module Description
3 SYSTEM ANALYSIS
3.1 Existing System
3.2 Proposed System
4 SYSTEM DESIGN
4.1 ER DIAGRAM
4.2 DATA FLOW DIAGRAM
4.3 UML DIAGRAM
4.4 DATABASE DESIGN
4.5 INPUT DESIGN
4.6 OUTPUT DESIGN
5 SYSTEM TESTING & IMPLEMENTATION

6 SCOPE FOR FUTURE ENHANCEMENT
7 CONCLUSION
8 BIBLIOGRAPHY
9 APPENDICES
9.1 SCREENSHOTS
9.2 SAMPLE CODING

1.INTRODUCTION
In the modern era, tourism has emerged as one of the largest and fastest-growing industries
worldwide. The allure of exploring new destinations, experiencing diverse cultures, and
escaping from the routines of daily life has fuel this exponential growth. However, the sheer
magnitude of this industry has led to new challenges, primarily in managing the various
aspects of tourism effectively.
The need for efficient management of tourist activities and resources has prompted the
development of the Tourist Management System (TMS). This project aims to address the
complexities of the tourism sector by integrating technology and management strategies to
enhance the overall tourist experience. TMS not only benefits tourists in planning and
enjoying their trips but also aids tourism authorities, service providers, and destination
managers in optimizing their operations.
This project report delves into the concepts, design, implementation, and impact of the
Tourist Management System. It provides an insight into the challenges faced by the tourism
industry and how TMS offers innovative solutions to these challenges. Furthermore, it
explores the architecture and features of the system, shedding light on how it streamlines the
management of tourist information, resources, and services.
This report is structured to provide a comprehensive understanding of the Tourist

Management System, from its inception to its real-world applications. By the end of this
document, readers will have a clear grasp of the system's capabilities, its potential to
revolutionize the tourism industry, and the benefits it offers to both tourists and the tourism
sector as a whole.
2.SYSTEM SPECIFICATION
2.1 Hardware Configuration
 Processor: AMD RYZEN 3/ INTEL I3 or Higher

 RAM: 8GB
 Storage: 500GB
2.2 Software Configuration
 Visual Studio Code

 Xampp
 Any web browser
2.3 Software Features
2.3.1 Visual Studio Code
Cross-Platform Compatibility: Visual Studio Code (VS Code) is a cross-platform code

editor available for Windows, macOS, and Linux. This allows developers to use the same
tool across different operating systems.
Extensibility: VS Code offers a vast library of extensions that can be installed to tailor the
editor to specific programming languages, frameworks, and development needs. This
extensibility makes it a versatile choice for various development tasks.
Integrated Development Environment (IDE) Features: Despite being lightweight, VS

Code provides IDE-like features such as code debugging, version control integration (e.g.,
Git), and intelligent code completion.
Syntax Highlighting: VS Code supports syntax highlighting for a wide range of
programming languages, making it easy for developers to read and understand code.
Customizable Themes: The editor allows users to customize its appearance with themes
and color schemes to create a comfortable and visually appealing coding environment.
Integrated Terminal: VS Code includes an integrated terminal that allows developers to

run command-line tools and scripts without leaving the editor.
Code Navigation: Features like "Go to Definition" and "Find All References" simplify
code navigation, making it easy to explore and understand large codebases.
Integrated Git Version Control: VS Code has built-in Git support, enabling developers to
manage version control, commit changes, and work with Git repositories directly within
the editor.
Debugger: The integrated debugger supports various programming languages and

frameworks, allowing developers to set breakpoints, inspect variables, and step through
code for debugging purposes.
Task Runner: VS Code can automate tasks using task runners like Grunt and Gulp. This
feature streamlines repetitive development tasks.
Live Share: Visual Studio Live Share is an extension that enables real-time collaboration
between developers. It allows multiple developers to edit and debug code together, even if
they are in different locations.
Intelligent Code Suggestions: The editor provides intelligent code suggestions and
autocompletion, which can significantly boost productivity by reducing the need to type
out repetitive code manually.
Extensions for Popular Frameworks: You can find a plethora of extensions tailored for
popular frameworks and libraries, enhancing your development experience for specific
projects.
Integrated Package Manager: VS Code can be used with package managers like npm
and yarn, simplifying the process of installing and managing project dependencies.
Interactive Playground: The "Jupyter" extension allows for creating interactive code
notebooks for data analysis, making it a powerful tool for data science and machine
learning projects.
2.3.2 XAMPP CONTROL PANEL
Cross-Platform Compatibility: XAMPP is compatible with multiple operating systems,

including Windows, macOS, and Linux, making it versatile and widely accessible for web
development.
Integrated Stack: XAMPP provides a complete web development stack, including Apache
HTTP Server, MySQL database, PHP, and Perl. This integrated stack simplifies the setup of a
local web server for testing and development.
Easy Installation and Configuration: XAMPP offers a user-friendly installation process

with minimal configuration required. This reduces the complexity of setting up a local web
development environment.
Control Panel: The control panel provides a graphical interface for starting, stopping, and
configuring the individual components of the stack (e.g., Apache and MySQL). This
simplifies server management and saves time.
Apache Web Server: XAMPP includes the Apache HTTP Server, a widely used web server
software, for serving web pages and applications. It supports features like virtual hosts and
SSL/TLS.
MySQL Database: XAMPP incorporates MySQL, a powerful open-source relational
database management system. It allows for easy database creation, management, and
integration into web applications.
PHP Support: XAMPP includes PHP, a popular scripting language for web development. It
supports various PHP versions and extensions, making it suitable for a wide range of web
applications.
phpMyAdmin: XAMPP includes phpMyAdmin, a web-based tool for managing MySQL

databases. It offers a user-friendly interface for database administration, including creating
tables, running queries, and exporting data.
Perl Support: In addition to PHP, XAMPP provides Perl support, enabling developers to
work with Perl scripts and applications.
File and Directory Permissions: XAMPP simplifies file and directory permission settings,
ensuring that web applications can access and modify files as needed.
Security Features: While designed for development and testing, XAMPP includes some
basic security features to protect the local environment, such as password protection for
phpMyAdmin.
Extensions and Add-Ons: Users can extend XAMPP's functionality by adding plugins,
modules, and extensions to the Apache server and other components.
Portability: XAMPP's portability allows developers to easily transfer and share their local
development environment, making it convenient for collaborative projects.
Open Source and Free: XAMPP is open-source software and freely available, making it an
accessible tool for both individual developers and small teams.
Community and Support: XAMPP benefits from a supportive community of users and
developers who provide resources, tutorials, and troubleshooting assistance.
2.4 LANGUAGES USED
 HTML 5
 CSS 4.15
 PHP 8.2.0
 SQL 16.0
 JAVASCRIPT ECMASCRIPT 2023
PHP 8.2.0:
Readonly Classes
PHP 8.1 introduced the readonly feature for class properties. Now, PHP 8.2 is adding
support to declare the entire class as readonly.
If you declare a class as readonly, all its properties will automatically inherit the readonly
feature. Thus, declaring a class readonly is the same as declaring every class property as
readonly.
For example, with PHP 8.1, you had to write this tedious code to declare all class
properties as readonly:
class MyClass { public readonly string $myValue, public readonly int $myOtherValue
public readonly string $myAnotherValue public readonly int $myYetAnotherValue }
Imagine the same with many more properties. Now, with PHP 8.2, you can just write this:
readonly class MyClass { public string $myValue, public int $myOtherValue public string
$myAnotherValue public int $myYetAnotherValue
}
You can also declare abstract or final classes as readonly. Here, the order of the keywords
doesn’t matter.
abstract readonly class Free {} final readonly class Dom {}
You can also declare a readonly class with no properties. Effectively, this prevents
dynamic properties while still allowing child classes to declare their readonly properties
explicitly.
Next up, readonly classes can only contain typed properties — the same rule for declaring
individual readonly properties.
You can use the mixed type property if you cannot declare a strictly typed property.
Trying to declare a readonly class without a typed property will result in a Fatal error:
readonly class Type { public $nope; } Fatal error: Readonly property Type::$nope must
have type in ... on line .
Furthermore, you cannot declare read-only for certain PHP features:
Enums (as they cannot contain any property)

Traits
Interfaces
Attempting to declare any of these features as readonly will result in a Parse error.
readonly interface Destiny {} Parse error: syntax error, unexpected token "interface",
expecting "abstra
As is the case for all PHP keywords, the readonly keyword is case insensitive.
PHP 8.2 also deprecates dynamic properties (more on that later). But you cannot prevent
dynamic properties from being added to a class. However, doing so for a readonly class
will only result in a Fatal Error.
Fatal error: Readonly property Test::$test must have type in ... on line .
Allow true, false, and null as Standalone Types:

PHP already includes scalar types like int, string, and bool. That was expanded in PHP 8.0
with the addition of union types, allowing values to be of different types. The same RFC
also allowed using false and null as part of a union type — they weren’t allowed as
standalone types, though.
If you tried declaring false or null or as standalone types — without them being part of a
union type — it resulted in a fatal error.
function spam(): null {} function eggs(): false {} Fatal error: Null can not be used as a
standalone type in ... on line ...
To avoid this scenario, PHP 8.2 is adding support for using false and null as standalone
types. With this addition, PHP’s type system is more expressive and complete. You can
now declare the return, parameter, and property types precisely.
Also, PHP still doesn’t include a true type, which seems to be a natural counterpart of the
false type. PHP 8.2 fixes that and adds support for the true type as well. It doesn’t allow
coercion, exactly like how the false type behaves.
Both true and false types are essentially a union type of PHP’s bool type. To avoid
redundancy, you cannot declare these three types together in a union type. Doing so will
result in a compile-time fatal error.
Fatal error: False can not be used as a standalone type in ... on line ...
Disjunctive Normal Form (DNF) Types

Disjunctive Normal Form (DNF) is a standardized way of organizing boolean expressions.
It consists of a disjunction of conjunctions — in boolean terms, that’s an OR of ANDs.
Applying DNF to type declarations allows for a standard way to write combined Union
and Intersection types that the parser can handle. PHP 8.2’s new DNF types feature is
simple yet powerful if used properly.
The RFC gives the following example. It assumes the following interface and class
definitions already exist:
interface A {} interface B {} interface C extends A {} interface D {}

class W implements A {} class X implements B {} class Y implements A, B {} class Z
extends Y implements C {}
With DNF types, you can perform type declarations for properties, parameters, and return
values like so:
// Accepts an object that implements both A and B,

// OR an object that implements D
(A&B)|D
// Accepts an object that implements C,

// OR a child of X that also implements D,
// OR null
C|(X&D)|null
// Accepts an object that implements all three of A, B, and D,

// OR an int, // OR null.
(A&B&D)|int|null
In some cases, the properties may not be in DNF forms. Declaring them as such will result
in a parse error. But you can always rewrite them as:
A&(B|D)
// Can be rewritten as (A&B)|(A&D)
A|(B&(D|W)|null)
// Can be rewritten as A|(B&D)|(B&W)|null
You should note that each segment of a DNF type must be unique. For instance, declaring
(A&B)|(B&A) is invalid as the two ORed segments are logically the same.
Adding to this, segments that are strict subsets of the other segment aren’t allowed either.
That’s because the superset will already have all instances of the subset, making it
redundant to use DNF.
Redact Sensitive Parameters in Back Traces:

Like almost any programming language, PHP allows tracing its call stack at any point in
the code’s execution. Stack tracing makes it easy to debug code to fix errors and
performance bottlenecks. It forms the backbone of tools like Kinsta APM, our custom-
designed performance monitoring tool for WordPress sites.
— Tracking slow WooCommerce transactions with Kinsta APM.

Performing a stack trace doesn’t halt the program’s execution. Typically, most stack traces
run in the background and are logged silently — for later inspection if needed.
However, some of these detailed PHP stack traces can be a drawback if you share them
with third-party services — usually for error log analysis, error tracking, etc. These stack
traces may include sensitive information such as usernames, passwords, and environment
variables.
This RFC proposal gives one such example:
One common “offender” is PDO which takes the database password as a constructor
parameter and immediately attempts to connect to the database within the constructor,
instead of having a pure constructor and a separate ->connect() method. Thus when the
database connection fails the stack trace will include the database password:
PDOException: SQLSTATE[HY000] [2002] No such file or directory in /var

Stack trace: #0 /var/www/html/test.php(3): PDO->__construct('mysql:hos
#1 {main}
PHP 8.2 allows you to mark such sensitive parameters with a new \SensitiveParameter
attribute. Any parameter marked sensitive will not be listed in your backtraces. Thus, you
can share them without concerns with any third-party services.
Here’s a straightforward example with a single sensitive parameter:
<?php
function example( $ham,

#[\SensitiveParameter] $eggs,
$butter ) { throw new \Exception('Error'); }
example('ham', 'eggs', 'butter');
/*
Fatal error: Uncaught Exception: Error in test.php:8 Stack trace:
#0 test.php(11): test('ham', Object(SensitiveParameterValue), 'butter')
#1 {main}
thrown in test.php on line 8 */
When you generate a backtrace, any parameter with the \SensitiveParameter attribute will
be replaced with a \SensitiveParameterValue object, and its real value will never be stored
in the trace. The SensitiveParameterValue object encapsulates the actual parameter value
— if you need it for any reason.
New mysqli_execute_query Function and mysqli::execute_query

Method:
Have you ever used the mysqli_query() function with dangerously escaping user values
just to run a parameterized MySQLi query?
PHP 8.2 makes running parameterized MySQLi queries easier with the new
mysqli_execute_query($sql, $params) function and mysqli::execute_query method.
Essentially, this new function is a combination of mysqli_prepare(), mysqli_execute() ,

and mysqli_stmt_get_result() functions. With it, the MySQLi query will be prepared,
bound (if you pass any parameters), and executed within the function itself. If the query
runs successfully, it’ll return a mysqli_result object. If unsuccessful, it’ll return false.
The RFC proposal gives a simple yet powerful example:
foreach ($db->execute_query('SELECT * FROM user WHERE name LIKE ? AND type

print_r($row);
}
Fetch enum Properties in const Expressions

This RFC proposes allowing the ->/?-> operator to fetch enum properties in const
expressions.
The main reason for this new feature is that you cannot use enum objects in some places,
like array keys. In such a case, you’ll have to repeat the value of the enum case just to use
it.
Allowing fetching of enum properties in places where enum objects aren’t allowed can
simplify this procedure.
It means the following code is now valid:
const C = [self::B->value => self::B];
And just to be safe, this RFC also includes support for the nullsafe operator ?->.
Allow Constants in Traits
PHP includes a way to reuse code called Traits. They’re great for code reuse across
classes.
Currently, Traits only allow defining methods and properties, but not constants. That
means you cannot define invariants expected by a Trait within the Trait itself. To get
around this limitation, you need to define constants in its composing class or an interface
implemented by its composing class.
This RFC proposes to allow defining constants in Traits. These constants can be defined
just like you’d define class constants. This example taken straight from the RFC clears the
air around its usage:
trait Foo { public const FLAG_1 = 1; protected const FLAG_2 = 2; private const
FLAG_3 = 2;
public function doFoo(int $flags): void { if ($flags & self::FLAG_1) { echo

'Got flag 1'; } if ($flags & self::FLAG_2) { echo 'Got flag 2'; } if
($flags & self::FLAG_3) { echo 'Got flag 3'; }
}
}
Trait constants are also merged into the composing class definition, the same as a Trait’s
property and method definitions. They also have similar restrictions as properties of Traits.
As noted in the RFC, this proposal — though a good start — needs further work to flesh
out the feature.
Deprecations in PHP 8.2
We can now move to explore all the deprecations in PHP 8.2. This list isn’t quite as big as
its new features:
Deprecate Dynamic Properties (and New #[AllowDynamicProperties]

Attribute)
Up until PHP 8.1, you could dynamically set and retrieve undeclared class properties in
PHP.
For example:
class Post { private int $pid; }
$post = new Post();

$post->name = 'Kinsta';
Here, the Post class doesn’t declare a name property. But because PHP allows dynamic
properties, you can set it outside the class declaration. That’s its biggest — and possibly,
the only — advantage.
Dynamic properties allow unexpected bugs and behaviour to crop up in your code. For
instance, if you make any mistake while declaring a class property outside of the class, it’s
easy to lose track of it — especially when debugging any errors within that class.
From PHP 8.2 onwards, dynamic properties are deprecated. Setting a value to an
undeclared class property will emit a deprecation notice the first time the property is set.
class Foo {} $foo = new Foo;
// Deprecated: Creation of dynamic property Foo::$bar is deprecated

$foo->bar = 1;
// No deprecation warning: Dynamic property already exists.
$foo->bar = 2;
However, from PHP 9.0 onwards, setting the same will throw an ErrorException error.
If your code is full of dynamic properties — and there’s a lot of PHP code that is — and if
you want to stop these deprecation notices after upgrading to PHP 8.2, you can use PHP
8.2’s new #[AllowDynamicProperties] attribute to allow dynamic properties on classes.
#[AllowDynamicProperties] class Pets {} class Cats extends Pets {}
// You'll get no deprecation warning

$obj = new Pets;
$obj->test = 1;
// You'll get no deprecation warning for child classes
$obj = new Cats;
$obj->test = 1;
As per the RFC, classes marked as #[AllowDynamicProperties], as well as their child

classes, can continue using dynamic properties without deprecation or removal.
You should also note that, in PHP 8.2, the only bundled class marked as
#[AllowDynamicProperties] is stdClass. Furthermore, any properties accessed through
__get() or __set() PHP magic methods are not considered dynamic properties, so that they
won’t throw a deprecation notice.
Deprecate Partially Supported Callables:
Another PHP 8.2 change, albeit with a more negligible impact, is to deprecate partially
supported callables.
These callables are termed partially supported because you cannot interact with them
directly via $callable(). You can only get to them with the call_user_func($callable)
function. The list of such callables is not long:
"self::method"
"parent::method"
"static::method"
["self", "method"]
["parent", "method"]
["static", "method"]
["Foo", "Bar::method"]
[new Foo, "Bar::method"]
From PHP 8.2 onwards, any attempts to invoke such callables — such as via
call_user_func() or array_map() functions — will throw a deprecation warning.
The original RFC gives solid reasoning behind this deprecation:
Apart from the last two cases, all of these callables are context-dependent. The method
that "self::method" refers to depends on which class the call or callability check is
performed from. In practice, this usually also holds for the last two cases, when used in the
form of [new Foo, "parent::method"].
Reducing the context-dependence of callables is the secondary goal of this RFC.

After this RFC, the only scope-dependence still left is method visibility:
"Foo::bar" may be visible in one scope, but not another. If callables were to be limited to
public methods in the future (while private methods would have to use first-class callables
or Closure::fromCallable() to be made scopeindependent), then the callable type would
become well-defined and could be used as a property type. However, changes to visibility
handling are not proposed as part of this RFC.
As per the original RFC, the is_callable() function and the callable type will continue to
accept these callables as exceptions. But only until support for them is removed entirely
from PHP 9.0 onwards.
To avoid confusion, this deprecation notice scope was expanded with a new RFC — it
now includes these exceptions.
It’s good to see PHP moving towards having a well-defined callable type.
Deprecate #utf8_encode() and utf8_decode() Functions:
PHP’s built-in functions utf8_encode() and utf8_decode() convert strings encoded in ISO-
8859-1 (“Latin 1”) to and from UTF-8.
However, their names suggest a more general use than their implementation allows. The
“Latin 1” encoding is commonly confused with other encodings like the “Windows Code
Page 1252.”
Furthermore, you’ll usually see Mojibake when these functions cannot convert any string
properly. The lack of error messages also means it’s difficult to spot them, especially
within a sea of otherwise legible text.
PHP 8.2 deprecates both #utf8_encode() and utf8_decode() functions. If you invoke them,
you’ll see these deprecation notices:
Deprecated: Function utf8_encode() is deprecated
Deprecated: Function utf8_decode() is deprecated
The RFC suggests using PHP’s supported extensions like mbstring, iconv, and intl instead.
Deprecate ${} String Interpolation:
PHP allows embedding variables in strings with double-quotes (") and heredoc (<<<) in
several ways:
1. Directly embedding variables — “$foo”

2. With braces outside the variable — “{$foo}”
3. With braces after the dollar sign — “${foo}”
4. Variable variables — “${expr}” — equivalent to using (string) ${expr}
The first two ways have their pros and cons, while the latter two have complex and
conflicting syntax. PHP 8.2 deprecates the last two ways of string interpolation.
You should steer clear of interpolating strings this way going forward:
"Hello, ${world}!";
Deprecated: Using ${} in strings is deprecated
"Hello, ${(world)}!";
Deprecated: Using ${} (variable variables) in strings is deprecated.Starting with PHP 9.0,
these deprecations will be upgraded to throw an exception error.
Deprecate mbstring Functions for Base64/QPrint/Uuencode/HTML Entities:
PHP’s mbstring (multi-byte string) functions help us work with Unicode, HTML
entities, and other legacy text encodings.
However, Base64, Uuencode, and QPrint aren’t text encodings and are still a part of these
functions — primarily due to legacy reasons. PHP also includes separate implementations
of these encodings.
As for HTML entities, PHP has built-in functions — htmlspecialchars() and htmlentities()
— to deal with these better. For example, unlike with mbstring, these functions will also
convert <. >, and & characters to HTML entities.
Moreover, PHP is always improving its built-in functions — just like PHP 8.1 with HTML
encoding and decoding functions.
So, keeping all that in mind, PHP 8.2 is deprecating the use of mbstring for these
encodings (the labels are case-insensitive):
BASE64
UUENCODE
HTML-ENTITIES
html (alias of HTML-ENTITIES) Quoted-Printable
qprint (alias of Quoted-Printable)
From PHP 8.2 onwards, using mbstring to encode/decode any of the above will emit a
deprecation notice. PHP 9.0 will remove mbstring support for these encodings altogether.
Other Minor Changes in PHP 8.2

Finally, we can discuss PHP 8.2’s minor changes, including its removed features
and functionalities.
Remove Support For Libmysql From Mysqli:
As of now, PHP allows both mysqli and PDO_mysql drivers to build against
mysqlnd and libmysql libraries. However, the default and recommended driver since PHP
5.4 has been mysqlnd.
Both these drivers have many advantages and disadvantages. However, removing support
for one of them — ideally, removing libmysql as it’s not the default — will simplify PHP’s
code and unit tests.
To make an argument for this favour, the RFC lists down many advantages of mysqlnd:
It’s bundled with PHP

It uses PHP memory management to monitor memory usage and improve
performance.
Provides quality-of-life functions (e.g. get_result()) Returns numeric values using
PHP native types
Its functionality does not depend on the external library
Optional plugin functionality
Supports asynchronous queries
The RFC also lists some advantages of libmysql, including:
Auto-reconnect is possible ( mysqlnd doesn’t support this functionality intentionally

because it can be easily exploited)
LDAP and SASL authentication modes (mysqlnd may add this feature soon too)
In addition, the RFC lists many disadvantages of libmysql — incompatibility with the PHP
memory model, many failing tests, memory leaks, differing functionalities between
versions, etc.
Keeping all this in mind, PHP 8.2 removed support for building mysqli against libmysql.
If you want to add any functionality that’s only available with libmysql, you’ll have to add
it explicitly to mysqlnd as a feature request. Also, you cannot add auto-reconnect.
Locale-Independent Case Conversion:

Before PHP 8.0, PHP’s locale was inherited from the system environment. But this
could cause a problem in some edge cases.
Setting your language while installing Linux will set the appropriate user interface
language for its built-in commands. However, it also unexpectedly changes how the C
library’s string handling functionality works.
For instance, if you selected “Turkish” or “Kazakh” language when installing Linux,
you’ll find that calling toupper('i') to get its uppercase equivalent would obtain the dotted
capital I (U+0130, ?).
PHP 8.0 stopped this anomaly by setting the default locale to “C,” unless the user
explicitly changes it via setlocale().
PHP 8.2 goes even further by removing locale sensitivity from case conversions. This RFC
primarily changes strtolower(), strtoupper(), and related functions. Read the RFC for a list
of all the affected functions.
As an alternative, if you want to use localized case conversion, then you can use
mb_strtolower().
Random Extension Improvement

PHP is planning to overhaul its random functionality.
As of now, PHP’s random functionality heavily relies on the Mersenne Twister state.
However, this state is implicitly stored in PHP’s global area — there’s no way a user can
access it. Adding randomization functions between the initial seeding stage and the
intended usage would break the code.
Maintaining such code can be even more complicated when your code uses external
packages.
Thus, PHP’s current random functionality cannot reproduce random values consistently. It
even fails empirical statistical tests of uniform random number generators, like TestU01’s
Crush and BigCrush. Mersenne Twister’s 32-bit limitation further exacerbates that.
Thus, using PHP’s built-in functions — shuffle(), str_shuffle(), array_rand() — is not
recommended if you need cryptographically secure random numbers. In such cases, you’ll
need to implement a new function using random_int() or similar functions.
However, several issues with this RFC were raised after the voting had begun. This
setback forced the PHP team to note all the issues in a separate RFC, with a ballot option
created for each issue. They’ll decide on moving further only after reaching a consensus.
Additional RFCs in PHP 8.2
PHP 8.2 also includes many new functions and minor changes. We’ll mention them below
with links to additional resources:
1. New curl_upkeep function: PHP 8.2 adds this new function to its Curl extension. It calls
the curl_easy_upkeep() function in libcurl, the underlying C library that the PHP Curl
extension uses.
2. New ini_parse_quantity function: PHP INI directives accept data sizes with a multiplier
suffix. For instance, you can write 25 Megabytes as 25M, or 42 Gigabytes as just 42G.
These suffixes are common in PHP INI files but are uncommon elsewhere. This new
function parses the PHP INI values and returns their data size in bytes.
3. New memory_reset_peak_usage function: This function resets the peak memory usage
returned by the memory_get_peak_usage function. It can be handy when you’re running
the same action multiple times and want to record each run’s peak memory usage.
4. Support for no-capture modifier (/n) in preg_* functions: In regex, the () metacharacters
indicate a capturing group. That means all matches for the expression within the bracket
are returned. PHP 8.2 adds a no-capture modifier (/n) to stop this behavior.
5. Make the iterator_*() family accept all iterables: As of now, PHP’s iterator_*() family only
accepts \Traversables (i.e. no plain arrays allowed). It’s unnecessarily limiting, and this
RFC fixes that.
SQL:
What is a database? Quite simply, it’s an organized collection of data. A database
management system (DBMS) such as Access, FileMaker Pro, Oracle or SQL Server
provides you with the software tools you need to organize that data in a flexible manner. It
includes facilities to add, modify or delete data from the database, ask questions (or
queries) about the data stored in the database and produce reports summarizing selected
contents.
MySQL is a multithreaded,multi-user SQL database management system(DBMS).

The basic program runs as a server providing multi-user access to a number of
databases.Originally financed in a similar fashion to the JBoss model, MySQL was owned
and sponsored by a single for-profit firm, the Swedish company MySQLAB now a
subsidiary of Sun Microsystem , which holds the copyright to most of the codebase. The
project’s source code is available under terms of the GNU General Public Licence, as well
as under a variety of proprietory agreements.
MySQL is a database.The data in MySQL is stored in database objects called

tables.A table is a collections of related data entries and it consists of columns and
rows.Databases are useful when storing information categorically. A company may have a
database with the following tables: “Employees”, “Products”, “Customers” and “Orders”.
Database Tables:
A database most often contains one or more tables. Each table is identified by a name (e.g.
“Customers” or “Orders”). Tables contain records (rows) with data.
Queries:
A query is a question or a request. With MySQL, we can query a database for
specific information and have a record set returned.
Create a connection to a database:

Before you can access data in a database, you must create a connection to the
database.In PHP, this is done with the mysqli_connect() function.
Syntax
Example :
In the following example we store the connection in a variable ($con) for later use in the
script. The “die” part will be executed if the connection fails:
Closing a Connection:
The connection will be closed automatically when the script ends. To close the
connection before, use the mysql_close() function:
Create a Database:
The CREATE DATABASE statement is used to create a database in MySQL.
Syntax:
CREATE DATABASE database_name
To get PHP to execute the statement above we must use the mysql_query()
function. This function is used to send a query or command to a MySQL connection.
Create a Table:
The CREATE TABLE statement is used to create a table in MySQL
Syntax
CREATE TABLE table_name
column_name1
data_type,
column_name2
data_type,
column_name3
data_type,
....
)
MySQL Functions:
mysql_affected_rows — Get number of affected rows in previous MySQL
operation mysql_change_user — Change logged in user of the active
connection mysql_client_encoding — Returns the name of the character set
mysql_close — Close MySQL connection
mysql_connect — Open a connection to a
MySQL Server mysql_create_db — Create a
MySQL database mysql_data_seek — Move
internal result pointer mysql_db_name —
Get result data mysql_db_query — Send a
MySQL query
mysql_drop_db — Drop (delete) a MySQL database
mysql_errno — Returns the numerical value of the error message from previous MySQL
operation mysql_error — Returns the text of the error message from previous MySQL
operation mysql_escape_string — Escapes a string for use in a mysql_query
mysql_fetch_array — Fetch a result row as an associative array, a numeric array,
or both mysql_fetch_assoc — Fetch a result row as an associative array
mysql_fetch_field — Get column information from a result and return as
an object mysql_fetch_lengths — Get the length of each output in a result
mysql_fetch_object — Fetch a result row as an object

wsmysql_num_rows — Get number of rows in result mysql_pconnect
— Open a persistent connection to a MySQL server
mysql_ping — Ping a server connection or reconnect if there is no
connection mysql_query — Send a MySQL query
mysql_result — Get result data
mysql_select_db — Select a MySQL
database mysql_set_charset
— Sets the client character set
mysql_stat — Get current system status
mysql_tablename —
Get table name of field mysql_thread_id —
Return the current thread ID
mysql_unbuffered_query — Send an SQL query to MySQL, without fetching and
buffering the result.
2.5 MODULE DESCRIPTION
Number of Modules
After careful analysis the system has been identified to have the following modules:
1. Administrator module
2. User (Traveler) module
3. Guest user
2.5.1. ADMINISTRATOR MODULE:
This module provides administrator related functionality. Administrator manages all

information and has access rights to add, delete, edit and view the data related to places,
travels, routes, bookings, Enquiries etc.
Package: Admin will create the packages and manage the packages (Create, Update, delete)
Users: Admin view all Information of all users.
Booking: Admin will responsible for manage booking. Admin can confirm and cancel a
booking of traveller.
Manage issues/ Complaint: Admin can take action on any issue /complaint raised by
user(traveller) and Put remark.
Manage Enquiries: admin can manage all enquiries raised by users(traveller).
Manage pages: Admin can edit the info of all pages that are display on the website,
Dashboard: Here admin can view all count of booking, issues, Enquiries and Users.
Change password: Admin can change own password.
2.5.2.USER(TRAVELLER) MODULE:
Signup- User can register yourself for booking.
Sign in: Here user can login with valid username and password.
Forgot Password: User can recover his/her own password.
My Profile: user can update own profile.
Tour history: After login user can book any tour that will show in Tour history. User can
cancel his/her booking before 24 hr of travelling.
Change Password: User can own Password.
Write-us: Here user can raise any issue related to booking. Cancelation etc.
2.5.3. GUEST MODULE:
Guest user can visit the website and view the all content of website. Guest user can also
Enquiry.
3.SYSTEM STUDY
3.1 EXISTING SYSTEM

 In the present system a customer has to approach various agencies to find details of
places and to book tickets.
 This often requires a lot of time and effort.
 A customer may not get the desired information from these offices and often the
customer may be misguided.
 It is tedious for a customer to plan a particular journey and have it executed
properly.
3.2 PROPOSED SYSTEM
 The proposed system is a web-based application and maintains a centralized

repository of all related information.
 The system allows one to easily access the relevant information and make
necessary travel arrangements.
 Users can decide about places they want to visit and make bookings online for
travel and accommodation.
4.SYSTEM DESIGN
4.1 ER DIAGRAM(USERS)
ER DIAGRAM (ADMIN)
ER DIAGRAM (PACKAGE):
4.2 DATA FLOW DIAGRAM

USER:
ADMIN:
PACKAGE:
UML DIAGRAM:
DATABASE DESIGN
INPUT DESIGN:
Input design is a part of overall system design. The main objective during the
input design is as given below:
• To produce a cost-effective method of input.

• To achieve the highest possible level of accuracy.
• To ensure that the input is acceptable and understood by the user.
INPUT STAGES:
The main input stages can be listed as below:
• Data recording
• Data transcription
• Data conversion
• Data verification
• Data control
• Data transmission
• Data validation
• Data correction
INPUT TYPES:
It is necessary to determine the various types of inputs. Inputs can be categorized

as follows:
• External inputs, which are prime inputs for the system.

• Internal inputs, which are user communications with the system.
• Operational, which are computer department’s communications to
the system?
• Interactive, which are inputs entered during a dialogue.
INPUT MEDIA:
At this stage choice has to be made about the input media. To conclude
about the input media consideration has to be given to;
• Type of input
• Flexibility of format
• Speed
• Accuracy
• Verification methods
• Rejection rates
• Ease of correction
• Storage and handling requirements
• Security
• Easy to use
• Portability
Keeping in view the above description of the input types and input media, it can
be said that most of the inputs are of the form of internal and interactive. As Input
data is to be the directly keyed in by the user, the keyboard can be considered to
be the most suitable input device.
OUTPUT DESIGN:
Outputs from computer systems are required primarily to communicate the results
of processing to users. They are also used to provide a permanent copy of the
results for later consultation. The various types of outputs in general are:
• External Outputs whose destination is outside the organization.
• Internal Outputs whose destination is within organization and they

are the User’s main interface with the computer.
• Operational outputs whose use is purely with in the computer
department.
• Interface outputs, which involve the user in communicating directly

with the system.
OUTPUT DEFINITION:
The outputs should be defined in terms of the following points:
 Type of the output

 Content of the output
 Format of the output
 Location of the output
 Frequency of the output
 Volume of the output
 Sequence of the output
It is not always desirable to print or display data as it is held on a computer. It

should be decided as which form of the output is the most suitable.
For Example:
• Will decimal points need to be inserted
• Should leading zeros be suppressed.
OUTPUT MEDIA:
In the next stage it is to be decided that which medium is the most appropriate for
the output. The main considerations when deciding about the output media are:
• The suitability for the device to the particular application.
• The need for a hard copy.
• The response time required.
• The location of the users
• The software and hardware available.
Keeping in view the above description the project is to have outputs

mainly coming under the category of internal outputs. The main outputs desired
according to the requirement specification are:
The outputs were needed to be generated as a hard copy and as well as queries to be
viewed on the screen. Keeping in view these outputs, the format for the output is
taken from the outputs, which are currently being obtained after manual processing.
The standard printer is to be used as output media for hard copies.
5.SYSTEM TESTING & IMPLEMENTATION
The software which has been developed has to be tested to prove its validity. Testing is
considered to be the least creative phase of the whole cycle of system design. In real sense it
is the phase, which helps to bring out the creativity of the other phases, and makes it shine.
WHITE BOX TESTING:
 By using the technique, it was tested that all the individual logical paths were
executed at least once.
 All the logical decisions were tested on both their true and false sides.
 All the loops were tested with the data in between the ranges and especially at the
boundary values.
 Here this testing is performed to check the user interface.
BLACK BOX TESTING:
 By the use of these techniques the missing functions are identified and placed in their
positions.
 The errors in the interfaces were identified and corrected.
 This technique was also used to identify the initialization and termination errors and
correct them.
 Login: Entering invalid credentials and checking for error messages.
 Login: Entering valid credentials and checking the login.
SOFTWARE TESTING STRATERGIES:
Any software has to be tested with pre planned strategies. To carry out the testing in an
efficient manner certain amount of strategic planning has to be done. Any testing strategy
must incorporate test planning, test case design, test execution and the resultant data
collection and evaluation.
UNIT TESTING:
In Unit testing, we have to test the programs making up the system. The software units in a
system are called modules and routines that are assembled and integrated to perform a
specific function. Unit testing focuses first on the modules, independently of one another, to
locate errors.
This enables to detect errors in coding and logic that are contained within the module. In the
lines of this strategy all the individual functions and modules were put to the test
independently. This method was applied in combination with white and black box testing
techniques to find the errors in each module.
INTEGRATED TESTING:
Again, this software testing strategy has two different approaches namely the top- down
approach in which the integration is carried out from the top-level module to the bottom and
the bottom-up approach in which the integration is carried out from the low-level modules to
the top.
The module was tested using the bottom-up approach by introducing stubs for the top-level
functions. This test was used to identify the errors in the interfaces, the errors in passing the
parameters between the functions and to correct them.
VALIDATION TESTING:
Software validation is achieved through a series of black box test that demonstrate
conformity with requirements. Both plan and procedure are designed to ensure that all
functional required area achieved.
Using validation testing we have tested this project. The user should not leave any input area
blank and it is not allowed to enter improper data. Many validations are needed for each and
every file in the form like textbox validations.
SYSTEM TESTING:
The software and hardware are integrated and a full range of system tests are conducted in an
attempt to uncover error at the software and hardware interface. Before the system is released
to user, testing is the sole duty of the developer to see that the system is free from all kinds of
bugs.
The main purpose of testing an information system is to find out errors and correct them.
Testing was done in two phases
 Foreground testing
 Background testing
The Foreground testing includes the testing of all kinds of bugs that would be visible to the
user on the screen.
 Testing for validity of inputs.

 Testing whether the help message is displayed properly.
 Testing for the proper flow of sequence.
 Testing whether the system is user friendly.
The background testing includes, whether the database get updated as required. A message
such as “Record Stored Successfully” on the monitor may ensure that data has really been
updated in the required tables.
Table updating and Data Validation test.
 Date Retrieval, Calculation and Report generation test.

 Date and Form Security test.
6.SCOPE FOR FUTURE ENHANCEMENT
Mobile Application Development:

Consider developing a mobile app to allow tourists to access the system more easily
while on the go. This app could include features like GPS-based recommendations, tour
booking, and in-app payments.
Integration with IoT:

Implement IoT devices to collect data on tourist behaviour and preferences. For
example, you could use sensors to track foot traffic in popular tourist areas, helping you make
real-time recommendations.
Machine Learning and AI:

Incorporate machine learning and AI to provide personalized recommendations to
tourists. Analysing their past behaviour and preferences can lead to more tailored suggestions.
Augmented Reality (AR):

Create AR features to enhance the tourist experience. This might include guided tours
with AR overlays, allowing tourists to learn about historical sites or landmarks in an
interactive way.
Blockchain for Security:

Implement blockchain technology for enhanced security and transparency, especially
in online payments and booking systems.
Language Support:
Expand language support to cater to a more diverse group of tourists. This might
include real-time translation services or multilingual content.
Sustainability and Eco-Tourism:

Consider features that promote sustainable tourism. This can include information on
eco-friendly practices, local conservation efforts, and carbon footprint tracking.
Social Integration:
Allow users to share their experiences on social media directly from the app. This can
enhance the visibility of your system and provide valuable user-generated content.
Feedback and Review System:

Implement a robust feedback and review system, allowing tourists to rate their
experiences and provide suggestions for improvement.
Data Analytics and Reporting:

Develop tools for data analysis and reporting to help tourism authorities and
businesses make data-driven decisions for better management.
Offline Functionality:
Ensure that the system can work offline, as tourists may not always have a reliable
internet connection.
Accessibility Features:
Enhance accessibility features to accommodate tourists with disabilities.
7.CONCLUSION:
To conclude the description about the project: The project, developed using PHP and
MySQL is based on the requirement specification of the user and the analysis of the existing
system, with flexibility for future enhancement.
The expanded functionality of today’s software requires an appropriate approach

towards software development. This hostel management software is designed for people who
want to manage various activities in the hostel. For the past few years, the number of
educational institutions are increasing rapidly.
Thereby the number of hostels are also increasing for the accommodation of the
students studying in this institution. And hence there is a lot of strain on the person who are
running the hostel and software’s are not usually used in this context. This particular project
deals with the problems on managing a hostel and avoids the problems which occur when
carried manually.
Identification of the drawbacks of the existing system leads to the designing of

computerized system that will be compatible to the existing system with the system which is
more user friendly and more GUI oriented.
8. BIBILIOGRAPHY
1. http://www.w3schools.com
2. in.php.net
3. en.wikipedia.org/wiki/PHP
4. www.hotscripts.com/category/php/
5. http://www.apache.org/
6.www.mysql.com/
9.APPENDICES
9.1 SCREENSHOTS:
ADMIN LOGIN:
ADMIN DASHBOARD:
CREATING TOUR PACAKGES:
MANAGING PACKAGE:
UPDATE PACKAGE:
MANAGE USERS:
MANAGE BOOKING:
MANAGE ISSUES:
MANAGE ENQUIRY:
MANAGE PAGES:
USER SIGN-UP:
USER SIGN-IN:
HOME PAGE:
USER PROFILE:
PACKAGE LIST:
PACKAGE DETAILS:
BOOKING:
TICKET ISSUING:
TOUR HISTORY:
HELP:
9.2 SAMPLE CODE
Home Page:
<?php
session_start();
error_reporting(0);
include('includes/config.php');
?>
<!DOCTYPE HTML>
<html>
<head>
<title>TMS | Tourism Management System</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<script type="applijewelleryion/x-javascript"> addEventListener("load", function()

{ setTimeout(hideURLbar, 0); }, false); function hideURLbar(){ window.scrollTo(0,1); }
</script>
<link href="css/bootstrap.css" rel='stylesheet' type='text/css' />
<link href="css/style.css" rel='stylesheet' type='text/css' />
<link href='//fonts.googleapis.com/css?family=Open+Sans:400,700,600' rel='stylesheet'

type='text/css'>
<link href='//fonts.googleapis.com/css?family=Roboto+Condensed:400,700,300'
rel='stylesheet' type='text/css'>
<link href='//fonts.googleapis.com/css?family=Oswald' rel='stylesheet' type='text/css'>
<link href="css/font-awesome.css" rel="stylesheet">


<script src="js/jquery-1.12.0.min.js"></script>
<script src="js/bootstrap.min.js"></script>

<link href="css/animate.css" rel="stylesheet" type="text/css" media="all">
<script src="js/wow.min.js"></script>
<script>
new WOW().init();
</script>

</head>
<body>
<?php include('includes/header.php');?>
<div class="banner">
<div class="container">
<h1 class="wow zoomIn animated animated" data-wow-delay=".5s" style="visibility: visible;

animation-delay: 0.5s; animation-name: zoomIn;"> TMS - Tourism Management
System</h1>
</div>
</div>

<div class="rupes">
<div class="col-md-4 rupes-left wow fadeInDown animated animated" data-wow-
delay=".5s" style="visibility: visible; animation-delay: 0.5s; animation-name: fadeInDown;">
<div class="rup-left">
<a href="offers.html"><i class="fa fa-usd"></i></a>
</div>
<div class="rup-rgt">
<h3>UP TO USD. 50 OFF</h3>
<h4><a href="offers.html">TRAVEL SMART</a></h4>
</div>
<div class="clearfix"></div>
</div>

<a href="offers.html"><i class="fa fa-h-square"></i></a>
</div>
<h3>UP TO 70% OFF</h3>
<h4><a href="offers.html">ON HOTELS ACROSS WORLD</a></h4>
</div>
</div>
<a href="offers.html"><i class="fa fa-mobile"></i></a>
</div>
<h3>FLAT Rs. 5000 OFF</h3>
<h4><a href="offers.html">US APP OFFER</a></h4>
</div>
</div>
</div>
</div>


<div class="holiday">
<h3>Package List</h3>
<?php $sql = "SELECT * from tbltourpackages order by rand() limit 4";
$query = $dbh->prepare($sql);
$query->execute();
$results=$query->fetchAll(PDO::FETCH_OBJ);
$cnt=1;
if($query->rowCount() > 0)
foreach($results as $result)
{ ?>
<div class="rom-btm">
<div class="col-md-3 room-left wow fadeInLeft animated" data-wow-delay=".5s">
<img src="admin/pacakgeimages/<?php echo htmlentities($result->PackageImage);?>"

class="img-responsive" alt="">
</div>
<div class="col-md-6 room-midle wow fadeInUp animated" data-wow-delay=".5s">
<h4>Package Name: <?php echo htmlentities($result->PackageName);?></h4>
<h6>Package Type : <?php echo htmlentities($result->PackageType);?></h6>
<p><b>Package Location :</b> <?php echo htmlentities($result->PackageLocation);?></p>
<p><b>Features</b> <?php echo htmlentities($result->PackageFetures);?></p>
</div>
<div class="col-md-3 room-right wow fadeInRight animated" data-wow-delay=".5s">
<h5>Rs. <?php echo htmlentities($result->PackagePrice);?></h5>
<a href="package-details.php?pkgid=<?php echo htmlentities($result->PackageId);?>"

class="view">Details</a>
</div>
</div>
<?php }} ?>
<div><a href="package-list.php" class="view">View More Packages</a></div>
</div>
</div>

<div class="routes">
<div class="col-md-4 routes-left wow fadeInRight animated" data-wow-delay=".5s">
<div class="rou-left">
<a href="#"><i class="glyphicon glyphicon-list-alt"></i></a>
</div>
<div class="rou-rgt wow fadeInDown animated" data-wow-delay=".5s">
<h3>80000</h3>
<p>Enquiries</p>
</div>
</div>
<div class="col-md-4 routes-left">
<a href="#"><i class="fa fa-user"></i></a>
</div>
<div class="rou-rgt">
<h3>1900</h3>
<p>Regestered users</p>
</div>
</div>
<div class="col-md-4 routes-left wow fadeInRight animated" data-wow-delay=".5s">
<a href="#"><i class="fa fa-ticket"></i></a>
</div>
<div class="rou-rgt">
<h3>7,00,00,000+</h3>
<p>Booking</p>
</div>
</div>
</div>
</div>
<?php include('includes/footer.php');?>

<?php include('includes/signup.php');?>


<?php include('includes/signin.php');?>


<?php include('includes/write-us.php');?>

</body>
</html>
PROFILE PAGE:
<?php
session_start();
error_reporting(0);
if(strlen($_SESSION['login'])==0)
header('location:index.php');
else{
if(isset($_POST['submit6']))
$name=$_POST['name'];
$mobileno=$_POST['mobileno'];
$email=$_SESSION['login'];
$sql="update tblusers set FullName=:name,MobileNumber=:mobileno where

EmailId=:email";
$query->bindParam(':name',$name,PDO::PARAM_STR);
$query->bindParam(':mobileno',$mobileno,PDO::PARAM_STR);
$query->bindParam(':email',$email,PDO::PARAM_STR);
$query->execute();
$msg="Profile Updated Successfully";
?>
<!DOCTYPE HTML>
<html>
<head>
<title>TMS | Tourism Management System</title>
<meta name="keywords" content="Tourism Management System In PHP" />

</script>

type='text/css'>

<script>
new WOW().init();
</script>
<style>
.errorWrap {
padding: 10px;
margin: 0 0 20px 0;
background: #fff;
border-left: 4px solid #dd3d36;
-webkit-box-shadow: 0 1px 1px 0 rgba(0,0,0,.1);
box-shadow: 0 1px 1px 0 rgba(0,0,0,.1);
.succWrap{
padding: 10px;
margin: 0 0 20px 0;
background: #fff;
border-left: 4px solid #5cb85c;
</style>
</head>
<body>

<div class="top-header">
<div class="banner-1 ">
<h1 class="wow zoomIn animated animated" data-wow-delay=".5s"

style="visibility: visible; animation-delay: 0.5s; animation-name: zoomIn;">TMS-Tourism
Management System</h1>
</div>
</div>


<div class="privacy">
<h3 class="wow fadeInDown animated animated" data-wow-delay=".5s"

style="visibility: visible; animation-delay: 0.5s; animation-name: fadeInDown;">My
Profile!!</h3>
<form name="chngpwd" method="post">
<?php if($error){?><div class="errorWrap"><strong>ERROR</strong>:<?

php echo htmlentities($error); ?> </div><?php }
else if($msg){?><div
class="succWrap"><strong>SUCCESS</strong>:<?php echo htmlentities($msg); ?>
</div><?php }?>
<?php
$useremail=$_SESSION['login'];
$sql = "SELECT * from tblusers where EmailId=:useremail";
$query = $dbh -> prepare($sql);
$query -> bindParam(':useremail',$useremail, PDO::PARAM_STR);
$query->execute();
$cnt=1;
{ ?>
<p style="width: 350px;">
<b>Name</b> <input type="text" name="name" value="<?php echo

htmlentities($result->FullName);?>" class="form-control" id="name" required="">
</p>
<b>Mobile Number</b>
<input type="text" class="form-control" name="mobileno" maxlength="10" value="<?php

echo htmlentities($result->MobileNumber);?>" id="mobileno" required="">
</p>
<b>Email Id</b>
<input type="email" class="form-control" name="email" value="<?php echo

htmlentities($result->EmailId);?>" id="email" readonly>
</p>
<b>Last Updation Date : </b>
<?php echo htmlentities($result->UpdationDate);?>
</p>

<b>Reg Date :</b>
<?php echo htmlentities($result->RegDate);?>
</p>
<?php }} ?>
<button type="submit" name="submit6" class="btn-primary btn">Updtae</button>
</p>
</form>
</div>
</div>









</body>
</html>
<?php } ?>
SIGN IN PAGE:
<?php
session_start();
if(isset($_POST['signin']))
$email=$_POST['email'];
$password=md5($_POST['password']);
$sql ="SELECT EmailId,Password FROM tblusers WHERE EmailId=:email and

Password=:password";
$query= $dbh -> prepare($sql);
$query-> bindParam(':email', $email, PDO::PARAM_STR);
$query-> bindParam(':password', $password, PDO::PARAM_STR);
$query-> execute();
$_SESSION['login']=$_POST['email'];
echo "<script type='text/javascript'> document.location = 'package-list.php'; </script>";
} else{
echo "<script>alert('Invalid Details');</script>";
?>
<div class="modal fade" id="myModal4" tabindex="-1" role="dialog" aria-

labelledby="myModalLabel">
<div class="modal-dialog" role="document">
<div class="modal-content modal-info">
<div class="modal-header">
<button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-

hidden="true">×</span></button>
</div>
<div class="modal-body modal-spa">
<div class="login-grids">
<div class="login">
<div class="login-left">
<ul>
<li><a class="fb" href="#"><i></i>Facebook</a></li>
<li><a class="goog" href="#"><i></i>Google</a></li>
</ul>
</div>
<div class="login-right"><form method="post">

<h3>Signin with your account </h3>
<input type="text" name="email" id="email" placeholder="Enter your Email" required="">
<input type="password" name="password" id="password" placeholder="Password" value=""

required="">
<h4><a href="forgot-password.php">Forgot password</a></h4>
<input type="submit" name="signin" value="SIGNIN">
</form>
</div>
</div>
<p>By logging in you agree to our <a href="page.php?type=terms">Terms and

Conditions</a> and <a href="page.php?type=privacy">Privacy Policy</a></p>
</div>
</div>
</div>
</div>
</div>
SIGN-UP PAGE:
<?php
error_reporting(0);
if(isset($_POST['submit']))
{
$fname=$_POST['fname'];
$mnumber=$_POST['mobilenumber'];
$email=$_POST['email'];
$password=md5($_POST['password']);
$sql="INSERT INTO tblusers(FullName,MobileNumber,EmailId,Password)

VALUES(:fname,:mnumber,:email,:password)";
$query->bindParam(':fname',$fname,PDO::PARAM_STR);
$query->bindParam(':mnumber',$mnumber,PDO::PARAM_STR);
$query->bindParam(':email',$email,PDO::PARAM_STR);
$query->bindParam(':password',$password,PDO::PARAM_STR);
$query->execute();
$lastInsertId = $dbh->lastInsertId();
if($lastInsertId)
$_SESSION['msg']="You are Scuccessfully registered. Now you can login ";
header('location:thankyou.php');
else
$_SESSION['msg']="Something went wrong. Please try again.";
header('location:thankyou.php');
?>

<script>
function checkAvailability() {
$("#loaderIcon").show();
jQuery.ajax({
url: "check_availability.php",
data:'emailid='+$("#email").val(),
type: "POST",
success:function(data){
$("#user-availability-status").html(data);
$("#loaderIcon").hide();
},
error:function (){}
});
</script>
<div class="modal fade" id="myModal" tabindex="-1" role="dialog" aria-

labelledby="myModalLabel">
<div class="modal-dialog" role="document">
<div class="modal-content">
<div class="modal-header">
<button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-

hidden="true">×</span></button>
</div>
<section>
<div class="modal-body modal-spa">
<div class="login-grids">
<div class="login">
<div class="login-left">
<ul>
<li><a class="fb" href="#"><i></i>Facebook</a></li>
<li><a class="goog" href="#"><i></i>Google</a></li>
</ul>
</div>
<div class="login-right">
<form name="signup" method="post">
<h3>Create your account </h3>
<input type="text" value="" placeholder="Full Name" name="fname" autocomplete="off"

required="">
<input type="text" value="" placeholder="Mobile number" maxlength="10"

name="mobilenumber" autocomplete="off" required="">
<input type="text" value="" placeholder="Email id" name="email" id="email"

onBlur="checkAvailability()" autocomplete="off" required="">
<span id="user-availability-status" style="font-size:12px;"></span>
<input type="password" value="" placeholder="Password" name="password" required="">

<input type="submit" name="submit" id="submit" value="CREATE ACCOUNT">
</form>
</div>
</div>
<p>By logging in you agree to our <a href="page.php?type=terms">Terms and

Conditions</a> and <a href="page.php?type=privacy">Privacy Policy</a></p>
</div>
</div>
</section>
</div>
</div>
</div>
PACKAGE DETAILS PAGE:

<?php
session_start();
error_reporting(0);
if(isset($_POST['submit2']))
$pid=intval($_GET['pkgid']);
$useremail=$_SESSION['login'];
$fromdate=$_POST['fromdate'];
$todate=$_POST['todate'];
$comment=$_POST['comment'];
$status=0;
$sql="INSERT INTO tblbooking(PackageId,UserEmail,FromDate,ToDate,Comment,status)

VALUES(:pid,:useremail,:fromdate,:todate,:comment,:status)";
$query->bindParam(':pid',$pid,PDO::PARAM_STR);
$query->bindParam(':useremail',$useremail,PDO::PARAM_STR);
$query->bindParam(':fromdate',$fromdate,PDO::PARAM_STR);
$query->bindParam(':todate',$todate,PDO::PARAM_STR);
$query->bindParam(':comment',$comment,PDO::PARAM_STR);
$query->bindParam(':status',$status,PDO::PARAM_STR);
$query->execute();
$lastInsertId = $dbh->lastInsertId();
if($lastInsertId)
$msg="Booked Successfully";
else
$error="Something went wrong. Please try again";
?>
<!DOCTYPE HTML>
<html>
<head>
<title>TMS | Package Details</title>

</script>

type='text/css'>

<link rel="stylesheet" href="css/jquery-ui.css" />
<script>
new WOW().init();
</script>
<script src="js/jquery-ui.js"></script>
<script>
$(function() {
$( "#datepicker,#datepicker1" ).datepicker();
});
</script>
<style>
.errorWrap {
padding: 10px;
margin: 0 0 20px 0;
background: #fff;
.succWrap{
padding: 10px;
margin: 0 0 20px 0;
background: #fff;

}
</style>
</head>
<body>

<div class="banner-3">
<h1 class="wow zoomIn animated animated" data-wow-delay=".5s" style="visibility: visible;

animation-delay: 0.5s; animation-name: zoomIn;"> TMS -Package Details</h1>
</div>
</div>


<div class="selectroom">
<?php if($error){?><div class="errorWrap"><strong>ERROR</strong>:<?php echo

htmlentities($error); ?> </div><?php }
else if($msg){?><div class="succWrap"><strong>SUCCESS</strong>:<?php echo

htmlentities($msg); ?> </div><?php }?>
<?php
$pid=intval($_GET['pkgid']);
$sql = "SELECT * from tbltourpackages where PackageId=:pid";
$query -> bindParam(':pid', $pid, PDO::PARAM_STR);

$query->execute();
$cnt=1;
{ ?>
<form name="book" method="post">
<div class="selectroom_top">
<div class="col-md-4 selectroom_left wow fadeInLeft animated" data-wow-delay=".5s">
<img src="admin/pacakgeimages/<?php echo htmlentities($result->PackageImage);?>"

class="img-responsive" alt="">
</div>
<div class="col-md-8 selectroom_right wow fadeInRight animated" data-wow-delay=".5s">
<h2><?php echo htmlentities($result->PackageName);?></h2>
<p class="dow">#PKG-<?php echo htmlentities($result->PackageId);?></p>
<p><b>Package Type :</b> <?php echo htmlentities($result->PackageType);?></p>
<p><b>Package Location :</b> <?php echo htmlentities($result->PackageLocation);?></p>
<div class="ban-bottom">
<div class="bnr-right">
<label class="inputLabel">From</label>
<input class="date" id="datepicker" type="text" placeholder="dd-mm-yyyy"

name="fromdate" required="">
</div>
<div class="bnr-right">
<label class="inputLabel">To</label>
<input class="date" id="datepicker1" type="text" placeholder="dd-mm-yyyy" name="todate"

required="">
</div>
</div>
<div class="grand">
<p>Grand Total</p>
<h3>Rs.60000</h3>
</div>
</div>
<h3>Package Details</h3>
<p style="padding-top: 1%"><?php echo htmlentities($result->PackageDetails);?> </p>
</div>
<div class="selectroom_top">
<h2>Travels</h2>
<div class="selectroom-info animated wow fadeInUp animated" data-wow-

duration="1200ms" data-wow-delay="500ms" style="visibility: visible; animation-duration:
1200ms; animation-delay: 500ms; animation-name: fadeInUp; margin-top: -70px">
<ul>
<li class="spe">
<label class="inputLabel">Total Passengers(Adult-Male/Female,
Children-Male/Female)</label>
<input class="special" type="text" name="comment" required="">
</li>
<?php if($_SESSION['login'])
{?>
<li class="spe" align="center">
<button type="submit" name="submit2" class="btn-primary btn">Book</button>
</li>
<?php } else {?>
<li class="sigi" align="center" style="margin-top: 1%">
<a href="#" data-toggle="modal" data-target="#myModal4" class="btn-primary btn" >

Book</a></li>
<?php } ?>
</ul>
</div>
</div>
</form>
<?php }} ?>
</div>
</div>

<





</body>
</html>
MANAGE BOOKING:
<?php
session_start();
error_reporting(0);
if(strlen($_SESSION['alogin'])==0)
else{
// code for cancel
if(isset($_REQUEST['bkid']))
$bid=intval($_GET['bkid']);
$status=2;
$cancelby='a';
$sql = "UPDATE tblbooking SET status=:status,CancelledBy=:cancelby WHERE

BookingId=:bid";
$query -> bindParam(':status',$status, PDO::PARAM_STR);
$query -> bindParam(':cancelby',$cancelby , PDO::PARAM_STR);
$query-> bindParam(':bid',$bid, PDO::PARAM_STR);
$query -> execute();
$msg="Booking Cancelled successfully";
if(isset($_REQUEST['bckid']))
$bcid=intval($_GET['bckid']);
$status=1;
$cancelby='a';
$sql = "UPDATE tblbooking SET status=:status WHERE BookingId=:bcid";
$query -> bindParam(':status',$status, PDO::PARAM_STR);
$query-> bindParam(':bcid',$bcid, PDO::PARAM_STR);
$query -> execute();
$msg="Booking Confirm successfully";
?>
<!DOCTYPE HTML>
<html>
<head>
<title>TMS | Admin manage Bookings</title>
<script type="application/x-javascript"> addEventListener("load", function()

</script>
<link href="css/bootstrap.min.css" rel='stylesheet' type='text/css' />
<link rel="stylesheet" href="css/morris.css" type="text/css"/>
<link rel="stylesheet" type="text/css" href="css/table-style.css" />

<link rel="stylesheet" type="text/css" href="css/basictable.css" />
<script type="text/javascript" src="js/jquery.basictable.min.js"></script>
<script type="text/javascript">
$(document).ready(function() {
$('#table').basictable();
$('#table-breakpoint').basictable({
breakpoint: 768
});
$('#table-swap-axis').basictable({
swapAxis: true
});
$('#table-force-off').basictable({
forceResponsive: false
});
$('#table-no-resize').basictable({
noResize: true
});
$('#table-two-axis').basictable();
$('#table-max-height').basictable({
tableWrapper: true
});
});
</script>
<link href='//fonts.googleapis.com/css?family=Roboto:700,500,300,100italic,100,400'
rel='stylesheet' type='text/css'/>
<link href='//fonts.googleapis.com/css?family=Montserrat:400,700' rel='stylesheet'

type='text/css'>
<link rel="stylesheet" href="css/icon-font.min.css" type='text/css' />
<style>
.errorWrap {
padding: 10px;
margin: 0 0 20px 0;
background: #fff;
.succWrap{
padding: 10px;
margin: 0 0 20px 0;
background: #fff;

</style>
</head>
<body>
<div class="page-container">

<div class="left-content">
<div class="mother-grid-inner">

<div class="clearfix"> </div>
</div>

<ol class="breadcrumb">
<li class="breadcrumb-item"><a href="index.html">Home</a><i class="fa fa-angle-

right"></i>Manage Bookings</li>
</ol>
<div class="agile-grids">

<?php if($error){?><div class="errorWrap"><strong>ERROR</strong>:<?php echo

htmlentities($error); ?> </div><?php }
else if($msg){?><div class="succWrap"><strong>SUCCESS</strong>:<?php echo

htmlentities($msg); ?> </div><?php }?>
<div class="agile-tables">
<div class="w3l-table-info">
<h2>Manage Bookings</h2>
<table id="table">
<thead>
<tr>
<th>Booikn id</th>
<th>Name</th>
<th>Mobile No.</th>
<th>Email Id</th>
<th>RegDate </th>
<th>From /To </th>
<th>Comment </th>
<th>Status </th>
<th>Action </th>
</tr>
</thead>
<tbody>
<?php $sql = "SELECT tblbooking.BookingId as bookid,tblusers.FullName as

fname,tblusers.MobileNumber as mnumber,tblusers.EmailId as
email,tbltourpackages.PackageName as pckname,tblbooking.PackageId as
pid,tblbooking.FromDate as fdate,tblbooking.ToDate as tdate,tblbooking.Comment as
comment,tblbooking.status as status,tblbooking.CancelledBy as
cancelby,tblbooking.UpdationDate as upddate from tblusers join tblbooking on
tblbooking.UserEmail=tblusers.EmailId join tbltourpackages on
tbltourpackages.PackageId=tblbooking.PackageId";

$query->execute();
$cnt=1;
{ ?>
<tr>
<td>#BK-<?php echo htmlentities($result->bookid);?></td>
<td><?php echo htmlentities($result->fname);?></td>
<td><?php echo htmlentities($result->mnumber);?></td>
<td><?php echo htmlentities($result->email);?></td>
<td><a href="update-package.php?pid=<?php echo htmlentities($result->pid);?>"><?php

echo htmlentities($result->pckname);?></a></td>
<td><?php echo htmlentities($result->fdate);?> To <?php echo htmlentities($result->tdate);?

></td>
<td><?php echo htmlentities($result->comment);?></td>
<td><?php if($result->status==0)
echo "Pending";
if($result->status==1)
echo "Confirmed";
}
if($result->status==2 and $result->cancelby=='a')
echo "Canceled by you at " .$result->upddate;
if($result->status==2 and $result->cancelby=='u')
echo "Canceled by User at " .$result->upddate;
?></td>
<?php if($result->status==2)
?><td>Cancelled</td>
<?php } else {?>
<td><a href="manage-bookings.php?bkid=<?php echo htmlentities($result->bookid);?>"

onclick="return confirm('Do you really want to cancel booking')" >Cancel</a> / <a
href="manage-bookings.php?bckid=<?php echo htmlentities($result->bookid);?>"
onclick="return confirm('booking has been confirm')" >Confirm</a></td>
<?php }?>
</tr>
<?php $cnt=$cnt+1;} }?>
</tbody>
</table>
</div>
</table>
</div>

<script>
var navoffeset=$(".header-main").offset().top;
$(window).scroll(function(){
var scrollpos=$(window).scrollTop();
if(scrollpos >=navoffeset){
$(".header-main").addClass("fixed");
}else{
$(".header-main").removeClass("fixed");
});
});
</script>


<div class="inner-block">
</div>



</div>
</div>


<?php include('includes/sidebarmenu.php');?>
</div>
<script>
var toggle = true;
$(".sidebar-icon").click(function() {
if (toggle)
$(".page-container").addClass("sidebar-collapsed").removeClass("sidebar-collapsed-back");
$("#menu span").css({"position":"absolute"});
else
$(".page-container").removeClass("sidebar-collapsed").addClass("sidebar-collapsed-back");
setTimeout(function() {
$("#menu span").css({"position":"relative"});
}, 400);
toggle = !toggle;
});
</script>

<script src="js/jquery.nicescroll.js"></script>
<script src="js/scripts.js"></script>


</body>
</html>
<?php } ?>
ADMIN DASHBOARD:
<?php
session_start();
if(strlen($_SESSION['alogin'])==0)
else{
?>
<!DOCTYPE HTML>
<html>
<head>
<title>TMS | Admin Dashboard</title>
<script type="application/x-javascript"> addEventListener("load", function()

</script>

<link href="css/bootstrap.min.css" rel='stylesheet' type='text/css' />

<link rel="stylesheet" href="css/morris.css" type="text/css"/>



<link href='//fonts.googleapis.com/css?family=Roboto:700,500,300,100italic,100,400'
rel='stylesheet' type='text/css'/>
<link href='//fonts.googleapis.com/css?family=Montserrat:400,700' rel='stylesheet'

type='text/css'>

<link rel="stylesheet" href="css/icon-font.min.css" type='text/css' />

</head>
<body>
<div class="page-container">

<div class="left-content">
<div class="mother-grid-inner">


<ol class="breadcrumb">
<li class="breadcrumb-item"><a href="index.html">Home</a> <i class="fa fa-angle-

right"></i></li>
</ol>

<div class="four-grids">
<div class="col-md-3 four-grid">
<div class="four-agileits">
<div class="icon">
<i class="glyphicon glyphicon-user" aria-hidden="true"></i>
</div>
<div class="four-text">
<h3>User</h3>
<?php $sql = "SELECT id from tblusers";
$query->execute();
$cnt=$query->rowCount();
?> <h4> <?php echo htmlentities($cnt);?> </h4>
</div>
</div>
</div>
<div class="four-agileinfo">
<div class="icon">
<i class="glyphicon glyphicon-list-alt" aria-hidden="true"></i>
</div>
<h3>Bookings</h3>
<?php $sql1 = "SELECT BookingId from tblbooking";
$query1 = $dbh -> prepare($sql1);
$query1->execute();
$results1=$query1->fetchAll(PDO::FETCH_OBJ);
$cnt1=$query1->rowCount();
?>
<h4><?php echo htmlentities($cnt1);?></h4>
</div>
</div>
</div>
<div class="four-w3ls">
<div class="icon">
<i class="glyphicon glyphicon-folder-open" aria-hidden="true"></i>
</div>
<h3>Enquiries</h3>
<?php $sql2 = "SELECT id from tblenquiry";
$query2= $dbh -> prepare($sql2);
$query2->execute();
?>
</div>
</div>
</div>
<div class="four-wthree">
<div class="icon">
<i class="glyphicon glyphicon-briefcase" aria-hidden="true"></i>
</div>
<h3>Toatal packages</h3>
<?php $sql3 = "SELECT PackageId from tbltourpackages";
$query3->execute();
?>
</div>
</div>
</div>
</div>
<div class="four-grids">
<div class="four-w3ls">
<div class="icon">
<i class="glyphicon glyphicon-folder-open" aria-hidden="true"></i>
</div>
<h3>Issues Riaised</h3>
<?php $sql5 = "SELECT id from tblissues";
$query5->execute();
?>
</div>
</div>
</div>
</div>

<div class="inner-block">
</div>


</div>
</div>

<?php include('includes/sidebarmenu.php');?>
</div>
<script>
var toggle = true;

$(".sidebar-icon").click(function() {
if (toggle)
$(".page-container").addClass("sidebar-collapsed").removeClass("sidebar-collapsed-back");
$("#menu span").css({"position":"absolute"});
else
$(".page-container").removeClass("sidebar-collapsed").addClass("sidebar-collapsed-back");
setTimeout(function() {
$("#menu span").css({"position":"relative"});
}, 400);
toggle = !toggle;
});
</script>

<script src="js/jquery.nicescroll.js"></script>
<script src="js/scripts.js"></script>




<script src="js/raphael-min.js"></script>
<script src="js/morris.js"></script>
<script>
//BOX BUTTON SHOW AND CLOSE
jQuery('.small-graph-box').hover(function() {
jQuery(this).find('.box-button').fadeIn('fast');
}, function() {
jQuery(this).find('.box-button').fadeOut('fast');
});
jQuery('.small-graph-box .box-close').click(function() {
jQuery(this).closest('.small-graph-box').fadeOut(200);
return false;
});
//CHARTS
function gd(year, day, month) {
return new Date(year, month - 1, day).getTime();
graphArea2 = Morris.Area({
element: 'hero-area',
padding: 10,
behaveLikeLine: true,
gridEnabled: false,
gridLineColor: '#dddddd',
axes: true,
resize: true,
smooth:true,
pointSize: 0,
lineWidth: 0,
fillOpacity:0.85,
data: [
{period: '2014 Q1', iphone: 2668, ipad: null, itouch: 2649},
{period: '2014 Q2', iphone: 15780, ipad: 13799, itouch: 12051},
{period: '2016 Q2', iphone: 8442, ipad: 5723, itouch: 1801}
],
lineColors:['#ff4a43','#a2d200','#22beef'],
xkey: 'period',
redraw: true,
ykeys: ['iphone', 'ipad', 'itouch'],
labels: ['All Visitors', 'Returning Visitors', 'Unique Visitors'],
pointSize: 2,
hideHover: 'auto',
resize: true
});
});
</script>
</body>
</html>
<?php } ?>

Tourist Management System

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Tourist Management System

Uploaded by

Copyright:

Available Formats

TOURIST MANAGEMENT SYSTEM

V. YUVARAJ, M.C.A., M.Phil., (Ph.D.)

DEPARTMENT OF COMPUTER APPLICATIONS

Dr. N.G.P. ARTS AND SCIENCE COLLEGE

Dr. N.G.P.-Kalapatti Road, Coimbatore-641 048, Tamil Nadu, India.

Website: www.drngpasc.ac.in Email: info@drngpasc.ac.in. Phone: +91-422-2369100

We, ANDREW PATRICK.L(Reg. No.:211CA103), KAVINKUMAR.B(Reg.

ANDREW PATRICK L KAVINKUMAR B

This is to certify that the project, entitled "Tourist Management System"

(V. Yuvaraj) (Dr. R. Kousalya) (Prof. Dr. K. Ramamurthi)

Viva-Voce Examination held on…………………………….

We record a deep sense of gratitude to Dr. NALLA. G. PALANISWAMI, M.D,

We record our sincere thanks to Prof. Dr. K. RAMAMURTHI, M.Com., B.L.,

I would like to thank Dr. F. MARY MAGDALENE JANE, Dean, Faculty of

We express our sincere thank to Dr. R. KOUSALYA, M.C.A., M.Phil., Ph.D.,

We would like to extend the sincere thanks to my guide V. YUVARAJ, M.C.A.,

We take this opportunity to acknowledge my sincere thanks to all the staff

As the name specifies “TOURIST MANAGEMENT SYSTEM” is a web

Identification of the drawbacks of the existing system leads to the designing of

· Less human error

· Strength and strain of manual labour can be reduced

· Data redundancy can be avoided to some extent

· Easy data updating

· Easy record keeping

· Backup data can be easily generated

Chapter Number Contents Page No

2.1 Software Configuration

2.2 Hardware Configuration

2.3 Software Description

2.4 Languages Used

2.5 Module Description

3.1 Existing System

3.2 Proposed System

4.2 DATA FLOW DIAGRAM

4.3 UML DIAGRAM

4.4 DATABASE DESIGN

4.5 INPUT DESIGN

4.6 OUTPUT DESIGN

5 SYSTEM TESTING & IMPLEMENTATION

9.2 SAMPLE CODING

This report is structured to provide a comprehensive understanding of the Tourist

2.1 Hardware Configuration

 Processor: AMD RYZEN 3/ INTEL I3 or Higher

2.2 Software Configuration

 Visual Studio Code

2.3 Software Features

2.3.1 Visual Studio Code

Cross-Platform Compatibility: Visual Studio Code (VS Code) is a cross-platform code

Integrated Development Environment (IDE) Features: Despite being lightweight, VS

Integrated Terminal: VS Code includes an integrated terminal that allows developers to

Debugger: The integrated debugger supports various programming languages and

2.3.2 XAMPP CONTROL PANEL

Cross-Platform Compatibility: XAMPP is compatible with multiple operating systems,

Easy Installation and Configuration: XAMPP offers a user-friendly installation process

phpMyAdmin: XAMPP includes phpMyAdmin, a web-based tool for managing MySQL

2.4 LANGUAGES USED

 JAVASCRIPT ECMASCRIPT 2023

abstract readonly class Free {} final readonly class Dom {}

Furthermore, you cannot declare read-only for certain PHP features:

Enums (as they cannot contain any property)

Allow true, false, and null as Standalone Types:

Disjunctive Normal Form (DNF) Types

interface A {} interface B {} interface C extends A {} interface D {}