E-CAMPUS TRAINING AND

PLACEMENT SYSTEM
A Project Report

Submitted by:

BURHAN NABI (18205135045)

ZARKA YOUNIS (18205135027)

FALAK MANZOOR (18205135011)

in partial fulfillment for the award of the degree

of

BACHELOR OF ENGINEERING

IN

COMPUTER ENGINEERING

at

SSM COLLEGE OF ENGINEERING

PARIHASPORA PATTAN, BARAMULLA, KASHMIR

to

THE UNIVERSITY OF KASHMIR, HAZRATBAL SRINAGAR

2022
 DECLARATION

We hereby declare that the project entitled “E-campus Training and Placement System”
submitted for the B.E. (CSE) degree is our original work and the project has not formed
the basis for the award of any degree, diploma, fellowship or any other similar titles.

Date: Signature of the students:

ii
 CERTIFICATE

This is to certify that the project entitled

E-CAMPUS TRAINING AND PLACEMENT SYSTEM

Submitted by:

BURHAN NABI Enroll: 18205135045

FALAK MANZOOR Enroll: 18205135011

ZARKA YOUNIS Enroll: 18205135027

is the Bonafide work carried out by them under supervision of Mrs. YASMEEN VIQAR,
and is approved for the partial fulfillment of the requirement for the award of the degree of
Bachelor of engineering (Computer Engineering) of SSM College of Engineering and
Technology, Kashmir affiliated to University of Kashmir, Srinagar during the academic
year 2022.

This Project Report has not been earlier submitted to any other institute or university for
the award of any Degree.

Mrs. YASMEEN VIQAR Mrs. YASMEEN VIQAR

Project Guide Head of Department

Department of CSE Department of CSE

Principal

iii
 ACKNOWLEGEMENT

It is our proud privilege and duty to acknowledge the kind help and guidance received from
several people in preparation for this project. It would not have been possible to prepare
this project in this form without their valuable help, cooperation and guidance.

First and foremost, we would like to extend our deepest gratitude to Mrs. YASMEEN
VIQAR, head of the department CSE and internal guide, for her constant support and
encouragement in the preparation of the project and for making data and other facilities
available which were required for successful preparation of this project. We extend our
heartfelt gratitude to her for providing us with the right guidance and advice at crucial
junctures and for showing us the right course of action. We are also grateful to her for her
immense support and supervision during the course of the completion of the project.

We are also thankful to the principal of SSM College of Engineering, for expressing his
confidence in us by letting us work on a project of this magnitude and providing his
support, help, and encouragement in implementing this project.

At last, we would like to thank our family and friends for their encouragement and support
during the course of our work.

FALAK MANZOOR

BURHAN NABI

ZARKA YOUNIS

iv
 ABSTRACT

The Project Named “E- Campus training and placement system” is a student, campus
Information system. It is a management system which is supported by database. TPO has a
major role in every college in which most of the work till now is carried out manually. The
goal is to automate the Training and Placement procedure in colleges. This application reduces
manual work and maximize the optimization, abstraction and security. This is a web
application which will help students as well as the administrator authority to carry out each and
every activity in campus hiring. This application can be used for the Training and placement
cell of the college to manage the student information regarding placement. Students will able to
view eligibility criteria based on their percentage for the up-coming placement drives and they
can access technical and Questions regarding particular company. It has the facility to maintain
the details of the student and reducing the manual work. Training and Placement Officer (TPO)
is able to view information about student and collect their resumes and so many ad-on
functionalities. This system can be accessed through proper login. A forum is a platform
provided to all students for communication. The purpose of Training and Placement System is
to automate the existing manual system by the help of computerized equipment and full-
fledged computer software, fulfilling their requirements, so that their valuable data /
information can be stored for a longer period with easy accessing and manipulation of the
same. The required software and hardware are easily available and easy to work with. Training
and Placement System, as described above, can lead to error free, secure, reliable and fast
system. It can assist the user to concentrate on their other activities rather to concentrate on the
record keeping. Thus, it will help campus in better utilization of resources. The organization
can maintain computerized records without redundant entries. That means that one need not be
distracted by information that is not relevant, while being able to reach the information.

v
 LIST OF FIGURES/DIAGRAMS

Figure Title Page No.

FIG 1 MVT MODEL

8
FIG 2 ARCHITECTURE 9
FIG 3 SOFTWARE MODEL 13
FIG 4 ENTITY-RELATIONSHIP DIAGRAM 21
FIG 5 USER WORK FLOW DIAGRAM 23
FIG 6 ADMIN WORK FLOW DIAGRAM 24
FIG 7 CONTEXT LEVEL DATA FLOW DIAGRAM 25

vi
 TABLE OF CONTENTS

Title Page
Declaration of the Student ii
Certificate of the Guide iii
Acknowledgement iv
Abstract v
List of Figures vi
List of Tables vii
Table of contents
1. Introduction 1
2. Literature Review 4
3. Design Specifications & Methodology 8
4. Program Code/Result 26
5. Conclusions 63
6. Refrences 64

vii
E-CAMPUS TRAINING & PLACEMENT SYSTEM

CHAPTER 1

INTRODUCTION
In today’s world everyone is travelling for jobs after Completion of their graduation. It has
became need for each and every student, but for that they need to travel worldwide in searching
of jobs. For simplicity of this whole hectic procedures E-campus Training and Placement
System has been introduced because of earlier system is totally done manually by maintaining
records, time consuming and very difficult to maintain coordination between student and
companies.
The project is aimed at developing an online web application for the training and placement
department of the college. The system is an online web application that can be accessed
throughout the Institute with proper login provided. This system can be used as an application
for the TPO of the college to manage the student information with regard to placement. Student
logging should be able to upload their information. Organizations representatives logging in
may also access/search an information put up by the students. TPO have to collect the
information and manage them manually according to various streams. If any modification is
required that is also to be done manually. Overall it will reduce the paper work and utilize the
maximum capability of the setup and organization as well as it will save time and money.

1.1 Background

The earlier system was not computerized, transactions in the previous system were done
manually by maintaining records. It takes much time for a placement officer to collect and
approve the details of students. There is poor communication between students and placement
officer. Students may not obtain the desired information. It is difficult to coordinate students,
companies, and interviews. The proposed system is a web-based application. The system allows
students to access details of recruitments. The system allows students to access any material
posted by various departments. Recruiters can access the student details. It is easy for one to
access desired information through the well- defined interfaces. For the purpose of training and
placement of the Students. This application will perform various tasks for student
administrative authority. This project helps a better student support and time-saving factor. The
1
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
various types of reports will be available quickly without any effort. Training and placement
provide infrastructural facility to conduct the group discussion. This project is aimed at
developing a web portal for training and placement.
Campus placements are conducted in all colleges for all the education fields. Various software
and other sector companies are conducting campus recruitment process for selecting candidates.
When campus selections are conducted in colleges the students have to provide their curriculum
vitae to the concern TPO officer for attending the campus interviews. This routine process is
maintained manually. Many colleges have automated system but have some limitations.
Students uploaded their CVs early in the year, leaving them as it is in time. Lists were
produced for each company based on the present information. Students have to check their mail
regularly. Searching is done based on the company criteria and requirement. The student will
get notify rough mailing only. The students were not being made aware of the T&P activity other
than placements. The information like company technical question paper, Resume Format, Job
details are not available to the student. There was no record kept of the past students and their
working status. There was less communication between the student with the Training and
Placement department. So that this can be improved by designing Advanced software.

