Migrating Pages Between Django Apps

Your current approach has a significant issue: it redirects all non-existent URLs to the new app, which isn't ideal for user experience or SEO. Here's a better strategy for migrating a small subset of pages between apps while maintaining URL integrity.

Option 1: Use a Data Migration with a Lookup Table

Instead of blindly redirecting, create a lookup table to track which pages have been migrated:

PYTHONCopied
# models.py in mainapp or a new migration_utils app
from django.db import models

class MigratedPage(models.Model):
    old_url = models.SlugField(unique=True)
    new_app = models.CharField(max_length=100)
    
    class Meta:
        indexes = [
            models.Index(fields=['old_url']),
        ]

Then modify your view to check this table:

PYTHONCopied
# mainapp/views.py
from django.shortcuts import redirect, get_object_or_404
from django.http import Http404
from .models import Page, MigratedPage

def generic(request, page_url):
    try:
        # Try to get the page from the main app
        page = Page.objects.get(url=page_url)
        return render(request, 'mainapp/page.html', {'page': page})
    except Page.DoesNotExist:
        # Check if this page has been migrated
        try:
            migrated = MigratedPage.objects.get(old_url=page_url)
            if migrated.new_app == 'newapp':
                return redirect('generic_newapp', page_url=page_url)
        except MigratedPage.DoesNotExist:
            # Page doesn't exist in either app
            raise Http404("Page does not exist")

Option 2: Use a Data Migration with a Custom Middleware

Create a middleware to handle redirects before the view is even called:

PYTHONCopied
# middleware.py
from django.shortcuts import redirect
from mainapp.models import MigratedPage

class PageRedirectMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        # Only process if it looks like a main app URL
        path = request.path.lstrip('/')
        if '/' not in path and path:
            try:
                migrated = MigratedPage.objects.get(old_url=path)
                if migrated.new_app == 'newapp':
                    return redirect('generic_newapp', page_url=path)
            except MigratedPage.DoesNotExist:
                pass
        
        return self.get_response(request)

Add this middleware to your settings:

PYTHONCopied
MIDDLEWARE = [
    # ... other middleware
    'yourproject.middleware.PageRedirectMiddleware',
    # ... other middleware
]

Creating the Migration

Use a data migration to populate your lookup table:

PYTHONCopied
from django.db import migrations

def populate_migrated_pages(apps, schema_editor):
    MigratedPage = apps.get_model('mainapp', 'MigratedPage')
    
    # List of pages to migrate
    migrated_pages = [
        'page1',
        'page2',
        # ... add all ~120 pages here
    ]
    
    for page_url in migrated_pages:
        MigratedPage.objects.create(
            old_url=page_url,
            new_app='newapp'
        )

class Migration(migrations.Migration):
    dependencies = [
        ('mainapp', 'previous_migration'),
    ]

    operations = [
        migrations.RunPython(populate_migrated_pages),
    ]

Benefits of This Approach

1. Only redirects URLs that have actually been migrated
2. Provides a clear record of which pages have moved
3. Avoids unnecessary redirects for non-existent pages
4. Follows Django's design philosophy of loose coupling between URLs and code
5. Makes it easy to migrate more pages in the future

This approach aligns with Django's design philosophy of URL flexibility while maintaining a clean separation between your apps.