Professional Documents
Culture Documents
ERP Espresso
ERP Espresso
ESPRESSO
CHIRAG KATHPALIA
B.TECH. – CSE 7th Sem
Reg. No:191380195
(College Of Engineering)
This is to certify that the work being presented in the Major project entitled
“ESPRESSO” submitted by undersigned student of Bachelor of Technology in
Computer Science Engineering to Maharishi Dayanand University (MDU),
Rohtak-124001, Haryana in the fulfilment for award of semester 7th is a record
of my own work carried out by me under guidance and supervision of concerned
faculty and staff of the college. I certify the content of this work has not submitted
elsewhere for award of any other degree.
CHIIRAG KATHPALIA
191380195
8 Flowchart 17
9 Requirements 18
Hardware 18
Software 18
18
Language
19
Libraries
10 Procedures, Codes and UI 21
Installation 21
views 22
24
urls.py
28
settings.py
29
models.py
30
database 31
templates 32
39
UI
11 References 40
ERP stands for Enterprise Resource Planning. ERP for colleges are ERP solutions
that are created specifically to cater to the needs of colleges. Educational
institutions, in general, are in need of ERP software for the simple reason that
they have specific managerial needs. The management of an educational
institution is a complex affair that involves several departments working together
in tandem.
It’ll also facilitate keeping all the records of students, such as their id, name,
mailing address, phone number, DOB etc. So all the information about a student
will be available in a few seconds.
Overall, it’ll make Student Information an easier job for the administrator and the
student of any organization. The main purpose of this project is to illustrate the
requirements of the project College Information Management System and is
intended to help any organization to maintain and manage personal data.
This reduces data error and ensures that information is always up-to-date
throughout the college. It provides a single source of data repository for
streamlining your processes and for all reporting purposes. It has a simple user
interface and is intuitive. This insures that the users spend less time in learning
the system and hence, increase their productivity. Efficient security features
provide data privacy and hence, increase their productivity
In the past we used to collect all the data in files and pages which were hard to
maintain and were also difficult to access, also there was the problem of
redundant data and lots of time used to get wasted in sorting, we had to make a
storage room where all the files needed to be maintained in order so we could
easily access it.
It used to take a lot of time and lots of effort. Then we started to maintain the
same things in our computers for easy accessibility and less effort, it is also a very
time taking thing and also the problem of redundancy still stands.
In addition to that it's hard if we want to remove or edit anything from the
required data as it can create a mess with the order of things and also can take a
lot of time to maintain it back. And the accessibility from everyone is still a bigger
hole which is needed to be filled, because everyone is unable to access the data
and every time they want to know something they have to enquire from the
administration which creates a lot of ruckus for both users and Admin.
In today’s world, where all teaching, learning, and grading are online, the ERP
could act as a facilitator for the teacher, replacing most physical tasks with the
clicks of buttons. Sharing lesson plans, course materials, and grades are easier
with an ERP platform. Most data captured from students are recorded for future
reference and the risks of human error are reduced to a minimum.
Additionally, educators can access specific student data across departments that
will help them understand the student journey better and provide personalized
learning experiences. For example, enrolments in extra-curricular courses, etc. As
educators, the onus of delivering lessons per the curriculum is made easier with
an ERP platform and tracking progress is faster. The other uses of an ERP to the
educator are:
Student
If used well, a good ERP solution eases the learning process for the student. The
shift to virtual classrooms has not been easy for some students, even though they
are considered to be digital natives. With automated assignment reminders,
lesson query resolutions, submissions, and grades, the process of interaction with
the teachers is made easy.
Following are the must have functioning features for college ERP
System:
1. Attendance management
2. Staff Management and Supervision
3. Fees Management and Accounting
4. Time Table or Schedule Management
5. Library Management
6. Exams Management
7. Performance monitoring for Parents
8. SMS and Email Alert
If you are an institute looking for implementing ERP, you should take a look at
all the options available and check what they have to offer. The best way to
know about it is by listening to what the software company has to present.
The management, as well as employees, should be present to know the
features of ERP software.
The team should check functionality of the software and see if it is suitable to
cater to their daily activities and processes. The team should list down if
anything is missing or if they need any customizations in the system.
2. ERP Installation
Once you have checked all the available options, choose the one which is best
suited for your institute. The choice should be made based on all the details
and statistics that are gathered by the team during the demonstration.
The employees and faculty members of the institute work on the system to
understand how it functions. They try to carry out the normal processes using
the system and then decide if it is the right fit for the institute or they need
any changes.
3. Analysing Problems
4. Making Customizations
If there are any minor changes to be made in the system, they are taken care
of by the software providers as soon as they are addressed. But in case of
major changes, there is a requirement of written approval by the institute.
These include customizations that need changes in the codes of the software.
The software is made in such a way that it fits clean with the existing
processes of the institute. The software providers make sure that no function
is disturbed. They put several teams to work for faster results.
Sample data is tested on the system by various teams. Everyone’s comfort for
the usage of the system is considered before approving any aspect of the ERP
software. The live reports of tests are generated and presented to the
institute. If there are any problems, they are solved there and then
themselves. The institute operates the system to see if they understand its
operability level.
They make sure that the system is fully functional and easy to use for their
employees. After taking approval from all the departments, the software is
approved by the institute.
The client decides whether they want a cloud ERP or an on-premise system.
They can choose the one which is best suitable for their requirements.
After the approval of the system, the real data of the institute is imported into
the system and it is made ready to use for the institute. The module is made
live. Login credentials are shared with the employees and they can begin their
work using the ERP software.
The head of department is a part of the teaching staff but has special privileges. They
manage the operations of each department. The HOD could still conduct courses for
students. So, they will have all the features given to a teacher. Also, as the HOD, they
will have access to the records of every teacher, courses, students who belong to the
same department.
Teachers
Teachers are the key stakeholders of the college ERP. Because they are the one who
manage, edit, update the contents of the database of students such as attendance,
internal marks, CGPA etc...It also helps them to assign their class to other teachers when
they are on leave. This makes it easier to identify who among them are free to take the
class at that time. So this software help them reduce their overhead and make their
tasks easier and simple.
Students
Students are end users of ERP software. The attendance, internals marks uploaded by
the teachers are viewed by students. It helps them track their attendance status. It also
helps them to communicate with teachers and their classmates. So students make up
another set of stakeholders of this software.
Administrator
College administrator is responsible for maintaining the database of the college. They
will have the privilege to modify the database i.e., to add/remove
students/teachers/staff, update information regarding each of these. It is their
responsibility to maintain the database of students who pass out from the college and
who freshly get admission to the college. So the Administrator play a major role in the
ERP.
HOD viewpoint
For HOD, they can view, add and edit all the information about teacher’s and student’s,
Courses, batches, subjects, etc. Hod can also approve staff leave’s.
Teacher’s viewpoint
For a teacher, this software must be easy to use. It should be easy to find different
modules like attendance, leave module, internals marks, result etc...Teachers are the
one who update the contents of the student’s database.
Student’s viewpoint
A student can only view the information about himself, other than that everything will
be hidden from them. They will not have the option to edit anything. So the graphical
user interface must be good. They expect it to be functional.
Administrator’s viewpoint
Administrator will have the privilege to view all the information about the college. They
will have the option to track goals like, Average marks of all the students in a subject,
Average attendance of all the students of a class etc...
1. Hardware Requirement
i. 4 systems (4 GB RAM, 25 GB storage, 1.6Ghz processor)
ii. Clouds server for database
iii. Hosting, domain & SSL Certification
2. Software Requirement
i. PyCharm
ii. Postgres Stack builder
iii. VS code
iv. PostgreSQL
v. Amazon S3 bucket
vi. Heroku
3. Languages Used
i. Frontend (HTML, CSS, JS, tailwind, bootstrap)
ii. Backend (Java, Python (Django, Rest, Postman))
iii. Database (SQL, Python)
iv. Server-side languages (Python, JavaScript)
i. Django==4.1.1
Django is a web development python framework that makes it
easy to build powerful web applications.
ii. django-binary-database-files==1.0.17
This is a storage system for Django that stores uploaded files in
binary fields in the database.Files can be served from the database
(usually a bad idea), the file system, or a CDN.
iii. django-imagekit==4.1.0
ImageKit is a Django app for processing images
iv. djangorestframework==3.13.1
Django REST framework is a powerful and flexible toolkit for
building Web APIs.
v. easygui==0.98.3
EasyGUI is a module for very simple, very easy GUI programming in
Python
vi. mysql-connector-python==8.0.30
Python needs a MySQL driver to access the MySQL database
viii. redmail==0.4.1
Red Mail is an advanced email sender library. It is a sister library for
Red Box, advanced email reader.
ix. sqlparse==0.4.2
sqlparse is a non-validating SQL parser for Python. It provides support
for parsing, splitting and formatting SQL statement.
def dologin(request):
if request.method != 'POST':
return HttpResponse("<h1>Error 404</h1>")
else:
user = EmailBackend.authenticate(request,
username=request.POST.get("email"),
password=request.POST.get("password"))
if user != None:
login(request, user)
user_type= user.user_type
if user_type == '1':
return HttpResponseRedirect('/adminhome')
elif user_type == '2':
pass
elif user_type == '3':
return HttpResponseRedirect('/studenthome')
else:
messages.error(request, "Email and password are
not identified")
return render('loginpage')
# return HttpResponse("Email :" +
request.POST.get("email") + ", Password :" +
request.POST.get("password"))
else:
messages.error( request, "Invalid Login Details")
return HttpResponseRedirect("/")
def userdetails(request):
def dologout(request):
logout(request)
return HttpResponseRedirect("/")
# def temp(req):
# return render(req, "base.html")
@login_required(login_url='/')
def userprofile(request):
return render (request, 'profile.html')
@login_required(login_url='/')
def editprofile(request):
user= CustomUser.objects.get(id= request.user.id)
# print(user)
context= {
"user":user,
}
return render(request, "editprofile.html", context)
@login_required(login_url='/')
def updateprofile(request):
if request.method == "POST":
profile_pic= request.FILES.get('profile_pic')
first_name= request.POST.get('first_name')
last_name= request.POST.get('last_name')
# email= request.POST.get('email')
# username= request.POST.get('username')
password= request.POST.get('password')
# aboutme= request.POST.get('about')
# print(profile_pic, first_name, last_name, password,
email, username)
try:
customuser = CustomUser.objects.get(id =
request.user.id)
customuser.first_name = first_name
customuser.last_name= last_name
# customuser.username = username
# customuser.email = email
if password != None and password != "":
customuser.set_password(password)
@login_required(login_url='/')
def addstudent(request):
course = Courses.object.all()
session = Session.object.all()
if request.method == 'POST':
profile_pic = request.FILES.get('profile_pic')
first_name = request.POST.get('first_name')
last_name = request.POST.get('last_name')
email = request.POST.get('email')
address = request.POST.get('address')
username = request.POST.get('username')
password_var = request.POST.get('password')
gender_var = request.POST.get('gender')
course_selected = request.POST.get('course')
# session_selected =
request.POST.get('session')
if
CustomUser.objects.filter(email=email).exists():
messages.warning(request, "email exists
for another user")
return redirect('addstudent')
if
CustomUser.objects.filter(username=username).exists():
messages.warning(request, "email exists
for another user")
return redirect('addstudent')
else:
user = CustomUser(
user.set_password(password_var)
user.save()
course_var =
Courses.object.get(id=course_selected)
# session_var =
Session.object.get(id=session_selected)
student = students(
admin=user,
address=address,
# session_id = session_var,
course_id=course_var,
gender=gender_var
)
context = {
"course": course,
'session': session,
}
return render(request, 'hod/addstudent.html',
context)
@login_required(login_url='/')
def addstaff(request):
return render(request, 'hod/addstaff.html')
@login_required(login_url='/')
@login_required(login_url='/')
def addcourse(request):
return render(request, 'hod/addcourse.html')
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
# 'livereload',
'django.contrib.staticfiles',
'Esetup'
TEMPLATES = [
{
'BACKEND':
'django.template.backends.django.DjangoTemplates',
'DIRS': [os.path.join(BASE_DIR, 'templates')],
'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',
],
},
},
]
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': 'sms',
'USER': 'postgres',
'PASSWORD': 'root',
'HOST': '127.0.0.1',
'PORT': '5432',
}
}
#teacher function
path('staffhome', staffviews.studenthome, name='staffhome'),
]
urlpatterns += static(settings.MEDIA_URL,
document_root=settings.MEDIA_ROOT)
urlpatterns += static(settings.STATIC_URL,
document_root=settings.STATIC_ROOT)
class CustomUser(AbstractUser):
user_data = ((1, "Hod"), (2, "staff"), (3, "student"))
user_type = models.CharField(default=1, choices=user_data,
max_length=10)
# gender_data = ((1, "Male"), (2, "Female"))
# user_gender = models.CharField(default = 1, choices=
gender_data, max_length= 10)
# user_address= models.CharField(default ="Not defined",
max_length= 300)
display_pic= models.ImageField(default= "",
upload_to='displaypic')
class students(models.Model):
id = models.AutoField(primary_key=True)
admin = models.OneToOneField(CustomUser,
on_delete=models.CASCADE)
address = models.TextField()
gender = models.CharField(max_length=255)
course_id = models.ForeignKey(Courses,
on_delete=models.DO_NOTHING)
created_at = models.DateTimeField(auto_now=True)
updated_at = models.DateTimeField(auto_now=True)
objects = models.Manager()
class attendence(models.Model):
id = models.AutoField(primary_key=True)
Student_id = models.ForeignKey(students,
on_delete=models.DO_NOTHING)
attendence_date = models.DateTimeField(blank=True)
created_at = models.DateTimeField(blank=True)
updated_at = models.DateTimeField(blank=True)
objects = models.Manager(
{% extends "commonbase.html" %}
{% block content %}
<div class="page-header">
<div class="row">
<div class="col-sm-12">
<h3 class="page-title">Welcome
<span>{{user.first_name}} {{user.last_name}}</span></h3>
<ul class="breadcrumb">
<li class="breadcrumb-item active">Dashboard</li>
</ul>
</div>
</div>
</div>
<div class="row">
<div class="col-xl-3 col-sm-6 col-12 d-flex">
<div class="card bg-one w-100">
<div class="card-body">
<div class="db-widgets d-flex justify-content-
between align-items-center">
<div class="db-icon">
<i class="fas fa-user-graduate"></i>
</div>
<div class="db-info">
<h3>45</h3>
<h6>Students</h6>
</div>
</div>
</div>
</div>
</div>
<div class="col-xl-3 col-sm-6 col-12 d-flex">
<div class="card bg-two w-100">
<div class="card-body">
<div class="db-widgets d-flex justify-content-
between align-items-center">
<div class="db-icon">
<i class="fas fa-crown"></i>
</div>
<div class="db-info">
<h3>8+</h3>
<h6>Awards</h6>
</div>
</div>
</div>
1. https://stackoverflow.com/
2. https://www.w3schools.com/
3. https://getbootstrap.com/