1.2 Problem Statement

Nowadays, student joins the college for better education as well as for better placement for
their future. The placement activities play very important role in student career and building
college reputation. In the current system all training and placement activities are done
manually, there are more chances of error. It is very time consuming activity for collecting,
managing, updating student data as number of student increases. The notice board is old
method of informing student about the placement activities. The training and placement officer
has to short list according to company requirement. It is required to design of a computerized
student automation module to speed up capabilities.
For every student as well as college placement is important. Placement process is very difficult
to handle as it involves a lot of data. In the Placement Process, college departments face issues
in keeping track of the student database, eligible students, placed students and other processes.
Department manually collects data most of the time and it is time consuming and databases
stored as excel sheets may be altered by mistake. Students may or may not inform the
2
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
department if they receive personal emails. Interview experiences are not available to every
student. The proposed work provides the facility to the students for viewing the job , applying
for the same and sharing the experience, which help the students to prepare themselves for the
interviews and help to increase the technical knowledge. Details of the Company are provided
to the students with the Eligibility Criteria and other Requirements by the admin. So the
students can prepare themselves according to the requirements. The ultimate goal of the Project
is to provide the students with clear information about the Company, and secure the student
data. This Project also provides the clear information about, how many students placed, Total
number of students, Total number of companies visited.

1.3 Objectives

To avoid the problems arising in the existing system we are developing online training and
placement system to make interactive, automated and effective work of placement activities.
• Automatic resume generator where the student will provide the details for the student
profile and a resume will be generated that will be saved in the form of the pdf in the user’s
system.
• Provides the searching facilities based on various factors. Such as Training, Student,
CGPA Marks, Technical Skill.
• Dynamic back-end for CRUD operations.
• Shows the information or description of the Jobs, Training, Student, Courses.
• Easy to access and avoid fake entry.
• Filter out placement postings so that only eligible candidates must see the posting.
• It will have a user-friendly and mobile optimized interface.
• Data importing\ exporting facility, where the data can be exported in different ways like in
the .csv format, excel format etc.
• To get the track of the job application whether it is in the pending state, selected or
rejected.

3
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
CHAPTER 2

LITERATURE REVIEW

An interactive training and placement system which automates the training and placement
activities that provides the many opportunities to raise the selection ratio. This system intimates
about job openings for the students in various fields, apply to those postings and invite various
organizations for hiring the students from the college and track the progress of the students. It
can generate the list of short-listed students as per HR requirements and their different
criteria’s.
A Final Year Management System that provides the complete details of the students in the
college by which we can overcome the many problems like managing the records of thousands
of students and searching the list of eligible students from those thousands of records for
recruitment purpose, list companies visited to the college for hiring the students.
To Automate the registration process and generate the list of eligible students for recruitment a
College Talent Placement System is developed. The students who are eligible can register
through the portal and update their personal details including their resume which can be
accessed and seen by the placement director.
The Placement Officer fixes the schedule based on the activities in the institution. Finally, the
student will be able to see the details of examination and status of recruitment. A modular
architecture-based system which provides multiple functionalities for performing the placement
related activities. In this modular based system, we can add or remove modules in the future
based on the specifications required for TPO.

Paper 1: Survey on: Training and Placement Automation System

In this paper, the author focused to provide a detailed survey of different Training and
Placement Automation Systems by analysing parameters like technology, scope, feasibility,
security and efficiency of the system.

Paper 2: Online Training and Placement System (IRJET)

In this paper author focus onOnline Training and Placement, It has become need for each and

4
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
every student, but for that they need to travel worldwide in searching of jobs. It is very difficult
to maintain coordination between student and companies and it is also time consuming

Paper 3:ANDROID BASED TRAINING AND PLACEMENT AUTOMATION

The System focuses on the automation of the training and placement cell and profile matching.
Observing and controlling the progress of the selection process and communicating with
different eligible candidate via SMS or Email notification. For accessing the data on android
platform we are using JSON. This system reduces the human efforts and maintaining large
amount of data efficiently.

Paper 4: STUDENT PLACEMENT ANALYZER: A recommendation system using

machine learning
This paper is reviewed to predict the placement status of the students which is to help teachers
and placement cell in an institution to find the prospective students and provide them with
better coaching so as to excel in placement processes by various companies.

Paper 5: Online Training and Placement Management System

This paper describes the Automation of Training and Placement unit of AMCEC (AMC
Engineering College).This paper is a web based application for the Training and placement
officers (TPO) of the college to manage the student information with regard to placement.

Paper 6: TnP Vision: Automation and Analysis of Campus Placements in Colleges

This paper represents an Enterprise Resource Planning (ERP) system for Training and
Placement Cell in educational institute campuses. The proposed system called TnP Vision aims
to automate the entire placement process.It is an interactive software platform that focuses on
student data management and analysis to digitize practices, providing visibility into students’
success, and providing a forum for employers to streamline the hiring process.

Paper 7: Placement Management System for Campus Recruitment

This paper describes a web based solution for placement activity and reduces manual work and

5
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
keeps track of student education details.Authors built web portal using PHP framework.

Paper 8: A Review on Placement Management System

This paper describes the need for a placement system to reduce manual work and built an
Android app to overcome the problem.

Paper 9: Data mining paper for placement & training system

The auther’s paper for data mining provides easier ways to handle data of students.The
interface of student and administer is maximum which makes the system time consuming.
students created and submitted their cv’s early in the year, leaving them frozen in time. lists
were produced for each company, and students had to regularly travel in to review the notice
board. the process was slowing ,valuable academic time was diverted from activity That is
more useful at ACE the record were stored in modified,excel sheet hence sorting is a problem.

Paper 10: Design Paper on Online Training and Placement System (OTAP)
The system provides considerable features of online registration, system security, automated
percentage calculation, data sorting and notification services. But lacks Event Management
System’s features along with report generation.

6
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
2.2 EXISTING SYSTEM
All processes in existing system are handled manually. All the work that is done in the existing
system is done by the human intervention .As all the work is done manually, there were a lot of
workload on placement officer and it also increases the maximum chances of errors. This is so
slow and time consuming. Due to increase in number of user’s the process become more
difficult. Problems faced in existing system are as follows-
• Searching of eligible students is done manually by TPO based on the company criteria.
• The records were stored in modified excel sheets hence sorting problem.
• The duplication of records was usual hence data redundancy.
• TPO’s have to collect all the information and Resumes of students and organize them
manually and sort them according to various streams.
Collecting CV’s of so many student is a painful and time consuming task and handling of too
many CV’s is a great overhead.

• It takes too much time to managing, updating and informing specific student for specific
company criteria.

2.3 PROPOSED SYSTEM

The main purpose of proposed Web based Training and Placement portal is meant to give more
easiness to TPO, Placement coordinators and Students that they can modify and access
information so quickly. The system provides a better way to maintain students information in
the database, ensures data correctness and data integrity as well. The system also reduces the
paperwork time and provides an efficient information flow between different system modules.
Our system consists of different modules to interact with.
The aim of the proposed system is to develop a system with improved facilities. The proposed
system can overcome all the limitation of the existing system, such as student’s information is
maintained in the database, it gives more security to data, ensures data accuracy, reduces paper
work and save time, only eligible students get chance, it makes information flow efficient and
paves way for easy report generation, reduce the space. proposed system is cost effective.

