DEV Community: Joe

Filtering and Searching Transactions

Joe — Thu, 11 Sep 2025 22:32:41 +0000

Let’s add filter options to your transaction list, so users can:

Filter by date range
Filter by category
Filter by transaction type
Search notes

1. Update Your View: Accept Query Parameters

We’ll use GET parameters for filtering.

```python name=tracker/views.py
from django.db.models import Sum, Q
from .models import Transaction, Category

def transaction_list(request):
# Get filter params
category_id = request.GET.get('category')
transaction_type = request.GET.get('transaction_type')
start_date = request.GET.get('start_date')
end_date = request.GET.get('end_date')
search_query = request.GET.get('search')

transactions = Transaction.objects.select_related('category').order_by('-date')

# Apply filters
if category_id:
    transactions = transactions.filter(category_id=category_id)
if transaction_type:
    transactions = transactions.filter(transaction_type=transaction_type)
if start_date:
    transactions = transactions.filter(date__gte=start_date)
if end_date:
    transactions = transactions.filter(date__lte=end_date)
if search_query:
    transactions = transactions.filter(notes__icontains=search_query)

# Summaries (same as before)
income = transactions.filter(transaction_type='IN').aggregate(total=Sum('amount'))['total'] or 0
expenses = transactions.filter(transaction_type='EX').aggregate(total=Sum('amount'))['total'] or 0
balance = income - expenses
category_totals = transactions.values('category__name').annotate(total=Sum('amount'))

# Send all categories for filter dropdown
categories = Category.objects.all()

return render(request, 'tracker/transaction_list.html', {
    'transactions': transactions,
    'income': income,
    'expenses': expenses,
    'balance': balance,
    'category_totals': category_totals,
    'categories': categories,
    'selected_category': category_id,
    'selected_type': transaction_type,
    'start_date': start_date,
    'end_date': end_date,
    'search_query': search_query,
})




---

### **2. Update Your Template: Add Filter Form**

Add this form above your transaction list in `transaction_list.html`:



````html
<form method="get">
    <label>Category:
        <select name="category">
            <option value="">All</option>
            {% for cat in categories %}
                <option value="{{ cat.id }}" {% ifselected_category == cat.id|stringformat:"s" %}selected{% endif %}>{{ cat.name }}</option>
            {% endfor %}
        </select>
    </label>
    <label>Type:
        <select name="transaction_type">
            <option value="">All</option>
            <option value="IN" {% if selected_type == "IN" %}selected{% endif %}>Income</option>
            <option value="EX" {% if selected_type == "EX" %}selected{% endif %}>Expense</option>
        </select>
    </label>
    <label>Start Date:<input type="date" name="start_date" value="{{ start_date }}"></label>
    <label>End Date:<input type="date" name="end_date" value="{{ end_date }}"></label>
    <label>Search Notes:<input type="text" name="search" value="{{ search_query }}"></label>
    <button type="submit">Filter</button>
    <a href="{% url 'transaction_list' %}">Clear</a>
</form>

Django Finance App: Summaries & Analytics (Income, Expenses, Balance)

Joe — Thu, 11 Sep 2025 22:17:53 +0000

Liquid syntax error: Unknown tag 'url'

Django CRUD: Building Views, Forms & Templates for Your Finance App

Joe — Thu, 11 Sep 2025 21:59:30 +0000

Liquid syntax error: Unknown tag 'url'

Django Admin: Powerful Data Management for Finance Apps

Joe — Thu, 11 Sep 2025 21:59:08 +0000

Django comes with a built-in admin interface—no coding required!

1. Create a Superuser

Run:

python manage.py createsuperuser

Follow the prompts.

2. Register Models for Admin

Edit tracker/admin.py:

from django.contrib import admin
from .models import Category, Transaction

@admin.register(Category)
class CategoryAdmin(admin.ModelAdmin):
    list_display = ['name']

@admin.register(Transaction)
class TransactionAdmin(admin.ModelAdmin):
    list_display = ['date', 'transaction_type', 'category', 'amount']
    list_filter = ['transaction_type', 'category', 'date']
    search_fields = ['notes']

3. Run the Server & Use Admin

python manage.py runserver

Go to http://127.0.0.1:8000/admin/

Now you can add, edit, delete, and search transactions and categories!

Next: building custom views, forms, and templates.

Django Migrations: Turning Models Into Database Tables

Joe — Thu, 11 Sep 2025 21:58:42 +0000

Django migrations take your Python models and create real database tables.

1. Create Migrations

Run:

python manage.py makemigrations tracker

2. Apply Migrations

Run:

python manage.py migrate

3. What Just Happened?

The Category and Transaction tables are now in your database!
Django tracks changes for future updates.

Next: manage your data easily with Django admin.

Designing Django Models: Transactions & Categories for Finance Apps

Joe — Thu, 11 Sep 2025 21:58:27 +0000

To track finances, we need two main data types—categories (like "Food") and transactions (money in or out).

1. Plan Your Models

Category: e.g. Food, Rent, Salary
Transaction: amount, date, category, type, notes

2. Code the Models

Edit tracker/models.py:

from django.db import models

class Category(models.Model):
    name = models.CharField(max_length=50, unique=True)
    def __str__(self):
        return self.name

class Transaction(models.Model):
    INCOME = 'IN'
    EXPENSE = 'EX'
    TRANSACTION_TYPES = [
        (INCOME, 'Income'),
        (EXPENSE, 'Expense'),
    ]
    category = models.ForeignKey(Category, on_delete=models.CASCADE)
    amount = models.DecimalField(max_digits=10, decimal_places=2)
    date = models.DateField()
    transaction_type = models.CharField(max_length=2, choices=TRANSACTION_TYPES)
    notes = models.TextField(blank=True)
    def __str__(self):
        return f"{self.get_transaction_type_display()} - {self.category.name}: {self.amount} on {self.date}"

3. Why This Structure?

ForeignKey connects transactions to categories
Choices enforce transaction type

Let’s turn these models into database tables next!

Creating Your First Django App for Personal Finance

Joe — Thu, 11 Sep 2025 21:57:59 +0000

Now that our Django project is set up, it's time to add an app—the heart of your financial tracker!

1. What Is a Django App?

A "Django app" is a module that handles a specific feature (like tracking transactions). Projects can have many apps.

2. Create the Tracker App

Run this command:

python manage.py startapp tracker

Your folder now includes tracker/ with:

models.py: Data models
views.py: Request handlers
admin.py: Admin settings

3. Register the App

Open config/settings.py and add 'tracker', to INSTALLED_APPS:

INSTALLED_APPS = [
    # ...default apps
    'tracker',
]

4. Why Register?

This lets Django know to include your app's models, views, and admin features.

Next up: designing the models for your tracker!

Setting Up Django: Your Financial Tracker Starts Here

Joe — Thu, 11 Sep 2025 21:57:31 +0000

Setting Up Django: Your Financial Tracker Starts Here

Welcome to Part 2 of my Django financial tracker series! In this post, we'll go from zero to a working Django project—you'll be ready to code in minutes.

1. Create a Python Virtual Environment

A virtual environment keeps your dependencies isolated.

Run these commands in your project folder:

python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

2. Install Django

Install Django inside your virtual environment:

pip install django

3. Start Your Django Project

In your folder, run:

django-admin startproject config .

Your folder should now look like:

config/
    __init__.py
    settings.py
    urls.py
    asgi.py
    wsgi.py
manage.py

4. What Are These Files?

manage.py: Django's command-line utility
config/: Project settings, URLs, and core files

That’s it! You’ve got a Django project ready to go.

Next up: creating the core tracker app.

Building a Django Financial Tracker: Planning, Goals, and Kickoff

Joe — Thu, 11 Sep 2025 21:22:02 +0000

Hi devs! I’m Hermit-commits-code, and I’m starting a hands-on series where I build a personal finance tracker from scratch—using Django and some modern frontend tools.

Why? Just like many devs, I want to better manage my money, but I also want a tool that fits my workflow and gives me a reason to level up my backend skills. Plus, I love sharing what I learn in public!

What Will This Project Do?

I’m aiming for:

Tracking income and expenses with details for each transaction
Categories (like Food, Rent, Salary) for every transaction
Summaries and analytics (totals, balances, breakdowns)
Search and filter tools (by category, date, amount, etc.)
A modern UI (planning to use HTMX for dynamic interactions after the backend is up)

Bonus goals:

CSV import/export
User authentication
Budgets and alerts
Analytics charts

Tech Stack

Backend: Django (Python)
Frontend: HTMX (for interactivity, later in the series)
Database: SQLite (simple for dev; upgradeable)
Platform: dev.to for blogging the journey

My Approach

Share every step, including the “why” behind design choices
Include code, commands, and explanations
Be honest about mistakes, pivots, and discoveries
Welcome feedback (and maybe even collaborators!)

What’s Next?

The next post will cover:

Creating a Python virtual environment
Installing Django
Bootstrapping the project folder

I’ll include all commands and code so you can follow along—or use this as a reference for your own Django projects.

Ready to build together? Let’s go!

Stay tuned for Part 2: “Setting Up Django From Scratch for Your Financial Tracker”