21CS62

Model Question Paper-1/2 with effect from 2021(CBCS Scheme)

USN
Sixth Semester B.E. Degree Examination
Subject Title: Fullstack Development

TIME: 03 Hours Max. Marks:

100 SET - 1

Note: 1. Answer any FIVE full questions, choosing at least ONE question from each
MODULE. THESE ANSWERS FROM TEXTBOOK

*Bloom’s COs
Module -1 Taxonomy Marks
DOWNLOAD Level

Q.01 a Define Web Framework? Explain with example of L2 1 10

design of a Web application written using the
Common Gateway Interface
(CGI) standard with its disadvantage.

Web Frameworks and CGI Applications

Definition of a Web Framework:

A web framework provides a programming infrastructure
for applications, allowing developers to focus on writing
clean, maintainable code without reinventing common
functionalities. It aims to solve issues like environment-
specific configurations and separation of concerns
between logic and presentation. One example of a web
framework is Django.

Example of Design of a Web Application using CGI

Standard:
In a sample Python CGI script displaying the ten most
recent books from a database, the code connects to a
MySQL database, retrieves book titles, and generates an
HTML list of these titles. This CGI script demonstrates a
basic approach to web development but lacks modern
conveniences and best practices found in web frameworks
like Django.

Disadvantages of CGI Standard Approach:

1. Duplication of Database Connection Code: Each CGI
script needing database connection duplicates code,
leading to inefficiency and maintenance challenges.
2. Boilerplate Code for Setup and Teardown Tasks:
Page 01 of 02
07082024
 21CS62
Tasks like printing the "Content-Type" line and closing
database connections introduce room for errors and reduce
programmer productivity.
3. Limited Reusability: Lack of shared functions or
infrastructure for common tasks limits code reusability
and modularity.
4. Maintenance Challenges: Manual handling of setup
and teardown tasks can make maintenance and updates
cumbersome and error-prone.
5. Limited Separation of Concerns: The CGI approach
lacks clear separation between business logic and
presentation, making it harder to maintain and update
code without affecting other components.
6. Scalability Concerns: The CGI approach may not
scale well for complex web applications requiring robust
architecture and scalability features.
7. Security Vulnerabilities: Direct database connections
and manual handling of tasks may introduce security
vulnerabilities if not implemented securely.
8. Lack of Abstraction: CGI scripts lack the abstractions
and conventions provided by web frameworks, leading to
verbose and less maintainable code.

Additional Notes:
- Django, as a web framework, exemplifies modern web
development practices by offering clear separation of
concerns, reusability, and scalability features.
- The Model-View-Controller (MVC) design pattern is
commonly followed in web frameworks like Django to
separate data, logic, and presentation layers for better
maintainability and flexibility.
b Explain how Django Processes a Request. L2 1 10

Answer
How Django Processes a Request

Overview
Django processes a request by following a series of steps
that involve determining the root URLconf, matching the
requested URL with URLpatterns, calling the associated
view function, and converting the HttpResponse to a
proper HTTP response.

Steps in Django Request Processing

1. Request Initiation : A request comes in to a specific
URL.
2. Root URLconf Determination : Django identifies
Page 01 of 02
07082024
 21CS62
the root URLconf by looking at the ROOT_URLCONF
setting.
3. URLpattern Matching : Django compares the requested
URL with the patterns in the URLconf until it finds a
match.
4. View Function Invocation : If a match is found, Django
calls the associated view function.
5. Response Generation : The view function returns an
HttpResponse.
6. HTTP Response Construction : Django converts the
HttpResponse to the appropriate HTTP response, resulting
in a web page.

Additional Details
- Django starts processing a request by looking for the
settings file, which contains crucial project configurations
like ROOT_URLCONF.
- The ROOT_URLCONF setting specifies the Python
module to be used as the URLconf for the website.
- When a request is made for a specific URL, Django loads
the URLconf pointed to by ROOT_URLCONF and
matches the requested URL with URLpatterns to determine
the appropriate view function to call.
- Once the view function returns an HttpResponse, Django
handles the conversion to a proper HTTP response,
generating the web page for the user.

OR
Q.02 a Explain Wildcard URL patterns and Django’s Pretty Error L2 1 10
Pages.

Explanation of Wildcard URL Patterns and Django’s

Pretty Error Pages

Wildcard URL Patterns

- Django uses wildcard URL patterns, which are regular
expressions, to handle arbitrary patterns in URLs.
- These patterns allow for powerful URL matching using
specific symbols like dot (.), \d for any single digit, [A-Z]
for any uppercase character, and more.
- Wildcard URL patterns enable flexible matching criteria,
providing the ability to specify complex URL structures.
- They are essential for designing applications that need to
handle dynamic or variable components in URLs.

Django’s Pretty Error Pages

- Django emphasizes the use of clean and readable URLs for

Page 01 of 02
07082024
 21CS62
a quality web application.
- Pretty URLs like '/time/plus/3/' are preferred over query
string parameters like '/time/plus?hours=3' for improved
readability and user experience.
- The Django error page can display detailed information in
special cases such as template syntax errors.
- Developers can leverage the Django error page for
debugging by triggering it with specific code snippets like
'assert False'.
- It is important to avoid exposing sensitive information
through error pages to prevent potential security risks and
reverse engineering attempts.

URL Configuration in Django

- In Django, URL patterns are defined in the URLconf,
where each pattern is associated with a corresponding view
function.
- Requests are matched against URL patterns in the
URLconf to determine which view function should handle
the request.
- The URLconf system in Django follows a sequential
matching process, calling the first matching view function
for a requested URL.
- View functions in Django must return an HttpResponse
object, which Django then processes to generate the
appropriate HTTP response for the web page.