7
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
CHAPTER 3

SYSTEM ANALYSIS AND DESIGN

3 .1 METHODOLOGY FLOW
Django is based on MVT (model-view-template) architecture. MVT is a software design
pattern for developing a web application. Software models improves the productivity of the
development team. It reduces the number of defects int the final code. It improves the
understandability of the system. In this project MVT model is being used which comprises of
the following three components:
• Model – A model provides the interface for the data stored in the Database. It is responsible
for maintaining the data and handling the logical data structure for the entire web application.
• View – A view in MVT is a user interface. It is responsible for displaying Model Data to the
user and also to take up information from the user. It is represented by HTML/CSS/Javascript.
• Template – The Template is a text document or a python string marked-up using Django
template language. Some constructs are recognized and interpreted by the template engine. The
main ones are variables and tags. A template is rendered with text.

Fig 1: MVT MODEL

8
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM

3.2 ARCHITECTURE

Fig 2: Architecture of e-campus training and placement system

Web Based Training And Placement System is a centralized system where TPO, Student,
admin are the users of the system.

Admin Module
The admin is the most important part in this web application. The admin is basically a
superuser and is permitted to bring any change in the system . The admin can login the system
through the admin login where in he/she has to enter the username and password. Admin can
add jobs and the trainings and also notify the users about it through the emails. When a user
tries to login the system admin first checks his/her details if they are authentic and after that he
can allow them to login the system . It is also upto the admin whom the status of the different
users . The admin can give the permissions to the users like the CRUD operations and also the
status of the staff can be made active by the admin.

9
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM

Student
Students are the main component of the system , they are the users of the system. Students can
login the system through the student login wherein he/she has to provide the enroll and the
password and after the admin allows them they can enter the system. The student has to
provide the personal information like the name, contact, qualification and resume will be
generated for the same in the form of a pdf. The student can apply for any training there is no
restriction for a training but in case of a job the company has its own criteria of marks and the
students having sufficient marks can see the job posts and can apply for the same. Also they
can get notified for the job and trainings through email.

Staff module
Faculty/TPO:
The training and placement officers are also the main component of this application. They first
need to register in the system by providing the specific details after that they can login by
giving the login id and the password. They basically login through the admin login. So
according to the permissions provided by admin they can do their job. It depends on the admin
which status he will give them. If the admin allow a faculty member to update the job or
trainings then he/she will be able to do the same. The placement officer can also add the newly
visiting company name to the database. The TPO can assign the placed in some company the
TPO should update the details such as in which company the student has been placed. The TPO
can maintain all the HRS information in this section by adding the details of the HR such as his
name, mobile number, HR level, email, company name etc. The TPO can also maintain the
information of other college TPO details. In this section the TPO have the option of
maintaining the workshop or training details that are going to be held in the college.

10
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM

HR Module:
The HR module can give permissions to the student whether he/she can view their resume,
send emails, add available jobs on their profile, can add training etc.

3.3 SYSTEM DESIGN

The most creative and challenging face of the system development is System Design. It
provides the understanding and procedural details necessary for the logical and physical stages
of development. In designing a new system, the system analyst must have a clear understanding
of the objectives, which the design is aiming to fulfill. The first step is to determine how the
output is to be produced and in what format. Second, input data and master files have to be
designed to meet the requirements of the proposed output. The operational phases are handled
through program construction and testing.

11
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
Design of the system can be defined as a process of applying various techniques and principles
for the purpose of defining a device, a process or a system in sufficient detail to permit its
physical realization. Thus system design is a solution to ―how to‖ approach to the creation of
a new system. This important phase provides the understanding and the procedural details
necessary for implementing the system recommended in the feasibility study. The design step
provides a data design, architectural design, and a procedural design.

3.4 SOFTWARE MODEL

Agile Model: The model that we used in our project is the Agile Model. The meaning of Agile

is swift or versatile. “Agile process model" refers to a software development approach

based on iterative development. Agile methods break tasks into smaller iterations, or parts do
not directly involve long term planning. The project scope and requirements are laid down at
the beginning of the development process. Plans regarding the number of iterations, the
duration and the scope of each iteration are clearly defined in advance.

Each iteration is considered as a short time "frame" in the Agile process model, which typically
lasts from one to four weeks. The division of the entire project into smaller parts helps to
minimize the project risk and to reduce the overall project delivery time requirements. Each
iteration involves a team working through a full software development life cycle including
planning, requirements analysis, design, coding, and testing before a working product is
demonstrated to the client.

12
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM

FIG 3: AGILE MODEL

Phases of Agile Model:

Following are the phases in the Agile model:

1. Requirements gathering
2. Design the requirements
3. Construction/ iteration
4. Testing/ Quality assurance
5. Deployment
6. Feedback

1. Requirements gathering: In this phase, we define the requirements. We explained business

opportunities and planned the time and effort needed to build the project. Based on this
information, we evaluated technical and economic feasibility.

13
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
2. Design the requirements: When we have identified the project, work with stakeholders to
define requirements. We can use the user flow diagram or the high-level UML diagram to show
the work of new features and show how it will apply to your existing system.

3. Construction/ iteration: When the team defines the requirements, the work begins.
Designers and developers start working on their project, which aims to deploy a working
product. The product will undergo various stages of improvement, so it includes simple,
minimal functionality.

4. Testing: In this phase, the Quality Assurance team examines the product's performance and
looks for the bug.

5. Deployment: In this phase, the team issues a product for the user's work environment.

6. Feedback: After releasing the product, the last step is feedback. In this, the team receives
feedback about the product and works through the feedback

3.5 TESTING OF THE SYSTEM:

The process of verifying and validation whether a software or application is bug-free, meets the
technical requirements as guided by its design and development, and meets the user
requirements effectively and efficiently by handling all the exceptional and boundary cases is
called testing. This process of software testing aims not only at finding faults in the existing
software but also at finding measures to improve the software in terms of efficiency, accuracy,
and usability. It mainly aims at measuring the specification, functionality, and performance of a
software program or application.
Verification: it refers to the set of tasks that ensure that the software correctly implements a
specific function.
Validation: it refers to a different set of tasks that ensure that the software that has been built is
traceable to customer requirements.
In our testing phase, the modules developed were initially tested just after the completion of

14
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
each function. This implies that unit testing was done when the modules were developed. The
verification of the project was also accomplished during the development phase. The test data
was provided to the system to check the system’s functionalities and those were recorded to be
satisfactory. Once all the modules were unit tested then the integration of the modules was
done and integration testing, verification and validation were again performed to double check
the working of the system. Some errors were encountered and corrected. Errors related to the
databases were also encountered during both the unit testing and integration testing where some
of the queries failed to execute due to either missing fields or data. Those errors were also
resolved during the testing phase. The user’s input data is also validated against the rules,
example a user cannot enter a number or numerical where alphabet is required, or a user cannot
miss a required field.
As the project is on bit large scale, we always need testing to make it successful. If each
components work properly in all respect and gives desired output for all kind of inputs then
project is said to be successful. The code for the new system has been written completely using
PYTHON as the coding language and JAVASCRIPT, CSS & HTML for front-end designing
and DJANGO FRAMEWORK as the interface for back-end designing. The new system has
been tested well with the help of the users and all the applications have been verified from
every nook and corner of the user. Although some applications were found to be erroneous
these applications have been corrected before being implemented. The flow of the forms has
been found to be very much in accordance with the actual flow of data.

