Python reversion.get_for_object_reference函数代码示例

    def testCanGetForObjectReference(self):
        # Can get version for proxy model
        proxy_versions = reversion.get_for_object_reference(ReversionTestModel1Proxy, self.proxy.id)
        self.assertEqual(len(proxy_versions), 2)
        self.assertEqual(proxy_versions[0].field_dict["name"], self.proxy.name)
        self.assertEqual(proxy_versions[1].field_dict["name"], self.concrete.name)

        # Can get the same version for concrete model
        concrete_versions = reversion.get_for_object_reference(ReversionTestModel1, self.concrete.id)
        self.assertEqual(list(concrete_versions), list(proxy_versions))

 def testCanGetForObjectReference(self):
     # Test a model with an int pk.
     versions = reversion.get_for_object_reference(ReversionTestModel1, self.test11.pk)
     self.assertEqual(len(versions), 2)
     self.assertEqual(versions[0].field_dict["name"], "model1 instance1 version2")
     self.assertEqual(versions[1].field_dict["name"], "model1 instance1 version1")
     # Test a model with a str pk.
     versions = reversion.get_for_object_reference(ReversionTestModel2, self.test21.pk)
     self.assertEqual(len(versions), 2)
     self.assertEqual(versions[0].field_dict["name"], "model2 instance1 version2")
     self.assertEqual(versions[1].field_dict["name"], "model2 instance1 version1")

def add_site_to_revision(sender, **kwargs):
    revision = kwargs["revision"]
    versions = kwargs["versions"]
    sites = []

    if revision.versionsites.exists():
        # If the sites are already set earlier, don't reset them here
        return

    for ver in versions:
        # Add any sites from the new version
        if "sites" in ver.field_dict:
            sites.extend([int(s) for s in ver.field_dict["sites"]])
        elif "site" in ver.field_dict:
            sites.append(int(ver.field_dict["site"]))
        # Add any sites from the previous version, so we can see that it has
        # moved
        try:
            available_versions = reversion.get_for_object_reference(ver.content_type.model_class(), ver.object_id)
            prev_ver = available_versions.exclude(id=ver.id).order_by("-id")[0]
            if "sites" in prev_ver.field_dict:
                sites.extend([int(s) for s in prev_ver.field_dict["sites"]])
            elif "site" in prev_ver.field_dict:
                sites.append(int(prev_ver.field_dict["site"]))
        except (IndexError, SerializerDoesNotExist):
            pass

    for site_id in set(s.id for s in Site.objects.filter(id__in=sites)):
        site = Site.objects.get(pk=site_id)
        # Add meta data didn't work, so do it manually
        vsite = VersionSite(revision=revision, site=site)
        vsite.save()

    def get_queryset(self, **kwargs):
        thisModel = self.kwargs['model']

        # thisObject = get_object_or_404(thisModel, pk=self.kwargs['pk'])
        versions = reversion.get_for_object_reference(thisModel, self.kwargs['pk'])

        return versions

    def test_diff_template_has_users_of_changes(self):
        user1 = User.objects.create(username='test user 1')
        with reversion.revision:
            instance = Page.objects.create(title=get_unique_page_title(),
                                           content="test content")
            reversion.revision.user = user1

        user2 = User.objects.create(username='test user 2')
        with reversion.revision:
            instance.content = "changed test content"
            instance.save()
            reversion.revision.user = user2

        new_version, old_version = reversion.get_for_object_reference(Page,
                                                                    instance.pk)

        request, context = self._prepare_request(old_version, new_version)
        response = render(request, self.template, context)

        self.assertHasElement(response,
                              ".wikify-old .wikify-user:contains('%s')"
                              % user1.username)
        self.assertHasElement(response,
                              ".wikify-new .wikify-user:contains('%s')"
                              % user2.username)

    def get_object(self, queryset=None):
        """
        Returns revision based on edid_pk and revision_pk.
        """

        edid_pk = self.kwargs.get('edid_pk', None)
        revision_pk = self.kwargs.get('revision_pk', None)

        # Get version based on edid_pk and revision_pk or return 404.
        version = reversion.get_for_object_reference(EDID, edid_pk) \
                           .filter(revision__pk=revision_pk)

        try:
            version = version.get()
        except version.model.DoesNotExist:
            raise Http404()

        # Check revision and EDID date
        # FIXME: Works fine, but tests fail due to milliseconds difference
        if version.revision.date_created == version.object.modified:
            return HttpResponseBadRequest(
                'You can not revert to the current revision.'
            )

        self.kwargs['revision'] = version.revision

        # Return EDID instance
        return version.object

    def test_diff_template_shows_no_previous_if_viewing_first_version(self):
        with reversion.revision:
            instance = Page.objects.create(title=get_unique_page_title(),
                                           content="test content")
        new_version = reversion.get_for_object_reference(Page, instance.pk)[0]

        request, context = self._prepare_request(None, new_version)
        response = render(request, self.template, context)

        self.assertHasNoElement(response,
                                "a:contains('previous')")