Summary
Wildcard URL patterns in Django allow for flexible and
dynamic URL matching using regular expressions. Django
promotes the use of clean and aesthetically pleasing URLs
for better user experience. The Django error page serves as a
tool for debugging and handling errors while emphasizing
the importance of securing sensitive information. URL
configuration in Django involves mapping URL patterns to
view functions in the URLconf for efficient request handling
and response generation.

b Write a Django app that displays date and time four L2 1 10

hours ahead
and four hours before as an offset of current date and
time in server.

Certainly! Here's a step-by-step guide to creating a Django

app that displays the current date and time along with the
times four hours ahead and four hours before:

1. Set Up the Django Project

Page 01 of 02
07082024
 21CS62

If you haven't already set up a Django project, create one

first:

```bash
django-admin startproject myproject
cd myproject
```

2. Create a New Django App

Within your project directory, create a new app named

`time_offset`:

```bash
python manage.py startapp time_offset
```

3. Define the View

1. Open `time_offset/views.py` and define a view to

calculate and display the date and time offsets:

```python
from django.shortcuts import render
from datetime import datetime, timedelta

def time_offset_view(request):
Get current date and time
now = datetime.now()

Calculate the offset times

four_hours_ahead = now + timedelta(hours=4)
four_hours_before = now - timedelta(hours=4)

context = {
'current_time': now,
'four_hours_ahead': four_hours_ahead,
'four_hours_before': four_hours_before,
}

return render(request, 'time_offset/time_offset.html',

context)
```

4. Create the Template

1. Create a directory named `templates` inside the

Page 01 of 02
07082024
 21CS62
`time_offset` app directory.

2. Within the `templates` directory, create another directory

named `time_offset`.

3. Inside the `time_offset` directory, create a file named

`time_offset.html` with the following content:

```html
<!DOCTYPE html>
<html>
<head>
<title>Time Offset</title>
</head>
<body>
<h1>Current Date and Time</h1>
<p>{{ current_time }}</p>

<h2>Four Hours Ahead</h2>

<p>{{ four_hours_ahead }}</p>

<h2>Four Hours Before</h2>

<p>{{ four_hours_before }}</p>
</body>
</html>
```

5. Configure URLs for the App

1. In the `time_offset` app directory, create a file named

`urls.py` if it doesn't already exist, and add the following
code:

```python
from django.urls import path
from .views import time_offset_view

urlpatterns = [
path('', time_offset_view, name='time_offset'),
]
```

2. Include the `time_offset` app URLs in the project's main

`urls.py` file, which is located in the `myproject` directory:

```python
from django.contrib import admin
from django.urls import path, include
Page 01 of 02
07082024
 21CS62

urlpatterns = [
path('admin/', admin.site.urls),
path('time_offset/', include('time_offset.urls')),
]
```

6. Run the Development Server

1. Make sure you're in your project directory and run the

server:

```bash
python manage.py runserver
```

2. Open your web browser and go to

`http://127.0.0.1:8000/time_offset/` to see the current date
and time, along with the times four hours ahead and four
hours before.

This setup will display the current date and time along
with the times offset by four hours in both directions.
Module-2
DOWNLOAD
Q. 03 a Explain Basic Template Tags and Filters. L2 2 10

Basic Template Tags and Filters in Django

Template System Basics

- A Django template separates the presentation of a
document from its data using placeholders and basic logic
through template tags.
- Django templates can generate any text-based format, not
just HTML.

Variables and Template Tags

- Text surrounded by a pair of braces like `{{ person_name
}}` represents a variable to insert the value of the variable
with the given name.
- Text surrounded by curly braces and percent signs like `{%
if ordered_warranty %}` is a template tag that instructs the
template system to perform certain actions.
- Template tags like `{% for item in item_list %}` and `{%
if ordered_warranty %}` enable looping over sequences and
conditional logic in templates.

Filters
Page 01 of 02
07082024
 21CS62
- Filters provide a convenient way to modify the formatting
of a variable in Django templates.
- Example of a filter: `{{ ship_date|date:"F j, Y" }}` where
the `date` filter formats the `ship_date` variable according to
the specified format.
- Django templates offer built-in filters like `addslashes`,
`date`, and `length` for various formatting and manipulation
tasks.

Template Tags
- Django template system includes built-in tags like `if/else`
for conditional logic.
- The `if` tag evaluates a variable, displaying content based
on its truth value.
- Example:
```
{% if today_is_weekend %}
<p>Welcome to the weekend!</p>
{% endif %}
```

Filter Arguments
- Some filters accept arguments that come after a colon and
are enclosed in double quotes.
- Example: `{{ bio|truncatewords:"30" }}` displays the first
30 words of the `bio` variable.

Using the Template System

- The Django template system is a Python library that can be
used independently of Django views.
- The basic steps to use Django's template system in Python
code involve creating a `Template` object and rendering it
with a set of variables using the `render()` method.

Additional Information
- Django templates support creating custom tags and filters
for more specialized requirements.
- Appendix F in the Django documentation contains a
comprehensive list of tags and filters available in Django
templates.

b Explain MTV Development Pattern. L2 2 10

Explanation of MTV Development Pattern

Overview of MTV Development Pattern

- The MTV development pattern is an architectural pattern
Page 01 of 02
07082024
 21CS62
used in software development.
- It stands for Model-Template-View, representing the
three main components of the pattern.

Components of the MTV Development Pattern

1. Model (M):
- Represents the data access layer.
- In Django, the data-access portion is handled by the
database layer.
- Contains information on how to access data, validate it,
define behaviors, and manage relationships.