A series of testing is done for the proposed system before the system is ready for the user
acceptance testing. The steps involved in Testing are:

• Unit Testing: Unit testing focuses verification efforts on the smallest unit of the software
design, the module. This is also known as “Module Testing”. The modules are tested
separately. This testing carried out during programming stage itself. In this testing each module
is found to be working satisfactorily as regards to the expected output from the module.

• Integration Testing: Data can be grossed across an interface; one module can have adverse
efforts on another. Integration testing is systematic testing for construction the program

15
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
structure while at the same time conducting tests to uncover errors associated with in the
interface. The objective is to take unit tested modules and build a program structure. All the
modules are combined and tested as a whole. Here correction is difficult because the isolation
of cause is complicate by the vast expense of the entire program. Thus, in the integration
testing stop, all the errors uncovered are corrected for the text testing steps.

• System testing: System testing is the stage of implementation that is aimed at ensuring that
the system works accurately and efficiently for live operation commences. Testing is vital to
the success of the system. System testing makes a logical assumption that if all the parts of the
system are correct, then goal will be successfully achieved.

• Validation Testing: At the conclusion of integration testing software is completely

assembled as a package, interfacing errors have been uncovered and corrected and a final series
of software tests begins, validation test begins. Validation test can be defined in many ways.
But the simple definition is that validation succeeds when the software function in a manner
that can reasonably expected by the customer. After validation test has been conducted one of
two possible conditions exists. One is the function or performance characteristics confirm to
specifications and are accepted and the other is deviation from specification is uncovered and a
deficiency list is created. Proposed system under consideration has been tested by using
validation testing and found to be working satisfactorily

• Output Testing: After performing validation testing, the next step is output testing of the
proposed system since no system could be useful if it does not produce the required output in
the specified format. Asking the users about the format required by them tests the outputs
generated by the system under consideration. Here the output format is considered in two ways,
one is on the screen and other is the printed format. The output format on the screen is found to
be correct as the format was designed in the system designed phase according to the user needs.
For the hard copy also, the output comes as the specified requirements by the users. Hence
output testing does not result any corrections in the system.

• User Acceptance Testing: User acceptance of a system is the key factor of the success of any

16
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
system. The system under study is tested for the user acceptance by constantly keeping in touch
with the prospective system users at the time of developing and making changes wherever
required.

Test ID Input Expected remarks Actual remarks

1 Correct username System, should Get login of
& password of accept it jobseeker
Student.
2 Incorrect System should Invalid username
username & reject it & password
password of
Student
3 Correct username System should Get login of staff
of staff accept it
4 Incorrect System should Invalid username
username and reject it or password
password of staff
5 Correct username System should Get login of
and password of accept it Admin
admin
6 Student fills System should Student get
correct details for allow registration registered
registration of student
7 Student fills System should not Students not gets
incorrect allow registering registered
username and student
password
8 Student keeps System should Student not gets
blank fields for give warnings to registered
registration fill blank fields
9 Staff fills correct System should Staff gets
details for allow registering registered
registration staff

17
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
3.6 TECHNOLOGY USED IN THE PROJECT:

FRONT END REQUIREMENTS

• HTML
• CSS
• JAVASCRIPT

HTML (Hypertext Markup Language) is a text-based approach to describing how content

contained within an HTML file is structured. This markup tells a web browser how to display
text, images and other forms of Multimedia on webpage.

CSS stands for Cascading Style Sheets. It is a style sheet language which is used to describe
the look and formatting of a document written in markup language. It provides an additional
feature to HTML. It is generally used with HTML to change the style of web pages and user
interfaces. It can also be used with any kind of XML documents including plain XML, SVG
and XUL.CSS is used along with HTML and JavaScript in most websites to create user
interfaces for web applications and user interfaces for many mobile applications.

JAVASCRIPT is a dynamic programming language that's used for web development, in web
applications, for game development, and lots more. It allows you to implement dynamic
features on web pages that cannot be done with only HTML and CSS.

BACKEND REQUIREMENTS

• DJANGO
• JAZZMIN
• MYSQL

Django is an advanced Web framework written in Python that makes use of the model view
controller (MVC) architectural pattern. Django was created in a fast-moving newsroom
environment, and its key objective is to ease the development of complicated, database-driven
18
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
websites. This Web framework was initially developed for The World Company for managing
some of their news-oriented sites. In July 2005, it was publicly released under a BSD license.

JAZZMIN intended as a drop-in app to jazz up your django admin site, with plenty of things
you can easily customise, including a built-in UI customizer.

MySQL is an Oracle-backed opensource relational database management system (RDBMS)

based on Structured Query Language (SQL). MySQL runs on virtually platform including
Linux, Unix and Windows. Although it can be used in a wide range of applications, MySQL is
most often associated with web applications and online publishing .MySQL is based on a client
server model. The core of MySQL is MySQL server, which handles all of the database
instructions (or commands).

3.7 REQUIREMENTS FOR THE DEVELOPMENT OF THE PROJECT:

To facilitate implementation of the experimental setup, installation of some software is
required, and the hardware or system must satisfy the minimum requirement for the proper
installation and working of the required software. The software required for the successful
implementation of the project includes an integrated development environment of python
which contains basic workspace and an extensible plug-in system for customizing the
environment. Since our project has a requirement to connect to a database, MY SQL server can
be used. 1 GB of memory and 256GB of hard disk drive is required for efficient execution of
the modules.
To summarize it all:

1. MINIMUM SOFTWARE REQUIREMENTS:

• Python Django for developing the web application

• Microsoft SQL Server for database connectivity

19
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
• Windows 7 Operating System

2. MINIMUM HARDWARE REQUIREMENTS:

• Processor: Intel core i3

• Hard Disk Drive: 256GB

• Memory: 1GB

3.8 ENTITY RELATIONSHIP DIAGRAM (ERD):

This entity relation diagram depicts the relationship between various entities involved in this
project/system. This ERD illustrates how “entities” such as students, TPO and admin relate to
each other within the system. This ERD depicts the design and is used to further debug the
relational database. This diagram was initially used to determine requirements for the
information system project. Later it was used to model the database “E-Campus Training and
Placement System”. The dataset used in this project is the campus dummy data. The main
entities involved in this project are the student, TPO, faculty and admin. The entity “student”
has various attributes like first_name, last_name, phone_no, email, password, and id. This is
basically a dynamic system where the superuser is the admin of the system. The admin has the
highest role in the system he can perform the CRUD operations. The admin can grant the
specific permissions to the other user. The entity “faculty” has attributes like email, password.
Various other tables are included in the ERD, which ensures the system works in a better and
efficient way and handles as many queries as possible with ease.

20
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM

Entity-Relationship Model

21
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
ER MODELLING:

The schemas for the database application can be displayed by means of graphical notation
known as Entity Relationship diagram. The ER model describes data as entities, relationships
and attributes.

ENTITIES AND ATTRIBUTES:

An entity may be an object with a physical existence for e.g. A particular person, car
or employee) or it may be an object with a conceptual existence for e.ga company, a
job, or a university course. Each entity has attributes i.e., the particular properties that
describe it. The attribute values that describe each entity become a major part of the
data store in the database.

