How to filter the queryset used by the widgets in a form collection?

[tolland]

Hi,

I am trying to use the form collections for a set of nested models and filter the queryset for relevant form widgets in the context of the correct "parent" foreign key object. For example using the testapp companies model, if I have a form collection view on some "Department" and department has a field "sales_team" to teams. Then I want to filter the options in the sales_team selection widget in the department form to only those teams in the same department.

To show what I mean, I have added a "sales_team" field to department, which points (nullably) to one of its own teams.

    sales_team = models.ForeignKey(
        "Team",
        on_delete=models.CASCADE,
        related_name='sales_team',
        null=True,
    )

code

I tell the DepartmentForm about the queryset using the __init_method:

    class Meta:
        model = Department
        fields = ['id', 'name', 'sales_team']

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        # we have current object so get any teams that are related to this department
        if "instance" in kwargs and kwargs["instance"]:
            self.fields["sales_team"].queryset = Team.objects.filter(department_id=kwargs["instance"].id)
        # we don't have an instance so we are creating a new department
        # so no teams to show
        else:
            self.fields["sales_team"].queryset = Team.objects.none()

code

And that works to limit the available sales teams to only those owned by that department:

That is filtered from the full list of teams:

However when this is switched over to using form collections, it stops applying the filters. The problem I am having with form collections is that the modelForms for the collection are initialized during import, so I can't use the "init" method to set the querysets for the widgets.

Like, this Form is created at package import time, so the form can't easily be given any instance data at that time:

The collections form version is finding the "teams" for the department:

I've been digging about in the code looking for the correct method to override.... can anyone give me a pointer

[tolland]

I created a fork with my tests here:
https://github.com/jrief/django-formset/compare/releases/1.5...tolland:django-formset:filter-on-parent?expand=1#

there is some fixture data to replicate the compant/team/department fixtures/company.json

[tolland]

so it seems like I can modify the fieldset used by the widget during the form rendering by overriding get_context:

class MyForm(
    FormMixin,
    ModelForm,
):
...
    def get_context(self):
        self.fields["contact"].queryset = Contact.objects.all()[:10]
        context = super().get_context()
        print(f"context: {context}")
        return context

but I don't see anything in the ModelForm instance that gets passed from the View.... other than the initial object. So maybe pass some extra values in that...?

[suspiciousRaccoon]

I found myself with the same problem in my use case.
This discussion has some solutions.

I ended up writing these:

class FormsetContextCollectionViewMixin:
    def get_collection_kwargs(self):
        kwargs = super().get_collection_kwargs()
        kwargs["args"] = self.args
        kwargs["kwargs"] = self.kwargs
        kwargs["request"] = self.request
        return kwargs

class ContextFormCollection(FormCollection):
    def __init__(self, *args, **kwargs):
        self.request_args = {}
        self.request_args["request"] = kwargs.pop("request")
        self.request_args["args"] = kwargs.pop("args")
        self.request_args["kwargs"] = kwargs.pop("kwargs")

        for name, holder in self.declared_holders.items():
            self.update_holder_instances(name, holder)

        super().__init__(*args, **kwargs)

    def update_holder_instances(self, name, holder):
        """
        Request args are available in the self.request_args dict. Implement form logic here
        """
        pass

And I use them like this:

# views.py
class UserCollectionCreateView(FormsetContextCollectionViewMixin, EditCollectionView):
    model = User
    collection_class = UserCollection
    template_name = "form-collection.html"
    success_url = "/" 
    
# forms.py      
class UserForm(ModelForm):
    class Meta:
        model = User
        fields = ["email", "username", "password"]


class ExtendUserForm(ModelForm):
    class Meta:
        model = ExtendUser
        fields = ["phone_number"]

    def model_to_dict(self, user):
        try:
            return model_to_dict(
                user.extend_user, fields=self._meta.fields, exclude=self._meta.exclude
            )
        except ExtendUser.DoesNotExist:
            return {}

    def construct_instance(self, user):
        try:
            extend_user = user.extend_user
        except ExtendUser.DoesNotExist:
            extend_user = ExtendUser(user=user)
        form = ExtendUserForm(data=self.cleaned_data, instance=extend_user)
        if form.is_valid():
            construct_instance(form, extend_user)
            form.save()


class UserCollection(ContextFormCollection):
    default_renderer = FormRenderer()
    user = UserForm()
    extend_user = ExtendUserForm()

    def update_holder_instances(self, name, holder):
        print({name: holder}) 
        # the holder is the instanced form, you can either change it directly or call a method in it,
        # and we have access to the views context from self.request_args