COLLAGE COVER PAGE

Project Name

CONTENTS

1. Acknowledgement
2. Abstract
3. Introduction.
4. Objective
5. Literature Survey
5.1 Existing System.
5.2 Proposed System.
6. Requirement Specification
6.1 Software Requirement(Tools)
 6.2 Hardware Requirement
6.3 Languages using
7. Design
7.1 Architecture Diagram
7.2 Dataflow Diagram
7.3 Use case Diagram
7.4 Sequence Diagram
7.5 E-R Diagram
8) Modules Used
8.1) Admin
8.2) Client
9) Implementation code ‘
9.1)
9.2)
9.3)

10) Testing
10.1) Why Testing
10.2) Types of testing
10.2.1) Unit Testing
10.2.2) Integration Testing
10.2.3)Functional Testing
10.2.4) System testing
10.2.5)White Box Testing
10.2.6)Black Box Testing
11) Advantage
12) Conclusion
ACKNOWLEDGEMENT

DESIGN

DATA FLOW DIAGRAMS

A data flow diagram (DFD) is a significant modeling technique for analyzing and
constructing information processes. Data-flow diagram (DFD) is a graphical representation of
the "flow" of data through an information system. DFDs can also be used for the visualization
of data processing (structured design).On a DFD, data items flow from an external data
source or an internal data store to an Internal data store or an external data sink, via an
internal process. A DFD provides no information about the timing or ordering of processes,
or about whether processes will operate in sequence or in parallel. It is therefore quite
different from a flowchart.
This shows the flow of control through an algorithm, allowing a reader to determine what
operations will be performed, in what order, and under what circumstances, but not what
kinds of data will be input to and output from the system, nor where the data will come from
and go to, nor where the data will be stored (all of which are shown on a DFD). Data-flow
diagrams provide the end user with a physical idea of where the data they input ultimately has
an effect upon the structure of the whole system from order to dispatch to report. How any
system is developed can be determined through a data-flow diagram.
With a data-flow diagram, users are able to visualize how the system will operate, what the
system will accomplish, and how the system will be implemented. A designer usually draws a
context-level DFD showing the relationship between the entities inside and outside of a
system as one single step. This basic DFD can be then disintegrated to a lower level diagram
demonstrating smaller steps exhibiting details of the system that is being modeled. Numerous
levels may be required to explain a complicated system.
The different versions are Context Diagrams (Level 0), Partitioned Diagrams (single process
only -- one level), functionally decomposed, leveled sets of Data Flow Diagrams.

DATA FLOW DIAGRAMS SYMBOLS:

A DFD usually comprises of four components. These four components can be represented by
four simple symbols. These symbols can be explained in detail as follows: External entities
(source/destination of data) are represented by squares; Processes (input-processing-output)
are represented by rectangles with rounded corners; Data Flows (Physical or electronic data)
are represented by arrows; and finally, Data Stores (physical or electronic like XML files) are
represented by open-ended rectangles.
A data store stores data passively for later access. A data store responds to requests to store
and access data. It does not generate any operations.
A data store allows values to be accessed in an order different from the order in which they
were generated.

Input flows indicate information or operations that modify the stored data such as adding or
deleting elements or changing values. Output flows indicate information retrieved from the
store; this information can be an entire value or a component of a value.

Data flow

A data flow moves data between processes or between processes and data stores. As such, it
represents a data value at some point within a computation and an intermediate value within a
computation if the flow is internal to the diagram. This value is not changed. The names of
input and output flows can indicate their roles in the computation or the type of the value they
move. Data names are preferably nouns. The name of a typical piece of data, the data aspect,
is written alongside the arrow.

Data Process

Or

A process shows a transformation or manipulation of data flows within the system. The
symbol used is rounded rectangle or oval. A descriptive title is placed in the centre of the
circle.This should be a simple imperative sentence with a specific verb, for example
'maintain customer records' or 'find driver'. E.g.: May be a clerk computing discounts or a
combination of manual and electronic activities.
Source or Sink

Or

An external entity is a source or destination of a data flow which is outside the area of study.
The symbol used is a rectangle or square containing a meaningful and unique identifier.
Only those entities which originate or receive data are represented on a business process
diagram E.g.: May be one customer or a number of customers with transactions (orders).

Rules for Creating DFD

 Processes should be named and numbered for easy reference. Each name should be
representative of the process.
 The direction of flow is from top to bottom and from left to right. Data traditionally
flow from the source (upper left corner) to the destination although they may flow
back to a source. One way to indicate this is to repeat the source symbol as a
destination. Since it is used more than once in the DFD, it is marked with a short
diagonal in the lower right corner.
 When a process is exploded into the lower-level details, they are numbered.
 The names of data stores, sources and destinations are written in capital letters.
Process and data flow names have the first letter of each word capitalized.
DATAFLOW DIAGRAMS:

Level-0:

Admin

User

Kitchen
order
ticket

Staff

Owner

Admin

login Menu List

Add chef
 Customer:

If items to change
Cancel order

customer login View items

order

View bill

logout
Staff:

staff

login Menu List

order

Cancel order

Change password

View bill

logout
SOFTWARE LANGUEGE USED
HTML 5

It is next version of 4.5 with advanced features like in-built plug-in auto-resizing, multiple
platform support and rich java script engine.

Hyper Text Mark-up Language, commonly referred to as HTML, is the standard mark-up
language used to create webpages. Along with CSS and JavaScript, HTML is a cornerstone
technology used to create web pages as well as to create user interfaces for mobile and web
applications. Web browsers can read HTML files and render them into visible or audible web
pages. HTML describes the structure of a website semantically pages. HTML describes the
structure of a programming language.

HTML elements form the building blocks of HTML pages. HTML allows images and other
objects to be embedded and it can be used to create interactive forms. It provides a means to
create structured documents by denoting structural semantics for text such as headings,
paragraphs, lists, links, quotes and other items. HTML elements are delineated by tags,
written using angle brackets. Tags such as <img /> and <input /> introduce content into the
page directly. Others such as <p>...</p> surround and provide information about document
text and may include other tags as sub-elements. Browsers do not display the HTML tags, but
use them to interpret the content of the page.