RELATIONSHIP BETWEEN ENTITIES:

Whenever an attribute of one entity type refers to another entity type, a relationship
exists. In the initial design of entity types, relationships are typically captured in the
form of attributes. As the design is refined these attributes get converted into
relationships between entity types.
In the ER diagrams the emphasis is on representing the schemas rather than the
instances. This is more useful in the database design because a database schema
changes rarely.

22
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
3.9 FLOWCHART:

USER WOKFLOW:

FIG4 User flow diagram

23
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
ADMIN WORKFLOW:

FIG5 Admin workflow diagram

24
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
3.10 DATA FLOW DIAGRAMS:

Context level Data Flow Diagram:

FIG6 Context level data flow diagram

25
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
CHAPTER 4
RESULTS/OUTPUTS
4.1 Program Code
college/administrator/admin.py

from django.contrib import admin

from import_export.admin import ImportExportMixin
from .models import *
# Register your models here.

@admin.register(Notice)
class NoticeAdmin(ImportExportMixin,admin.ModelAdmin):
list_display = ['title','description','date','course']

@admin.register(Teacher)
class TecherAdmin(ImportExportMixin,admin.ModelAdmin):
list_display = ['name','designation','is_show']
list_editable = ['is_show']

@admin.register(Event)
class EventAdmin(ImportExportMixin,admin.ModelAdmin):
pass

@admin.register(Gallery)
class GalleryAdmin(ImportExportMixin,admin.ModelAdmin):
pass

@admin.register(WhatsappMessage)
class WhatsappMessageAdmin(ImportExportMixin,admin.ModelAdmin):
pass

@admin.register(WhatsappGroup)
class WhatsappGroupAdmin(ImportExportMixin,admin.ModelAdmin):
pass

@admin.register(TechnicalStaff)
26
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
class TechnicalStaffAdmin(ImportExportMixin,admin.ModelAdmin):
pass

@admin.register(AboutUs)
class AboutUsAdmin(ImportExportMixin,admin.ModelAdmin):
pass

college/administrator/models.py

import pywhatkit
from django.db import models
from authenticate_user.models import Course,User
# Create your models here.

class Notice(models.Model):
title = models.CharField(max_length = 150)
description = models.CharField(max_length = 150)
date = models.DateField(auto_now_add=True)
course =
models.ForeignKey(Course,on_delete=models.CASCADE,null=True,blank=True)
file = models.FileField(upload_to='notice/',null=True,blank=True)
def __str__(self):
return self.title

class Event(models.Model):
title = models.CharField(max_length = 150)
description = models.CharField(max_length = 150)
date = models.DateField(auto_now_add=True)
course =
models.ForeignKey(Course,on_delete=models.CASCADE,null=True,blank=True)
file = models.FileField(upload_to='notice/',null=True,blank=True)
def __str__(self):
return self.title

class Teacher(models.Model):
image = models.ImageField(upload_to='teacher/')
designation = models.CharField(max_length=150,null=True,blank=True)
name = models.CharField(max_length=150)
facebook = models.URLField(max_length=250)
gmail = models.URLField(max_length=250)
twitter = models.URLField(max_length=250)
27
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
linkedin = models.URLField(max_length=250)
description = models.TextField(null=True,blank=True)
is_show = models.BooleanField(default=False)
def __str__(self):
return self.name

class AboutUs(models.Model):
about = models.TextField()

class Meta:
verbose_name = 'About U'

def __str__(self):
return self.about

class TechnicalStaff(models.Model):
name = models.CharField(max_length=150)
image = models.ImageField(upload_to='user/staff/')
description = models.TextField()
facebook = models.URLField()
linkedin = models.URLField()
instagram = models.URLField()
twitter = models.URLField()

def __str__(self):
return self.name

class Gallery(models.Model):
image = models.ImageField(upload_to='media/gallery')

class WhatsappGroup(models.Model):
User = models.ManyToManyField(User,null=True,blank=True)
group_name = models.CharField(max_length=150)

def __str__(self):
return self.group_name

class WhatsappMessage(models.Model):
group = models.ForeignKey(WhatsappGroup, on_delete=models.CASCADE)
message = models.TextField()

def __str__(self):
return self.message

28
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
def save(self,*args,**kwargs):
for number in self.group.User.all():
pywhatkit.sendwhatmsg_instantly(number.phone_number,self.message,5,
tab_close=False)
super(WhatsappMessage,self).save(*args,**kwargs)

college/administrator/models.py

from django.shortcuts import render

from django.views import View
from .models import *
from django.utils.decorators import method_decorator
from django.contrib.auth.decorators import login_required

# Create your views here.

class CollegeNotice(View):

template_name = 'notice.html'

@method_decorator(login_required(login_url='/login'))
def get(self,request):
context = {
'notice':Notice.objects.all()
}
return render(request,self.template_name,context)

class CollegeAbout(View):

template_name = 'about.html'

@method_decorator(login_required(login_url='/login'))
def get(self,request):
context = {
'staff':TechnicalStaff.objects.all(),
'about':AboutUs.objects.first()
}
return render(request,self.template_name,context)

29
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
college/authenticate_user/admin.py

from django.contrib import admin

from .models import *
from student.models import *
from import_export.admin import ImportExportMixin

# Register your models here.

class UserQualification(admin.TabularInline):
model = StudentQualification
extra = 0

class UserResume(admin.TabularInline):
model = Resume
extra = 0

class UserAdmin(ImportExportMixin,admin.ModelAdmin):
inlines = [UserQualification, UserResume]
list_display =
['username','email','phone_number','is_superuser','is_staff','is_active']
list_filter =
['username','email','phone_number','is_superuser','is_staff','is_active']
search_fields =
['username','email','phone_number','is_superuser','is_staff','is_active']
list_editable = ['is_staff','is_active']
list_max_show_all = 10
list_per_page = 20

admin.site.register(User,UserAdmin)

@admin.register(ContactDetails)
class ContactDetailAdmin(ImportExportMixin,admin.ModelAdmin):
pass

@admin.register(Course)
class CourseAdmin(ImportExportMixin,admin.ModelAdmin):
pass

30
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
@admin.register(Addres)
class AddresAdmin(admin.ModelAdmin):
pass

@admin.register(Subscriber)
class SubAdmin(admin.ModelAdmin):
pass

college/authenticate_user/models.py

from django.db import models

from django.contrib.auth.models import AbstractUser, PermissionsMixin,
BaseUserManager
from django.utils.translation import gettext_lazy as _
# Create your models here.

class Course(models.Model):
image = models.ImageField(upload_to='course/',null=True,blank=True)
course_name = models.CharField(max_length=150)
date = models.DateField(auto_now_add=False,null=True,blank=True)
description = models.TextField(null=True,blank=True)
def __str__(self):
return self.course_name

class UserManager(BaseUserManager):

def create_users(self,username,email,first_name,last_name,password):
user = self.create_user(
username=username,
password=password
)
user.first_name = first_name
user.last_name = last_name
user.email = email
user.set_password(password)
user.is_active=False
user.save(using=self._db)
return user

def create_user(self,username,password):
user = self.model(username=username)
user.set_password(password)
user.save(using=self._db)
31
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
return user

def create_superuser(self,username,password):
user = self.create_user(username=username,password=password)
user.is_staff = True
user.is_active = True
user.is_superuser = True
user.save(using=self._db)
return user