2. Template (T):
- Represents the presentation layer.
- In Django, the portion that decides how data should be
displayed on a web page or other documents.
- Contains presentation-related decisions.

3. View (V):
- Represents the business logic layer.
- In Django, the logic that accesses the model and
determines which template(s) to use.
- Acts as a bridge between models and templates.

Comparison with MVC Pattern

- The MTV pattern in Django is akin to the Model-View-
Controller (MVC) pattern in software architecture.
- In Django, the Model corresponds to the data access
layer, the View corresponds to selecting and displaying
data, and the Controller is handled by the framework itself
based on user input.
- Django has been referred to as an MTV framework due to
the handling of Controller responsibilities by the
framework.

Implementing MTV in Django

- Django closely follows the MTV pattern, with the
database layer handling the Model, views and templates
handling the View, and the framework managing
Controller aspects.
- The Model focuses on data access, the Template on
presentation, and the View on business logic.
- Django's structure makes it efficient for building
database-driven web applications.

Significance of MTV Development Pattern

- Using the MTV pattern helps in organizing code,
separating concerns, and improving communication among
Page 01 of 02
07082024
 21CS62
developers.
- It provides a structured way to handle data access,
presentation, and business logic in software development.

OR
Q.04 a Explain Template Inheritance with example. L2 2 10

Explanation of Template Inheritance with Example

Template Inheritance Overview

Template inheritance in Django allows for the creation of a
base template that includes common elements shared
across multiple pages. Child templates can then override
specific sections of the base template. This approach helps
reduce duplication and streamlines the development
process by defining common page areas and allowing
customization per page.

Example of Template Inheritance

To illustrate template inheritance, consider the following
base template structure:

```html
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML
4.01//EN">
<html lang="en">
<head>
<title>{% block title %}{% endblock %}</title>
</head>
<body>
<h1>My helpful timestamp site</h1>
{% block content %}{% endblock %}
{% block footer %}
<hr>
<p>Thanks for visiting my site.</p>
{% endblock %}
</body>
</html>
```

In this example, the base template defines blocks for the

title, content, and footer areas that child templates can fill
in with specific content. This structured approach allows
for modular design and efficient management of site-wide
components.

Page 01 of 02
07082024
 21CS62
Benefits of Template Inheritance
1. Reduction of Redundancy : Avoids duplication of
common page elements.
2. Customization Per Page : Enables flexibility in
modifying specific sections for individual pages.
3. Maintainability : Simplifies updates and changes by
centralizing common components in the base template.
4. Structured Design : Promotes a systematic approach to
organizing templates for efficient web development.

Implementing Template Inheritance

To implement template inheritance in Django:
1. Create a base template with defined blocks for common
sections.
2. Extend the base template in child templates and override
specific block content as needed.
3. Utilize the `{% block %}` tags to designate areas that
can be customized in child templates.
4. Maintain consistency across pages while allowing for
unique content variations.

By following these steps and leveraging template

inheritance, developers can streamline the creation of
dynamic and consistent web pages with reusable
components.

b Explain Making Changes to a Database Schema. L2 2 10

Making Changes to a Database Schema

Overview of Database Schema Changes

- Making changes to a database schema involves modifying
the structure of the database, such as tables, relationships,
and constraints.
- Changes to a database schema can include adding new
tables, altering existing tables, defining relationships
between tables, and modifying data types or constraints.
- It is essential to carefully plan and execute schema
changes to maintain data integrity and application
functionality.

Steps for Making Changes to a Database Schema

1. Plan the Changes : Identify the specific modifications
needed and evaluate the impact on existing data and
applications.
2. Backup Data : Before proceeding with any schema
changes, ensure to back up the database to prevent data
loss in case of errors.
Page 01 of 02
07082024
 21CS62
3. Execute Changes : Implement the planned changes
using SQL statements or database management tools.
4. Test Changes : After applying the modifications,
thoroughly test the database to ensure that the changes
work as intended and do not cause unexpected issues.
5. Deploy Changes : Once the changes have been tested
and validated, deploy them to the production environment.

6. Monitor Performance : Monitor the database

performance post-change to detect any issues and optimize
performance if necessary.

Considerations for Database Schema Changes

- Data Migration : When altering the schema, data
migration might be required to ensure existing data aligns
with the new schema structure.
- Impact Analysis : Evaluate the impact of schema changes
on existing queries, applications, and performance. -
Version Control : Maintain version control of the database
schema to track changes and facilitate rollback if needed.

- Documentation : Document all schema changes for

reference and future maintenance.
Strategies for Handling Database Schema Changes
- Use Migration Tools : Employ database migration tools
that automate the process of applying and managing
schema changes.
- Incremental Changes : Implement schema modifications
in incremental stages to minimize disruptions and facilitate
easier troubleshooting.
- Rollback Plan : Have a rollback plan in place in case
issues arise during or after applying schema changes.

Best Practices for Database Schema Management

- Regular Review : Regularly review and optimize the
database schema to enhance performance and
accommodate evolving requirements.
- Collaboration : Involve database administrators,
developers, and stakeholders in the decision-making
process for schema changes.
- Testing : Thoroughly test schema changes in a controlled
environment before deploying to production to mitigate
risks.

Page 01 of 02
07082024
 21CS62
Module-3
DOWNLOAD
Q. 05 a Explain Customizing the Admin Interface. L2 3 10

Customizing the Admin Interface in Django

Overview of Django Admin Interface

The Django admin site provides a powerful and
production-ready interface allowing site administrators to
manage site content efficiently. It simplifies tasks like user
authentication, form handling, and input validation, making
it a valuable tool for managing website data.