HTML can embed scripts written in languages such as Java scripts which affect the behaviour
of HTML web pages. HTML markup can also refer the browser to Cascading Style Sheets
(CSS) to define the look and layout of text and other material.
The WORLD WIDE WEB CONSORTIUM (W3C), maintainer of both the HTML and the
CSS standards, has encouraged the use of CSS over explicit presentational HTML since
1997.
HTML is a markup language that web browsers use to interpret and compose text, images,
and other material into visual or audible web pages. Default characteristics for every item of
HTML markup are defined in the browser, and these characteristics can be altered or
enhanced by the web page designer's additional use of CSS. . Many of the text elements are
found in the 1988 ISO technical report TR 9537 Techniques for using SGML, which in turn
covers the features of early text formatting languages such as that used by the RUNOFF
command developed in the early 1960s for the CTSS (Compatible Time-Sharing System)
operating system: these formatting commands were derived from the commands used by
typesetters to manually format documents. However, the SGML concept of generalized
markup is based on elements (nested annotated ranges with attributes) rather than merely
print effects, with also the separation of structure and markup; HTML has been progressively
moved in this direction with CSS

It is the mark-up "code" that is read by web browsers like Internet Explorer, Firefox, Safari,
etc., either as straight HTML or a newer, XML version of HTML called XHTML. The
differences between these versions are beyond the scope of these notes. All the "experts"
can't even seem to agree when you can or should use XHTML. Just know that if you use
either, any web browser will be able to display your pages for some time to come. I will use
both, but try to emphasize XHTML, because it makes your pages ready for stuff we haven't
thought up yet.