class Addres(models.Model):
address = models.TextField()
city = models.CharField(max_length = 150)
state = models.CharField(max_length = 150)
zip = models.CharField(max_length = 150)

def __str__(self):
return self.address

class Meta:
verbose_name = 'User Addres'

class User(AbstractUser,PermissionsMixin):
profile_pic = models.ImageField(upload_to='profile/',null=True,blank=True)
username = models.CharField(_('username'),max_length=150,unique=True)
email = models.EmailField(null=True,blank=True)
course = models.OneToOneField(Course,
on_delete=models.CASCADE,null=True,blank=True)

phone_number = models.CharField(max_length=15,null=True,blank=True)
address =
models.ForeignKey(Addres,on_delete=models.CASCADE,null=True,blank=True)

objects = UserManager()
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = []

def __str__(self):
return self.username

def save(self,*agrs,**kwagrs):
super(User,self).save(*agrs,**kwagrs)

32
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM

class Resume(models.Model):
user = models.ForeignKey(User,
on_delete=models.CASCADE,related_name='resume')
resume = models.FileField(upload_to='resume/',null=True,blank=True)

def __str__(self):
return self.user.username

class Subscriber(models.Model):
subscribe = models.EmailField(max_length=150)

def __str__(self):
return self.subscribe

class ContactDetails(models.Model):
name = models.CharField(max_length = 150)
email = models.EmailField(max_length = 150)
subject = models.CharField(max_length = 150)
message = models.TextField()
contact = models.Manager()

class Meta:
verbose_name = 'Contact'

def __str__(self):
return self.name

college/authenticate_user/views.py

from django.shortcuts import render, redirect

from django.views import View
from django.contrib.auth import login, logout, authenticate
from .models import *
from django.http import *
from django.utils.decorators import method_decorator
from django.contrib.auth.decorators import login_required
from student.models import *
from administrator.models import *

33
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
class LoginUser(View):
template_name = 'login.html'

def get(self,request):
if request.user.is_authenticated:
return redirect('home')
else:
return render(request, self.template_name)

def post(self,request):
user = authenticate(
username=request.POST.get('username'),
password=request.POST.get('password')
)
if user:
login(request,user)
return redirect('home')
else:
context = {
'details':'Invalid Cridential'
}
return render(request, self.template_name,context)

def get_course_data(request):
course = Course.objects.get(id=request.GET.get('data'))
return HttpResponse(course.description)

class Home(View):
template_name = 'home.html'

def get(self,request):
course = Course.objects.all()[:3]
teachers = Teacher.objects.all()[:3]
notice = Notice.objects.all()[:5]
event = Event.objects.all()[:5]
context = {
'course':course,
'teachers':teachers,
'notice':notice,
'events':event,
'gallery1':Gallery.objects.all()[0:3],
'gallery2':Gallery.objects.all()[3:6],
34
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
'gallery3':Gallery.objects.all()[6:9],
'about':AboutUs.objects.first()
}
return render(request,self.template_name,context)

class Contact(View):
template_name = 'contact.html'

def get(self,request):
return render(request,self.template_name)

def post(self,request):
name = request.POST.get('name')
email = request.POST.get('email')
subject = request.POST.get('subject')
message = request.POST.get('message')

contact = ContactDetails.contact.create(
name=name,
email=email,
subject=subject,
message=message
)
return redirect('contact')

class Register(View):

def post(self,request):
User.objects.create_users(
username = request.POST.get('roll'),
password = request.POST.get('password'),
first_name = request.POST.get('first_name'),
last_name = request.POST.get('last_name'),
email = request.POST.get('email')
)
return redirect('home')

def logout_user(request):
logout(request)
return redirect('home')

class Profile(View):
35
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM

@method_decorator(login_required(login_url='/login'))
def get(self,request):
return render(request,'profile.html')

@method_decorator(login_required(login_url='/login'))
def post(self,request):
if request.FILES.get('profile_pic'):
request.user.profile_pic = request.FILES['profile_pic']

request.user.first_name = request.POST.get('first_name')
request.user.last_name = request.POST.get('last_name')
request.user.email = request.POST.get('email')
request.user.phone_number = request.POST.get('phone')
address = Addres(
address=request.POST.get('address'),
state=request.POST.get('state'),
city=request.POST.get('city'),
zip=request.POST.get('zip')
)
address.save()
request.user.address = address
request.user.save()
return redirect('profile')

class Qualification(View):

@method_decorator(login_required(login_url='/login'))
def get(self,request,id):
StudentQualification.objects.get(id=id).delete()
return redirect('profile')

@method_decorator(login_required(login_url='/login'))
def post(self,request):
course_type = request.POST.get('course_type')
course = request.POST.get('course')
grade = request.POST.get('grade')
session = request.POST.get('session')
institute = request.POST.get('institute')
university = request.POST.get('university')
qualification = StudentQualification.objects.create(
user=request.user,
36
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
course_type=course_type,
course_name=course,
grades=grade,
session=session,
institute=institute,
university_name=university
)
return redirect('profile')

class Dashboard(View):
template_name = 'dashboard.html'

@method_decorator(login_required(login_url='/login'))
def get(self,request):
return render(request, self.template_name)

class ProfileView(View):

def get(self,request):
return render(request,'profile_preview.html')

class GalleryView(View):

def get(self,request):
context = {
'gallery':Gallery.objects.all()
}
return render(request,'gallery.html',context)

class NoticeView(View):

def get(self,request):
context = {
'notice':Notice.objects.all()
}
return render(request,'notices.html',context)

37
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
class EventView(View):

def get(self,request):
context = {
'event':Event.objects.all()
}
return render(request,'event.html',context)

def post(self,request):
Subscriber.objects.create(
subscribe=request.POST.get('newsletter')
)
return redirect('home')

college/human_resource/admin.py

from django.contrib import admin

from .models import *
from import_export.admin import ImportExportMixin
# Register your models here.

@admin.register(Job)
class JobAdmin(ImportExportMixin,admin.ModelAdmin):
pass

@admin.register(SendMail)
class SendMailAdmin(ImportExportMixin,admin.ModelAdmin):
pass

@admin.register(TraningApplication)
class TableApplicationAdmin(admin.ModelAdmin):
model = TraningApplication
extra = 0

class TableAdmin(admin.TabularInline):
model = Traning
extra = 0

@admin.register(TraningCategory)

38
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
class AdminTraning(admin.ModelAdmin):
inlines = [TableAdmin]

college/human_resource/models.py

from django.db import models

from authenticate_user.models import User
from django.template.defaultfilters import slugify
from django.db import transaction
from django.conf import settings
from django.core.mail import send_mail
from django.db.models.signals import post_save
from authenticate_user.models import User
from django.dispatch import receiver
from ckeditor_uploader.fields import RichTextUploadingField
from django.core.mail import EmailMessage

# Create your models here.

class Job(models.Model):
title = models.CharField(max_length=150)
slug = models.SlugField(max_length = 150,null=True,blank=True)
course = models.CharField(max_length=150)
requred_grades = models.CharField(max_length=150)
company_name = models.CharField(max_length=150)
description = models.TextField()
is_active = models.BooleanField(default=True)

class Meta:
verbose_name = 'Available Job'