Key Features of Django Admin Interface Customization

1. ModelAdmin Subclassing : Custom configurations for

specific admin models can be created by subclassing `
django.contrib.admin.ModelAdmin`.
2. Customizing List Display : The `list_display` option
allows specifying which fields to display on the change-list
page, enhancing the interface's usability.
3. Altering Registration : The `admin.site.register()`
function can be altered to include custom admin options for
models, providing tailored configurations.
4. Custom Ordering : Fields in the admin interface can be
ordered using the `ordering` option, allowing for a more
organized presentation of data.
5. Customizing Edit Forms : Edit forms can be customized
by altering the order of fields using the `fields` option in
the ModelAdmin subclass.
6. User Permissions Control : Django's admin site includes
a permissions system to grant specific users access to
designated parts of the interface, ensuring secure data
management.
7. Activation and Use : Activating and using the admin
interface involves utilizing metadata in models to create a
seamless and efficient interface for administrators.
8. Multi-Language Support : The Django admin site
supports multiple languages, allowing users to access the
interface in their preferred language for enhanced usability.

Benefits of Customization
- Efficiency * *: Customizing the admin interface
streamlines data management processes, increasing
efficiency for site administrators.
- Usability : Tailoring the interface to display relevant
information enhances user experience and simplifies
navigation.
Page 01 of 02
07082024
 21CS62
- Security : User permissions control ensures data security
by limiting access to sensitive areas of the admin interface.

- Flexibility : Customization options provide flexibility

in presenting data and organizing the admin interface
based on specific needs.

Use Cases
- Content Producers and Programmers Collaboration :
Facilitates simultaneous work between content producers
and programmers by providing an intuitive data entry
platform.
- Non- Technical Data Entry : Ideal for scenarios where
non-technical users need to enter data efficiently, making it
a valuable tool for various industries.

Recommendations
- Exploration : Even if not intending to use the Django
admin site, exploring its features can introduce valuable
concepts applicable to other aspects of Django
development.
- Customization : Leveraging customization options can
significantly enhance the user experience and efficiency of
data management tasks within the admin interface.

b Explain Creating a Feedback Form and Processing the L2 3 10

Submission.

Creating a Feedback Form and Processing the

Submission

Creating a Feedback Form

1. Form Library in Django : Django provides a form
library called django.forms to handle form-related tasks,
including display and validation.
2. Defining a Form Class : The primary way to use the
forms framework is by defining a Form class for each
HTML page.
3. ContactForm Class : A sample ContactForm class in
Django includes fields like subject, email, and message
with different validation options.
4. Setting Initial Values : Initial values can be set for form
fields, such as prepopulating the subject field with a
default value like "I love your site!".
5. Custom Validation Rules : Django allows for the
creation of custom validation rules beyond basic validation
like checking for the presence of '@' in an email address.

Page 01 of 02
07082024
 21CS62
Processing the Submission
1. Form Submission Handling :
- Checking if the request method is 'POST' to isolate form
submission cases from mere form display.
- Accessing submitted form data using request.POST
when the view is accessed via POST.
2. Data Validation :
- Validating required fields like subject and message,
handling missing keys and data appropriately.
- Fragile email validation by checking for the presence of
'@', with Django offering more robust validation options.
3. Sending Email :
- Using `django.core.mail.send_mail` function to send an
email with required arguments like subject, body, and
sender address.
4. Redirecting After Successful Submission : Best practice
in web development is to issue a redirect for successful
POST requests.

Additional Notes
- Complex Forms : While simple forms can be handled
without using Django's form library, more complex forms
like feedback forms benefit from utilizing the form
framework.
- Error Handling : Validation errors should prompt a
redisplay of the form with previously submitted data to aid
users in correcting mistakes.

OR
Q. 06 a Develop a Model form for student that contains his topic L2 3 10
chosen for project, languages used and duration with
a model called
project.

To create a Django model form for a student that contains

fields for the topic chosen for a project, languages used, and
duration, you can follow these steps:

1. Create the `Project` Model

First, define a `Project` model in your `models.py` file. This

model will include fields for the topic, languages used, and
duration.

1. Open the `models.py` file in your Django app (e.g.,

`time_offset/models.py` or another app where you want to
add this model).

Page 01 of 02
07082024
 21CS62

2. Add the following code to define the `Project` model:

```python
from django.db import models

class Project(models.Model):
topic = models.CharField(max_length=200)
languages_used = models.CharField(max_length=200)
duration = models.DurationField()

def __str__(self):
return self.topic
```

- `topic`: A `CharField` for the project topic.

- `languages_used`: A `CharField` to store the
programming languages used.
- `duration`: A `DurationField` to store the duration of the
project.

2. Create the Model Form

Next, create a model form based on the `Project` model.

1. Create a new file called `forms.py` in your Django app

