DRY collection for relations

[Actionb]

There seems to be a lot of repetition when using collections for model relations. I think a collection class specially for relations that implements generic model_to_dict and construct_instance methods would be a good addition:

class RelatedCollection(FormCollection):
    """A collection managing related objects of a parent instance."""
    min_siblings = 0
    extra_siblings = 0
    max_siblings = 1000  # mark the collection as a collection with siblings

    # The model managing the relation:
    relation_model = None
    # The name of the ForeignKey field to the parent model:
    fk_name = None
    # The name of the relation from the parent model:
    related_name = None

    def model_to_dict(self, instance):
        return [
            {self.related_name: model_to_dict(obj)}
            for obj in self.relation_model.objects.filter(**{self.fk_name: instance})
        ]

    def construct_instance(self, instance):
        model_form = self.declared_holders[self.related_name]
        for instance_data in self.cleaned_data:
            data = instance_data[self.related_name].copy()
            data[self.fk_name] = instance
            pk_name = self.relation_model._meta.pk.name
            try:
                related = self.relation_model.objects.get(pk=data[pk_name])
            except (ObjectDoesNotExist, KeyError):
                data.pop(pk_name, None)  # an invalid pk was sent?
                related = self.relation_model()
            form = model_form.__class__(data=data, instance=related)  # NOTE: use self.replicate instead?
            if form.is_valid():
                if MARKED_FOR_REMOVAL in data:
                    if related.pk:
                        related.delete()
                else:
                    construct_instance(form, related)
                    form.save()

    def retrieve_instance(self, data):
        pk = data[self.related_name].get(self.relation_model._meta.pk.name)
        if pk:
            return self.relation_model.objects.get(pk=pk)
        return self.relation_model()

For example, for adding aliases to a band:

class Band(models.Model):
    name = models.CharField(max_length=50)


class BandAlias(models.Model):
    alias = models.CharField(max_length=50, unique=True)
    band = models.ForeignKey('Band', on_delete=models.CASCADE, related_name='aliases')

You would use a RelatedCollection like this:

class AliasCollection(RelatedCollection):
    """Edit multiple aliases of a Band object from a Band model form."""
    aliases = forms.modelform_factory(BandAlias, fields=forms.ALL_FIELDS)
    legend = 'Aliases'

    relation_model = BandAlias
    fk_name = 'band'
    related_name = 'aliases'

Using this, a related_collection_factory function would be possible, too. And from that, a collection factory for entire models?

[jrief]

I agree that the current solution is not as DRY as it should be. However, I haven't found any generic solution yet, which is flexible enough as adding this kind of boilerplate to every Collection. For the typical 1:n-relation (ForeignKey) a generic solution might be possible and that's probably 99% of the use-cases. So I believe that I will add such a solution in version 1.1.

[Actionb]

Here's a gist of a collection class for relations + factory functions: https://gist.github.com/Actionb/243e5ff9e56c715f1439d95ed6401fd6)

[jrief]

Thanks, I will have a look at it.

[jrief]

@Actionb I believe to have found a generic solution. Please check the Company and Companies examples. There, the user of django-formset does not need to override method model_to_dict and construct_instance.

Please check branch releases/1.0.x

[Actionb]

That looks good to me.