def save(self,*args,**kwargs):
user =
User.objects.values("email").filter(is_staff=False).filter(is_superuser=False)
lt = []
for user in user:
lt.append(user['email'])

39
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
send_mail("New Job Available","New Job Has Been Posted \nCheck Out
Now.\n[SSM College Training &
Placement]\nParihaspora,Pattan",settings.EMAIL_HOST_USER,lt)
self.slug = slugify(self.title)
super(Job, self).save(*args,**kwargs)

def __str__(self):
return self.title

class SendMail(models.Model):
title = models.CharField(max_length = 150)
user = models.ForeignKey(User,
on_delete=models.CASCADE,null=True,blank=True)

description = RichTextUploadingField(blank=True)

def __str__(self):
return self.title

def save(self,*args,**kwargs):
super(SendMail,self).save(*args,**kwargs)

@receiver(post_save, sender=SendMail)
def send_mail_to_subs(sender, instance, created, **kwargs):
lt = []
lt.append(instance.user.email)
html_template = instance.description
message = EmailMessage(instance.title, html_template,
settings.EMAIL_HOST_USER, lt)

message.content_subtype = 'html'
message.send()
#send_mail(instance.title,instance.description,settings.EMAIL_HOST_USER,lt)

class TraningCategory(models.Model):
name = models.CharField(max_length = 150)

def __str__(self):
return self.name
40
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM

class Meta:
verbose_name = 'Traning'

class Traning(models.Model):
title = models.CharField(max_length = 150)
course_image = models.ImageField(upload_to='course/image/')
zoom_url = models.URLField(max_length = 200)
category = models.ForeignKey(TraningCategory, on_delete=models.CASCADE)
course = models.CharField(max_length=150)
description = models.TextField()
is_active = models.BooleanField(default=True)

def __str__(self):
return self.title

class TraningApplication(models.Model):
user =
models.ManyToManyField(User,related_name='user_traning',null=True,blank=True)
traning = models.ForeignKey(Traning, on_delete=models.CASCADE)
start_date = models.DateTimeField(auto_now=False, auto_now_add=False)
end_date = models.DateTimeField(auto_now=False, auto_now_add=False)
is_active = models.BooleanField(default=True)
def __str__(self):
return self.traning.title

def save(self,*args,**kwargs):
user =
User.objects.values("email").filter(is_staff=False).filter(is_superuser=False)
lt = []
for user in user:
lt.append(user['email'])

send_mail("New Training Available","New Training Has Been Posted

\nCheck Out Now.\n[SSM College Training &
Placement]\nParihaspora,Pattan",settings.EMAIL_HOST_USER,lt)
super(TraningApplication, self).save(*args,**kwargs)

class Meta:
verbose_name = 'Traning Application'

41
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
college/student/models.py

from django.db import models

from human_resource.models import *
from authenticate_user.models import User
# Create your models here.

status = (
("PENDING","PENDING"),
("SELECTED","SELECTED"),
("REJECTED","REJECTED"),
)

class ApplyForJob(models.Model):
user = models.ForeignKey(User,
on_delete=models.CASCADE,null=True,blank=True,related_name='user_jobs')
job = models.ForeignKey(Job,
on_delete=models.CASCADE,null=True,blank=True,related_query_name='job_in')
date = models.DateField(null=True,blank=True)
interview_start_time = models.TimeField(null=True,blank=True)
interview_end_time = models.TimeField(null=True,blank=True)
application_status = models.CharField(max_length =
150,choices=status,default="PENDING")

class Meta:
verbose_name = 'Job Application'

COURSE_TYPE = (
('10','10'),
('12','12'),
('GRADUATE','GRADUATE'),
('POST-GRADUATE','POST-GRADUATE'),
)

class StudentQualification(models.Model):
user = models.ForeignKey(User, on_delete=models.CASCADE,
related_name='user_qulification')
course_type =
models.CharField(max_length=150,choices=COURSE_TYPE,null=True,blank=True)
course_name = models.CharField(max_length=150)
42
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
grades = models.FloatField()
session = models.CharField(max_length=150)
institute = models.CharField(max_length=150)
university_name = models.CharField(max_length=150)

def __str__(self):
return self.user.username

college/student/views.py

from django.shortcuts import render, redirect

from django.views import View
from .models import ApplyForJob
from authenticate_user.models import *
from human_resource.models import *
from django.db.models import Q
from authenticate_user.models import *
from django.utils.decorators import method_decorator
from django.contrib.auth.decorators import login_required

class UserResume(View):
@method_decorator(login_required(login_url='/login'))
def get(self,request,id):
Resume.objects.get(id=id).delete()
return redirect('profile')

@method_decorator(login_required(login_url='/login'))
def post(self,request):
resume = request.FILES.get('resume')
Resume.objects.create(
user=request.user,
resume=resume
)
return redirect('profile')

class AllJobs(View):

template_name = "all_jobs.html"

@method_decorator(login_required(login_url='/login'))
def get(self,request):
try:
43
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
grade =
request.user.user_qulification.filter(course_type='GRADUATE').first().grades
all_jobs =
Job.objects.exclude(id__in=request.user.user_jobs.values('job__id').all()).filt
er(requred_grades__lte=grade)
context = {
'jobs':all_jobs
}
return render(request,self.template_name,context)
except:
return render(request,self.template_name)

class StudentJob(View):

template_name = 'student_job.html'

@method_decorator(login_required(login_url='/login'))
def get(self,request):
return render(request,self.template_name)

class ApplyJob(View):

@method_decorator(login_required(login_url='/login'))
def get(self,request,id):
ApplyForJob.objects.create(
user=request.user,
job_id=id
)
return redirect('all_jobs')

class Chat(View):

template_name = 'chat.html'

@method_decorator(login_required(login_url='/login'))
def get(self,request):
user = User.objects.exclude(id=request.user.id)
context = {
'user':user
}
return render(request,self.template_name,context)

class ChatUser(View):

44
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
template_name = 'chat.html'

@method_decorator(login_required(login_url='/login'))
def get(self,request,id):
get_user = User.objects.get(id=id)
user = User.objects.exclude(id=request.user.id)

context = {
'get_user':get_user,
'user':user
}
return render(request,self.template_name,context)

class PlacementTraning(View):

template_name = 'placement_traning.html'

@method_decorator(login_required(login_url='/login'))
def get(self,request):
traning = Traning.objects.all()
train =
TraningApplication.objects.exclude(user=request.user).filter(traning__is_active
=True)
context = {
'cat':train.values('traning__category__name','traning__title','tran
ing__course').distinct(),
'traning':train.values('traning__id','traning__title','traning__cou
rse_image','traning__course','traning__category__name','traning__description')
}
return render(request,self.template_name,context)

@method_decorator(login_required(login_url='/login'))
def post(self,request):
id = request.POST.get('train-id')
train = TraningApplication.objects.get(id=id)
train.user.add(request.user)
return redirect('placement')

class TraningInfo(View):
template_name = 'traning_info.html'

45
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
@method_decorator(login_required(login_url='/login'))
def get(self,request,id):
train = TraningApplication.objects.get(id=id)
context = {
'train':train
}
return render(request,self.template_name,context)

class PdfDownload(View):

def get(self,request):
pass

college/manage.py

#!/usr/bin/env python
"""Django's command-line utility for administrative tasks."""
import os
import sys

def main():
"""Run administrative tasks."""
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'college.settings')
try:
from django.core.management import execute_from_command_line
except ImportError as exc:
raise ImportError(
"Couldn't import Django. Are you sure it's installed and "
"available on your PYTHONPATH environment variable? Did you "
"forget to activate a virtual environment?"
) from exc
execute_from_command_line(sys.argv)

if __name__ == '__main__':
main()

46
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
college/requirements.txt

asgiref==3.5.2
async-timeout==4.0.2
beautifulsoup4==4.11.1
certifi==2022.9.24
channels==4.0.0
channels-redis==4.0.0
charset-normalizer==2.1.1
click==8.1.3
colorama==0.4.6
defusedxml==0.7.1
diff-match-patch==20200713
dj-database-url==1.0.0
Django==4.1.4
django-admin-interface==0.23.0
django-ckeditor==6.5.1
django-colorfield==0.8.0
django-flat-responsive==2.0
django-flat-theme==1.1.4
django-heroku==0.3.1
django-import-export==3.0.1
django-jazzmin==2.6.0
django-js-asset==2.0.0
et-xmlfile==1.1.0
Flask==2.2.2
gunicorn==20.1.0
idna==3.4
itsdangerous==2.1.2
Jinja2==3.1.2
MarkupPy==1.14
MarkupSafe==2.1.1
MouseInfo==0.1.3
msgpack==1.0.4
odfpy==1.4.1
openpyxl==3.0.10
Pillow==9.3.0
psycopg2==2.9.5
PyAutoGUI==0.9.53
PyGetWindow==0.0.9
PyMsgBox==1.0.9
pyperclip==1.8.2
PyRect==0.2.0
PyScreeze==0.1.28
python-dotenv==0.21.0

47
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
pytweening==1.0.4
pywhatkit==5.4
PyYAML==6.0
redis==4.4.0
requests==2.28.1
six==1.16.0
soupsieve==2.3.2.post1
sqlparse==0.4.3
tablib==3.2.1
tzdata==2022.7
urllib3==1.26.13
Werkzeug==2.2.2
whitenoise==6.2.0
wikipedia==1.4.0
xlrd==2.0.1
xlwt==1.3.0

48
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
4.2 OUTPUT/SCREENSHOTS
The following pages will depict the working of the system through the screenshots taken at the
time of adding the data into the system.
The user is presented with the homepage whenever he/she is accessing the web
application. It is presented with a student log-in and a faculty log-in. Also, a
registration tab is provided so that the students and faculty can first register
themselves to use the system.

Homepage of E-Campus Training and Placement System.

For the registration process for both students and faculty a form is displayed wherein
the user must enter his/her required details.

49
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM

Registration Page Of E-Campus Training and Placement System

Login Page for the student

50
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM

Login Page for the admin

Student Dashboard which contains the necessary details of the student such as his/her profile,
jobs , placement and trainings etc.

51
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM

Available jobs: Based on their skills/interest, student can apply for jobs and based on the
criteria given by the company they can get placed in the specific job. Student can get a track of
the job whether they are selected, rejected or it is pending yet.

52
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM

Avaliable Trainings Student can develop their skills and knowledge by applying for trainings.
Here any student can apply for training irrespective of their marks or skills.

Notices and Events displays the information regarding the campus any event or notice on the
homepage to the users.

53
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM

Shows the Admin Panel 1

Shows the Admin Panel 2

54
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM

Student Profile: Here the student has to fill the details like name , address etc . This
personal information is required to be filled by the student.

Resume Generation: After filling the personal details resume will be generated
55
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
automatically as a pdf and saved in the system.

CHATBOT SYSTEM

56
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM

Mobile optimized: Students can also access the website from mobile devices
and can have an user friendly experience .

57
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM

Email Notification: Students can get email notications of trainings, applied jobs.

Data Import Export Facility : Here the data can be imported or exported in different ways
like in csv format or excel or xsl etc.

58
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM

This figure shows the courses that can be added.

59
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
This figure shows the email facility of the system where the admin can send the email
regarding the trainings and jobs to the users.

Trainings Applications where the information related to the trainings can be added like the
validity of the training etc.

60
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM

Whatsapp Messages: Here basically message can be send to a particular user or

a group of users.

Job Application: Here the admin can add the related job details like the start and
end time date and time and also change the status of the user who have applied
61
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM
for that specific job like pending, selected or rejected.

62
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM

CHAPTER 5
CONCLUSION
The website “E-Campus training and placement” has been developed to provide
an easier way to students to register themselves for the training and placements. It
also reduces the loads of tedious work of training and placement officer by
automatically maintaining a centralized database of all students when they
register online.so the TNP officer can easily update the training and placement
status of each student and the same can be displayed online.

63
COMPUTER SCIENCE ENGINEERING
E-CAMPUS TRAINING & PLACEMENT SYSTEM

CHAPTER 6
REFERENCES
[1] Suraj Trimukhe, Anil Todmal, Kanchan Pote, Monali Gite, Asstt. Prof. S.S. Pophale “Online Training and
Placement System (IRJET)” Department of Information Technology, D.V.V.P.C.O.E.A., Ahmednagar,
Maharashtra, India, International Journal of Advanced Research in Computer Science and Software Engineering,
Volume 7, Issue 4, April 2017

[2] S. R. Bharamagoudar, R. B. Geeta, and S. G. Totad, “Web based student information management system,”
International Journal of Advanced Research in Computer and Communication Engineering, vol. 2, issue 6, pp.
2342-2348, 2013.

[3] Tejashri Gosavi, Shraddha Gaikwad, ANDROID BASED TRAINING AND PLACEMENT AUTOMATION,
Department of Computer Engineering, JSPM’s ICOER , Wagholi , Pune , India.

[4] S. K. Thangavel, P. D. Bkaratki and A. Sankar, "Student placement analyzer: A recommendation system using
machine learning," 2017 4th International Conference on Advanced Computing and Communication Systems
(ICACCS), 2017, pp. 1-5, doi: 10.1109/ICACCS.2017.8014632

[5] Santhosh Kumar H, Mrs. Srividhya V R, “Online Training and Placement Management System” ICACT -
2016 Conference Proceedings, Volume 4, Issue 22.

[6] A. S. Kendle, M. S. Nagare, H. G. Patre, R. S. Zanwar, V. G. Kottawar and P. B. Deshmukh, "TnP Vision:
Automation and Analysis of Campus Placements in Colleges," 2021 5th International Conference on Computer,
Communication and Signal Processing (ICCCSP), 2021.

[7] Ajeena Sunny, Aneena Felix, Angelin Saji, Christina Sebastian, Praseetha V.M, “Placement Management
System for Campus Recruitment” , May-2020 International Journal of Innovative Science and Research
Technology Volume5,Issue- 5.

[8] Spoorthi MS, Kavana V, Koushik SN, Veena M, “A Review on Placement Management System”, July 2021,
International Journal of Creative Research Thoughts(IJCRT), Volume-9,Issue-7.

[9] Romero, Cristóbal, and Sebastian Ventura. "Educational data mining: A survey from 1995 to 2005." Expert
systems with applications 33, no. 1 (2007): 135-146.

[10] Kabakchieva, Dorina. "Predicting student performance by using data mining methods for classification."
Cybernetics and Information Technologies 13, no. 1 (2013): 61-72

64
COMPUTER SCIENCE ENGINEERING