The html extension is what turns a regular text file into an HTML file. It only needs to be
added at the time you create the file, once it's made simply save the file each time you edit the
code. Save your file in a folder where you can easily find it.
The saved code can be opened and edited from within the text editor (make sure that "All
Files" is selected from the drop-down menu in the editor's dialog box).
To open the webpage in your browser simply go to the folder in which it is saved and click
on the webpage icon.

FEATURES OF HTML:
 It is not a programming language.
 It is not a data description language.
 It is simple to understand and implement.
  HTML constructs are very easy to comprehend, and can be used effectively by
anybody.
 The methodology used by HTML to mark up information is independent of its
representation on a particular hardware or software architecture.
 HTML syntax is a worldwide standard.
.

MYSQL
Structured Query Language (SQL) is the language used to manipulate relational databases.
SQL is tied very closely with the relational model.

 In the relational model, data is stored in structures called relations or tables.

SQL statements are issued for the purpose of:
 Data definition: Defining tables and structures in the database (DDL used to create, alter
and drop schema objects such as tables and indexes).
List of SQL statements that can be issued against an Oracle database schema are:
 ALTER - Change an existing table, view or index definition (DDL)
 AUDIT - Track the changes made to a table (DDL)
 COMMENT - Add a comment to a table or column in a table (DDL)
 COMMIT - Make all recent changes permanent (DML - transactional)
 CREATE - Create new database objects such as tables or views (DDL)
 DELETE - Delete rows from a database table (DML)
 DROP - Drop a database object such as a table, view or index (DDL)
 GRANT - Allow another user to access database objects such as tables or views
(DDL)
 INSERT - Insert new data into a database table (DML)
 No AUDIT - Turn off the auditing function (DDL)
 REVOKE - Disallow a user access to database objects such as tables and views
(DDL)
 ROLLBACK - Undo any recent changes to the database (DML - Transactional)
 SELECT - Retrieve data from a database table (DML)
 TRUNCATE - Delete all rows from a database table (can not be rolled back) (DML)
 UPDATE - Change the values of some data items in a database table (DML)
MySQL is an open source relational database system (RDBMS); in July 2013, it was the
world's second most widely used RDBMS, and the most widely used open-source client
server model RDBMS. The SQL abbreviation stands for Structured Query Language. The
MySQL development project has made its source code available under the terms of the
General Public License as well as under a variety of proprietary agreements. MySQL was
owned and sponsored by a single for-profit firm, the Swedish company MYSQL AB now
owned by Oracle Corporation. For proprietary use, several paid editions are available, and
offer additional functionality.

JAVASCRIPT
Java script is a fairly simple language which is only suitable for fairly simple tasks. The
language is best suited to tasks which run for a short time and is most commonly used to
manipulate the pieces of the document object model. The idea behind finding JavaScript is to
find a language which could be used to provide client-side in-browser applications but which
was not as complicated as Java.
JavaScript is Netscape's cross-platform, object-oriented scripting language. Core JavaScript
contains a core set of objects, such as Array, Date, and Math, and a core set of language
elements such as operators, control structures, and statements. It is mainly used here for
validation purpose.

BENEFITS OF JAVASCRIPT:
JavaScript has a number of benefits to anyone who wants to make their Web site dynamic.
 It is widely supported in Web browsers.
 It gives easy access to the document objects and can manipulate most of them.
 JavaScript can give interesting animations without the long download times
associated with many multimedia data types.

PYTHON
Python is a widely used high-level programming language known for its simplicity,
readability, and versatility. Created by Guido van Rossum and first released in 1991, Python
has grown to become one of the most popular programming languages, with a large and
active community of developers.

KEY FEATURES AND CHARACTERISTICS OF PYTHON:

Easy-to-Read Syntax: Python's syntax is designed to be clear and concise, making it easy
for both beginners and experienced developers to read and understand code.
Dynamic Typing: Python is dynamically typed, meaning variable types are determined at
runtime, allowing for flexibility in coding.

Object-Oriented: Python supports object-oriented programming (OOP) principles, enabling

developers to create and use classes and objects for building complex applications.

Interpreted Language: Python is an interpreted language, which means it is executed line-

by-line by an interpreter rather than compiled before execution.

Extensive Standard Library: Python comes with a rich standard library that provides a
wide range of modules and packages for various tasks, such as file I/O, networking, data
manipulation, and more.

Cross-Platform Compatibility: Python is compatible with various operating systems,

including Windows, macOS, and Linux, allowing developers to write code that can run on
different platforms without modification.

Large Community and Ecosystem: Python has a vast and active community of developers,
which has contributed to an extensive ecosystem of third-party libraries, frameworks, and
tools that enhance Python's capabilities.

Common Uses Of Python:

Web Development: Python is frequently used for web development, with popular
frameworks like Django and Flask providing the infrastructure to build robust and scalable
web applications.

Data Science and Analytics: Python's data manipulation libraries like NumPy, Pandas, and
SciPy, along with visualization tools like Matplotlib and Seaborn, make it a preferred choice
for data analysis, machine learning, and scientific computing.

Automation and Scripting: Python's ease of use and powerful standard library make it an
excellent choice for automating repetitive tasks and scripting.

GUI Development: Python supports various GUI libraries like Tkinter, PyQt, and wxPython,
enabling developers to create graphical user interfaces for desktop applications.

Game Development: Python is used for game development, often in combination with
popular gaming libraries like Pygame.

Networking: Python's built-in networking libraries, such as socket and requests, make it
suitable for developing network-based applications.

Artificial Intelligence and Natural Language Processing: Python is widely used in AI and
NLP applications, leveraging libraries like TensorFlow, Keras, and NLTK.
In summary, Python's simplicity, versatility, and extensive community support have made it a
go-to language for a wide range of applications, from web development to data science and
beyond. Its continued growth and popularity ensure that Python will remain a significant
player in the world of programming for years to come..
DJANGO
Django is a high-level web framework written in Python that follows the Model-View-
Controller (MVC) architectural pattern. It provides a robust and efficient toolkit for building
web applications rapidly and securely. Developed by Django Software Foundation and
released in 2005, Django has since become one of the most popular web frameworks in the
Python ecosystem.

KEY FEATURES AND CHARACTERISTICS OF DJANGO:

Model-View-Template (MVT) Architecture: Django follows the MVT architectural

pattern, which is similar to MVC. The model represents the data structure and database
schema, the view handles the user interface and presentation logic, and the template manages
the rendering of the HTML.

Admin Interface: Django comes with a powerful built-in admin interface. It automatically
generates an admin interface for managing site content and data, making it easy for
developers to handle tasks like data entry, content management, and user management
without writing additional code.

Object-Relational Mapping (ORM): Django's ORM abstracts the database interaction,

allowing developers to interact with the database using Python objects instead of raw SQL
queries. This simplifies database operations and enhances code readability.

URL Routing: Django's URL dispatcher helps map URLs to appropriate views, making it
easy to define URL patterns and direct user requests to the corresponding view functions.
Form Handling: Django provides form handling capabilities to simplify the process of
creating and validating HTML forms. It includes built-in form classes that assist in rendering
forms and processing user input.

Security Features: Django emphasizes security best practices and provides built-in features
like protection against common web vulnerabilities (e.g., Cross-Site Scripting, Cross-Site
Request Forgery), secure password management, and user authentication.

Template Language: Django's template language allows developers to create dynamic

HTML templates, enabling the separation of presentation from business logic.

Middleware: Django's middleware components allow developers to handle cross-cutting

concerns, such as authentication, request/response processing, and caching.

Internationalization and Localization: Django supports internationalization and

localization, making it easier to create web applications that can be adapted to different
languages and regions.

Common Uses of Django:

Web Development: Django is primarily used for building web applications and websites. Its
robust features and rapid development capabilities make it suitable for projects of various
sizes and complexities.

Content Management Systems (CMS): Django's admin interface and flexible database
models make it an excellent choice for building custom content management systems.

E-commerce Platforms: Many e-commerce websites use Django due to its efficient
handling of data models, user authentication, and session management.

Social Media Platforms: Django's user authentication and data management features make it
well-suited for creating social media platforms and community-driven websites.

Backend Services: Django can be used to build RESTful APIs and backend services to
support mobile applications and other client-side applications.
In conclusion, Django's clean design, powerful features, and focus on productivity make it an
ideal choice for developers looking to build robust and scalable web applications. Its active
community, extensive documentation, and large number of third-party packages contribute to
its popularity and continued growth in the web development ecosystem.

Code

Setings.py

"""
Django settings for jobprovider project.

Generated by 'django-admin startproject' using Django 4.2.

For more information on this file, see

https://docs.djangoproject.com/en/4.2/topics/settings/

For the full list of settings and their values, see

https://docs.djangoproject.com/en/4.2/ref/settings/
"""
import os
from pathlib import Path

# Build paths inside the project like this: BASE_DIR / 'subdir'.

BASE_DIR = Path(__file__).resolve().parent.parent

# Quick-start development settings - unsuitable for production

# See https://docs.djangoproject.com/en/4.2/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 'django-insecure-)3m35s65fm+
+lq200px4vu$reljgdj17oyf=daok#n(%v)g(02'

# SECURITY WARNING: don't run with debug turned on in production!

DEBUG = True

ALLOWED_HOSTS = []

# Application definition

INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'jobseeker',
]

MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

ROOT_URLCONF = 'jobprovider.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]

WSGI_APPLICATION = 'jobprovider.wsgi.application'

# Database
# https://docs.djangoproject.com/en/4.2/ref/settings/#databases

DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'portal',
'USER': 'root',
'PASSWORD': '',
'HOST': '127.0.0.1',
'PORT': '3306',
}
}
# Password validation
# https://docs.djangoproject.com/en/4.2/ref/settings/#auth-password-validators

AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]

# Internationalization
# https://docs.djangoproject.com/en/4.2/topics/i18n/

LANGUAGE_CODE = 'en-us'

TIME_ZONE = 'UTC'

USE_I18N = True

USE_TZ = True

# Static files (CSS, JavaScript, Images)

# https://docs.djangoproject.com/en/4.2/howto/static-files/
STATIC_URL = 'static/'

DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'

MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')

Urls.py