def _get_version_diff(version):
    """Get the difference betwee
    :param version: reversion.Version object
    :return: tuple (metadata as dict, compared values as dict)
    """
    ident = version.field_dict['id']
    model = version.content_type.model_class()
    # uses the class rather than the instance so that we can also work with deleted objects
    all_versions = reversion.get_for_object_reference(model, ident).select_related('revision__user')
    all_versions = list(all_versions)
    diff = {}
    diff['object_name'] = model.__name__

    fields = {}
    foreign_keys = {}
    many_to_manys = {}
    choices_display = {}    # CharField having a list of choices

    for field in model._meta.fields:
        fields[field.name] = field
        if type(field) is django.db.models.fields.related.ForeignKey:
            foreign_keys[field.name] = field
        elif type(field) is django.db.models.fields.CharField and field.choices:
            choices_display[field.name] = field
        elif type(field) is django.db.models.fields.TextField and field.choices:
            choices_display[field.name] = field
    for field in model._meta.many_to_many:
        fields[field.name] = field
        if type(field) is django.db.models.fields.related.ManyToManyField:
            many_to_manys[field.name] = field

    try:
        previous_version = all_versions[all_versions.index(version)+1]
        diff['has_previous'] = True
        if previous_version.revision.user:
            diff['previous_user'] = previous_version.revision.user.email
        else:
            diff['previous_user'] = 'System'
        diff['previous_date'] = previous_version.revision.date_created
        diff['previous_comment'] = previous_version.revision.comment
        compared = compare_dicts(version.field_dict, previous_version.field_dict)
    except IndexError:
        diff['has_previous'] = False
        compared = compare_dicts(version.field_dict, None)

    # stores an association between the type of fields
    # available and the function to transform the value
    transform_fields = [
        (foreign_keys, find_user_friendly_rel),
        (many_to_manys, find_user_friendly_many),
        (choices_display, find_user_friendly_display_name)]

    compared_values = _build_compared_values(compared, fields, transform_fields)
    return diff, compared_values

    def test_versions_template_has_author(self):
        user = User.objects.create(username='test_user')
        with reversion.revision:
            instance = Page.objects.create(title=get_unique_page_title(),
                                           content="test content")
            reversion.revision.user = user
        version = reversion.get_for_object_reference(Page, instance.pk)[0]

        request, context = self._prepare_request(versions=[version])
        response = render(request, self.template, context)

        self.assertHasElement(response,
                              ".wikify-user:contains('%s')" % user.username)

    def test_version_template_has_comment(self):
        comment = 'test comment'
        with reversion.revision:
            instance = Page.objects.create(title=get_unique_page_title(),
                                           content="test content")
            reversion.revision.comment = comment
        version = reversion.get_for_object_reference(Page, instance.pk)[0]

        request, context = self._prepare_request(version)
        response = render(request, self.template, context)

        self.assertHasElement(response,
                              ".wikify-comment:contains('%s')" % comment)

    def test_version_template_has_date_of_last_change(self):
        with reversion.revision:
            instance = Page.objects.create(title=get_unique_page_title(),
                                           content="test content")
        version = reversion.get_for_object_reference(Page, instance.pk)[0]

        request, context = self._prepare_request(version)
        response = render(request, self.template, context)

        date = defaultfilters.date(version.revision.date_created,
                                   settings.DATETIME_FORMAT)
        self.assertHasElement(response,
                              ".wikify-date:contains('%s')" % date)

def get_previous_version(version):
    thisId = version.object_id
    thisVersionId = version.pk

    versions = reversion.get_for_object_reference(version.content_type.model_class(), thisId)

    try:
        previousVersions = versions.filter(revision_id__lt=version.revision_id).latest(
            field_name='revision__date_created')
    except ObjectDoesNotExist:
        return False

    return previousVersions

    def test_versions_template_shows_ip_address(self):
        ip_address = '127.0.0.1'
        with reversion.revision:
            instance = Page.objects.create(title=get_unique_page_title(),
                                           content="test content")
            reversion.revision.add_meta(VersionMeta,
                                        ip_address=ip_address)
        version = reversion.get_for_object_reference(Page, instance.pk)[0]

        request, context = self._prepare_request(versions=[version])
        response = render(request, self.template, context)

        self.assertHasElement(response,
                              ".wikify-user:contains('%s')" % ip_address)

def construct_versions(version_count):
    assert version_count > 0

    with reversion.revision:
        instance = Page.objects.create(title=get_unique_page_title(),
                                        content="content_0")
        reversion.revision.comment = 'Version 0'

    versions = []
    for i in range(1, version_count):
        with reversion.revision:
            instance.content = "content_%s" % i
            instance.save()
            reversion.revision.comment = 'Version %s' % i

    return reversion.get_for_object_reference(Page, instance.pk).order_by("pk")

    def save_model(self, request, obj, form, change):
        if not hasattr(self, 'model'):
            raise AttributeError("You need to specify 'model', attr")
        super().save_model(request, obj, form, change)

        serialized = serializers.serialize(
            'json',
            [obj.translations.get(
                language_code=request.GET.get('language') or get_language()
            )]
        )
        try:
            revision = reversion.get_for_object_reference(
                self.model, obj.pk)[0]
            revision.serialized_data = serialized
            revision.save()
        except IndexError:
            pass