directory (if it doesn't already exist).

2. Add the following code to create the form:

```python
from django import forms
from .models import Project

class ProjectForm(forms.ModelForm):
class Meta:
model = Project
fields = ['topic', 'languages_used', 'duration']
```

- `ProjectForm`: This form will automatically generate

form fields based on the `Project` model.

3. Create a View to Handle the Form

Now, create a view that will handle displaying and

processing the form.

Page 01 of 02
07082024
 21CS62
1. Open your app's `views.py` file.

2. Add the following code to define the view:

```python
from django.shortcuts import render, redirect
from .forms import ProjectForm

def project_view(request):
if request.method == 'POST':
form = ProjectForm(request.POST)
if form.is_valid():
form.save()
return redirect('project_success')
else:
form = ProjectForm()

return render(request, 'project_form.html', {'form':

form})
```

- This view will render the form and handle form

submissions.

4. Create a Template for the Form

Next, create a template to display the form.

1. Create a file called `project_form.html` in your

`templates` directory.

2. Add the following content to the template:

```html
<!DOCTYPE html>
<html>
<head>
<title>Project Form</title>
</head>
<body>
<h1>Submit Your Project</h1>
<form method="post">
{% csrf_token %}
{{ form.as_p }}
<button type="submit">Submit</button>
</form>
</body>
</html>
Page 01 of 02
07082024
 21CS62
```

- This template includes a basic form submission

interface.

5. Configure URLs

Finally, set up the URL routing for your view.

1. In your app's `urls.py` file, add the following code:

```python
from django.urls import path
from .views import project_view

urlpatterns = [
path('project/', project_view, name='project_form'),
path('success/', lambda request: render(request,
'success.html'), name='project_success'),
]
```

- This will make the form accessible at `/project/`.

2. Create a `success.html` template in your `templates`

directory for the success page:

```html
<!DOCTYPE html>
<html>
<head>
<title>Success</title>
</head>
<body>
<h1>Project Submitted Successfully!</h1>
<p>Thank you for submitting your project.</p>
</body>
</html>
```

6. Migrate the Database

Apply the migrations to create the `Project` model in your

database.

```bash
python manage.py makemigrations
python manage.py migrate
Page 01 of 02
07082024
 21CS62
```

7. Run the Development Server

Start the development server and navigate to `/project/` to

see and use the form.

```bash
python manage.py runserver
```

This will allow users to submit their project topic,

languages used, and duration through the form, and save
the data in the database.
b List and Explain URLconf Tricks. L2 3 10

List and Explain URLconf Tricks

URLconf Tricks Overview

- URLconfs in Django are Python code segments that
define the mapping between URLs and views.
- Various tricks can be used to streamline URLconf
management and enhance functionality.

URL Include Functionality

- URLconfs can include other URLconfs to organize URLs
effectively.
- When using the `include()` function, Django processes
URLs from top to bottom in the included URLconf.
- Regular expressions in the included URLconf should not
have an end-of-string match character but include a trailing
slash.

Ordering URL Patterns

- URL patterns in URLconfs are processed from top to
bottom.
- Placing more specific patterns before general ones
ensures that the specific pattern is matched first.
- This approach helps avoid putting URL logic in views.

Capturing Text in URLs

- Captured arguments in URL patterns are sent to views as
plain Python Unicode strings.
- It is essential to consider data types when capturing
arguments to avoid errors in view code.

Streamlining Function Imports

- Views can be imported directly into URLconfs to
Page 01 of 02
07082024
 21CS62
streamline function imports.
- By importing the views module itself, the need to import
individual view functions is eliminated, enhancing code
manageability.

Special-Casing URLs in Debug Mode

- URLconf behavior can be altered dynamically based on
Django's debug mode.
- Checking the DEBUG setting at runtime allows for
conditional URL pattern additions.

Using Named Groups

- Named regular expression groups in URLconfs enable
capturing URL bits and passing them as keyword
arguments to views.
- Named groups provide a more structured and readable
way to handle URL parameters.

Next Steps
- Chapter 9 will delve into advanced tips and tricks for
Django's template system.

Page 01 of 02
07082024
 21CS62
Module-4
DOWNLOAD
Q. 07 a Define Generic Views and explain its types. L2 4 10

Generic Views Overview and Types

Definition of Generic Views:

Generic views in Django are pre-built views that simplify
the process of creating common view patterns without
needing to write extensive code. They abstract common
tasks in view development, allowing developers to quickly
generate views for data-related operations.

Types of Generic Views:

1. Direct_to_template view :
- Returns an `HttpResponse` and is used to render a
template directly.
- Handles missing templates by catching
`TemplateDoesNotExist` exceptions and returning 404
errors.

2. Object list view :

- Focuses on presenting views related to database content.
- Facilitates generating list and detail views of objects in
a database.
- Provides easy ways to display lists and details of objects
like `Publisher` objects.

3. Extending Generic Views :

- Useful for customizing and extending generic views to
handle a wider array of situations.
- Allows developers to tailor generic views to specific
project requirements.

4. Making "Friendly" Template Contexts :

- Involves improving the readability and usability of
template contexts.
- Enhances the naming convention of variables for better
understanding by template authors.

5. Customizing Responses :
- Enables modifying the response returned by generic
views.
- Example: Providing a downloadable plain-text version
of a list of authors with specific HTTP headers like
`Content-Disposition`.

Benefits of Generic Views:

Page 01 of 02
07082024
 21CS62
- Speed up development significantly.
- Handle common view patterns without extensive coding.
- Offer flexibility for customization and extension.
- Provide built-in options for generating various types of
views on database content.

Customization and Extension of Generic Views:

- Developers can extend generic views to accommodate a
broader range of use cases.
- Various patterns can be addressed by customizing generic
views according to specific project needs.

Further Details on Generic Views:

- Appendix C in the document covers all the available
generic views and their options in detail.
- Generic views can be reused and integrated into custom
views effectively to enhance functionality and efficiency.

b Explain Extending Generic Views L2 4 10

Explanation of Extending Generic Views in Django

Overview of Generic Views

- Generic views in Django are designed to streamline the
process of creating common views without excessive code.
- They abstract common tasks and patterns in view
development to simplify the creation of data views.
- Tasks like displaying a list of objects, rendering templates,
and handling detail pages are made more efficient with
generic views.

Extending Generic Views

- Generic views can be extended to handle a wider array of
situations beyond the built-in functionalities.
- Extending generic views is commonly required when the
standard generic views do not fully meet project
requirements.
- By customizing and extending generic views, developers
can address specific needs and enhance functionality as
needed.

Making "Friendly" Template Contexts

- Customizing template context names can enhance
readability and clarity for template authors.
- Providing descriptive variable names within the template
context improves the understanding of the content being
displayed.
- For instance, renaming variables like `object_list` to
Page 01 of 02
07082024
 21CS62
`publisher_list` can make the template more intuitive and
user-friendly.

Examples of Extending Generic Views

- Modifying template context names for better clarity and
understanding.
- Adding extra context to generic views to include additional
objects in the template.
- Implementing callbacks in `extra_context` to ensure
dynamic evaluation of data.
- Addressing potential issues with query evaluation timing
in extended generic views.

Benefits of Extending Generic Views

- Improved customization and flexibility in handling various
view requirements.
- Enhanced user experience through clear and intuitive
template contexts.
- Efficient utilization of Django's generic views with tailored
modifications for specific project needs.

Page 01 of 02
07082024
 21CS62

OR
Q. 08 a For student’s enrolment, create a generic class view which L2 4 10
displays
list of students and detail view that displays student details
for any selected student in the list.

Step-by-Step Guide to Creating a Generic Class-Based

View for Student Enrollment

Step 1: Define the Student Model

1. Navigate to your Django app's `models.py` file.

2. Define the `Student` model with the necessary fields.

```python
from django.db import models

class Student(models.Model):
name = models.CharField(max_length=100)
enrollment_number =
models.CharField(max_length=50, unique=True)
course = models.CharField(max_length=100)
date_of_birth = models.DateField()

def __str__(self):
return self.name
```

3. Save the `models.py` file.

Step 2: Create the Views

1. In your Django app, create or open the `views.py` file.

2. Import the required generic views and your `Student`
model.

```python
from django.views.generic import ListView, DetailView
from .models import Student
```

3. Create the `StudentListView` class to display the list of

students.

```python
class StudentListView(ListView):

Page 02 of 02
07082024
 21CS62
model = Student
template_name = 'students/student_list.html'
context_object_name = 'students'
```

4. Create the `StudentDetailView` class to display the

details of a selected student.

```python
class StudentDetailView(DetailView):
model = Student
template_name = 'students/student_detail.html'
context_object_name = 'student'
```

5. Save the `views.py` file.

Step 3: Define URLs

1. In your Django app, create or open the `urls.py` file.

2. Import the `StudentListView` and `StudentDetailView`
classes.

```python
from django.urls import path
from .views import StudentListView, StudentDetailView
```

3. Define the URL patterns for the list and detail views.

```python
urlpatterns = [
path('students/', StudentListView.as_view(),
name='student_list'),
path('students/<int:pk>/', StudentDetailView.as_view(),
name='student_detail'),
]
```

4. Save the `urls.py` file.

Step 4: Create Templates

1. Inside your app's `templates` directory, create a folder

named `students`.
2. Inside the `students` folder, create two HTML files:
`student_list.html` and `student_detail.html`.

Page 02 of 02
07082024
 21CS62
Creating `student_list.html`

1. Open the `student_list.html` file.

2. Add the following HTML code to display the list of
students:

```html
<!DOCTYPE html>
<html>
<head>
<title>Student List</title>
</head>
<body>
<h1>List of Students</h1>
<ul>
{% for student in students %}
<li><a href="{% url 'student_detail' student.pk
%}">{{ student.name }}</a></li>
{% endfor %}
</ul>
</body>
</html>
```

3. Save the `student_list.html` file.

Creating `student_detail.html`

1. Open the `student_detail.html` file.

2. Add the following HTML code to display the details of a
selected student:

```html
<!DOCTYPE html>
<html>
<head>
<title>{{ student.name }} - Details</title>
</head>
<body>
<h1>Details for {{ student.name }}</h1>
<p>Enrollment Number: {{ student.enrollment_number
}}</p>
<p>Course: {{ student.course }}</p>
<p>Date of Birth: {{ student.date_of_birth }}</p>
<a href="{% url 'student_list' %}">Back to Student
List</a>
</body>
</html>
Page 02 of 02
07082024
 21CS62
```

3. Save the `student_detail.html` file.

Step 5: Run Migrations

1. Open your terminal or command prompt.

2. Run the following commands to apply the migrations:

```bash
python manage.py makemigrations
python manage.py migrate
```

Step 6: Run the Development Server

1. Start the Django development server by running:

```bash
python manage.py runserver
```

2. Open your web browser and navigate to

`http://127.0.0.1:8000/students/`.

- You should see the list of students.

- Clicking on a student's name will take you to the detail
view for that student.

This completes the setup for displaying a list of students

and their details using generic class-based views in
Django.
b Write a note on followings i) Cookies ii) Users L2 4 10
and
Authentications.