"""
URL configuration for jobprovider project.

The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/4.2/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: path('', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: path('', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.urls import include, path
2. Add a URL to urlpatterns: path('blog/', include('blog.urls'))
"""

from django.contrib import admin

from django.urls import path

from jobseeker import views

from django.conf import settings
from django.conf.urls.static import static

urlpatterns = [
path('admin/', admin.site.urls),
path('',views.showindex,name='showindex'),
path('insertstaff',views.insertstaff,name='insertstaff'),
path('insertrounds',views.insertrounds,name='insertrounds'),
path('insertjobprovider1',views.insertjobprovider1,name='insertjobprovider1'),
path('insertjobseeker',views.insertjobseeker,name='insertjobseeker'),
path('insertjob',views.insertjob,name='insertjob'),
path('insertreviews',views.insertreviews,name='insertreviews'),
path('insertmessage',views.insertmessage,name='insertmessage'),
path('insertselection',views.insertselection,name='insertselection'),
path('insertjobdetails',views.insertjobdetails,name='insertjobdetails'),
path('showlogin',views.showlogin,name='showlogin'),

path('logcheck',views.logcheck,name='logcheck'),
path('changepassword',views.changepassword,name='changepassword'),
path('showstaff',views.showstaff,name='showstaff'),
path('showjobprovider1',views.showjobprovider1,name='showjobprovider1'),
path('showjobseeker',views.showjobseeker,name='showjobseeker'),
path('showjob',views.showjob,name='showjob'),
path('showreviews',views.showreviews,name='showreviews'),
path('showmessage',views.showmessage,name='showmessage'),
path('showrounds', views.showrounds, name='showrounds'),
path('showselection', views.showselection, name='showselection'),
path('showjobdetails', views.showjobdetails,name='showjobdetails'),
path('insertapply',views.insertapply,name='insertapply'),
path('insertdocument',views.insertdocument,name='insertdocument'),

path('jobprovider1_del/(?P<pk>\d+)/$', views.jobprovider1_del, name='jobprovider1_del'),

 path('jobdetails_del/(?P<pk>\d+)/$', views.jobdetails_del, name='jobdetails_del'),
path('job_del/(?P<pk>\d+)/$', views.job_del, name='job_del'),
path('message_del/(?P<pk>\d+)/$', views.message_del, name='message_del'),
path('reviews_del/(?P<pk>\d+)/$', views.reviews_del, name='reviews_del'),
path('rounds_del/(?P<pk>\d+)/$', views.rounds_del, name='rounds_del'),
path('selection_del/(?P<pk>\d+)/$', views.selection_del, name='selection_del'),
path('staff_del/(?P<pk>\d+)/$', views.staff_del, name='staff_del'),
path('jobseeker_del/(?P<pk>\d+)/$', views.jobseeker_del, name='jobseeker_del'),
]

if settings.DEBUG:
urlpatterns += static(settings.MEDIA_URL,document_root=settings.MEDIA_ROOT)

Views.py(server side code)

from datetime import date

from django.shortcuts import render, redirect

from django.urls import reverse

from jobseeker.models import

userlogin,staff,roundsdetails,jobprovider1,jobseeker,job,reviewsandrating,messages,selection
details,jobdetails
from django.core.files.storage import FileSystemStorage
import os
from jobprovider.settings import BASE_DIR

from jobseeker.models import documents

from jobseeker.models import jobapply

# Create your views here.
def showindex(request):
return render(request,"index.html")

def showlogin(request):

return render(request,"login.html")

def logcheck(request):
if request.method=="POST":
username=request.POST.get("t1")
password = request.POST.get("t2")
count=userlogin.objects.filter(username=username).count()
if count>=1:
udata=userlogin.objects.get(username=username)
request.session['username'] = username
upass=udata.password
utype=udata.utype
if upass==password:
if utype=='jobseeker':
return render(request,'jobseeker_home.html')
if utype=='jobprovider':
return render(request,'jobprovider_home.html')
if utype=='staff':
return render(request,'staff_home.html')

else:
return render(request,'login.html',{'msg':'invalid password'})
else:
return render(request, 'login.html', {'msg': 'invalid username'})

return render(request,'login.html',{'msg':'ok'})
def changepassword(request):
uname=request.session['username']
if request.method == 'POST':
currentpass = request.POST.get('t1', '')
newpass = request.POST.get('t2', '')
confirmpass = request.POST.get('t3', '')

