我一直在处理一个有序的ManyToManyField小部件，并且它的前端方面运行良好：
alt text http://i45.tinypic.com/33e79c8.png
不幸的是，我在后端工作方面遇到了很多麻烦。连接后端的一种显而易见的方法是使用through表，将ForeignKey的模型键入关系的两侧，并覆盖save方法。这会很有效，除了由于内容的特性，绝对要求将此小部件放在字段集中（使用ModelAdmin fieldsets属性），即apparently not possible。
我没有想法。有什么建议吗？
谢谢！
答案 0 :(得分：8)
关于如何设置模型，你是正确的，带有“order”列的直通表是表示它的理想方式。你也是对的，因为Django不会让你在字段集中引用那种关系。解决此问题的诀窍是要记住，您在ModelAdmin的“字段集”或“字段”中指定的字段名称实际上并不是指Model的字段，而是指字段ModelForm的{{1}}，我们可以自由地超越我们心中的喜悦。有很多2个字段，这很棘手，但请耐心等待：
假设您正试图代表竞争对手和竞争对手，竞争对手和竞争对手之间的订单数量很多，其中订单代表竞争对手在该竞赛中的排名。您的models.py将如下所示：
from django.db import models
class Contest(models.Model):
name = models.CharField(max_length=50)
# More fields here, if you like.
contestants = models.ManyToManyField('Contestant', through='ContestResults')
class Contestant(models.Model):
name = models.CharField(max_length=50)
class ContestResults(models.Model):
contest = models.ForeignKey(Contest)
contestant = models.ForeignKey(Contestant)
rank = models.IntegerField()
希望这与您正在处理的内容类似。现在，对于管理员。我写了一个例子admin.py，里面有很多评论来解释发生了什么，但这里有一个总结可以帮助你：
由于我没有编写你编写的有序m2m小部件的代码，我使用了一个简单地继承自TextInput的占位符虚拟小部件。输入包含一个逗号分隔的参赛者ID列表（没有空格），它们在字符串中的出现顺序决定了ContestResults模型中“rank”列的值。
我们用自己的方式覆盖竞赛的默认ModelForm，然后在其中定义“结果”字段（我们不能将字段称为“参赛者”，因为会有一个名字与模型中的m2m字段冲突）。然后我们覆盖__init__()，这在表单显示在管理员中时调用，因此我们可以获取可能已经为比赛定义的任何ContestResults，并使用它们来填充小部件。我们还会覆盖save()，以便我们可以从窗口小部件中获取数据并创建所需的ContestResults。
请注意，为了简单起见，此示例省略了诸如从窗口小部件验证数据之类的内容，因此如果您尝试在文本输入中键入任何意外的内容，事情就会中断。此外，创建ContestResults的代码非常简单，可以大大改进。
我还应该补充一点，我实际运行了这段代码并验证它是否有效。
from django import forms
from django.contrib import admin
from models import Contest, Contestant, ContestResults
# Generates a function that sequentially calls the two functions that were
# passed to it
def func_concat(old_func, new_func):
def function():
old_func()
new_func()
return function
# A dummy widget to be replaced with your own.
class OrderedManyToManyWidget(forms.widgets.TextInput):
pass
# A simple CharField that shows a comma-separated list of contestant IDs.
class ResultsField(forms.CharField):
widget = OrderedManyToManyWidget()
class ContestAdminForm(forms.models.ModelForm):
# Any fields declared here can be referred to in the "fieldsets" or
# "fields" of the ModelAdmin. It is crucial that our custom field does not
# use the same name as the m2m field field in the model ("contestants" in
# our example).
results = ResultsField()
# Be sure to specify your model here.
class Meta:
model = Contest
# Override init so we can populate the form field with the existing data.
def __init__(self, *args, **kwargs):
instance = kwargs.get('instance', None)
# See if we are editing an existing Contest. If not, there is nothing
# to be done.
if instance and instance.pk:
# Get a list of all the IDs of the contestants already specified
# for this contest.
contestants = ContestResults.objects.filter(contest=instance).order_by('rank').values_list('contestant_id', flat=True)
# Make them into a comma-separated string, and put them in our
# custom field.
self.base_fields['results'].initial = ','.join(map(str, contestants))
# Depending on how you've written your widget, you can pass things
# like a list of available contestants to it here, if necessary.
super(ContestAdminForm, self).__init__(*args, **kwargs)
def save(self, *args, **kwargs):
# This "commit" business complicates things somewhat. When true, it
# means that the model instance will actually be saved and all is
# good. When false, save() returns an unsaved instance of the model.
# When save() calls are made by the Django admin, commit is pretty
# much invariably false, though I'm not sure why. This is a problem
# because when creating a new Contest instance, it needs to have been
# saved in the DB and have a PK, before we can create ContestResults.
# Fortunately, all models have a built-in method called save_m2m()
# which will always be executed after save(), and we can append our
# ContestResults-creating code to the existing same_m2m() method.
commit = kwargs.get('commit', True)
# Save the Contest and get an instance of the saved model
instance = super(ContestAdminForm, self).save(*args, **kwargs)
# This is known as a lexical closure, which means that if we store
# this function and execute it later on, it will execute in the same
# context (i.e. it will have access to the current instance and self).
def save_m2m():
# This is really naive code and should be improved upon,
# especially in terms of validation, but the basic gist is to make
# the needed ContestResults. For now, we'll just delete any
# existing ContestResults for this Contest and create them anew.
ContestResults.objects.filter(contest=instance).delete()
# Make a list of (rank, contestant ID) tuples from the comma-
# -separated list of contestant IDs we get from the results field.
formdata = enumerate(map(int, self.cleaned_data['results'].split(',')), 1)
for rank, contestant in formdata:
ContestResults.objects.create(contest=instance, contestant_id=contestant, rank=rank)
if commit:
# If we're committing (fat chance), simply run the closure.
save_m2m()
else:
# Using a function concatenator, ensure our save_m2m closure is
# called after the existing save_m2m function (which will be
# called later on if commit is False).
self.save_m2m = func_concat(self.save_m2m, save_m2m)
# Return the instance like a good save() method.
return instance
class ContestAdmin(admin.ModelAdmin):
# The precious fieldsets.
fieldsets = (
('Basic Info', {
'fields': ('name', 'results',)
}),)
# Here's where we override our form
form = ContestAdminForm
admin.site.register(Contest, ContestAdmin)
如果你想知道，我自己在一个我正在研究的项目上遇到过这个问题，所以这些代码大部分来自那个项目。我希望你觉得它很有用。