Cookies
- Definition : Cookies are small pieces of data stored on
a user's device by websites to remember user
information or track user behavior.
- Purpose : Used for authentication, session
management, personalization, tracking, and analytics. -
Types : Session cookies (temporary), persistent cookies
(remain until deleted or expired), secure cookies (
transmitted over HTTPS), third-party cookies (from
external domains).
- Regulations : Subject to data privacy laws like
Page 02 of 02
07082024
 21CS62
GDPR, requiring user consent for non-essential cookies.

Users and Authentications

- Users : Represented by User instances, including
authenticated users and AnonymousUser instances for
unauthenticated users.
- Functions :
- `user`: Represents the current logged-in user.
- `messages`: Stores messages for logged-in users.
- `perms`: Represents the permissions of the current
logged-in user.
- Authentication : Involves verifying user identities to
grant access to resources.
- Context Processors : Used to add user-related
information to templates in Django applications.
- Permissions : Managed through `PermWrapper` to
control user access rights.

Page 02 of 02
07082024
 21CS62
Module-5
DOWNLOAD
Q. 09 a List and explain the technologies Ajax is overlaid on. L2 5 10

Technologies Ajax is Overlaid On

JavaScript
- JavaScript is the primary technology that Ajax is overlaid
on.
- Ajax runs JavaScript as its engine, working with various
components such as XMLHttpRequest, HTML, CSS, DOM,
XML, JSON, and more.

