在管理的内联窗体中选择时限制外键的选择

这种模式的逻辑是:

  • Building有许多 Rooms
  • 一个 Room可能在另一个 Room里面(例如,一个壁橱——“ self”上的 ForeignKey)
  • 一个 Room只能在同一栋楼里的另一个 Room里面(这是比较棘手的部分)

我的密码是这样的:

#spaces/models.py
from django.db import models


class Building(models.Model):
name=models.CharField(max_length=32)
def __unicode__(self):
return self.name


class Room(models.Model):
number=models.CharField(max_length=8)
building=models.ForeignKey(Building)
inside_room=models.ForeignKey('self',blank=True,null=True)
def __unicode__(self):
return self.number

以及:

#spaces/admin.py
from ex.spaces.models import Building, Room
from django.contrib import admin


class RoomAdmin(admin.ModelAdmin):
pass


class RoomInline(admin.TabularInline):
model = Room
extra = 2


class BuildingAdmin(admin.ModelAdmin):
inlines=[RoomInline]


admin.site.register(Building, BuildingAdmin)
admin.site.register(Room)

内联将只显示当前大楼中的房间(这是我想要的)。但问题是,对于 inside_room下拉列表,它显示 Rooms 表中的所有房间(包括其他建筑中的房间)。

在内联的 rooms,我需要限制的 inside_room选择只有 rooms是在当前的 building(建筑记录目前正在改变的主要 BuildingAdmin形式)。

我不能找到一种方法来做到这一点,无论是在模型中的 limit_choices_to,也不能弄清楚如何确切覆盖管理员的内联格式集正确(我觉得我应该以某种方式创建一个自定义内联表单,传递主表单的 build _ id 到自定义内联表单,然后限制查询集为字段的选择基于这一点-但我只是不能理解如何做到这一点)。

也许这对于管理站点来说太复杂了,但它似乎是一些通常有用的东西..。

43066 次浏览

If Daniel, after editing your question, hasn't answered - I don't think I will be much help... :-)

I'm going to suggest that you are trying to force fit into the django admin some logic that would be better off implemented as your own group of views, forms and templates.

I don't think it is possible to apply that sort of filtering to the InlineModelAdmin.

I have to admit, I didn't follow exactly what you're trying to do, but I think it's complex enough that you might want to consider not basing your site off of the admin.

I built a site once that started out with the simple admin interface, but eventually became so customized that it became very difficult to work with within the constraints of the admin. I would have been better off if I'd just started from scratch--more work at the beginning, but a lot more flexibility and less pain at the end. My rule-of-thumb would be if that what you're trying to do is not documented (ie. involves overriding admin methods, peering into the admin source code etc.) then you're probably better off not using the admin. Just me two cents. :)

This question and answer is very similar, and works for a regular admin form

Inside of an inline--and that's where it falls apart... I just can't get at the main form's data to get the foreign key value I need in my limit (or to one of the inline's records to grab the value).

Here's my admin.py. I guess I'm looking for the magic to replace the ???? with--if I plug in a hardcoded value (say, 1), it works fine and properly limits the the available choices in the inline...

#spaces/admin.py
from demo.spaces.models import Building, Room
from django.contrib import admin
from django.forms import ModelForm




class RoomInlineForm(ModelForm):
def __init__(self, *args, **kwargs):
super(RoomInlineForm, self).__init__(*args, **kwargs)
self.fields['inside_room'].queryset = Room.objects.filter(
building__exact=????)                       # <------


class RoomInline(admin.TabularInline):
form = RoomInlineForm
model=Room


class BuildingAdmin(admin.ModelAdmin):
inlines=[RoomInline]


admin.site.register(Building, BuildingAdmin)
admin.site.register(Room)

I found a fairly elegant solution that works well for inline forms.

Applied to my model, where I'm filtering the inside_room field to only return rooms that are in the same building:

#spaces/admin.py
class RoomInlineForm(ModelForm):
def __init__(self, *args, **kwargs):
super(RoomInlineForm, self).__init__(*args, **kwargs)  #On init...
if 'instance' in kwargs:
building = kwargs['instance'].building
else:
building_id = tuple(i[0] for i in self.fields['building'].widget.choices)[1]
building = Building.objects.get(id=building_id)
self.fields['inside_room'].queryset = Room.objects.filter(building__exact=building)

Basically, if an 'instance' keyword is passed to the form, it's an existing record showing in the inline, and so I can just grab the building from the instance. If not an instance, it's one of the blank "extra" rows in the inline, and so it goes through the hidden form fields of the inline that store the implicit relation back to the main page, and grabs the id value from that. Then, it grabs the building object based on that building_id. Finally, now having the building, we can set the queryset of the drop downs to only display the relevant items.

