First off, all your requirements are fully achievable with Django's built-in tools and some targeted customization. Let's break down each of your questions with clear, actionable steps and code examples:

1. Permissions to Assign for Content Editors #

For your content editor role, you’ll need to grant model-specific CRUD permissions for the three core modules. These are the exact permissions to assign:

• For Event: view_event, add_event, change_event, delete_event
• For Format: view_format, add_format, change_format, delete_format
• For Organiser: view_organiser, add_organiser, change_organiser, delete_organiser

You can assign these either via the Django Admin UI (once the group is created) or programmatically (recommended for consistency across environments).

Programmatically Create the Content Editor Group #

Add this code to a management command or a post-migration signal to automate group creation:

from django.contrib.auth.models import Group, Permission
from django.contrib.contenttypes.models import ContentType
from main.models import Event, Format, Organiser

def create_content_editor_group():
    # Get or create the group (avoids duplicates)
    group, created = Group.objects.get_or_create(name='Content Editors')
    
    # Fetch content types for your core models
    event_ct = ContentType.objects.get_for_model(Event)
    format_ct = ContentType.objects.get_for_model(Format)
    organiser_ct = ContentType.objects.get_for_model(Organiser)
    
    # Grab all permissions for each model
    event_perms = Permission.objects.filter(content_type=event_ct)
    format_perms = Permission.objects.filter(content_type=format_ct)
    organiser_perms = Permission.objects.filter(content_type=organiser_ct)
    
    # Assign permissions to the group
    group.permissions.add(*event_perms, *format_perms, *organiser_perms)
    group.save()

# Call this function (e.g., in a management command or on app startup)
create_content_editor_group()

2. Groups vs Custom User Fields: Stick with Django Groups #

Definitely use Django’s built-in Group system—here’s why it’s the right choice:

• It’s purpose-built for role-based permission management and integrates seamlessly with Django’s auth framework.
• Your custom User model already supports groups because it inherits from PermissionsMixin (which includes a many-to-many relationship with Group out of the box).
• Adding a custom role field would force you to write extra code to check permissions everywhere (views, templates, admin), which is redundant and error-prone.
• Groups are scalable: if you need to add new roles later (like "Event Moderators" with limited delete access), you can create a new group and adjust permissions without touching your User model.

To assign a user to the Content Editors group, do this via the Admin UI (edit the user, find the "Groups" section) or programmatically:

user = User.objects.get(email='editor@example.com')
content_editor_group = Group.objects.get(name='Content Editors')
user.groups.add(content_editor_group)
user.save()

3. Customizing the Admin for Content Editors #

Yes, you can absolutely extract the core modules to a tailored admin experience with custom styling. Here are two flexible approaches:

Option 1: Override the Admin Index Template #

This modifies the default admin homepage to only show your core modules and apply custom styling.

1. Create a templates/admin directory in your project root.
2. Copy Django’s default index.html (found in django/contrib/admin/templates/admin/index.html) into this directory.
3. Modify the template to filter modules and add custom CSS:

{% extends "admin/base_site.html" %}
{% load i18n static %}

{% block extrastyle %}
    {{ block.super }}
    <style>
        /* Custom styling for content editors */
        #header { background-color: #2d3748; }
        .module h2 { color: #2d3748; }
        /* Hide superuser-only elements for content editors */
        {% if not request.user.is_superuser %}
            #site-name { display: none; }
            .object-tools { display: none; }
        {% endif %}
    </style>
{% endblock %}

{% block content %}
    <div id="content-main">
        {% if app_list %}
            {% for app in app_list %}
                <!-- Only show your core modules -->
                {% if app.name in 'Events, Formats, Organisers' %}
                    <div class="app-{{ app.app_label }} module">
                        <table>
                            <caption>
                                <a href="{{ app.app_url }}" class="section">{{ app.name }}</a>
                            </caption>
                            {% for model in app.models %}
                                <tr class="model-{{ model.object_name|lower }}">
                                    {% if model.admin_url %}
                                        <th scope="row"><a href="{{ model.admin_url }}">{{ model.name }}</a></th>
                                    {% else %}
                                        <th scope="row">{{ model.name }}</th>
                                    {% endif %}
                                    {% if model.add_url %}
                                        <td><a href="{{ model.add_url }}" class="addlink">{% translate 'Add' %}</a></td>
                                    {% else %}
                                        <td>&nbsp;</td>
                                    {% endif %}
                                    {% if model.admin_url and show_changelinks %}
                                        <td><a href="{{ model.admin_url }}" class="changelink">{% translate 'Change' %}</a></td>
                                    {% else %}
                                        <td>&nbsp;</td>
                                    {% endif %}
                                </tr>
                            {% endfor %}
                        </table>
                    </div>
                {% endif %}
            {% endfor %}
        {% else %}
            <p>{% translate "You don't have permission to view or edit anything." %}</p>
        {% endif %}
    </div>
{% endblock %}

Option 2: Build a Custom Content Editor Dashboard #

If you want a completely separate page outside the default admin, create a custom view with permission checks:

# in main/views.py
from django.contrib.auth.decorators import login_required, user_passes_test
from django.shortcuts import render
from main.models import Event, Format, Organiser

def is_content_editor(user):
    return user.groups.filter(name='Content Editors').exists()

@login_required
@user_passes_test(is_content_editor)
def content_editor_dashboard(request):
    # Pass data to your custom template
    events = Event.objects.all()
    formats = Format.objects.all()
    organisers = Organiser.objects.all()
    return render(request, 'content_editor_dashboard.html', {
        'events': events,
        'formats': formats,
        'organisers': organisers,
    })

Then create templates/content_editor_dashboard.html with your own navigation bar, styling, and module layouts.

Customizing Model Detail Pages #

To tweak the look of individual module pages (like Event details), override their ModelAdmin classes:

# in main/admin.py
from django.contrib import admin
from .models import Event, Format, Organiser

class CustomModelAdmin(admin.ModelAdmin):
    # Use a custom change form template
    change_form_template = 'admin/custom_change_form.html'

class EventManager(CustomModelAdmin):
    list_display = ['event_name', 'organiser_of_event', 'format_of_event', 'date_of_event', 'registration_fees', 'created_at', 'updated_at']
    # Add custom filters, actions, or field layouts here

class FormatManager(CustomModelAdmin):
    # Customize Format admin here
    pass

class OrganiserManager(CustomModelAdmin):
    # Customize Organiser admin here
    pass

admin.site.register(Format, FormatManager)
admin.site.register(Organiser, OrganiserManager)
admin.site.register(Event, EventManager)

Create templates/admin/custom_change_form.html to add custom CSS or modify the page layout.

Final Tips #

• Run python manage.py collectstatic after adding custom templates to ensure they’re loaded correctly.
• Test permissions thoroughly: log in as a content editor to confirm they can only access the three core modules.
• For finer control (like hiding specific fields from editors), use fields/exclude in your ModelAdmin or override get_fields() to conditionally show fields based on user permissions.

内容的提问来源于stack exchange，提问作者Kushagra Gupta