XMLHttpRequest
- XMLHttpRequest is a crucial component for Ajax
functionality.
- It is used to make asynchronous requests to the server
without needing to reload the entire web page.

HTML, XHTML, HTML5

- Ajax works with HTML, XHTML, and HTML5 for
dynamic content manipulation on web pages.
- These technologies are essential for updating specific parts
of a webpage without refreshing the entire page.

CSS
- Cascading Style Sheets (CSS) are utilized in conjunction
with JavaScript for styling and formatting web content
dynamically in Ajax applications.

JSON
- JavaScript Object Notation (JSON) is commonly used with
Ajax in place of XML for data interchange.
- JSON is lightweight and efficient for transmitting data
between the client and server in Ajax applications.

DOM (Document Object Model)

- The Document Object Model is manipulated by JavaScript
to dynamically update the content of web pages in response to
Ajax requests.

Other Technologies
- Ajax can also work with additional technologies beyond the
core ones mentioned above, depending on specific application
requirements.
- AJAX can be implemented in conjunction with various
server-side technologies to create interactive and responsive
web applications.
Page 02 of 02
07082024
 21CS62

Conclusion
Ajax is a technique overlaid on multiple client-side
technologies, primarily JavaScript, that enables dynamic web
content updates without full page reloads. By leveraging
technologies like XMLHttpRequest, HTML, CSS, JSON, and
others, Ajax enhances user experience and interactivity on
web pages.

b Explain XHTML Http Request and Response. L2 5 10

Understanding XHTML Http Request and Response

Explanation of XHTML Http Request and Response

XHTML Http Request and Response are key components in

web development, particularly in the context of Django Ajax
with jQuery. Below are some relevant details extracted from
the provided documents:

1. Django Templating Engine and Ajax :

- The Django templating engine in Django Ajax
applications plays a crucial role in separating presentation
and logic.
- It is designed to provide power for presentation purposes
rather than for serious programming work.
- Django's templating engine allows for the integration of
Ajax requests and responses seamlessly.

2. jQuery Integration :
- jQuery is highlighted as the most common JavaScript
library used in conjunction with Django for web
development.
- It is noted for its ease of use and designed to facilitate
powerful results with simplicity, similar to Python's
approach.

3. Ajax Functionality :
- Ajax is described as a technique overlaid on top of
existing technologies, not a standalone technology.
- It enables asynchronous communication between the
client and server, enhancing user experience by allowing
data retrieval without a full page reload.

4. Application Development :
- The chapters in the document outline a detailed case
study on building a Django Ajax web application using
jQuery.
Page 02 of 02
07082024
 21CS62
- Topics covered include validating form input on the
server side using Ajax requests, server-side database
searches with Ajax, and more.

Key Features of the Integration Process

5. Separation of Concerns :
- The integration of XHTML Http Request and Response
in web development emphasizes the separation of concerns
between presentation and logic.
- This separation allows for efficient handling of data
exchange between the client and server.

6. Efficient Data Retrieval :

- By utilizing Ajax requests and responses, developers can
retrieve data from the server without refreshing the entire
web page.
- This asynchronous communication enhances the
responsiveness and interactivity of web applications.

Role of jQuery and Django Templating Engine

7. jQuery's Facilitation :
- jQuery simplifies the process of making Http requests
from the client side, enabling smoother interaction with the
server.
- Its integration with the Django templating engine
enhances the efficiency of rendering dynamic content based
on server responses.

8. Django Templating Engine Benefits :

- The Django templating engine in Django Ajax
applications aids in structuring and presenting data
dynamically.
- It provides a user-friendly interface for designers to
create visually appealing web interfaces.

Conclusion
XHTML Http Request and Response play a significant role
in modern web development, particularly when integrated
with technologies like jQuery and Django. By leveraging
these components effectively, developers can create
interactive and dynamic web applications with efficient data
exchange capabilities.

OR

Page 02 of 02
07082024
 21CS62
Q. 10 a List and explain the jQuery Ajax facilities. L2 5 10

jQuery Ajax Facilities

Overview
jQuery provides various Ajax facilities to enhance web
applications by enabling asynchronous communication
between the client and server. These facilities offer
efficient ways to handle data retrieval, form submissions,
and dynamic content updates without reloading the entire
web page.

List and Explanation of jQuery Ajax Facilities

1. $.ajax() Method :
- The foundational and low-level workhorse in jQuery for
making Ajax requests.
- Allows customization of request parameters such as
data, error handling, and success callbacks.
- Default values can be set using $.ajaxSetup().

2. $.get(), $.post(), $.load() Methods :

- Provide simplified alternatives to $.ajax() for common
Ajax tasks.
- $.get() and $.post() for making GET and POST
requests, respectively.
- $.load() for loading Ajax content into selected elements.

