Building a Full-Fledged Application Using Only Django Admin
Tags: django, python, admin, programming
Published: 2024-01-23 16:14:35

Django, renowned for its efficient, high-level Python framework, revolutionizes web development with its powerful and user-friendly admin interface. This feature-rich tool simplifies tasks like database operations and user authentication, aligning with Django’s “Don't Repeat Yourself” philosophy to promote rapid, clean design. Beyond just managing data, Django Admin’s versatility shines in its ability to create sophisticated applications. Its customizable models, views, and templates enable developers to craft complex systems, ranging from content management to e-commerce platforms, without venturing beyond Django's environment.

In this context, the development of a Tech Writer Portal exemplifies Django Admin's adaptability and strength. The portal, tailored for drafting, managing, and publishing technical content, harnesses Django Admin to offer an integrated platform for managing clients, tracking project statuses, and handling extensive articles. This case study not only highlights Django Admin’s capability to meet specific industry needs but also its proficiency in managing complex, content-driven workflows, transforming it into a fully functional application customized for tech writers' unique requirements.

---

# Overview of Django Admin
Django Admin, a key feature of the Django web framework, is celebrated for its simplicity and efficiency in managing database-driven websites. Its notable features include:
- Automatic Interface Generation: Auto-generates user-friendly interfaces, significantly cutting down development time.
- Customizable Models and Fields: Offers extensive customization for presenting and manipulating database models.
- User Authentication and Permissions: Provides built-in support for user authentication and granular access control.
- Inline Editing: Enables direct editing of related records within the parent record, enhancing workflow efficiency.
- Custom Actions and Filters: Supports creating custom actions for batch processing and filters for easier data navigation.
- Form and Field Validation: Ensures data integrity and consistency through robust validation.
- Responsive Design: Adapts to various devices and screen sizes for universal accessibility.
- Search and Organizational Tools: Includes advanced search functionality and tools for handling large datasets.

Django Admin is well-suited for building complex applications due to its extensive feature set, which includes:
- Rapid Prototyping and Development: Facilitates quick prototyping and deployment, handling initial setup and configuration.
- Customizable Dashboards: Allows the creation of tailored dashboards displaying key information and statistics.
- Extended Functionality through Extensions: Supports integration with various third-party packages, enhancing functionality.
- Complex Data Relationships Management: Efficiently manages intricate data relationships, such as many-to-many and one-to-many.
- Automated Workflow Management: Automates workflow aspects like email notifications and status updates for increased productivity.
- Custom Form and Field Behavior: Offers customization of forms and fields for unique data entry needs and validation rules, catering to specific business logic.

By capitalizing on these features, Django Admin becomes more than just an admin interface; it transforms into a powerful platform for building full-fledged web applications tailored to specific business needs.

---

# Building a Tech Writer Portal Using Django Admin
The construction of the Tech Writer Portal using Django Admin involves a structured approach to model creation and registration, which forms the backbone of the application.

## Step 1 - Defining Models for Clients, Status, and Articles
First, we make sure that we have a new Django app where we are going to create our application.
For that, you can run:

```
python manage.py startapp techwriter  
```


Don't forget to add it to the list of INSTALLED_APPS inside the settings.py file:

```
INSTALLED_APPS = [
    ...
    'techwriter',
]
```


Now we can create the models inside the techwriter application models.py file:

```
from django.db import models
from django.contrib.auth.models import User


class Client(models.Model):
    name = models.CharField(max_length=100)
    email = models.EmailField()
    industry_type = models.CharField(max_length=100)
    preferences = models.TextField()

    def __str__(self):
        return self.name

    class Meta:
        verbose_name_plural = 'Clients'


class Status(models.Model):
    name = models.CharField(max_length=100)
    description = models.TextField()

    def __str__(self):
        return self.name

    class Meta:
        verbose_name_plural = 'Status'


class Article(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()  # Rich text field can be implemented using a third-party package like django-ckeditor
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    client = models.ForeignKey(Client, on_delete=models.CASCADE, related_name='articles')
    status = models.ForeignKey(Status, on_delete=models.CASCADE, related_name='articles')
    deadline = models.DateField()
    last_modification_date = models.DateField(auto_now=True)
    # Additional fields like categories, tags, and comments can be added as needed

    def __str__(self):
        return self.title

    class Meta:
        verbose_name_plural = 'Articles'

```

The model definitions are comprised of three main models: Client, Status, and Article. The Client model is designed to store information about clients, the Status model is intended to track the status of articles and the Article model represents the articles themselves, with fields for title, content, and author.

Don't forget to create and run the migrations for the data model:

```
python manage.py makemigrations  # create migrations
python manage.py migrate  # run migrations
```


The Status will be the lookup for the possible status an article might have. We could use the Django Admin to add this information, but we can also create an initial data migration that populates it with standard statuses.

For that, you run: 

```
python manage.py makemigrations techwriter --empty --name load_initial_statuses
```


This will create an empty migrations file, like 000x_load_initial_statuses.py (where x is the migration number order). 

You can now edit the file to place the data loading logic:

```
from django.db import migrations

# Add this function
def add_status_data(apps, schema_editor):
    Status = apps.get_model('techwriter', 'Status')
    statuses = [
        'Draft',
        'Review',
        'Published'
    ]
    for status_name in statuses:
        Status.objects.create(name=status_name)


class Migration(migrations.Migration):

    # Standard migration logic, don't change
    dependencies = [
        ('techwriter', '0002_alter_article_options_alter_client_options_and_more'),
    ]

    # Add a new operation to run the previous function
    operations = [
        migrations.RunPython(add_status_data),
    ]

```

This completes the necessary data model for the Tech Writer application. In the next section, we will register the models with Django Admin to create our application.

---

Full article at https://developer-service.blog/building-a-full-fledged-application-using-only-django-admin/