Covid-19 Hospital Management System
Covid-19 Hospital Management System
Covid-19 Hospital patient management, system will full and advanced features. Hospital
Management System is a web application for the hospital which manages doctors and
patients. In this project, we use Python Django and SQLite database. A responsive web-app
with aesthetic and accessible UI for managing COVID patients of a certain hospital built
using Django and Bootstrap framework. Clean aesthetic User Interface, which changes
dynamically as per the status of patient changes. In bed availability grid the red color
indicates that bed is occupied else available. It is one of the two pages available for public to
view. Here you can add patient for storing it to the db. Patient's relative contact details are
also taken to check if the relative has contacted COVID virus. Bed numbers which are
available are only shown. Information filled here, will make changes in dashboard
dynamically. Since there are relatively more COVID patients than any other viruses/diseases,
a checklist for COVID symptoms only is present. Here you can search patients wrt to name,
bed no. doctor assigned and status. You Capacity concerns emerged as hospitals anticipated
being overwhelmed if they experienced a surge of patients, who may require special beds and
rooms to treat and contain infection. Many hospitals reported that post-acute-care facilities
were requiring negative COVID-19 tests before accepting patients discharged from hospitals,
meaning that some patients who no longer required acute care were taking up valuable bed
space while waiting to be discharged. Also find update button to update the patient details.
This is where the actual updates for individual patients are done Seat Management.
Equipment Management. Oxygen Management. Doctor Management. Daily Patient Routine
Checkup .Hospital capacity, including information on ICU capacity and available ventilators.
Staffing levels, including any shortages. How many patients are coming into the hospital with
confirmed or suspected COVID-19 cases, many other relevant details that public health
officials need to properly coordinate COVID responses.
working in the organization will be well planned and organized. The level of accuracy in the
proposed system will be higher.
2. SYSTEM STUDY
2.1 INTRODUCTION
All activities associated with each life cycle phase must be performed, managed and
documented. Hence, we define system analysis as the performance, management,
documentation of the activities related to the life cycle phases of a computer-based business
system. In the study phase a detailed study of the project is made and clear picture of the
project is in mind. In the design phase the designing of the input, output and table designs are
made. Development phase is where the physical designing of the input-output screens and
coding of the system is done. System implementation actually implements the system by
making necessary testing.
Hospitals currently use a manual system for the management and maintenance of critical
information. The current system requires numerous paper forms, with the data stores spread
throughout the hospital management infrastructure. Often information (on forms) is
incomplete, or does not follow management standards. Forms are often lost in transit between
department requiring a comprehensive auditing process to ensure that no vital information is
lost multiple copies of the same information exist in the hospital and may lead to
inconsistencies in data various data stores.
Covid -19 hospital management system is designed for any hospital to replace their existing
manual, paper based system. The new system is control the following information room
availability, staff and operating room schedules, and patient invoices. The service are to be
provided in an efficient, cost effective manner, with the goal of reducing the time and
resources currently required for such tasks.
3. PROBLEM ANALYSIS
1. Economic Feasibility
2. Behavioral Feasibility
3. Technical Feasibility
4. Operational Feasibility
5. Legal Feasibility
To be judged feasible, a proposal for the specific project must pass all these tests, otherwise it
is not considered as a feasible project. I gathered the details regarding the financial aspects
incorporated in the system to make it cost efficient.
There are a number of technical issues, which are generally raised during
the feasibility stage of the investigation. A study of function, performance and constraints
gave me the ability to achieve acceptable system. The software required for this system is:
PYTHON
SQLite
Suppose for a moment that technical and economic resources are both
judged adequate. The systems analyst must still consider the operational feasibility of the
requested project. Operational feasibility is dependent on human resources available for the
project and involves projecting whether the system will operate and be used once it is
installed. If users are virtually wed to the present system, see no problems with it, and
generally are not involved in requesting a new system, resistance to implementing the new
system will be strong. Chances for it ever becoming operational are low.
1. within the organization: How the project is to be implemented? What are various
constraints? What is market strategy?
2. With respect to the customer: Weekly or timely meetings with the customer with
presentations on status reports. Customer feedback is also taken and further modifications
and developments are done. Project milestones and deliverables are also presented to the
customer. For a successful project the following steps can be followed:
4. REQUIREMENT ENGINEERING
4.1 INTRODUCTION
Requirement analysis involves studying the current system to find out how
it works and where improvements could be made. A clear idea about the existing system is a
must for making improvements where it is required. Proper planning and collection of data
serves the purpose. The popularity of this document is to describe all the requirements for the
popularity of the website for Covid-19 Hospital Management System. This website gives all
the information for a person. In our busy life, we cannot go to each department or offices.
This problem will manage this site. It will help to avoid in correction and missing data.
HARDWARE REQUIREMENTS:
CPU - 1.8 GHz or faster processor
HARD DISK SPACE - Minimum 160GB
RAM - 2GB or more
Python is a widely used general-purpose, high level programming language. It was created by
Guido van Rossum in 1991 and further developed by the Python Software Foundation. It was
designed with an emphasis on code readability, and its syntax allows programmers to express
their concepts in fewer lines of code.
Python is a programming language that lets you work quickly and integrate systems more
efficiently.
There are two major Python versions: Python 2 and Python 3. Both are quite different.
Python is not that complex! It is a high-level dynamic programming language and is quite
easy to learn. Python code has a very ‘natural’ style to it, which makes it easy to read and
understand. The Python programming language is freely available and makes solving a
computer problem almost as easy as writing out your thoughts about the solution. The code
can be written once and run on almost any computer without needing to change the program.
Why Python?
Python works on different platforms (Windows, Mac, Linux, Raspberry Pi, etc).
Python has a simple syntax similar to the English language.
Python has syntax that allows developers to write programs with fewer lines than
some other programming languages.
Python runs on an interpreter system, meaning that code can be executed as soon as it
is written. This means that prototyping can be very quick.
Python can be treated in a procedural way, an object-orientated way or a functional
way.
Good to know
The most recent major version of Python is Python 3, which we shall be using in this
tutorial. However, Python 2, although not being updated with anything other than
security updates, is still quite popular.
In this tutorial Python will be written in a text editor. It is possible to write Python in
an Integrated Development Environment, such as Thonny, Pycharm, Netbeans or
Eclipse which are particularly useful when managing larger collections of Python
files.
Python was designed for readability, and has some similarities to the English
language with influence from mathematics.
Python uses new lines to complete a command, as opposed to other programming
languages which often use semicolons or parentheses.
Python relies on indentation, using whitespace, to define scope; such as the scope of
loops, functions and classes. Other programming languages often use curly-brackets
for this purpose.
Django
Django is a high-level Python Web framework that encourages rapid development and clean,
pragmatic design. Built by experienced developers, it takes care of much of the hassle of Web
development, so you can focus on writing your app without needing to reinvent the wheel.
It’s
free and open source.
Ridiculously fast
Django was designed to help developers take applications from concept to completion
as quickly as possible.
Reassuringly secure
Django takes security seriously and helps developers avoid many common security
mistakes.
Exceedingly scalable
Some of the busiest sites on the Web leverage Django’s ability to quickly and flexibly
scale.
Django has its own naming system for all functions and components (e.g., HTTP responses
are called “views”). It also has an admin panel, which is deemed easier to work with than in
Lavarel or Yii, and other technical features, including:
Simple syntax;
Its own web server;
MVC (Model-View-Controller) core architecture;
“Batteries included” (comes with all the essentials needed to solve solving common
cases);
An ORM (Object Relational Mapper);
HTTP libraries;
Middleware support; and
A Python unit test framework.
Additionally, Django provides a dynamic CRUD (create, read, update and delete) interface,
configured with admin models and generated via introspection. CRUD is used to describe the
basic database commands, which means the interface facilitates viewing, changing, and
searching for information.
HTML Relationship
When used to output HTML content, PYTHON is embedded inside HTML in code islands,
where HTML code is embedded inside the Python script.
Django promptly releases new security patches. It’s usually the first one to respond to
vulnerabilities and alert other frameworks.
It’s fully loaded with extras and scalable, so you can make applications that handle
heavy traffic and large volumes of information;
It is cross-platform, meaning that your project can be based on Mac, Linux or PC;
It works with most major databases and allows using a database that is more suitable
in a particular project, or even multiple databases at the same time.
It’s well-established
Django is time- and crowd-tested. It has a big, supportive community accessed through
numerous forums, channels, and dedicated websites. It’s easy to find help when there’s a
problematic function in the code, and to find developers if your company is looking to base
the next project on Django.
Django started off with great documentation, the best of any other open-source framework.
And it’s still maintained on a high level, updated along with the new functions and fixes, so
you can easily adapt to changes.You can trust that any issues with the framework will be
solved as soon as they arise. The software is constantly updated and new packages are
released to make working with Django more convenient than it already is.
DB Browser SQLite
The only surest and seamless way to handle SQLite databases on computers is by means of
DB
Browser for SQLite. Db Browser For SQLite is an open-source tool which is completely free
to use.
Db Browser for SQLite creates databases which are compatible with SQLite. The “.db”
database extension created by this software is completely compatible with SQLite. You
should never change the .db extension, use it as it is for all your SQLite database
manipulations.
What it is DB Browser for SQLite (DB4S) is a high quality, visual, open source tool to
create, design, and edit database files compatible with SQLite.
DB4S is for users and developers who want to create, search, and edit databases. DB4S uses
a familiar spreadsheet-like interface, and complicated SQL commands do not have to be
learned.
5. MODELING
5.1 INTRODUCTION
We create models to obtain a better understanding of the actual entity to be
built. The model focuses on what the system must do and not on how it does it. The second
and third operational analysis principles require that we build modules of function and
behavior. The written word is a wonderful vehicle for communication, but it isn't
necessarily the best way to represent the requirements for computer software. Analysis
modeling uses a combination of text and diagrammatic forms to depict requirements for
data, function, and behavior in a way that is relatively easy to understand, and more
important, straightforward to review for correctness, completeness and consistency. This
section presents resources for conventional and object-oriented analysis (OOA) methods as
well as resources for UML. Analysis modeling is an extremely robust subject.
The actors are connected by lines to the use cases that they carry out. The use
cases are placed in a rectangle but the actors are not .This rectangle is a visual remainder of
the system boundaries and that the actors are outside the system.
Register
Manage Patients
Manage Beds
View Patients
Admin Doctor
View Doctors
Add Doctors
Phone_Nu
Doctor_I
m
D
Name Doctor_N
otes
Password P_ID
Username
Status
View Pat_Det
Admin_D
et Address
Symptoms
Pat_rel_c Bed_Num
Last_Name First_Name ontact
Has
B_ID
Specializati Name
on
Bed_Det
Phone_Nu Doc_Det
m
Address Occupied
D_ID
Fig: ER Diagram
6. DESIGN
6.1 INTRODUCTION
Design for Web apps encompasses technical and non-technical activities
that include: establishing the look and feel of the Web app, creating the aesthetic layout of the
user interface, defining the overall architectural structure, developing the content and
functionality that reside within the architecture, and planning the navigation that occurs
within the Web app.
Design allows you to create a model that can be assessed for quality and
improved before content and code are generated, tests are conducted, and end users become
involved in large numbers. Design is the place where Web app quality is established.
In general, the following design objectives must be kept in mind;
System design sits at the technical kernel of the software engineering and is applied
regardless of the software process model that is used. Beginning once software requirements
have been analyzed and specified, software design is the first technical activity that is used to
build and verify the software. Each activity (designing, coding and testing) transforms
user interface is the link between the users and the employers. A well-designed user interface
makes it very easy for users to learn software. The user interface portion of software is
responsible for all interaction with the user. Development of good user interface usually takes a
significant portion of the total system development effort. GUI can be defined as a program
interface that takes advantages of the computer’s graphic capabilities to make the program
easier to use.
application use client/server architecture. The web application resides on a server and responds to
request from multiple clients over the Internet on the client side, a browser, such as Internet
Explorer, Netscape Navigator, hosts the Web application. The application’s user interface takes
the form of HTML pages that are interpreted and displayed by the client’s browser. On the server
side, the Web application runs under Microsoft Internet Information Services (IIS). IIS manages
the application, passes requests from clients to the application, and returns the application’s
6.8. DIAGRAMS
The data flow diagram (DFD) is one of the most important tools used
by system analysts. Data flow diagrams are made up of a number of symbols, which
represent system components. Most data flow modeling methods use four kinds of symbols.
These symbols are used to represent four kinds of system components. Possesses, data stores,
data flows and external entities are the components. Circles in DFD represent a process. Data
flow is represented by a thin line in DFD and square or rectangle represents external entities.
Level-0
Request
USER
COVID-19 Response
Hospital
Management
System
USER
Level-1
Login
Manage
Manage Beds Manage
Patients
Doctors
Patients Beds
Doctors
7. CODING
7.1 INTRODUCTION
The coding step is a process that transforms design into a programming
language. It translates a detail design representation of software into a programming language
realization. The translation process continues when a compiler accepts source code as input
and produces machine-dependent object code as output. Quality is an important goal during
coding. The quality of source code can be improved by the use of structured coding
techniques; good coding style and readable, consistent code format. During coding, some
coding standards are to be followed. This has two purposes; reducing the chance of making it
easier for some time to modify the code later on. Coding phase affects both testing and
maintenance profoundly. The Covid-19 Hospital Management System uses PHP as the
programming language for coding.
8. TESTING
8.1 INTRODUCTION
The purpose of system testing is to identify and correct errors in the candidate
system. Testing is an important element of the software quality assurance and represents the
ultimate review of specification, design and coding. The increasing visibility of the software
as a system element and the costs associated with a software failure are motivated forces for
well planned, through testing.
During testing the system is used experimentally to ensure that the software
does not fail, i.e., it will run according to the specification and in the way the user expects.
Preparation of test data plays n vital role in the system testing. Different set of test data are
generated and the system under study is tested using that data. While testing using test data
errors are again uncovered and corrected using different testing techniques.
System testing was conducted in order to detect errors and for comparing then
the final system with the requirement specification report. That is, whether the system meets
requirements. During testing the software was executed with a set of test cases and the output
of the program for the test cases was evaluated to determine if the program is performing as it
was expected to.
The turn error is used to refer the difference between the actual output of the
software and the correct output. Fault is a condition that causes the software to fail to perform
its required function. Software reliability is defined as the required function.
Software reliability is defined as the probability that the software will not
undergo failure for a specified time under specified condition. Failure is the inability of a
system or a component to perform a required function according to its specification.
Different levels of testing were employed for software to make an error free, fault free and
reliable. Basically, in software testing four type of testing methods are adopted.
These are common accepted standards like mentioned above about annoying colors, fonts,
frames, etc. Content should be meaningful. All the anchor text links should be working
properly. Images should be placed properly with proper sizes. These are some basic standards
that are followed in Covid-19 Hospital Management System
instead of just directly testing the method in question. While testing at the component level
you would have the application open and the document displayed but you would be testing
the method and evaluating its result.(without taking into account the shortcut or what get
displayed on the application afterwards). In Covid-19 Hospital Management System, the
system consists of several modules. All modules are tested and were found to be working
properly.
performance testing. Rather than testing for performance from the perspective of load you are
testing the effects of configuration changes in the application landscape on application
performance and behavior. Covid-19 Hospital Management System was tested for
successful acceptance and was found to be working properly.
true performance of a system can be ascertained. This system was tested for successful
acceptance and was found to be working properly.
Test cases
Project Title : Covid-19 Hospital Management System
Software Tool :
Test objective : To check whether the entered User name and Password are valid or invalid.
Test data : User name = admin and password = admin
Step Steps Data Expected results Actual
no: results
1 Enter User name and User name = Should display warning Login
press LOGIN Button admin message box "Please Enter failed
Password"
2 Enter Password and Password = Should display warning Login
press LOGIN Button admin message box "Please Enter failed
User name “
3 Enter User name and User = admin Should display warning Login
Password and press and Password = message box "Invalid User failed
LOGIN Button XYZ name or Password"
4 Enter User name and User = XYZ and Should display warning Login
Password and press Password = message box "Invalid User failed
LOGIN Button admin name or Password"
5 Enter User name and User = xyz and Should display warning Login
Password and press Password = xyz message box "Invalid User failed
LOGIN Button name or Password"
6 Enter User name and User = “ ” and Should display warning Login
Password and press Password = “ ” message box "Please Enter failed
LOGIN Button User name and Password“
7 Enter User name and User = admin Should navigate to admin Login
Password and press and password home page made
LOGIN Button =admin
9. IMPLEMENTATION
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', 'core.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()
Admin.py
Views.py
from django.shortcuts import render, redirect
from django.http import HttpResponse, JsonResponse
from .models import *
from .filters import PatientFilter
from django.contrib.auth.models import User, auth
from django.contrib import messages
from django.contrib.auth.decorators import login_required
# PatientFilter = OrderFilter
def login(request):
if request.user.is_authenticated:
return redirect('/')
else:
if request.method == 'POST':
username = request.POST['username']
password = request.POST['password']
user = auth.authenticate(username=username, password=password)
if user is not None:
auth.login(request, user)
return redirect('/')
else:
messages.error(request, 'Invalid username or password')
return redirect('login')
else:
return render(request, 'main/login.html')
@login_required(login_url='login')
def logout(request):
auth.logout(request)
return redirect('/')
def dashboard(request):
patients = Patient.objects.all()
patient_count = patients.count()
patients_recovered = Patient.objects.filter(status="Recovered")
patients_deceased = Patient.objects.filter(status="Deceased")
deceased_count = patients_deceased.count()
recovered_count = patients_recovered.count()
beds = Bed.objects.all()
beds_available = Bed.objects.filter(occupied=False).count()
context = {
'patient_count': patient_count,
'recovered_count': recovered_count,
'beds_available': beds_available,
'deceased_count':deceased_count,
'beds':beds
}
print(patient_count)
return render(request, 'main/dashboard.html', context)
def add_patient(request):
beds = Bed.objects.filter(occupied=False)
doctors = Doctor.objects.all()
if request.method == "POST":
name = request.POST['name']
phone_num = request.POST['phone_num']
patient_relative_name = request.POST['patient_relative_name']
patient_relative_contact = request.POST['patient_relative_contact']
address = request.POST['address']
symptoms = request.POST['symptoms']
prior_ailments = request.POST['prior_ailments']
bed_num_sent = request.POST['bed_num']
bed_num = Bed.objects.get(bed_number=bed_num_sent)
dob = request.POST['dob']
status = request.POST['status']
doctor = request.POST['doctor']
doctor = Doctor.objects.get(name=doctor)
print(request.POST)
patient = Patient.objects.create(
name = name,
phone_num = phone_num,
patient_relative_name = patient_relative_name,
patient_relative_contact = patient_relative_contact,
address = address,
symptoms = symptoms,
prior_ailments = prior_ailments,
bed_num = bed_num,
dob = dob,
doctor=doctor,
status = status
)
patient.save()
bed = Bed.objects.get(bed_number=bed_num_sent)
bed.occupied = True
bed.save()
id = patient.id
return redirect(f"/patient/{id}")
context = {
'beds': beds,
'doctors': doctors
}
return render(request, 'main/add_patient.html', context)
patient.doctor = doctor
patient.doctors_visiting_time = doctor_time
patient.doctors_notes = doctor_notes
print(patient.doctors_visiting_time)
print(patient.doctors_notes)
patient.status = status
patient.save()
context = {
'patient': patient
}
return render(request, 'main/patient.html', context)
def patient_list(request):
patients = Patient.objects.all()
# filtering
myFilter = PatientFilter(request.GET, queryset=patients)
patients = myFilter.qs
context = {
'patients': patients,
'myFilter': myFilter
}
'''
def autocomplete(request):
if patient in request.GET:
name = Patient.objects.filter(name__icontains=request.GET.get(patient))
name = ['js', 'python']
names = list()
names.append('Shyren')
print(names)
for patient_name in name:
names.append(patient_name.name)
return JsonResponse(names, safe=False)
return render (request, 'main/patient_list.html')
'''
def autosuggest(request):
query_original = request.GET.get('term')
queryset = Patient.objects.filter(name__icontains=query_original)
mylist = []
mylist += [x.name for x in queryset]
return JsonResponse(mylist, safe=False)
def autodoctor(request):
query_original = request.GET.get('term')
queryset = Doctor.objects.filter(name__icontains=query_original)
mylist = []
mylist += [x.name for x in queryset]
return JsonResponse(mylist, safe=False)
def info(request):
return render(request, "main/info.html")
Models.py
from django.db import models
from multiselectfield import MultiSelectField
# Create your models here.
class Patient(models.Model):
name = models.CharField(max_length=50)
phone_num = models.CharField(max_length=15)
patient_relative_name = models.CharField(max_length=50, null=True)
patient_relative_contact = models.CharField(max_length=15, null=True)
address = models.TextField()
SYMPTOMS = (
('Fever', 'Fever'),
('Dry cough', 'Dry cough'),
('Tiredness', 'Tiredness'),
('Aches and pains', 'Aches and pains'),
('Sore throat', 'Sore throat'),
('Diarrhoea', 'Diarrhoea'),
('Loss of taste or smell', 'Loss of taste or smell'),
('Difficulty in breathing or shortness of breath', 'Difficulty in breathing or shortness of
breath'),
('Chest pain or pressure', 'Chest pain or pressure'),
('Loss of speech or movement', 'Loss of speech or movement'),
)
def __str__(self):
return self.name
class Bed(models.Model):
bed_number = models.CharField(max_length=50)
occupied = models.BooleanField()
def __str__(self):
return self.bed_number
class Doctor(models.Model):
name = models.CharField(max_length=100)
def __str__(self):
return self.name
Add_patient.html
{% extends 'main/base.html' %}
{% load static %}
{% block contentTitle %}
Add Patients
{% endblock contentTitle %}
{% block content %}
<div class="container">
<div class="patient-form ">
<div class="row">
<div class="form-field col-md-6">
</div>
<div class="row">
<div class="form-field col-md-6">
<input type="date" id="dob" class="input-text" type="date" name="dob">
</div>
</div>
{{doctor}}
<!-- symptons field -->
<div class="patient-form row d-flex">
<div class="symptoms row">
<div class="symptoms-label col-12 text-center mt-0">Symptoms</div><br>
<div class="symptom">
<input type="checkbox" name="symptoms" id="fever" value="Fever"
class="checkbox">
<label for="fever">Fever</label><br>
</div>
<div class="symptom">
<input type="checkbox" name="symptoms" value="Dry Cough"
id="dry_cough">
<label for="">Dry cough</label><br>
</div>
<div class="symptom">
<input type="checkbox" name="symptoms" value="Tiredness"
id="tiredness">
<label for="">Tiredness</label><br>
</div>
</div>
<div class="symptom">
<input type="checkbox" name="symptoms" value="Aches and pains"
id="aches_and_pain">
<label for="">Aches and pains</label><br>
</div>
<div class="symptom">
<input type="checkbox" name="symptoms" value="Sore Throat"
id="sore_throat">
<label for="">Sore throat</label><br>
</div>
<div class="symptom">
<input type="checkbox" name="symptoms" valu="Diarrhoea"
id="diarrhoea">
<label for="">Diarrhoea</label><br>
</div>
<div class="symptom">
<input type="checkbox" name="symptoms" value="Loss of taste or smell"
id="loss_of_taste_or_smell">
<label for="">Loss of taste or smell</label><br>
</div>
</div>
</div>
<div class="symptom">
</div>
</div>
</div>
</div>
<button class="btn col-lg-4 btn-block mx-auto btn-info mb-4" >Add Patient</button>
</form>
{% endblock content %}
Login.html
{% load static %}
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8" />
<meta
name="viewport"
content="width=device-width, initial-scale=1.0, shrink-to-fit=no"
/>
<link
rel="stylesheet"
href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css"
integrity="sha384-
Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm"
crossorigin="anonymous"
/>
crossorigin="anonymous"
/>
<body id="bootstrap-overrides">
{% if messages %}
{% for message in messages %}
<div class="alert alert-{{message.tags}} alert-dismissible fade show" role="alert">
<strong>Message: </strong> {{message}}
<button type="button" class="close" data-dismiss="alert" aria-label="close" >
<span aria-hidden="true">×</span>
</button>
</div>
{% endfor %}
{% endif %}
<div class="container">
<div class="username">
<div class="name row">
<i class="fas fa-user-shield col-2"></i>
<input id="name" class="input-text col-9" type="text" name="username"
placeholder="Username">
</div>
</div>
<div class="password">
<div class="pass row">
<i class="fas fa-key col-2"></i>
<input id="password" class="input-text col-9" type="password"
name="password" placeholder="Password">
</div>
</div>
<script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/umd/popper.min.js"
integrity="sha384-
9/reFTGAW83EW2RDu2S0VKaIzap3H66lZH81PoYlFhbGU+6BZp6G7niu735Sk7lN"
crossorigin="anonymous"></script>
<script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/js/bootstrap.min.js"
integrity="sha384-
w1Q4orYjBQndcko6MimVbzY0tgp4pWB4lZ7lr30WKz0vr/aWKhXdBNmNb5D92v7s"
crossorigin="anonymous"></script>
</html>
12. CONCLUSION
Conclusion
Performance intelligence plays an essential role as part of a broader public health strategy in
guiding the decisions of health system actors on the implementation of contextualized
measures to tackle COVID-19 or any future epidemic as well as their effect on the health
system at large. This should be based on commonly agreed-upon standardized data and fit-
for-purpose indicators, making optimal use of existing health information infrastructures. The
Health Pros Network can make a meaningful contribution.
13. APPENDIX
SCREEN LAYOUT
Login Page
Add Patients
Update Patients
14. BIBILOGRAPHY
Books References:
Web References:
https://www.scribd.com/document/371478938/medical_shop_management
https://www.geeksforgeeks.org/django-tutorial/
https://w3points.com/django-tutorial/