1. INTRODUCTION
This Project Entitled as ‘WEB CHAT’ is used basically for chatting purpose with the remote clients or users
on Internet or local networks. Here in this project a PHP client / server combination is used to chat with
remote users. When a Client wants to chat with a user on a remote host, he sends a request to the Server
with a identification name like chat-id, the server responds to the request by identifying the client-id which is
already registered in the server domain and when matched his request is granted and the client can begin to
chat with the remote users present on the internet or local network.
The power of Internet is such that it integrates together LANs located across diverse software and hardware
forms into a single large communication network that spans the globe. The client needs to have a client
software such as Netscape Navigator or chrome to retrieve information as well as chat on the www: WWW
is referred to as Netsurfing. And it supports chatting, text, video and audio.
It is important to understand the terms client/server because the WEB CHAT project is supported completely
by client/server model. A server is anything that has some resource that can be shared. There are compute
servers, which provide computing power, web servers, which store web pages. A client is simply any other
entity that wants to gain access to a particular server. The interaction between client\server is like an
interaction between an electrical socket and a lamp.
Web chat is now the most used medium of communication on the internet. Various social networks, customer
care websites and forums have used this technology to grow, enhance, and increase the efficiency and
productivity of their sites and products.
Implementing a web chat from scratch can be very tricky This project however show how simple a web chat
can be built from scratch using PHP and MySQL. This includes
The login section will have login facility for the admin and for the user who will operate this system. While
taking orders from its customers, it will take all the details of its customers who is placing the orders and all
the details for the recipient such as its address, name, mobile number. process system will generate a
tracking id for their products. Through this tracking id, customers or its recipient will able to track their
products from any location using internet. It will provide status of the product after placing orders within 1
minute.
This web chat system Project will provide information recipient with following details:- where the current
consignment is, till when it will reached its final destination, if any delay then reason of the delay, the route
of current consignment, date of placing consignment, final date to reach its destination.
When the consignment will visit to the city office of destination, a message will be send to the recipient with
delivery status confirmation. Then after getting this message its recipient can take its parcels by using their
Track Id. When its recipient will receive their parcels, then this Track Id will be deleted automatically from
the system database after 1 week by sending final confirmation message to its recipient mobile number
which will include information of Track Id, date of receiving and time along with greeting message for
providing further service in future.
In modern age, as time increase, needs & requirements of the person are also increased. They want more
facility & try to do their task quickly & within time. But they can not get all the things at nearest market or
area, so they have to import the things from any place in the world.
Within the country, the things can be imported through post service. But it consumes the time & sometimes
problem of damage or missing occur. Where as in the international market, the one way is shipping. But it
also requires more time.
The web chat is one of the solutions of these problems. It is used to send some things to any person in the
world within time.
The web chat has number of branches, which are spread over the country or the world. So that when person
wants to send things then he has to contact at nearest courier service branch. The courier company creates
the schedule & gives internal/external services. The courier service work as destination office or source
office. The source office branch receives the order means consignments & sends it to the destination courier
branch. The company has certain rules according to the weight.
DEPARTMENT OF COMPUTER SCIENCE AND APPLICATIONS
WEB CHAT SYSTEM
3
Using the courier service person can easily send his/her parcel to other person in the particular destination
within the time. Now days, 50% of companies of the world uses the services of various courier company.
PROJECT DEFINITION
The main objective of the project on web chat is to manage the details of chat profile, chat user, group chat.
It manages all the information about chat profile, multi chat. The project totally build at administrative end
and thus only the administer is guaranteed the access. The purpose of the project is to build an application
program to reduce the manual work for managing the chat profile, chat user, multi chat, chat history. It
tracks all the details about the history, group chat.
Functionalities provided:
It tracks all the information of chat user, multi chat.
Provide searching facilities based on user profile.
Manage information of chat user.
Show the information and description of the chat profile, chat history.
To increase efficiency of managing the chat profiles, chat user.
Editing, adding records is improved which result in proper resources management of chat profiles
data.
Manage information of group chat.
1.1 PURPOSE
It may help collecting perfect management in details. In a very short time, the collection will
be obvious, simple and sensible. It will help a person to know the management of passed
year perfectly and vividly. It also helps in current all works relative to web chat. It will be
also reduced the cost of collecting the management and collection procedure will go on
smoothly.
Person has to fill only one form that can be easily generated.
To assist the client in capturing the effort less medium.
To satisfy user requirement.
Be easy to understand to the user and operator
Have a good user interface.
Be expandable
Delivered on schedule within the budget.
2. LITERATURE SURVEY
No Data Security
Time consuming
Flexible system you can edit its source code to make it more attractive or useful.
economical feasibility
this is very important aspect to be considered while developing a project. We decided the
technology based on minimum possible cost factor. All hardware and software cost has to be
cheap.
Overall we have estimated that the benefits the organization is going to receive from the proposed
system will surely overcome the initial costs and the later on running cost for system.
Technical feasibility
This included the study of function, performance and constraints that may affect the ability to
achieve an acceptable system. For this feasibility study, we studied complete functionality to be
provided in the system, as described in the system requirement specification, and checked if
everything was possible using different type of frontend and backend platform.
operational feasibility
no doubt the proposed system is fully GUI based that is very user friendly and all inputs to be taken
all self-explanatory even to a layman. Besides, a proper training has been conducted to let know
the essence of the system to the users so that they can feel comfortable with new system. As far
our study is concerned the clients are comfortable and happy as the system has cut down their
loads and doing.
The most popular server-side language on the web, PHP is designed to pull and edit information in the
database. It’s most commonly bundled with databases written in the SQL language. PHP was designed
strictly for the web and remains one of the most widely used languages around. It’s easy to install and
deploy, is staying competitive with lots of modern frameworks, and is the foundation for a number of
content-management systems. PHP-powered sites: WordPress, Wikipedia, Facebook
Designed to interact with back-end permanent storage, like databases, and process information from
the server to access the database—like a direct line from user to database
Facilitates the transfer of data from server to browser, bringing pages to life in the browser, e.g.,
processing and then delivering a field that a user requests or submits in a form
Runs on-call. When a webpage is “called up,” or when parts of pages are “posted back” to the server
with AJAX, server-side scripts process and return data
Powers functions in dynamic web applications, such as user validation, saving and retrieving data,
and navigating between other pages
Plays a big role in how a database is built from the ground up and managed afterwards—an example
of how roles often overlap in all aspects of development
Build application programming interfaces (APIs), which control what data and software a site
shares with other apps
b. MYSQL:
its an open source relational database management system. It is based on the structure query language
(SQL), which is used for adding, removing, and modifying information in the database. Standard SQL
commands, such as ADD, DROP, INSERT, and UPDATE can be used with MySQL.
MySQL can be used for a variety of applications, but is most commonly found on Web servers. A website
that uses MySQL may include Web pages that access information from a database. These pages are often
DEPARTMENT OF COMPUTER SCIENCE AND APPLICATIONS
WEB CHAT SYSTEM
9
referred to as "dynamic," meaning the content of each page is generated from a database as the page loads.
Websites that use dynamic Web pages are often referred to as database-driven websites.
Many database-driven websites that use MySQL also use a Web scripting language like PHP to access
information from the database. MySQL commands can be incorporated into the PHP code, allowing part or
all of a Web page to be generated from database information. Because both MySQL and PHP are both open
source (meaning they are free to download and use), the PHP/MySQL combination has become a popular
choice for database-driven websites.
phpMyAdmin:
phpMyAdmin is a free and open source tool written in PHP intended to handle the administration of
MySQL with the use of a web browser. It can perform various tasks such as creating, modifying or deleting
databases, tables, fields or rows; executing SQL statements; or managing users and permissions. The
software, which is available in 78 languages is maintained by The phpMyAdmin Project.
It can import data from CSV and SQL, and transform stored data into any format using a set of predefined
functions, like displaying BLOB-data as images or download-links.
Name Specification
Operating system Windows7, Linux
Language Php, mysql, javascript
Database Mysql
Browser Chrome
Web server Xampp
The software requirements specification is produced at the culmination of the analysis task. The function and
performance allocated to software as part of system engineering are refined by establishing a complete
information description, a detailed functional and behavioural description, and indication of performance
requirements and design constraints, appropriate validation criteria, and other data pertinent to requirements.
This section will cover the functional requirements of the chat application.
Login menu function
This functional requirement is for prompting the user with the option to register for the chat application,
logging in, or exit the program. It will take the form of a GUI
User Friendly
The chat application needs to be user friendly, when using its user interface.
GUI
By using GUI’s, it should make the application more user friendly and better to use instead of a command
line. Buttons will be used.
in this phase, a logical system is built which fulfils the given requirements. Design phase of software
development deals with transforming the clients requirements into a logically working system. Normally,
design is performed in the following two steps:
In this phase, the system is designed at block level. The block are created on the basis of analysis done
in the problem identification phase. Different blocks are created for different functions emphasis is put
on minimising the information flow between blocks. Thus, all activities which require more interaction
are kept in on e block.
The general tasks involved in the design process are the following:
User interface design is concerned with the dialogue between a user and the computer. It is concerned with
everything from starting the system or logging into the system to the eventually presentation of desired
outputs and inputs. The overall flow of screens and messages is called a dialogue.
The following steps are various guidelines for user interface design:
The system user should always be aware of what to do next.
The screen should be formatted so that various types of information, instructions and messages
always appears in the same general display area.\
Messages, instruction or information should be displayed long enough to allow system user to read
them.
User display attributes sparingly.
Default values for fields and answers to be entered by the user should be specified.
A user should not be allowed to proceed without correcting an error
The system user should never get an operating system message or fatal error.
5. DETAILED DESIGN
a. Level 0:
b. Level 1:
c. Level 2:
5.3 ER DIAGRAM
6. IMPLEMENTATION
Index.php:
<html>
<head>
<title>Welcome to WebChat</title>
<link rel="stylesheet" type="text/css" href="julio.css">
<script src="jquery-3.3.1.js"></script>
</head>
<body>
<form><header style="text-align:center; font-size:50px">webchat</header></form>
<div class="login">
<center>
<form method="post" action="login.php">
<h1 >sign in</h1>
<input type="text" name="uname" placeholder="user name" id="username"><br>
<input type="password" name="pass" placeholder="password" id="password"><br>
<button type="submit" name="submit" value="submit" style="background-color: #665851;
color: white;" >login</button>
<input type="button" id="mybtn" value="register">
<script>
var btn=document.getElementById('mybtn');
btn.addEventListener('click',function() {
document.location.href='register.php';
});
</script> </form> </div>
<div class="shadow"> </div> </center>
</body>
</html>
Register.php:
<html>
DEPARTMENT OF COMPUTER SCIENCE AND APPLICATIONS
WEB CHAT SYSTEM
23
<head>
<title>register account</title>
<script src="jquery-3.3.1.js"></script>
<link rel="stylesheet" type="text/css" href="reg.css">
</head>
<body>
<form>
<header style="text-align:center; font-size:50px">Register</header>
</form>
<div class="login">
<form action="signup.php" method="post">
<h1>sign up</h1>
<input type="text" name="uname" placeholder="user name"><br>
<input type="text" name="email" placeholder="email address" ><br>
<input type="password" name="pass" placeholder="password"><br>
<button style="background-color: #665851; color: white;" type="submit">register</button>
<input type="button" id="mybtn1" value="back">
</form>
<script>
var btn=document.getElementById('mybtn1');
btn.addEventListener('click',function() {
document.location.href='index.php';
});
</script>
</div>
</body>
</html>
Login.php
<html>
<head> <script src="jquery-3.3.1.js"></script> </head>
<body>
<?php
if(isset($_POST['submit'])){
if (empty($_POST['uname']) || empty($_POST['pass'])) {
/* Username or Password is invalid */
echo "<script> alert('username and password is empty');
window.location.href='index.php';</script>";
//header("Location:index.php");
}
else{
session_start();
include "db.php";
$name=$_POST['uname'];
$pass=$_POST['pass'];
$query="select * from profile where name='$name' and pass='$pass'";
$result=mysqli_query($con,$query);
$nrow=mysqli_num_rows($result);
if($nrow > 0){
while($row=mysqli_fetch_assoc($result) > 0){
$_SESSION['name']=$_POST['uname'];
header("Location:home.php");
}
}else
header("Location:index.php");
}
}
?>
</body>
</html>
home.php
<?php
session_start();
include 'db.php';
require('func.php');
?>
<?php
if(isset($_POST['send'])){
if(sendmsg($_SESSION['name'],$_POST['msg']))
echo "message send";
else
echo "message not send";
}
?>
<html>
<head>
<title>send a message in group</title>
<link rel="stylesheet" type="text/css" href="home.css">
<script src="jquery-3.3.1.js"></script>
</script>
</head>
<body onload="rsend();">
<div style="width:100px; height: 30px; text-align: center; background-color: red; float: left">
<form action="logout.php">
<input type="submit" style="width:100; background-color: blue; color:white" value="logout">
</form>
</div>
<div style="width:100px; height: 30px; background-color: blue; align: center; float: left "> online</div>
<div style="width:100px; height: 30px; text-align: center; background-color: green; float:left">
<input id="photo-hide" type="file" name="image">
</div>
<br>
<h1>logged in as: <?php echo $_SESSION['name']; ?> </h1>
DEPARTMENT OF COMPUTER SCIENCE AND APPLICATIONS
WEB CHAT SYSTEM
26
<div class="chatbox">
<div class="chatlogs">
<div class="chat">
<div id="chatmessage"></div>
</div>
<script type="text/javascript" src="jquery-3.3.1.js"></script>
<script type="text/javascript" src="autochat.js"></script>
</div>
<div class="chat-form">
<form action="home.php" name="form1" method="post">
<?php /* echo $_SESSION['name']; */ ?>
<textarea name="msg" placeholder="send message"class="form-control"></textarea>
<input id="test1" type="submit" name="send" value="send" >
</form>
</div>
</div>
</center>
</body>
</html>
Func.php
<?php
function getmsg(){
$db_host="localhost";
$db_user="root";
$db_pass="";
$db_name="group";
$connection=mysqli_connect($db_host,$db_user,$db_pass);
mysqli_select_db($connection,$db_name);
$query="SELECT `name`, `msg` FROM post order by id DESC";
$run=mysqli_query($connection,$query);
$messages=array();
while($message1=mysqli_fetch_assoc($run)){
$messages[]=array('Sender'=>$message1['name'],'Message'=>$message1['msg']); }
return $messages;
}
?>
<?php
function sendmsg(){
include 'db.php';
if($_POST['send']){
$msg=$_POST['msg'];
$name=$_SESSION['name'];
$query="insert into post(msg,name) values('$msg','$name')";
$result=mysqli_query($con,$query);
if($result)
return true;
else
return false;
}
else
return false;
} ?> <?php
DEPARTMENT OF COMPUTER SCIENCE AND APPLICATIONS
WEB CHAT SYSTEM
28
/**
* @file
* The PHP page that serves all page requests on a Drupal installation.
*
* The routines here dispatch control to the appropriate handler, which then
* prints the appropriate page.
*
* All Drupal code is released under the GNU General Public License.
* See COPYRIGHT.txt and LICENSE.txt.
*/
/**
* Root directory of Drupal installation.
*/
define('DRUPAL_ROOT', getcwd());
<?php
/**
* @file
/**
* Implements hook_permission().
*/
function autoassignrole_permission() {
return array(
'administer autoassignrole' => array(
'title' => t('Administer auto assign role'),
'description' => t('Perform administration tasks for auto assign role.'),
),
);
}
/**
* Implements hook_menu().
*/
function autoassignrole_menu() {
$items = array();
$items['admin/config/people/autoassignrole'] = array(
'title' => 'Auto assign role',
'description' => 'Configure auto role assignment.',
'access arguments' => array('administer autoassignrole'),
'page callback' => 'autoassignrole_admin_block_page',
'file' => 'autoassignrole.admin.inc',
);
$items['admin/config/people/autoassignrole/auto'] = array(
'title' => 'Automatic',
'description' => 'Configure which role(s) are automatically assigned on user creation.',
'access arguments' => array('administer autoassignrole'),
'page callback' => 'drupal_get_form',
'page arguments' => array('autoassignrole_auto_settings'),
'file' => 'autoassignrole.admin.inc',
);
$items['admin/config/people/autoassignrole/user'] = array(
'title' => 'User choice',
'description' => 'Configure the ability for an end user to choose their own roles during
registration.',
$items['admin/config/people/autoassignrole/pages/delete/%'] = array(
'title' => 'Delete Auto Assign Role Page',
'access arguments' => array('administer autoassignrole'),
'page callback' => 'drupal_get_form',
'page arguments' => array('autoassignrole_page_delete_confirm', 6),
'file' => 'autoassignrole.admin.inc',
);
$pages = autoassignrole_get_pages();
foreach ($pages as $page) {
$rids = unserialize($page->rids);
switch ($page->display) {
case AUTOASSIGNROLE_PAGE_DISPLAY_STANDARD:
$items[$page->path] = array(
'title' => check_plain($page->title),
'page arguments' => array($rids),
'page callback' => 'autoassignrole_register',
'access callback' => 'user_register_access',
'file' => 'autoassignrole.paths.inc',
'type' => MENU_NORMAL_ITEM,
'menu_name' => $page->menu,
);
$items[$page->path . '/register'] = array(
'title' => 'Register',
'page arguments' => array($rids),
'page callback' => 'autoassignrole_register',
'access callback' => 'user_register_access',
case AUTOASSIGNROLE_PAGE_DISPLAY_INDIVIDUAL:
$items[$page->path] = array(
'title' => check_plain($page->title),
'page arguments' => array($rids),
'page callback' => 'autoassignrole_register',
'access callback' => 'user_register_access',
'file' => 'autoassignrole.paths.inc',
'type' => MENU_CALLBACK,
);
$items[$page->path . '/register'] = array(
'title' => 'Register',
'page arguments' => array($rids),
'page callback' => 'autoassignrole_register',
'access callback' => 'user_register_access',
'file' => 'autoassignrole.paths.inc',
'type' => MENU_CALLBACK,
);
$items[$page->path . '/login'] = array(
'title' => 'Log In',
'page callback' => 'autoassignrole_login',
'access callback' => 'user_is_anonymous',
'file' => 'autoassignrole.paths.inc',
'type' => MENU_CALLBACK,
);
$items[$page->path . '/password'] = array(
'title' => 'Request New Password',
'page callback' => 'autoassignrole_password',
'access callback' => 'user_is_anonymous',
'file' => 'autoassignrole.paths.inc',
'type' => MENU_CALLBACK,
);
break;
}
}
return $items;
}
/**
* Finds any role ids attached to current page, if any.
*/
function autoassignrole_get_active_path_rid() {
$item = menu_get_item();
if ($item['page_callback'] == 'autoassignrole_register') {
return $item['page_arguments'][0];
}
return FALSE;
}
/**
* Implements hook_user_presave().
*/
function autoassignrole_user_presave(&$edit, $account, $category) {
// Use case http://drupal.org/node/971622
// Make sure we only assign roles automatically when enabled to do so.
if (variable_get('autoassignrole_auto_active', 0) ||
variable_get("autoassignrole_user_active", 0)
|| (variable_get('autoassignrole_admin_active', 0) && user_access('administer users'))
|| autoassignrole_get_active_path_rid()) {
// Use case http://drupal.org/node/944864
// Only assign roles if this is a new account.
if (isset($account->is_new) && !empty($account->is_new)) {
// Get the existing user roles with the exception of the anonymous role.
$user_roles = user_roles(TRUE);
$roles_to_add = array();
/**
* Implements hook_form_FORM_ID_alter() for user_register_form().
*/
function autoassignrole_form_user_register_form_alter(&$form, &$form_state) {
if (variable_get("autoassignrole_user_active", 0) && !user_access('administer users')
&& !autoassignrole_get_active_path_rid()) {
if ($roles) {
$form['autoassignrole_user'] = array(
'#type' => 'fieldset',
'#title' => filter_xss(variable_get('autoassignrole_user_fieldset_title', t('User Roles'))),
'#collapsible' => FALSE,
$type = 'select';
if ($user_selection == AUTOASSIGNROLE_ELEMENT_RADIO_CHECKBOX) {
$type = $user_selection == AUTOASSIGNROLE_ELEMENT_RADIO_CHECKBOX && !
$multiple ? 'radios' : 'checkboxes';
}
/**
* Function to retrieve all role-specific pages.
*
* @return SelectQuery
* An array of page objects.
*/
function autoassignrole_get_pages() {
$query = _autoasignrole_get_page_query();
return $query->execute();
}
/**
* Function to get role-specific page details.
*
* @param int $id
* The id of the page to be updated.
*
* @return SelectQuery
* A query object with all page details.
*/
function autoassignrole_get_page($id) {
$query = _autoasignrole_get_page_query();
$query->condition('rid_page_id', $id, '=');
return $query->execute()->fetchObject();
}
/**
* Helper method for getting the page query object.
*
* @return SelectQuery
* The query object.
*/
function _autoasignrole_get_page_query() {
return db_select('autoassignrole_page', 'p')
->fields('p', array(
'rids',
'path',
'title',
'menu',
'display',
));
}
/**
* @file
* Paths used for autoassignrole created user pages.
*
* Autoassignrole allows an admin to create specific register, login and reset
* password pages for a particular set of roles. The menu callback arguments
* for these pages are defined here.
*
* These functions simply call the standard user forms from Drupal core, the
* reason we wrap them like this is so that we can detect when one of our
* role-specific pages are being called rather than the default ones.
*/
//We require this file from the user module to get the user_pass form.
require_once drupal_get_path('module', 'user') . '/user.pages.inc';
/**
* Loads the user registration form.
*
* $rid is not actually used in the function but by passing it we can find out
* which roles are meant to be added to the new user by using
* autoassignrole_get_active_path_rid();
*
* @see autoassignrole.module
*
* @param $rid
* $rid is the 'rid_page_id' of the page we are currently generating.
*
* @return string
* User registration form renderer.
*/
function autoassignrole_register($rid) {
$output = drupal_get_form('user_register_form');
return $output;
}
/**
* Loads the user login form
*/
function autoassignrole_login() {
$output = drupal_get_form('user_login');
return $output;
}
/**
* Loads the password reset form
*/
function autoassignrole_password() {
$output = drupal_get_form('user_pass');
return $output;
}
/**
* Implements hook_form_alter().
*
* Adds the action and redirect fields. Used by node type edit and node edit forms.
*/
function node_save_redirect_form_alter(&$form, &$form_state, $form_id) {
if (isset($form['#node_type'])) {
'#description' => t('Choose where the user should be sent after creating new content.'),
'#default_value' => variable_get('node_save_redirect_' . $form['#node_type']->type, 0)
);
/**
* A function that is called when a node is saved.
*
// load settings
$node_save_redirect_settings = variable_get('node_save_redirect_' . $form['type']
['#value'], NULL);
$custom_location = variable_get('node_save_redirect_location_' . $form['type']['#value'],
'');
if (!is_null($node_save_redirect_settings)) {
if ($node_save_redirect_settings == '1') {
$form_state['redirect'] = 'node/' . $form_state['nid'] . '/edit';
}
else if ($node_save_redirect_settings == '2' && user_access('access content overview')) {
$form_state['redirect'] = 'admin/content';
}
else if ($node_save_redirect_settings == '4' && user_access('access workbench')) {
$form_state['redirect'] = 'admin/workbench';
}
else if ($node_save_redirect_settings == '3') {
$options = drupal_parse_url($custom_location);
/**
* @file
* CTools primary module file.
*
* Most of the CTools tools are in their own .inc files. This contains
* nothing more than a few convenience functions and some hooks that
* must be implemented in the module file.
*/
define('CTOOLS_API_VERSION', '2.0.8');
/**
* The current working ctools version.
*
* In a release, it should be 7.x-1.x, which should match what drush make will
* create. In a dev format, it should be 7.x-1.(x+1)-dev, which will allow
/**
* Test the CTools API version.
*
* This function can always be used to safely test if CTools has the minimum
* API version that your module can use. It can also try to protect you from
* running if the CTools API version is too new, but if you do that you need
* to be very quick about watching CTools API releases and release new versions
* of your software as soon as the new release is made, or people might end up
* updating CTools and having your module shut down without any recourse.
*
* It is recommended that every hook of your module that might use CTools or
* might lead to a use of CTools be guarded like this:
*
* @code
* if (!module_invoke('ctools', 'api_version', '1.0')) {
* return;
*}
* @endcode
*
* Note that some hooks such as _menu() or _theme() must return an array().
*
* You can use it in your hook_requirements to report this error condition
* like this:
*
* @code
* define('MODULENAME_MINIMUM_CTOOLS_API_VERSION', '1.0');
* define('MODULENAME_MAXIMUM_CTOOLS_API_VERSION', '1.1');
*
* function MODULENAME_requirements($phase) {
* $requirements = array();
* if (!module_invoke('ctools', 'api_version',
MODULENAME_MINIMUM_CTOOLS_API_VERSION,
MODULENAME_MAXIMUM_CTOOLS_API_VERSION)) {
* $requirements['MODULENAME_ctools'] = array(
* 'title' => $t('MODULENAME required Chaos Tool Suite (CTools) API Version'),
* 'value' => t('Between @a and @b', array('@a' =>
MODULENAME_MINIMUM_CTOOLS_API_VERSION, '@b' =>
MODULENAME_MAXIMUM_CTOOLS_API_VERSION)),
* 'severity' => REQUIREMENT_ERROR,
* );
* }
* return $requirements;
*}
* @endcode
*
* Please note that the version is a string, not an floating point number.
* This will matter once CTools reaches version 1.10.
*
* A CTools API changes history will be kept in API.txt. Not every new
* version of CTools will necessarily update the API version.
* @param $minimum
* The minimum version of CTools necessary for your software to run with it.
* @param $maximum
* The maximum version of CTools allowed for your software to run with it.
*/
function ctools_api_version($minimum, $maximum = NULL) {
if (version_compare(CTOOLS_API_VERSION, $minimum, '<')) {
return FALSE;
}
return TRUE;
}
// -----------------------------------------------------------------------
// General utility functions
/**
* Include .inc files as necessary.
*
* This fuction is helpful for including .inc files for your module. The
* general case is including ctools funcitonality like this:
*
* @code
* ctools_include('plugins');
* @endcode
*
* Similar funcitonality can be used for other modules by providing the $module
* and $dir arguments like this:
*
* @code
* // include mymodule/includes/import.inc
* ctools_include('import', 'mymodule');
* // include mymodule/plugins/foobar.inc
* ctools_include('foobar', 'mymodule', 'plugins');
* @endcode
*
* @param $file
* The base file name to be included.
* @param $module
* Optional module containing the include.
* @param $dir
* Optional subdirectory containing the include file.
*/
function ctools_include($file, $module = 'ctools', $dir = 'includes') {
static $used = array();
if (!isset($used[$module][$dir][$file])) {
require_once DRUPAL_ROOT . '/' . drupal_get_path('module', $module) . "$dir$file.inc";
$used[$module][$dir][$file] = TRUE;
}
}
/**
* Include .inc files in a form context.
*
* This is a variant of ctools_include that will save information in the
* the form_state so that cached forms will properly include things.
*/
function ctools_form_include(&$form_state, $file, $module = 'ctools', $dir = 'includes') {
if (!isset($form_state['build_info']['args'])) {
$form_state['build_info']['args'] = array();
}
/**
* Add an arbitrary path to the $form_state so it can work with form cache.
*
// Now add this to the build info files so that AJAX requests will know to load it.
$form_state['build_info']['files']["$filename"] = $filename;
require_once DRUPAL_ROOT . '/' . $filename;
}
/**
* Provide the proper path to an image as necessary.
*
* This helper function is used by ctools but can also be used in other
* modules in the same way as explained in the comments of ctools_include.
*
* @param $image
* The base file name (with extension) of the image to be included.
* @param $module
* Optional module containing the include.
* @param $dir
* Optional subdirectory containing the include file.
*/
function ctools_image_path($image, $module = 'ctools', $dir = 'images') {
/**
* Include css files as necessary.
*
* This helper function is used by ctools but can also be used in other
* modules in the same way as explained in the comments of ctools_include.
*
* @param $file
* The base file name to be included.
* @param $module
* Optional module containing the include.
* @param $dir
* Optional subdirectory containing the include file.
*/
function ctools_add_css($file, $module = 'ctools', $dir = 'css') {
drupal_add_css(drupal_get_path('module', $module) . "/$dir/$file.css");
}
/**
* Format a css file name for use with $form['#attached']['css'].
*
* This helper function is used by ctools but can also be used in other
* modules in the same way as explained in the comments of ctools_include.
*
* @code
* $form['#attached']['css'] = array(ctools_attach_css('collapsible-div'));
* $form['#attached']['css'][ctools_attach_css('collapsible-div')] = array('preprocess' =>
FALSE);
* @endcode
*
* @param $file
* The base file name to be included.
* @param $module
* Optional module containing the include.
* @param $dir
* Optional subdirectory containing the include file.
*/
function ctools_attach_css($file, $module = 'ctools', $dir = 'css') {
return drupal_get_path('module', $module) . "/$dir/$file.css";
}
/**
* Include js files as necessary.
*
* This helper function is used by ctools but can also be used in other
* modules in the same way as explained in the comments of ctools_include.
*
* @param $file
* The base file name to be included.
* @param $module
* Optional module containing the include.
* @param $dir
/**
* Format a javascript file name for use with $form['#attached']['js'].
*
* This helper function is used by ctools but can also be used in other
* modules in the same way as explained in the comments of ctools_include.
*
* @code
* $form['#attached']['js'] = array(ctools_attach_js('auto-submit'));
* @endcode
*
* @param $file
* The base file name to be included.
* @param $module
* Optional module containing the include.
* @param $dir
* Optional subdirectory containing the include file.
*/
function ctools_attach_js($file, $module = 'ctools', $dir = 'js') {
return drupal_get_path('module', $module) . "/$dir/$file.js";
}
/**
* Get a list of roles in the system.
*
* @return
* An array of role names keyed by role ID.
*
* @deprecated
* user_roles() should be used instead.
*/
function ctools_get_roles() {
return user_roles();
}
/*
* Break x,y,z and x+y+z into an array. Numeric only.
*
* @param $str
* The string to parse.
*
* @return $object
* An object containing
* - operator: Either 'and' or 'or'
* - value: An array of numeric values.
*/
function ctools_break_phrase($str) {
$object = new stdClass();
if (empty($object->value)) {
$object->value = array();
}
return $object;
/**
* Set a token/value pair to be replaced later in the request, specifically in
* ctools_page_token_processing().
*
* @param $token
* The token to be replaced later, during page rendering. This should
* ideally be a string inside of an HTML comment, so that if there is
* no replacement, the token will not render on the page.
* @param $type
* The type of the token. Can be either 'variable', which will pull data
* directly from the page variables
* @param $argument
* If $type == 'variable' then argument should be the key to fetch from
* the $variables. If $type == 'callback' then it should either be the
* callback, or an array that will be sent to call_user_func_array().
*
* @return
* A array of token/variable names to be replaced.
*/
function ctools_set_page_token($token = NULL, $type = NULL, $argument = NULL) {
static $tokens = array();
if (isset($token)) {
$tokens[$token] = array($type, $argument);
}
return $tokens;
}
/**
* Easily set a token from the page variables.
*
* This function can be used like this:
* $token = ctools_set_variable_token('tabs');
*
* $token will then be a simple replacement for the 'tabs' about of the
* variables available in the page template.
*/
function ctools_set_variable_token($token) {
$string = '<!-- ctools-page-' . $token . ' -->';
ctools_set_page_token($string, 'variable', $token);
return $string;
}
/**
* Easily set a token from the page variables.
*
* This function can be used like this:
* $token = ctools_set_variable_token('id', 'mymodule_myfunction');
*/
function ctools_set_callback_token($token, $callback) {
// If the callback uses arguments they are considered in the token.
if (is_array($callback)) {
/**
* Tell CTools that sidebar blocks should not be rendered.
*
* It is often desirable to not display sidebars when rendering a page,
* particularly when using Panels. This informs CTools to alter out any
* sidebar regions during block render.
*/
function ctools_set_no_blocks($blocks = FALSE) {
$status = &drupal_static(__FUNCTION__, TRUE);
$status = $blocks;
}
/**
* Wrapper function to create UUIDs via ctools, falls back on UUID module
* if it is enabled. This code is a copy of uuid.inc from the uuid module.
* @see http://php.net/uniqid#65879
*/
function ctools_uuid_generate() {
if (!module_exists('uuid')) {
ctools_include('uuid');
$callback = drupal_static(__FUNCTION__);
if (empty($callback)) {
if (function_exists('uuid_create') && !function_exists('uuid_make')) {
$callback = '_ctools_uuid_generate_pecl';
}
elseif (function_exists('com_create_guid')) {
$callback = '_ctools_uuid_generate_com';
}
else {
$callback = '_ctools_uuid_generate_php';
}
}
return $callback();
}
else {
return uuid_generate();
}
}
/**
* Check that a string appears to be in the format of a UUID.
* @see http://drupal.org/project/uuid
*
* @param $uuid
/**
* Add an array of classes to the body.
*
* @param mixed $classes
* A string or an array of class strings to add.
* @param string $hook
* The theme hook to add the class to. The default is 'html' which will
* affect the body tag.
*/
/**
* Remove an array of classes from the body.
*
* @param mixed $classes
* A string or an array of class strings to remove.
* @param string $hook
* The theme hook to remove the class from. The default is 'html' which will
* affect the body tag.
*/
function ctools_class_remove($classes, $hook = 'html') {
if (!is_array($classes)) {
$classes = array($classes);
}
// -----------------------------------------------------------------------
// Drupal core hooks
/**
* Implement hook_init to keep our global CSS at the ready.
*/
function ctools_init() {
ctools_add_css('ctools');
// If we are sure that CTools' AJAX is in use, change the error handling.
if (!empty($_REQUEST['ctools_ajax'])) {
ini_set('display_errors', 0);
register_shutdown_function('ctools_shutdown_handler');
}
}
}
/**
* Shutdown handler used during ajax operations to help catch fatal errors.
*/
function ctools_shutdown_handler() {
if (function_exists('error_get_last') AND ($error = error_get_last())) {
switch ($error['type']) {
case E_ERROR:
case E_CORE_ERROR:
case E_COMPILE_ERROR:
case E_USER_ERROR:
// Do this manually because including files here is dangerous.
$commands = array(
array(
'command' => 'alert',
'title' => t('Error'),
'text' => t('Unable to complete operation. Fatal error in @file on line @line:
@message', array(
'@file' => $error['file'],
'@line' => $error['line'],
'@message' => $error['message'],
)),
),
);
// Change the status code so that the client will read the AJAX returned.
header('HTTP/1.1 200 OK');
drupal_json($commands);
}
}
}
/**
* Implements hook_theme().
*/
function ctools_theme() {
ctools_include('utility');
$items = array();
ctools_passthrough('ctools', 'theme', $items);
return $items;
}
/**
* Implements hook_menu().
*/
function ctools_menu() {
ctools_include('utility');
$items = array();
ctools_passthrough('ctools', 'menu', $items);
return $items;
}
/**
* Implements hook_permission().
*/
function ctools_permission() {
return array(
'use ctools import' => array(
'title' => t('Use CTools importer'),
'description' => t('The import functionality allows users to execute arbitrary PHP code, so
extreme caution must be taken.'),
'restrict access' => TRUE,
),
);
}
/**
* Implementation of hook_cron. Clean up old caches.
*/
function ctools_cron() {
ctools_include('utility');
$items = array();
ctools_passthrough('ctools', 'cron', $items);
}
/**
* Implements hook_flush_caches().
*/
function ctools_flush_caches() {
// Only return the CSS cache bin if it has been activated, to avoid
// drupal_flush_all_caches() from trying to truncate a non-existing table.
return variable_get('cache_class_cache_ctools_css', FALSE) ? array('cache_ctools_css') :
array();
}
/**
* Implements hook_element_info_alter().
*
*/
function ctools_element_info_alter(&$type) {
ctools_include('dependent');
ctools_dependent_element_info_alter($type);
}
/**
* Implementation of hook_file_download()
*
* When using the private file system, we have to let Drupal know it's ok to
* download CSS and image files from our temporary directory.
*/
function ctools_file_download($filepath) {
if (strpos($filepath, 'ctools') === 0) {
$mime = file_get_mimetype($filepath);
// For safety's sake, we allow only text and images.
if (strpos($mime, 'text') === 0 || strpos($mime, 'image') === 0) {
return array('Content-type:' . $mime);
}
}
}
/**
* Implements hook_registry_files_alter().
*
* Alter the registry of files to automagically include all classes in
* class-based plugins.
*/
function ctools_registry_files_alter(&$files, $indexed_modules) {
ctools_include('registry');
return _ctools_registry_files_alter($files, $indexed_modules);
}
// -----------------------------------------------------------------------
// CTools hook implementations.
/**
* Implementation of hook_ctools_plugin_directory() to let the system know
* where all our own plugins are.
*/
function ctools_ctools_plugin_directory($owner, $plugin_type) {
if ($owner == 'ctools') {
return 'plugins/' . $plugin_type;
}
}
/**
* Implements hook_ctools_plugin_type().
*/
function ctools_ctools_plugin_type() {
ctools_include('utility');
$items = array();
// Add all the plugins that have their own declaration space elsewhere.
ctools_passthrough('ctools', 'plugin-type', $items);
return $items;
}
// -----------------------------------------------------------------------
// Drupal theme preprocess hooks that must be in the .module file.
/**
* A theme preprocess function to automatically allow panels-based node
* templates based upon input when the panel was configured.
*/
function ctools_preprocess_node(&$vars) {
// The 'ctools_template_identifier' attribute of the node is added when the pane is
// rendered.
if (!empty($vars['node']->ctools_template_identifier)) {
$vars['ctools_template_identifier'] = check_plain($vars['node']-
>ctools_template_identifier);
$vars['theme_hook_suggestions'][] = 'node__panel__' . check_plain($vars['node']-
>ctools_template_identifier);
}
}
/**
* Implements hook_page_alter().
*
* Last ditch attempt to remove sidebar regions if the "no blocks"
* functionality has been activated.
*
* @see ctools_block_list_alter().
*/
function ctools_page_alter(&$page) {
$check = drupal_static('ctools_set_no_blocks', TRUE);
if (!$check) {
foreach ($page as $region_id => $region) {
// @todo -- possibly we can set configuration for this so that users can
// specify which blocks will not get rendered.
if (strpos($region_id, 'sidebar') !== FALSE) {
unset($page[$region_id]);
}
}
}
$page['#post_render'][] = 'ctools_page_token_processing';
}
/**
* A theme post_render callback to allow content type plugins to use page
* template variables which are not yet available when the content type is
* rendered.
*/
function ctools_page_token_processing($children, $elements) {
$tokens = ctools_set_page_token();
if (!empty($tokens)) {
foreach ($tokens as $token => $key) {
list($type, $argument) = $key;
switch ($type) {
case 'variable':
$tokens[$token] = isset($elements[$argument]) ? $elements[$argument] : '';
break;
case 'callback':
if (is_string($argument) && function_exists($argument)) {
$tokens[$token] = $argument($elements);
}
if (is_array($argument) && function_exists($argument[0])) {
$function = array_shift($argument);
$argument = array_merge(array(&$elements), $argument);
$tokens[$token] = call_user_func_array($function, $argument);
}
break;
}
}
$children = strtr($children, $tokens);
}
return $children;
}
/**
* Implements hook_process().
*
* Add and remove CSS classes from the variables array. We use process so that
* we alter anything added in the preprocess hooks.
*/
function ctools_process(&$variables, $hook) {
if (!isset($variables['classes'])) {
return;
}
// -----------------------------------------------------------------------
// Menu callbacks that must be in the .module file.
/**
* Determine if the current user has access via a plugin.
*
* This function is meant to be embedded in the Drupal menu system, and
* therefore is in the .module file since sub files can't be loaded, and
* takes arguments a little bit more haphazardly than ctools_access().
*
* @param $access
* An access control array which contains the following information:
* - 'logic': and or or. Whether all tests must pass or one must pass.
* - 'plugins': An array of access plugins. Each contains:
* - - 'name': The name of the plugin
* - - 'settings': The settings from the plugin UI.
* - - 'context': Which context to use.
* @param ...
* zero or more context arguments generated from argument plugins. These
$contexts = array();
foreach (func_get_args() as $arg) {
if (is_object($arg) && get_class($arg) == 'ctools_context') {
$contexts[$arg->id] = $arg;
}
}
ctools_include('context');
return ctools_access($access, $contexts);
}
/**
* Determine if the current user has access via checks to multiple different
* permissions.
*
* This function is a thin wrapper around user_access that allows multiple
* permissions to be easily designated for use on, for example, a menu callback.
*
* @param ...
* An indexed array of zero or more permission strings to be checked by
* user_access().
*
* @return
* Iff all checks pass will this function return TRUE. If an invalid argument
* is passed (e.g., not a string), this function errs on the safe said and
* returns FALSE.
*/
function ctools_access_multiperm() {
foreach (func_get_args() as $arg) {
if (!is_string($arg) || !user_access($arg)) {
return FALSE;
}
}
return TRUE;
}
/**
* Check to see if the incoming menu item is js capable or not.
*
* This can be used as %ctools_js as part of a path in hook menu. CTools
* ajax functions will automatically change the phrase 'nojs' to 'ajax'
/**
* Provides the default value for %ctools_js.
*
* This allows drupal_valid_path() to work with %ctools_js.
*/
function ctools_js_to_arg($arg) {
return empty($arg) || $arg == '%' ? 'nojs' : $arg;
}
/**
* Menu _load hook.
*
* This function will be called to load an object as a replacement for
* %ctools_export_ui in menu paths.
*/
function ctools_export_ui_load($item_name, $plugin_name) {
$return = &drupal_static(__FUNCTION__, FALSE);
if (!$return) {
ctools_include('export-ui');
$plugin = ctools_get_export_ui($plugin_name);
$handler = ctools_export_ui_get_handler($plugin);
if ($handler) {
return $handler->load_item($item_name);
}
}
return $return;
}
// -----------------------------------------------------------------------
// Caching callbacks on behalf of export-ui.
/**
* Menu access callback for various tasks of export-ui.
*/
function ctools_export_ui_task_access($plugin_name, $op, $item = NULL) {
ctools_include('export-ui');
$plugin = ctools_get_export_ui($plugin_name);
$handler = ctools_export_ui_get_handler($plugin);
if ($handler) {
return $handler->access($op, $item);
/**
* Callback for access control ajax form on behalf of export ui.
*
* Returns the cached access config and contexts used.
* Note that this is assuming that access will be in $item->access -- if it
* is not, an export UI plugin will have to make its own callbacks.
*/
function ctools_export_ui_ctools_access_get($argument) {
ctools_include('export-ui');
list($plugin_name, $key) = explode(':', $argument, 2);
$plugin = ctools_get_export_ui($plugin_name);
$handler = ctools_export_ui_get_handler($plugin);
if ($handler) {
ctools_include('context');
$item = $handler->edit_cache_get($key);
if (!$item) {
$item = ctools_export_crud_load($handler->plugin['schema'], $key);
}
$contexts = ctools_context_load_contexts($item);
return array($item->access, $contexts);
}
}
/**
* Callback for access control ajax form on behalf of export ui
*
* Returns the cached access config and contexts used.
* Note that this is assuming that access will be in $item->access -- if it
* is not, an export UI plugin will have to make its own callbacks.
*/
function ctools_export_ui_ctools_access_set($argument, $access) {
ctools_include('export-ui');
list($plugin_name, $key) = explode(':', $argument, 2);
$plugin = ctools_get_export_ui($plugin_name);
$handler = ctools_export_ui_get_handler($plugin);
if ($handler) {
ctools_include('context');
$item = $handler->edit_cache_get($key);
if (!$item) {
$item = ctools_export_crud_load($handler->plugin['schema'], $key);
}
$item->access = $access;
return $handler->edit_cache_set_key($item, $key);
}
}
/**
* Implements hook_menu_local_tasks_alter().
*/
function ctools_menu_local_tasks_alter(&$data, $router_item, $root_path) {
ctools_include('menu');
_ctools_menu_add_dynamic_items($data, $router_item, $root_path);
}
/**
* Implement hook_block_list_alter() to potentially remove blocks.
*
* This exists in order to replicate Drupal 6's "no blocks" functionality.
*/
function ctools_block_list_alter(&$blocks) {
$check = drupal_static('ctools_set_no_blocks', TRUE);
if (!$check) {
foreach ($blocks as $block_id => $block) {
// @todo -- possibly we can set configuration for this so that users can
// specify which blocks will not get rendered.
if (strpos($block->region, 'sidebar') !== FALSE) {
unset($blocks[$block_id]);
}
}
}
/**
* Implements hook_modules_enabled().
*
* Clear caches for detecting new plugins.
*/
function ctools_modules_enabled($modules) {
ctools_include('plugins');
ctools_get_plugins_reset();
cache_clear_all('ctools_plugin_files:', 'cache', TRUE);
}
/**
* Implements hook_modules_disabled().
*
* Clear caches for removing disabled plugins.
*/
function ctools_modules_disabled($modules) {
ctools_include('plugins');
ctools_get_plugins_reset();
cache_clear_all('ctools_plugin_files:', 'cache', TRUE);
}
/**
* Menu theme callback.
*
* This simply ensures that Panels ajax calls are rendered in the same
* theme as the original page to prevent .css file confusion.
*
* To use this, set this as the theme callback on AJAX related menu
* items. Since the ajax page state won't be sent during ajax requests,
* it should be safe to use even if ajax isn't invoked.
*/
function ctools_ajax_theme_callback() {
if (!empty($_POST['ajax_page_state']['theme'])) {
return $_POST['ajax_page_state']['theme'];
}
}
/**
* Implements hook_ctools_entity_context_alter().
*/
function ctools_ctools_entity_context_alter(&$plugin, &$entity, $plugin_id) {
ctools_include('context');
switch ($plugin_id) {
case 'entity_id:taxonomy_term':
$plugin['no ui'] = TRUE;
break;
case 'entity:user':
$plugin = ctools_get_context('user');
unset($plugin['no ui']);
unset($plugin['no required context ui']);
break;
<?php
/**
* @file
* Contains install and update functions for ctools.
*/
/**
* Use requirements to ensure that the CTools CSS cache directory can be
$path = 'public://ctools/css';
if (!file_prepare_directory($path, FILE_CREATE_DIRECTORY)) {
$requirements['ctools_css_cache']['description'] = t('The CTools CSS cache directory,
%path could not be created due to a misconfigured files directory. Please ensure that the
files directory is correctly configured and that the webserver has permission to create
directories.', array('%path' => file_uri_target($path)));
$requirements['ctools_css_cache']['severity'] = REQUIREMENT_ERROR;
$requirements['ctools_css_cache']['value'] = t('Unable to create');
}
if (!function_exists('error_get_last')) {
$requirements['ctools_php_52']['title'] = t('CTools PHP requirements');
$requirements['ctools_php_52']['description'] = t('CTools requires certain features only
available in PHP 5.2.0 or higher.');
$requirements['ctools_php_52']['severity'] = REQUIREMENT_WARNING;
$requirements['ctools_php_52']['value'] = t('PHP !version', array('!version' =>
phpversion()));
}
}
return $requirements;
}
/**
* Implements hook_schema().
*/
function ctools_schema() {
return ctools_schema_3();
}
/**
* Version 3 of the CTools schema.
*/
function ctools_schema_3() {
$schema = ctools_schema_2();
return $schema;
}
/**
// DO NOT MODIFY THIS TABLE -- this definition is used to create the table.
// Changes to this table must be made in schema_3 or higher.
$schema['ctools_css_cache'] = array(
'description' => 'A special cache used to store CSS that must be non-volatile.',
'fields' => array(
'cid' => array(
'type' => 'varchar',
'length' => '128',
'description' => 'The CSS ID this cache object belongs to.',
'not null' => TRUE,
),
return $schema;
}
/**
* CTools' initial schema; separated for the purposes of updates.
*
* DO NOT MAKE CHANGES HERE. This schema version is locked.
*/
function ctools_schema_1() {
Login page
Registration page:
Profile of user:
8. TESTING
Web Chat or messengers are trending enormously. The most famous applications are WhatsApp, Facebook,
Google Alo, WeChat etc. There are a lots of chat applications available with new and exciting features but
some of them only success.
This is due to the quality which they maintain and quality comes with testing process, so here I have outlined
those points that would help you understand the process in precise.
Some of the Positive and Non-Functional Test Cases/Scenarios of Web Chat/Functionality are:
1. Verify there are minimum two Users should be available for the chat.
2. Verify there are minimum two devices (Desktop, Laptop, Phones etc) should be available.
5. Verify that Users are able to send requests to other Users for chat or not.
6. Verify that how many number of words or characters can be send in a time.
7. Verify that Status (Active, Inactive, Invisible, etc.) of User is changing or not.
10. Verify that User is able to Login in a system simultaneously with two or more different IDs or not.
11. Verify that User is able to send messages to other offline User.
12. Verify that User is able to see the time of comment in Chat or not.
13. Verify that User is able to sent special characters in Chat or not.
14. Verify that “is it a Forum or Contact us Chat functionality where any user can leave a message or
not?”
DEPARTMENT OF COMPUTER SCIENCE AND APPLICATIONS
WEB CHAT SYSTEM
94
15. Verify that User is able to set its profile pic which is visible to other users or not.
16. Verify that Users are able to accept message from other Users for chat or not.
17. Verify that Users are able to Chat with their group or not.
18. Verify that Users are able to see current Chat/discussion in the group.
19. Verify that Users are able to see Chat history of the group or not.
20. Verify that Users are able join current Chat/discussion in their group.
21. Verify that Multiple Users can do Chat or discussion in their group simultaneously and every Chat
should be visible to every member of the group.
22. Verify that Chat application or functionality saves their Chat history or removes after session expire/
Chat application close.
23. Verify that name of the User should be displaying to others in Chat application while chatting with
other Users or group.
24. Verify that whenever any member join or leave the Chat / discussion then it should be notified in the
group and is visible to every member of the group.
25. Verify that User is able to share Image, Video, documents etc or not.
26. Verify that is there any size limit of files if any file (Video, Image, Documents etc.) is uploading and
sharing through the Chat application / functionality.
27. Verify that Chat application is able to display that whether comment or comments have been seen by
the respective User or not.
28. Verify that User is chatting with only original Users not any bot.
30. Verify that User is able to Chat with two or more different devices with one ID at a time to other user
or in a group.
31. Verify that “Does a User is able to login in two different devices at a time or not?”
32. Verify that “How much time is it taking to send a message from one User to another?”
33. Verify that “How much time is it taking to send a message in a group?”
There are many more Test Cases/Scenarios can be implement because human mind has no limit to think.
9. CONCLUSION
Online chatting has become increasingly popular. Individuals are no longer hindered from communicating
with each other due to physical barriers such as distance , borders or sea. The most common place for people
to chat is in chat rooms. Many people , especially youngsters , use 'messenger' services like 'Facebook
Messenger' and the newest is 'Whatsapp Messenger' to chat. However , there are advantages and
disadvantages of online chatting.
Firstly , the lack of physical and face-to-face contact makes people more confident and open when chatting.
Chatters remain anonymous , identified only by pseudonyms or nicknames. The lack of identity makes for a
guessing game. Anonymity can also spice up communications , as chatters get caught up in the thrills and
excitement of the guessing game.
In addition , chatting with others in terms of studies helps students to understand different points of view and
leads to a better understanding of what is available in terms of online resources. Meeting with individuals
from different towns , cultures , and countries on the Internet and the exchanging ideas and thoughts can
widen a chatter's horizon. Similarly , chatting to people abroad gives a wider appreciation of global's events
and deeper understanding of the impact of local and international decision making. From chatting with our
Internet acquaintances, our storehpuse of knowledge of other cultures and countries will improve.
On the other hand , online chatting can lead to frightening consequences. Young people make friends easily
and are often willing to give out personal details like their e-mail address, home address and phone
numbers. This might lead to dangerous encounters. Children may be exposed to inappropriate language and
ideas from explicit sexual talk in chat boxes.
With the knowledge I have gained by developing this application, I am confident that in the future I can
make the application more effectively by adding this services.
Extending this application by providing Authorisation service.
Creating Database and maintaining users.
Increasing the effectiveness of the application by providing Voice Chat.
Extending it to Web Support.
11. BIBLIOGRAPHY