accessing many-to-many queryset of a version...

[jedie]

One questions, how can i access a many-to-many field queryset of a version?

This doesn't work, because it's not the data from the version, it's the current obj data:

obj = version.object_version.object
related = getattr(obj, field.name)
queryset = related.all()

the same with this:

concrete_model = obj._meta.concrete_model
many_to_many_fields = concrete_model._meta.many_to_many
for field in many_to_many_fields:
    queryset = field.value_from_object(obj)

One way i get the right data is this:

obj = version.object_version.object
related = getattr(obj, field.name)
ids = version.field_dict[field.name]
queryset = many_related_manager.filter(pk__in=ids)

Is this a best practise solution?

EDIT: Find out that the last example doesn't work, too: many_related_manager.all() will not return all existing values...

It's for: jedie/django-reversion-compare@90b9c48#L0R70

EDIT2:
Some info of the objects in the example:
version: instance of reversion.models.Version
field: instance of django.db.models.fields.related.ManyToManyField and comes from: obj._meta.concrete_model._meta.many_to_many
many_related_manager: instance of django.db.models.fields.related.ManyRelatedManager

[jedie]

Found the problem:
RelatedManagers used a "core_filters" to prefilter the queryset, e.g.:

                self.core_filters = {
                    '%s__%s' % (rel_field.name, attname): getattr(instance, attname)
                }
...

            def get_query_set(self):
...
                    return super(RelatedManager, self).get_query_set().using(db).filter(**self.core_filters)

current work-a-round:

obj = version.object_version.object
related = getattr(obj, field.name)
ids = version.field_dict[field.name]

old_core_filters = many_related_manager.core_filters
many_related_manager.core_filters = {} # disable

queryset = many_related_manager.all().filter(pk__in=ids)

many_related_manager.core_filters = old_core_filters # restore

any better solution?

[etianen]

Rather than hack the related querysets, a cleaner way to do it is to traverse the revision set and pull out the other Version objects from the revision.

I wrote a more in-depth explanation in issue #149

[etianen]

(The current admin integration spends a lot of time doing just this. The alternative was some very dark magic to make related fields Just Work, and someone even attempted it once, but the result was not pretty)

[jedie]

Sorry, i don't know how the code from #149 can help me.

I have the Version object and want to get the related many-to-many objects.

Far as i see, RelatedManager will always filters the related objects by the current instance pk.

[etianen]

Yes, which is why to actually get the related objects, you need to do the following:

version = reversion.get_for_object(obj)[-1]  # Get the last but one version of the obj.

revision = version.revision  # Get the associated 'revision' for this version, that groups all associated models.

m2m_relations = revision.version_set.filter(
    content_type = ContentType.objects.get_for_model(RelatedM2MModel),
)

All foreign keys and related manages in a retrieved version object will query the current state of the database.

[jedie]

Sorry, didn't help. With revision.version_set.filter() i get only a Version instance and this instance has no m2m fields.

I have the pk from the version and get the Version instance with a simple queryset and it seems that m2m_relations contains the same simple Version instance...

[jedie]

I found a very simple way without the need to hack the related manager: Simply get a "fresh" model manager:

related_model = field.rel.to
ids = version.field_dict[field.name]
queryset = related_model.objects.all().filter(pk__in=ids)

info:
version: instance of reversion.models.Version
field: instance of django.db.models.fields.related.ManyToManyField and comes from: obj._meta.concrete_model._meta.many_to_many

EDIT: See also: jedie/django-reversion-compare@bf408d8

[etianen]

Sorry, it looks like I don't actually understand what you're trying to achieve here. I was under the impression that you were looking to access an old version of a model, then access the old versions of the m2m relations as they existed in the database at that time.

If at any point you use the normal Django database API calls, you're going to get the most recent version of the m2m related models.

[jedie]

Yes you are right, i wanted to get the old versions m2m relations.

I created a pseudo-code example here: https://gist.github.com/2652328

e.g.:

Version 1 was: [<PersonModel: Person 'paul'>, <PersonModel: Person 'max'>]
current Version 2 is: [<PersonModel: Person 'max'>]

I get version 1 from reversions and want the m2m list of version 1 -> [<PersonModel: Person 'paul'>, <PersonModel: Person 'max'>]
But i will only get the current version 2 one -> [<PersonModel: Person 'max'>]

If i used the m2m related manager from m2m_maneger = getattr(obj, field.name) than i get a manager with core_filters dict that filter all current objects.

One additional question:
m2m relations are in general problematic with django-reversion, isn't it?
e.g.: The person 'paul' from the example was deleted. Then you want to revert to version 1 -> The person 'paul' would not be recreated, isn't it? Even if it also under reversion and accessible via "Recover deleted model"
In general: related object would not be revered.

That's not a big problem for me and i understand that this is very complicated. But IMHO the user should be get a info, if he access to a old versions with changed relations??? Create a info messages?

Should i open a separate issues? btw. this is nowhere documented, or?

[etianen]

Which related models are reverted a recovered during a revision revert depends on how they were registered with reversion.

For example:

class Pet(models.Model):
    name = models.CharField(max_length=100)

class Person(models.Model):
    name = models.CharField(max_length=100)
    pets = models.ManyToManyField(Pet, blank=True)

reversion.register(Person, follow=["pets"])
reversion.register(Pet, follow=["person_set"])

with reversion.create_revision():
    pet1 = Pet.objects.create(name="Catworth")
    pet2 = Pet.objects.create(name="Dogwoth")
    person = Person.objects.create(name="Dave")
    person.pets.add(pet1, pet2)

with reversion.create_revision():
    pet1.name = "Catworth the second"
    pet2.save()
    pet2.delete()
    person.save()

# Get back the pets that were altered / deleted.
reversion.get_for_object(person)[1].revision.revert()

Note: I haven't tested the above, but something along those lines will work.

[jedie]

Example works as expected! Standalone test app: https://gist.github.com/2652502

Output:

version 1: Dave [<Pet: Catworth>, <Pet: Dogwoth>]
version 2: Dave [<Pet: Catworth the second>]
revert to version 1: Dave [<Pet: Catworth>, <Pet: Dogwoth>]

EDIT: Bugfix needed: pet1.save() was missed.

[jedie]

To the origin problem: I changed to code a little bit and display the old version before the revert():

version 1: Dave [<Pet: Catworth>, <Pet: Dogwoth>]
version 2: Dave [<Pet: Catworth the second>]
old version 1: Dave [<Pet: Catworth the second>]
revert to version 1: Dave [<Pet: Catworth>, <Pet: Dogwoth>]

The Line old version 1: Dave [<Pet: Catworth the second>] is wrong, it should be: old version 1: Dave [<Pet: Catworth>, <Pet: Dogwoth>]

My solution from #153 (comment) didn't helps here, because i access the current state of 'Pet' and not the "old state", e.g.:

    ids = old_revision.field_dict["pets"]
    print ids
    queryset = Pet.objects.all().filter(pk__in=ids)
    print "old version 1 pets:", queryset

Will output:

[u'1', u'2']
old version 1 pets: [<Pet: Catworth the second>]

[jedie]

Ha, my fault! I have a bug in my test code! Now it works: https://gist.github.com/2652502

Output:

version 1: Dave [<Pet: Catworth>, <Pet: Dogwoth>]
version 2: Dave [<Pet: Catworth the second>]
old version test 1: Dave [<Pet: Catworth the second>]
old version test 2: [u'1', u'2'] [<Pet: Catworth the second>]
old version test 3: [<Version: Catworth>, <Version: Dogwoth>]
revert to version 1: Dave [<Pet: Catworth>, <Pet: Dogwoth>]

Many thanks!

[etianen]

Phew! Just occasionally, someone still does manage to find a bug in the core reversion code. I dread those days.. :P

[jedie]

my problem comes (again) IMHO from the terms that looks like the same:

• version
• revision
• reversion

(specially the last two one)

I should create different colors in PyDev for them ;)