More elegant than my original solution, which crashed and burned as inline (but worked--well, if you don't mind saving the form partway to make the drop downs fill in-- for the individual forms):

class RoomForm(forms.ModelForm): # For the individual rooms
class Meta:
mode = Room
def __init__(self, *args, **kwargs):  # Limits inside_room choices to same building only
super(RoomForm, self).__init__(*args, **kwargs)  #On init...
try:
self.fields['inside_room'].queryset = Room.objects.filter(
building__exact=self.instance.building)   # rooms with the same building as this room
except:                  #and hide this field (why can't I exclude?)
self.fields['inside_room']=forms.CharField( #Add room throws DoesNotExist error
widget=forms.HiddenInput,
required=False,
label='Inside Room (save room first)')

For non-inlines, it worked if the room already existed. If not, it would throw an error (DoesNotExist), so I'd catch it and then hide the field (since there was no way, from the Admin, to limit it to the right building, since the whole room record was new, and no building was yet set!)...once you hit save, it saves the building and on reload it could limit the choices...

I just need to find a way to cascade the foreign key filters from one field to another in a new record--i.e., new record, select a building, and it automatically limits the choices in the inside_room select box--before the record gets saved. But that's for another day...

Used request instance as temporary container for obj. Overrided Inline method formfield_for_foreignkey to modify queryset. This works at least on django 1.2.3.

class RoomInline(admin.TabularInline):


model = Room


def formfield_for_foreignkey(self, db_field, request=None, **kwargs):


field = super(RoomInline, self).formfield_for_foreignkey(db_field, request, **kwargs)


if db_field.name == 'inside_room':
if request._obj_ is not None:
field.queryset = field.queryset.filter(building__exact = request._obj_)
else:
field.queryset = field.queryset.none()


return field






class BuildingAdmin(admin.ModelAdmin):


inlines = (RoomInline,)


def get_form(self, request, obj=None, **kwargs):
# just save obj reference for future processing in Inline
request._obj_ = obj
return super(BuildingAdmin, self).get_form(request, obj, **kwargs)

After reading through this post and experimenting a lot I think I have found a rather definitive answer to this question. As this is a design pattern that is ofter used I have written a Mixin for the Django admin to make use of it.

(Dynamically) limiting the queryset for ForeignKey fields is now as simple as subclassing LimitedAdminInlineMixin and defining a get_filters(obj) method to return the relevant filters. Alternateively, a filters property can be set on the admin if dynamic filtering is not required.

Example usage:

class MyInline(LimitedAdminInlineMixin, admin.TabularInline):
def get_filters(self, obj):
return (('<field_name>', dict(<filters>)),)

Here, <field_name> is the name of the FK field to be filtered and <filters> is a list of parameters as you would normally specify them in the filter() method of querysets.

You can create a couple of custom classes that will then pass along a reference to the parent instance to the form.

from django.forms.models import BaseInlineFormSet
from django.forms import ModelForm


class ParentInstInlineFormSet(BaseInlineFormSet):
def _construct_forms(self):
# instantiate all the forms and put them in self.forms
self.forms = []
for i in xrange(self.total_form_count()):
self.forms.append(self._construct_form(i, parent_instance=self.instance))


def _get_empty_form(self, **kwargs):
return super(ParentInstInlineFormSet, self)._get_empty_form(parent_instance=self.instance)
empty_form = property(_get_empty_form)




class ParentInlineModelForm(ModelForm):
def __init__(self, *args, **kwargs):
self.parent_instance = kwargs.pop('parent_instance', None)
super(ParentInlineModelForm, self).__init__(*args, **kwargs)

in class RoomInline just add:

class RoomInline(admin.TabularInline):
formset = ParentInstInlineFormset
form = RoomInlineForm #(or something)

In your form you now have access in the init method to self.parent_instance! parent_instance can now be used to filter choices and whatnot

something like:

class RoomInlineForm(ParentInlineModelForm):
def __init__(self, *args, **kwargs):
super(RoomInlineForm, self).__init__(*args, **kwargs)
building = self.parent_instance
#Filtering and stuff

There is limit_choices_to ForeignKey option that allows to limit the available admin choices for the object

In django 1.6:

 form = SpettacoloForm( instance = spettacolo )
form.fields['teatro'].queryset = Teatro.objects.filter( utente = request.user ).order_by( "nome" ).all()

The problem in @nogus answer there's still wrong url in popup /?_to_field=id&_popup=1

which allow user to select wrong item in popup

To finally make it work I had to change field.widget.rel.limit_choices_to dict

class RoomInline(admin.TabularInline):
model = Room


def formfield_for_foreignkey(self, db_field, request=None, **kwargs):


field = super(RoomInline, self).formfield_for_foreignkey(
db_field, request, **kwargs)


if db_field.name == 'inside_room':
building = request._obj_
if building is not None:
field.queryset = field.queryset.filter(
building__exact=building)
# widget changed to filter by building
field.widget.rel.limit_choices_to = {'building_id': building.id}
else:
field.queryset = field.queryset.none()


return field


class BuildingAdmin(admin.ModelAdmin):


inlines = (RoomInline,)


def get_form(self, request, obj=None, **kwargs):
# just save obj reference for future processing in Inline
request._obj_ = obj
return super(BuildingAdmin, self).get_form(request, obj, **kwargs)