3. Error Handling :
- Implement error handling mechanisms to manage Ajax
request failures effectively.
- Utilize error callbacks within Ajax requests to display
error messages or handle specific error scenarios.
- Global error handling can be set up using
$.ajaxSetup({error: myErrorHandler}).

4. Server-Side Validation :
- Validate form input on the server side using Ajax
requests sent via jQuery.
- Ensure secure validation practices to verify input data
integrity and prevent malicious or invalid submissions.

5. Server-Side Database Search :

- Compare server-side and client-side searching
approaches for database queries.
- Evaluate the performance implications and limitations
of client-side processing for search functionalities.

Page 02 of 02
07082024
 21CS62
6. Authentication and Account Management :
- Implement Ajax-based authentication processes for user
sign-up and login functionalities.
- Explore client-side communication with the server to
handle authentication updates dynamically.

7. In-place Editing Using Ajax :

- Utilize jQuery to enable in-place editing features within
web applications.
- Implement background communication with the server
for persistent data changes without page reloads.

8. jQuery UI Autocomplete Integration :

- Integrate jQuery UI Autocomplete feature into Django
templates for enhanced user experience.
- Utilize jQuery's plugin-friendly design to incorporate
autocomplete functionality easily.

Conclusion
jQuery's Ajax facilities offer a robust toolkit for developers
to create interactive and responsive web applications with
seamless data exchange between the client and server.

b Write a program to develop a search application in L2 5 10

Django
using AJAX that displays courses enrolled by a student
being searched.

To develop a search application in Django that uses AJAX

to display courses enrolled by a student, you can follow
this step-by-step guide:

Step 1: Set Up the Django Project

1. Create a new Django project (if you haven't

already):

```bash
django-admin startproject student_course_search
cd student_course_search
```

2. Create a new app within the project:

```bash
python manage.py startapp courses
```

Page 02 of 02
07082024
 21CS62
3. Add the `courses` app to the `INSTALLED_APPS` in
`settings.py`:

```python
INSTALLED_APPS = [
Other installed apps...
'courses',
]
```

Step 2: Define the Models

1. Open the `models.py` file in the `courses` app and

define `Student` and `Course` models:

```python
from django.db import models

class Student(models.Model):
name = models.CharField(max_length=100)
enrollment_number =
models.CharField(max_length=50, unique=True)

def __str__(self):
return self.name

class Course(models.Model):
student = models.ForeignKey(Student,
related_name='courses', on_delete=models.CASCADE)
course_name = models.CharField(max_length=100)

def __str__(self):
return self.course_name
```

2. Apply the migrations to create the database tables:

```bash
python manage.py makemigrations
python manage.py migrate
```

Step 3: Create the AJAX Search View

1. In the `views.py` file, create a view to handle the

AJAX request:

```python
Page 02 of 02
07082024
 21CS62
from django.http import JsonResponse
from django.shortcuts import render
from .models import Student

def search_student_courses(request):
if request.is_ajax():
query = request.GET.get('query', None)
if query:
student =
Student.objects.filter(name__icontains=query).first()
if student:
courses =
student.courses.all().values('course_name')
courses_list = list(courses)
return JsonResponse({'courses': courses_list},
status=200)
return JsonResponse({'courses': []}, status=200)
return JsonResponse({'error': 'Invalid request'},
status=400)
```

2. Create a view for rendering the search page:

```python
def search_page(request):
return render(request, 'courses/search.html')
```

Step 4: Set Up URLs

1. In the `urls.py` file of the `courses` app, define the

URLs:

```python
from django.urls import path
from .views import search_student_courses, search_page

urlpatterns = [
path('search/', search_page, name='search_page'),
path('search/courses/', search_student_courses,
name='search_student_courses'),
]
```

2. Include the `courses` app's URLs in the main

`urls.py`:

```python
Page 02 of 02
07082024
 21CS62
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
path('admin/', admin.site.urls),
path('courses/', include('courses.urls')),
]
```

Step 5: Create the HTML Template

1. In the `templates` directory of the `courses` app,

create the `search.html` file:

```html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width,
initial-scale=1.0">
<title>Student Course Search</title>
<script
src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jque
ry.min.js"></script>
</head>
<body>
<h1>Search Courses by Student Name</h1>
<input type="text" id="studentName"
placeholder="Enter student name">
<button id="searchBtn">Search</button>

<h2>Courses Enrolled:</h2>
<ul id="courseList"></ul>

<script>
$(document).ready(function(){
$(' searchBtn').click(function(){
var query = $(' studentName').val();
$.ajax({
url: '{% url "search_student_courses" %}',
data: {'query': query},
dataType: 'json',
success: function(data){
$(' courseList').empty();
if (data.courses.length > 0) {
$.each(data.courses, function(index,
course){
Page 02 of 02
07082024
 21CS62
$(' courseList').append('<li>' +
course.course_name + '</li>');
});
} else {
$(' courseList').append('<li>No courses
found for this student.</li>');
}
}
});
});
});
</script>
</body>
</html>
```

Step 6: Run the Server and Test

1. Start the Django development server:

```bash
python manage.py runserver
```

2. Navigate to `http://127.0.0.1:8000/courses/search/` in
your browser.

- You should see a search box where you can enter a

student's name.
- Clicking the "Search" button will use AJAX to fetch and
display the courses the student is enrolled in.

Summary

- Models : `Student` and `Course` are defined with a

ForeignKey relationship.
- AJAX View : A view handles the AJAX request,
querying the `Student` model for matching students and
returning their courses.
- URLs : Proper URL patterns are set up for rendering
the search page and processing the AJAX request.
- Template : The `search.html` file contains the form, an
AJAX call and , a list to display the courses.

Page 02 of 02
07082024