ucheck = userlogin.objects.filter(username=uname).values()
for a in ucheck:
u = a['username']
p = a['password']
if u == uname and currentpass == p:
if newpass == confirmpass:
userlogin.objects.filter(username=uname).update(password=newpass)
base_url=reverse('logcheck')
msg='password has been changed successfully'
return redirect(base_url,msg=msg)
else:
return render(request, 'changepassword.html',{'msg': 'both the usename and
password are incorrect'})
else:
return render(request, 'changepassword.html',{'msg': 'invalid username'})
return render(request, 'changepassword.html')

def insertstaff(request):
if request.method=="POST":
s1=request.POST.get("t1")
s2 = request.POST.get("t2")
s3 = request.POST.get("t3")
s4 = request.POST.get("t4")
s5 = request.POST.get("t5")
s6 = request.POST.get("t6")
s7 = request.POST.get("t7")
staff.objects.create(staffid=s1,name=s2,email=s3,password=s4,contact=s5,usertype=s6,create
dat=s7)
p = staff.objects.all().order_by('id').last()
pid = int(p.staffid)+1
return render(request,"staffinfo.html",{'pid':pid})
p = staff.objects.all().order_by('id').last()
pid = int(p.staffid) + 1
return render(request, "staffinfo.html", {'pid': pid})

def showstaff(request):
userdict=staff.objects.all()
return render(request, "viewstaffinfo.html",{'userdict':userdict})

def staff_del(request,pk):
id=staff.objects.get(id=pk)
id.delete()
udata=staff.objects.all()
return render(request,'viewstaffinfo.html',{'udata':udata})

def insertrounds(request):
if request.method=="POST":
s1=request.POST.get("t1")
s2 = request.POST.get("t2")
s3 = request.POST.get("t3")
s4 = request.POST.get("t4")
roundsdetails.objects.create(companyid=s1,roundname=s2,details=s3,jobid=s4)
return render(request,"roundsinfo.html")
return render(request, "roundsinfo.html")

def showrounds(request):
userdict=roundsdetails.objects.all()
return render(request, "viewroundsinfo.html",{'userdict':userdict})
def rounds_del(request,pk):
id=roundsdetails.objects.get(id=pk)
id.delete()
udata=roundsdetails.objects.all()
return render(request,'viewroundsinfo.html',{'udata':udata})

def insertjobprovider1(request):
if request.method=="POST":
s1=request.POST.get("t1")
s2 = request.POST.get("t2")
s3 = request.POST.get("t3")
s4 = request.POST.get("t4")
s5 = request.POST.get("t5")
s6 = request.POST.get("t6")
s7 = request.POST.get("t7")
s8 = request.POST.get("t8")

jobprovider1.objects.create(jobproviderid=s1,userid=s2,companyname=s3,companywebsite=
s4,companylogo=s5,industry=s6,location=s7,createdat=s8)
p = jobprovider1.objects.all().order_by('id').last()
pid = int(p.jobproviderid) + 1
return render(request, "jobprovider1info.html", {'pid': pid})
p = jobprovider1.objects.all().order_by('id').last()
pid = int(p.jobproviderid) + 1
return render(request, "jobprovider1info.html", {'pid': pid})

def insertapply(request):
uname = request.session['username']
if request.method=="POST":
s1=request.POST.get("t1")
s2 = request.POST.get("t2")
s3 = request.POST.get("t3")
 today = date.today()

jobapply.objects.create(userid=uname,jobid=s1,companyid=s2,jobtype=s3,applydate=today,s
tatus='New')

return render(request, "applyjobs.html" )

return render(request, "applyjobs.html")

def showjobprovider1(request):
userdict=jobprovider1.objects.all()
return render(request, "viewjobprovider1info.html",{'userdict':userdict})

def jobprovider1_del(request,pk):
id=(jobprovider1.objects.get(id=pk))
id.delete()
udata=jobprovider1.objects.all()
return render(request,'viewjobprovider1info.html',{'udata':udata})

def insertjobseeker(request):
if request.method=="POST" and request.FILES['myfile']:
s1=request.POST.get("t1")
s2 = request.POST.get("t2")
myfile = request.FILES['myfile']
s4 = request.POST.get("t4")
s5 = request.POST.get("t5")
s6 = request.POST.get("t6")
s7 = request.POST.get("t7")
jobseeker.objects.create(seekerid=s1,userid=s2,resumeupload=myfile,skills=s4,exeperience=
s5,education=s6,createdat=s7)
p = jobseeker.objects.all().order_by('id').last()
pid = int(p.seekerid) + 1
return render(request, "jobseekerinfo.html", {'pid': pid})
p = jobseeker.objects.all().order_by('id').last()
pid = int(p.seekerid) + 1
return render(request, "jobseekerinfo.html", {'pid': pid})

def insertdocument(request):
uname = request.session['username']
if request.method=="POST" and request.FILES['myfile']:
s1=request.POST.get("t1")
s2 = request.POST.get("t2")
myfile = request.FILES['myfile']

documents.objects.create(seekerid=s1,docname=s2,file=myfile)

return render(request, "documentinfo.html",{'uname':uname} )

return render(request, "documentinfo.html",{'uname':uname} )

def showjobseeker(request):
userdict=jobseeker.objects.all()
return render(request, "viewjobseekerinfo.html",{'userdict':userdict})

def jobseeker_del(request,pk):
id=jobseeker.objects.get(id=pk)
id.delete()
udata=jobseeker.objects.all()
 return render(request,'viewjobseekerinfo.html',{'udata':udata})

def insertjob(request):
if request.method=="POST":
s1=request.POST.get("t1")
s2 = request.POST.get("t2")
s3 = request.POST.get("t3")
s4 = request.POST.get("t4")
s5 = request.POST.get("t5")
s6 = request.POST.get("t6")
s7 = request.POST.get("t7")
s8 = request.POST.get("t8")
s9 = request.POST.get("t9")
s10 = request.POST.get("t10")

job.objects.create(jobid=s1,employerid=s2,title=s3,description=s4,requirements=s5,salaryran
ge=s6,jobtypes=s7,location=s8,postedat=s9,status=s10)
p = job.objects.all().order_by('id').last()
pid = int(p.jobid) + 1
return render(request, "jobinfo.html", {'pid': pid})
p = job.objects.all().order_by('id').last()
pid = int(p.jobid) + 1
return render(request, "jobinfo.html", {'pid': pid})

def showjob(request):
userdict=job.objects.all()
return render(request, "viewjobinfo.html",{'userdict':userdict})

def job_del(request,pk):
id=job.objects.get(id=pk)
id.delete()
udata=job.objects.all()
return render(request,'viewjobinfo.html',{'udata':udata})
def insertreviews(request):
if request.method=="POST":
s1=request.POST.get("t1")
s2 = request.POST.get("t2")
s3 = request.POST.get("t3")
s4 = request.POST.get("t4")
s5 = request.POST.get("t5")
s6 = request.POST.get("t6")

reviewsandrating.objects.create(reviewid=s1,employerid=s2,seekerid=s3,rating=s4,review=s
5,createdat=s6)
p = reviewsandrating.objects.all().order_by('id').last()
pid = int(p.reviewid) + 1
return render(request, "reviewsinfo.html", {'pid': pid})
p = reviewsandrating.objects.all().order_by('id').last()
pid = int(p.reviewid) + 1
return render(request, "reviewsinfo.html", {'pid': pid})

def showreviews(request):
userdict=reviewsandrating.objects.all()
return render(request, "viewreviewsinfo.html",{'userdict':userdict})

def reviews_del(request,pk):
id=reviewsandrating.objects.get(id=pk)
id.delete()
udata=reviewsandrating.objects.all()
return render(request,'viewreviewsinfo.html',{'udata':udata})

def insertmessage(request):
if request.method=="POST":
s1=request.POST.get("t1")
s2 = request.POST.get("t2")
 s3 = request.POST.get("t3")
s4 = request.POST.get("t4")
s5 = request.POST.get("t5")

messages.objects.create(messageid=s1,senderid=s2,recieverid=s3,message=s4,sentat=s5)
p = messages.objects.all().order_by('id').last()
pid = int(p.messageid) + 1
return render(request, "messageinfo.html", {'pid': pid})
p = messages.objects.all().order_by('id').last()
pid = int(p.messageid) + 1
return render(request, "messageinfo.html", {'pid': pid})

def showmessage(request):
userdict=messages.objects.all()
return render(request, "viewmessageinfo.html",{'userdict':userdict})

def message_del(request,pk):
id=messages.objects.get(id=pk)
id.delete()
udata=messages.objects.all()
return render(request,'viewmessageinfo.html',{'udata':udata})

def insertselection(request):
if request.method=="POST":
s1=request.POST.get("t1")
s2 = request.POST.get("t2")
s3 = request.POST.get("t3")
s4 = request.POST.get("t4")
s5 = request.POST.get("t5")
s6 = request.POST.get("t6")

selectiondetails.objects.create(companyid=s1,jobid=s2,userid=s3,details=s4,packagedetails=s
5,startdate=s6)
 return render(request,"selectioninfo.html")
return render(request, "selectioninfo.html")

def showselection(request):
userdict=selectiondetails.objects.all()
return render(request, "viewselectioninfo.html",{'userdict':userdict})

def selection_del(request,pk):
id=selectiondetails.objects.get(id=pk)
id.delete()
udata=selectiondetails.objects.all()
return render(request,'viewselectioninfo.html',{'udata':udata})

def insertjobdetails(request):
if request.method=="POST":
s1=request.POST.get("t1")
s2 = request.POST.get("t2")
s3 = request.POST.get("t3")
s4 = request.POST.get("t4")
s5 = request.POST.get("t5")
s6 = request.POST.get("t6")
s7 = request.POST.get("t7")
s8 = request.POST.get("t8")
s9 = request.POST.get("t9")
s10 = request.POST.get("t10")

jobdetails.objects.create(jobid=s1,companyid=s2,jobtype=s3,category=s4,minqualification=s
5,cutoffdetails=s6,packagedetails=s7,location=s8,dateofapplication=s9,interviewdate=s10)
p = jobdetails.objects.all().order_by('id').last()
pid = int(p.jobid) + 1
return render(request, "jobdetailsinfo.html", {'pid': pid})
p = jobdetails.objects.all().order_by('id').last()
pid = int(p.jobid) + 1
return render(request, "jobdetailsinfo.html", {'pid': pid})
def showjobdetails(request):
userdict=jobdetails.objects.all()
return render(request, "viewjobdetailsinfo.html",{'userdict':userdict})

def jobdetails_del(request,pk):
id=(jobdetails.objects.get(id=pk))
id.delete()
udata=jobdetails.objects.all()
return render(request,'viewjobdetailsinfo.html',{'udata':udata})

models.py(tables)

from django.db import models

# Create your models here.

class userlogin(models.Model):
username=models.CharField(max_length=40)
password=models.CharField(max_length=20)
utype=models.CharField(max_length=20)

class staff(models.Model):
staffid=models.CharField(max_length=40)
name=models.CharField(max_length=40)
email=models.CharField(max_length=100)
password=models.CharField(max_length=40)
contact=models.CharField(max_length=20)
usertype= models.CharField(max_length=20)
createdat= models.CharField(max_length=20)
class jobprovider1(models.Model):
providerid=models.CharField(max_length=40)
userid=models.CharField(max_length=40)
companyname=models.CharField(max_length=40)
companywebsite=models.CharField(max_length=40)
companylogo=models.CharField(max_length=20)
industry= models.CharField(max_length=20)
location= models.CharField(max_length=40)
createdat= models.CharField(max_length=20)

class jobseeker(models.Model):
seekerid=models.CharField(max_length=40)
userid=models.CharField(max_length=40)
resumeupload=models.FileField(upload_to='documents/')
skills=models.CharField(max_length=40)
exeperience=models.CharField(max_length=20)
education=models.CharField(max_length=20)
createdat=models.CharField(max_length=20)

class documents(models.Model):
seekerid=models.CharField(max_length=40)
docname=models.CharField(max_length=100)
file=models.FileField(upload_to='documents/')

class jobapply(models.Model):
userid=models.CharField(max_length=80)
jobid=models.CharField(max_length=40)
companyid=models.CharField(max_length=40)
jobtype=models.CharField(max_length=40)
applydate=models.CharField(max_length=40)
status = models.CharField(max_length=40)
class job(models.Model):
jobid=models.CharField(max_length=40)
employerid=models.CharField(max_length=40)
title=models.CharField(max_length=40)
description=models.CharField(max_length=100)
requirements=models.CharField(max_length=40)
salaryrange=models.CharField(max_length=10)
jobtypes=models.CharField(max_length=20)
location=models.CharField(max_length=40)
postedat=models.CharField(max_length=20)
status=models.CharField(max_length=20)

class reviewsandrating(models.Model):
reviewid=models.CharField(max_length=40)
employerid=models.CharField(max_length=40)
seekerid=models.CharField(max_length=40)
rating=models.CharField(max_length=40)
review=models.CharField(max_length=40)
createdat=models.CharField(max_length=40)

class messages(models.Model):
messageid=models.CharField(max_length=40)
senderid=models.CharField(max_length=40)
recieverid=models.CharField(max_length=40)
message=models.CharField(max_length=40)
sentat=models.CharField(max_length=10)

class roundsdetails(models.Model):
companyid=models.CharField(max_length=40)
roundname=models.CharField(max_length=40)
details=models.CharField(max_length=60)
jobid=models.CharField(max_length=40)

class selectiondetails(models.Model):
 companyid=models.CharField(max_length=40)
jobid=models.CharField(max_length=40)
userid=models.CharField(max_length=40)
details=models.CharField(max_length=60)
packagedetails=models.CharField(max_length=60)
startdate=models.CharField(max_length=20)

class jobdetails(models.Model):
jobid=models.CharField(max_length=40)
companyid=models.CharField(max_length=40)
jobtype=models.CharField(max_length=40)
category=models.CharField(max_length=20)
minqualification=models.CharField(max_length=20)
cutoffdetails=models.CharField(max_length=60)
packagedetails=models.CharField(max_length=60)
location=models.CharField(max_length=40)
dateofapplication=models.CharField(max_length=40)
interviewdate=models.CharField(max_length=20)

index.html

<!DOCTYPE html>
{% load static %}
<html>
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title></title>
<style type="text/css">

* { box-sizing:border-box; }

body { margin:0px;
 padding:0px; }

.header { background-image: linear-gradient(to top,dodgerblue, darkblue);

padding:5px;
text-align:center;
text-shadow:2px 3px 5px black;
color:white; }

.header img { width:60px;

height:80px;
float:left; }

.nav { background-color:black; }

.nav a { color:white;
text-decoration:none;
padding:5px 10px;
display:inline-block; }

.nav a:hover { color:orange;

}

.main { display:flex; }

.left { flex:65%; }

.left img { width:130%; }

.right { flex:35%;
background-color:linen;
color:darkred;
text-align:justify;
 padding:10px;
font-size:20px; }

.footer { padding:5px;
text-align:center;
background-color:orange; }

</style>
</head>
<body>
<div class="header">

<img src="{% static 'logo.jpeg' %}">

<h1> ONLINE JOB PORTAL </h1>

</div>

<div class="nav">
<a href=""> HOME </a>
<a href=""> ABOUT US </a>
<a href=""> CONTACT US </a>
<a href="{% url 'showlogin' %}"> LOGIN </a>

</div>

<div class="main">

<div class="left">
<img src="{% static 'job.jpeg' %}">
</div>
<div class="right">
<h3> WELCOME TO ONLINE JOB WEBSITE... </h3>
<p> An online job portal is a web-based platform that connects job seekers with
employers, serving as a bridge between those looking for employment opportunities and
companies seeking qualified candidates. It provides users with the ability to search for jobs
based on various criteria such as job title, location, industry, experience level, and more. Job
seekers can create profiles, upload resumes, and apply for jobs directly through the portal.
Meanwhile, employers can post job vacancies, review applications, and manage the
recruitment process efficiently. Many portals also offer additional features like job alerts,
resume-building tools, career advice articles, and interview preparation resources to support
users throughout their job search journey. By digitizing and centralizing the hiring process,
online job portals make it easier, faster, and more accessible for both candidates and
employers to connect and fulfill their professional needs.

</p>
</div>
</div>

<div class="footer">
contact us : [email protected]
</div>
</body>
</html>
Screen Shots

Index.html

Login.html

Adminhome
Userhome

Changepassword
Forgot password
 E R DIAGRAM

takes

order bill
Suggestion
get
ma feedback
ke
s
gives

Cust_phno
Takes m
Customer
m order 1 1
Email_id
Cust_na
captain
Cust_id address
details
designatio chek
details
name booking
address

phno
Email Order
id details menu

photo bill
IMPLEMENTION CODE

TESTING

The purpose of testing is to discover errors. Testing is the process of trying to discover every
conceivable fault or weakness in a work product. It provides a way to check the functionality
of components, sub-assemblies, assemblies and/or a finished product it is the process of
exercising software with the intent of ensuring that the Software system meets its
requirements and user expectations and does not fail in an unacceptable manner. There are
various types of test. Each test type addresses a specific testing requirement.

TYPES OF TESTING:

UNIT TESTING
Unit testing involves the design of test cases that validate that the internal program logic is
functioning properly, and that program input produces valid outputs. All decision branches
and internal code flow should be validated. It is the testing of individual software units of the
application .it is done after the completion of an individual unit before integration. This is a
structural testing, that relies on knowledge of its construction and is invasive. Unit tests
perform basic tests at component level and test a specific business process, application,
and/or system configuration. Unit tests ensure that each unique path of a business process
performs accurately to the documented specifications and contains clearly defined inputs and
expected results.

INTEGRATION TESTING
Integration tests are designed to test integrated software components to determine if they
actually run as one program. Testing is event driven and is more concerned with the basic
outcome of screens or fields. Integration tests demonstrate that although the components were
individually satisfaction, as shown by successfully unit testing, the combination of
components is correct and consistent. Integration testing is specifically aimed at exposing
the problems that arise from the combination of components.

FUNCTIONAL TEST
Functional tests provide a systematic demonstration that functions tested are available as
specified by the business and technical requirements, system documentation, and user
manuals.

Functional testing is centered on the following items:

Valid Input : identified classes of valid input must be accepted.

Invalid Input : identified classes of invalid input must be rejected.

Functions : identified functions must be exercised.

Output : identified classes of application outputs must be exercised.

Systems/Procedures : interfacing systems or procedures must be invoked.

Organization and preparation of functional tests is focused on requirements, key functions, or
special test cases. In addition, systematic coverage pertaining to identify

Business process flows; data fields, predefined processes, and successive processes must be
considered for testing. Before functional testing is complete, additional tests are identified
and the effective value of current tests is determined.

SYSTEM TEST
System testing ensures that the entire integrated software system meets requirements. It tests
a configuration to ensure known and predictable results. An example of system testing is the
configuration oriented system integration test. System testing is based on process descriptions
and flows, emphasizing pre-driven process links and integration points.

WHITE BOX TESTING

White Box Testing is a testing in which in which the software tester has knowledge of the
inner workings, structure and language of the software, or at least its purpose. It is purpose. It
is used to test areas that cannot be reached from a black box level.

BLACK BOX TESTING

Black Box Testing is testing the software without any knowledge of the inner workings,
structure or language of the module being tested. Black box tests, as most other kinds of tests,
must be written from a definitive source document, such as specification or requirements
document, such as specification or requirements document. It is a testing in which the
software under test is treated, as a black box .you cannot “see” into it. The test provides
inputs and responds to outputs without considering how the software works.
UNIT TESTING:
Unit testing is usually conducted as part of a combined code and unit test phase of the
software lifecycle, although it is not uncommon for coding and unit testing to be conducted as
two distinct phases.

Test strategy and approach

Field testing will be performed manually and functional tests will be written in detail.
Test objectives
 All field entries must work properly.
 Pages must be activated from the identified link.
 The entry screen, messages and responses must not be delayed.
Features to be tested
 Verify that the entries are of the correct format
 No duplicate entries should be allowed
 All links should take the user to the correct page.

INTEGRATION TESTING
Software integration testing is the incremental integration testing of two or more integrated
software components on a single platform to produce failures caused by interface defects.
The task of the integration test is to check that components or software applications, e.g.
components in a software system or – one step up – software applications at the company
level – interact without error.

Integration testing for Database Synchronization:

 Testing the links that call the Change Username & password, Migration and
Synchronization screens etc.
 The username should be retained throughout the application in the form of hidden
variables or by using cookies.
  If the login user does not have enough privileges to invoke a screen, the link should
be disabled.
 Any modification in the Master server should be reflected in the Slave server.
 The XML file should retrieve only the records, which have been modified.
Test Results: All the test cases mentioned above passed successfully. No defects
encountered.

ACCEPTANCE TESTING

User Acceptance Testing is a critical phase of any project and requires significant
participation by the end user. It also ensures that the system meets the functional
requirements.

Acceptance testing for Data Synchronization:

 Users have separate roles to modify the database tables.

 The timestamp for all insertions and updating should be maintained.
 Users should have the ability to modify the privilege for a screen.
 Once the Synchronization starts, the Master server or Slave Server should not be
stopped without notifying the other.
 The XML file should be generated in short time, i.e., before the next modification
occurs.

Test Results: All the test cases mentioned above passed successfully. No defects
encountered.
ADVANTAGES
 Display screen is present at the kitchen, so that the chef should be able to see what a
particular has ordered. All the ordered items are displayed on the screen giving the
table number below. They should be sufficiently large to be seen by chef at a
reasonable distance.

 Wastage of paper is avoided as our implementation is working just on tablet and does
not need any paper work. e.g.-For taking the order, we are not using papers. Also, our
menu card would be digitized.

 A customer going into restaurant does not has to wait for the waiters to take the order.
As soon as he occupies a seat, he would order whatever he needs.

 As soon as the order is ready, it would be notified to the customer. So, there would
not be any issue of late delivery in spite of the food being ready.

 There will be a tablet on each table. This will allow the customers to browse the food
items for the time they wish.

 This will allow the customers to browse the food items the way the customer wish.

 Customer can enter the feedback about the service and the food served.

CONCLUSION
"Conclusively, the Kitchen Order Ticket has proven to be an essential tool for seamless
restaurant operations. The role it plays in providing a clear, concise, and legible version of the
customer's order to the kitchen staff cannot be overemphasized. It's an effective means to
ensure order accuracy, minimize communication errors, and enhance the overall dining
experience for the customer. Additionally, it aids in inventory control, efficient billing, and
offers valuable insights for operational improvements. Thus, the effective use and
management of KOTs are crucial to any successful food service establishment."

In conclusion, the implementation of a sophisticated Kitchen Order Ticket (KOT) system

represents a pivotal advancement in the realm of restaurant and kitchen management. This
comprehensive solution addresses the intricacies and challenges associated with order
processing, communication, and coordination between front-of-house and kitchen staff. As
we reflect on the benefits and implications of a well-designed KOT system, several key
points come to the forefront.

First and foremost, the KOT system serves as a bridge that seamlessly connects the diverse
elements of a culinary establishment. By digitizing and streamlining the process of order
entry, transmission, and preparation, the system minimizes the potential for
miscommunication and errors. The visual display of orders on kitchen screens ensures that
each dish is prepared accurately, expediting service and enhancing overall efficiency.

Furthermore, the KOT system has a profound impact on the customer experience. With real-
time updates on order status and timely delivery of meals, patrons are treated to a smoother
and more enjoyable dining journey. Reduced waiting times, precise order fulfillment, and the
ability to accommodate customization requests contribute to heightened satisfaction and the
cultivation of positive reviews and repeat business.

The integration of modern technology, such as mobile and cloud-based solutions, brings
newfound flexibility to the management of kitchen orders. Accessibility from various devices
and locations empowers restaurant managers and chefs to monitor and oversee operations
remotely, ensuring that quality and standards are upheld even in their absence.

While the KOT system offers an array of advantages, its successful implementation is not
without challenges. Overcoming resistance to technology adoption, ensuring proper staff
training, and addressing initial implementation costs require careful planning and strategic
management. However, the potential benefits far outweigh these challenges, as evidenced by
the growing body of research and success stories in the industry.

As we peer into the future, the trajectory of Kitchen Order Ticket systems continues to
evolve. The potential integration of AI-driven predictive analytics promises to revolutionize
kitchen operations, paving the way for even greater efficiency, resource optimization, and an
enhanced customer experience. In this dynamic landscape, the KOT system stands as a
testament to the remarkable potential of technology to redefine traditional practices and
elevate the art of culinary management.

REFERENCES
1. https://wiki.python.org/moin/ReferenceBooks
2. https://docs.python.org/3/reference/index.html
3. https://python-reference.readthedocs.io/en/latest/intro.html
4. https://realpython.com/python-application-layouts/
5. https://docs.djangoproject.com/en/4.2/intro/tutorial01/
6. https://www.interviewbit.com/blog/django-projects/
7. www.questionsanswered.net/tech/learn-python-on-my-own
8. www.ask.com/news/need-know-using-free-project-spreadsheet
9. https://www.colaninfotech.com/python/developer
10. www.reference.com/world-view/strip-python-a096fc712d9fc865