基于变量创建模型与模板名称的技术实现咨询

Got it, even though this approach isn't exactly standard or aligned with best practices, let's walk through how you can implement this—assuming you're working with Django since you mentioned models and forms (adjust if you're using another framework):

First, set up your UserProfile model along with the three template-specific models. Each template model will have a one-to-one relationship with UserProfile to link them:

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

class UserProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    template = models.IntegerField(choices=[(1, 'Template 1'), (2, 'Template 2'), (3, 'Template 3')])
    # Add any other fields your profile needs here

class TemplateProfile1(models.Model):
    user_profile = models.OneToOneField(UserProfile, on_delete=models.CASCADE)
    # Fields unique to Template 1, e.g.:
    background_color = models.CharField(max_length=7, default="#ffffff")
    font_family = models.CharField(max_length=50, default="Arial")

class TemplateProfile2(models.Model):
    user_profile = models.OneToOneField(UserProfile, on_delete=models.CASCADE)
    # Fields unique to Template 2, e.g.:
    sidebar_width = models.IntegerField(default=250)
    header_image = models.ImageField(upload_to="template_headers/", blank=True)

class TemplateProfile3(models.Model):
    user_profile = models.OneToOneField(UserProfile, on_delete=models.CASCADE)
    # Fields unique to Template 3, e.g.:
    dark_mode_enabled = models.BooleanField(default=False)
    layout_style = models.CharField(max_length=20, choices=[("grid", "Grid"), ("list", "List")], default="grid")

When the user submits the profile form, you'll save the UserProfile first, then create the corresponding template model instance based on the selected template value. We'll also add logic to clean up old template profiles if the user switches templates later:

from django.shortcuts import render, redirect
from .forms import UserProfileForm
from .models import UserProfile, TemplateProfile1, TemplateProfile2, TemplateProfile3

def update_profile(request):
    # Get the existing UserProfile for the logged-in user
    profile_instance = request.user.userprofile

    if request.method == 'POST':
        form = UserProfileForm(request.POST, instance=profile_instance)
        if form.is_valid():
            saved_profile = form.save()
            selected_template = saved_profile.template

            # Delete any existing template profiles to avoid orphaned records
            TemplateProfile1.objects.filter(user_profile=saved_profile).delete()
            TemplateProfile2.objects.filter(user_profile=saved_profile).delete()
            TemplateProfile3.objects.filter(user_profile=saved_profile).delete()

            # Create the matching template profile
            if selected_template == 1:
                TemplateProfile1.objects.create(user_profile=saved_profile)
                # You can set default values here if needed, e.g.:
                # TemplateProfile1.objects.create(user_profile=saved_profile, background_color="#f0f0f0")
            elif selected_template == 2:
                TemplateProfile2.objects.create(user_profile=saved_profile)
            elif selected_template == 3:
                TemplateProfile3.objects.create(user_profile=saved_profile, dark_mode_enabled=True)

            return redirect('profile_updated')  # Redirect to a success page
    else:
        form = UserProfileForm(instance=profile_instance)

    return render(request, 'profile_edit.html', {'form': form})

A simple ModelForm will handle the dropdown selection for the template field:

from django import forms
from .models import UserProfile

class UserProfileForm(forms.ModelForm):
    class Meta:
        model = UserProfile
        fields = ['template']  # Add other profile fields here as needed

Just to reinforce what you already know—this approach isn't ideal. Maintaining separate models for each template violates the DRY (Don't Repeat Yourself) principle and makes future updates (like adding a 4th template) more tedious. A cleaner alternative would be a single TemplateProfile model with a template_type field and a JSONField to store template-specific config:

class TemplateProfile(models.Model):
    user_profile = models.OneToOneField(UserProfile, on_delete=models.CASCADE)
    template_type = models.IntegerField(choices=[(1, 'Template 1'), (2, 'Template 2'), (3, 'Template 3')])
    config = models.JSONField(default=dict)

This way, you only have one model to maintain, and you can store unique settings for each template in the config field (e.g., {"background_color": "#ffffff"} for Template 1). But if you're set on using separate models per template, the first solution will get the job done.

内容的提问来源于stack exchange，提问作者Jason Howard