def current_version_id(self):
     versions = reversion.get_for_object(self)
     if versions:
         version = reversion.get_for_object(self)[0]
         return "V{0} | R{1}".format(version.pk, version.revision.pk)
     else:
         return None

    def test_edit_plugin_directly(self):
        content1 = 'Content 1 text'
        content2 = 'Content 2 text'

        with force_language('en'):
            event = self.create_default_event()
        # revision 1
        self.create_revision(event, content1)

        self.assertEqual(len(reversion.get_for_object(event)), 1)

        # revision 2
        with transaction.atomic():
            with reversion.create_revision():
                plugins = event.description.get_plugins().filter(
                    language=event.get_current_language())
                plugin = plugins[0].get_plugin_instance()[0]
                plugin.body = content2
                plugin.save()
                create_revision_with_placeholders(event)

        self.assertEqual(len(reversion.get_for_object(event)), 2)

        response = self.client.get(event.get_absolute_url())
        self.assertContains(response, content2)
        self.assertNotContains(response, content1)

        self.revert_to(event, 1)
        event = Event.objects.get(pk=event.pk)
        response = self.client.get(event.get_absolute_url())
        self.assertContains(response, content1)
        self.assertNotContains(response, content2)

 def last_edited_at(self):
     versions = reversion.get_for_object(self)
     if versions:
         version = reversion.get_for_object(self)[0]
         return version.revision.date_created
     else:
         return None

    def test_people_revision_is_reverted(self):
        rev_1_values = self.make_new_values(
            self.data_raw['person']['en'], 1)
        # rev 1
        self.person1.set_current_language('en')
        self.create_revision(self.person1, **rev_1_values)
        self.assertEqual(len(reversion.get_for_object(self.person1)), 1)
        # check that values are actually changed
        self.assertEqual(self.person1.function, rev_1_values['function'])
        self.assertEqual(self.person1.description, rev_1_values['description'])

        # rev 2
        rev_2_values = self.make_new_values(
            self.data_raw['person']['en'], 2)
        self.create_revision(self.person1, **rev_2_values)
        self.assertEqual(len(reversion.get_for_object(self.person1)), 2)
        # check that values are actually changed
        self.assertEqual(self.person1.function, rev_2_values['function'])
        self.assertEqual(self.person1.description, rev_2_values['description'])

        # revert
        self.revert_to(self.person1, 1)
        self.person1 = Person.objects.get(pk=self.person1.pk)
        # check previous values
        self.assertEqual(
            self.person1.function, rev_1_values['function'])
        self.assertEqual(
            self.person1.description, rev_1_values['description'])

 def testCanRevertRevisionWithDeletedVersions(self):
     self.assertEqual(ReversionTestModel1.objects.count(), 2)
     self.assertEqual(ReversionTestModel2.objects.count(), 2)
     with reversion.create_revision():
         self.test11.name = "model1 instance1 version3"
         self.test11.save()
         self.test12.delete()
         self.test21.name = "model2 instance1 version3"
         self.test21.save()
         self.test22.delete()
     self.assertEqual(ReversionTestModel1.objects.count(), 1)
     self.assertEqual(ReversionTestModel2.objects.count(), 1)
     with reversion.create_revision():
         self.test11.name = "model1 instance1 version4"
         self.test11.save()
         self.test21.name = "model2 instance1 version4"
         self.test21.save()
     self.assertEqual(ReversionTestModel1.objects.count(), 1)
     self.assertEqual(ReversionTestModel2.objects.count(), 1)
     # Revert to a revision where some deletes were logged.
     reversion.get_for_object(self.test11)[1].revision.revert()
     self.assertEqual(ReversionTestModel1.objects.count(), 1)
     self.assertEqual(ReversionTestModel2.objects.count(), 1)
     self.assertEqual(ReversionTestModel1.objects.get(id=self.test11.id).name, "model1 instance1 version3")
     self.assertEqual(ReversionTestModel2.objects.get(id=self.test21.id).name, "model2 instance1 version3")
     # Revert the a revision before the deletes were logged.
     reversion.get_for_object(self.test11)[2].revision.revert()
     self.assertEqual(ReversionTestModel1.objects.count(), 2)
     self.assertEqual(ReversionTestModel2.objects.count(), 2)

 def last_edited_by(self):
     versions = reversion.get_for_object(self)
     if versions:
         version = reversion.get_for_object(self)[0]
         return version.revision.user
     else:
         return None

 def testRevisionsSavedNotOnAddButOnChange(self):
     self.assertEqual(AutoInitialAdminModel.objects.count(), 0)
     # Create an instance via the admin.
     response = self.client.post("/admin/auth/autoinitialadminmodel/add/", {
         "name": "instance1 version1",
         "_continue": 1,
     })
     self.assertEqual(response.status_code, 302)
     obj_pk = response["Location"].split("/")[-2]
     obj = AutoInitialAdminModel.objects.get(id=obj_pk)
     # Check that no version is created.
     versions = reversion.get_for_object(obj)
     self.assertEqual(versions.count(), 0)
     # Save a new version.
     response = self.client.post("/admin/auth/autoinitialadminmodel/%s/" % obj_pk, {
         "name": "instance1 version2",
         "_continue": 1,
     })
     self.assertEqual(response.status_code, 302)
     # Check that 2 versions were created.
     versions = reversion.get_for_object(obj)
     self.assertEqual(versions.count(), 2)
     self.assertEqual(versions[0].field_dict["name"], "instance1 version2")
     self.assertEqual(versions[1].field_dict["name"], "instance1 version1")
     # Delete the object.
     response = self.client.post("/admin/auth/autoinitialadminmodel/%s/delete/" % obj_pk, {
         "_continue": 1,
     })
     self.assertEqual(response.status_code, 302)
     # Check that only 1 version is created.
     versions = reversion.get_for_object(obj)
     self.assertEqual(versions.count(), 3)

    def test_edit_plugin_directly(self):
        content0 = self.rand_str(prefix='content0_')
        content1 = self.rand_str(prefix='content1_')
        content2 = self.rand_str(prefix='content2_')

        article = self.create_article(content=content0)

        # Revision 1
        self.create_revision(article, content=content1)

        self.assertEqual(
            len(reversion.get_for_object(article)), 1)

        # Revision 2
        with transaction.atomic():
            plugins = article.content.get_plugins()
            plugin = plugins[0].get_plugin_instance()[0]
            plugin.body = content2
            plugin.save()
            create_revision(article)

        self.assertEqual(
            len(reversion.get_for_object(article)), 2)

        response = self.client.get(article.get_absolute_url())
        self.assertContains(response, content2)
        self.assertNotContains(response, content1)

        # Revert to revision 1
        self.revert_to(article, 1)

        response = self.client.get(article.get_absolute_url())
        self.assertContains(response, content1)
        self.assertNotContains(response, content2)

    def test_save_version(self):
        # first get all current versions of the document from the database
        document = Document.objects.get()
        versions = reversion.get_for_object(document)
        self.assertEqual(len(versions), 1)

        # get the editor page and add a new revision
        response = self.app.get(reverse("information_pages:edit", args=[self.document.url_title]), user=self.user)
        self.assertEqual(response.status_code, 200)

        form = response.form
        new_string = self.document.text + "\nHallo Bibi Blocksberg!!"
        form.set("text", new_string)
        form.set("comment", "hallo Bibi Blocksberg")
        form.set("url_title", "bibi-blocksberg")
        response = form.submit().follow()
        self.assertEqual(response.status_code, 200)

        # check whether number of versions increased
        versions = reversion.get_for_object(self.document)
        self.assertEqual(len(versions), 2)

        # check whether the comment of the version correct
        self.assertEqual(versions[0].revision.comment, "hallo Bibi Blocksberg")
        self.assertEqual(versions[1].revision.comment, "test version")

 def test_create_revision(self):
     import reversion
     version_list = reversion.get_for_object(self.lex)
     assert len(version_list) == 0
     self.client.login(username="admin", password="test")
     response = self.client.post(self.url, self.get_post_data(self.lex), follow=True)
     version_list = reversion.get_for_object(self.lex)
     assert len(version_list) == 1

 def testReverseFollowRevertWithDelete(self):
     with reversion.create_revision():
         follow2 = TestFollowModel.objects.create(name="related instance2 version 1", test_model_1=self.test11)
     # Test that a revert with delete works.
     follow2_pk = follow2.pk
     reversion.get_for_object(self.test11)[1].revision.revert(delete=True)
     self.assertEqual(TestFollowModel.objects.count(), 1)
     self.assertRaises(TestFollowModel.DoesNotExist, lambda: TestFollowModel.objects.get(id=follow2_pk))

    def get_context_data(self, **kwargs):
        context = super(UpdateView, self).get_context_data(**kwargs)
        self.object.get_parsed_content()

        extensions = Extension.objects.filter(public=True) | self.object.extensions.all()
        if not self.request.user.is_anonymous():
            extensions |= Extension.objects.filter(author=self.request.user)

        extensions = extensions.distinct()

        context["extensions"] = [e.as_json() for e in extensions]

        context["editable"] = self.editable
        context["can_delete"] = self.can_delete
        context["can_copy"] = self.can_copy
        context["navtab"] = "questions"

        if not self.request.user.is_anonymous():
            context["starred"] = self.request.user.userprofile.favourite_questions.filter(pk=self.object.pk).exists()
        else:
            context["starred"] = False

        context["access_rights"] = [
            {"id": qa.user.pk, "name": qa.user.get_full_name(), "access_level": qa.access}
            for qa in QuestionAccess.objects.filter(question=self.object)
        ]

        versions = [version_json(v, self.user) for v in reversion.get_for_object(self.object)]

        licences = [licence.as_json() for licence in Licence.objects.all()]

        question_json = context["question_json"] = {
            "questionJSON": json.loads(self.object.as_json()),
            "editable": self.editable,
            "licences": licences,
            "numbasExtensions": context["extensions"],
            "previewURL": reverse("question_preview", args=(self.object.pk, self.object.slug)),
            "previewWindow": str(calendar.timegm(time.gmtime())),
            "starred": context["starred"],
            "versions": versions,
            "timeline": timeline_json(self.object.timeline, self.user),
        }
        if self.editable:
            question_json["public_access"] = self.object.public_access
            question_json["access_rights"] = context["access_rights"]
            context["versions"] = reversion.get_for_object(self.object)

        part_type_path = "question/part_types/" + ("editable" if self.editable else "noneditable")
        context["partNames"] = [
            (name, "{}/{}.html".format(part_type_path, name))
            for name in "jme", "gapfill", "numberentry", "patternmatch", "1_n_2", "m_n_2", "m_n_x", "matrix"
        ]

        context["stamp_choices"] = STAMP_STATUS_CHOICES

        return context

    def setUp(self):
        super(CBViewTest, self).setUp()
        test_data = TestData(verbose=False)
        self.item1, self.item2 = test_data.create_Simple_data()

        queryset = get_for_object(self.item1)
        self.version_ids1 = queryset.values_list("pk", flat=True)

        queryset = get_for_object(self.item2)
        self.version_ids2 = queryset.values_list("pk", flat=True)

 def testCanGetUniqueForObject(self):
     with reversion.create_revision():
         self.test11.save()
         self.test21.save()
     # Test a model with an int pk.
     self.assertEqual(reversion.get_for_object(self.test11).count(), 3)
     self.assertEqual(len(reversion.get_unique_for_object(self.test11)), 2)
     # Test a model with a str pk.
     self.assertEqual(reversion.get_for_object(self.test21).count(), 3)
     self.assertEqual(len(reversion.get_unique_for_object(self.test21)), 2)

 def get_context_data(self, **kwargs):
     context = super(PortalRevisionDiffView, self).get_context_data(**kwargs)
     try:
         revids = sorted(self.request.GET.getlist("r"))
         context["newversion"] = reversion.get_for_object(self.object).get(
                 id=revids[0])
         context["oldversion"] = reversion.get_for_object(self.object).get(
                 id=revids[1])
     except reversion.revisions.Revision.DoesNotExist, IndexError:
         raise Http404

 def test_create_revision(self):
     import reversion
     version_list = reversion.get_for_object(self.lex1)
     assert len(version_list) == 0
     self.client.login(username="admin", password="test")
     postdata = self.get_post_data(self.items)
     postdata['form-0-entry'] = 'apricot' # replace 'sausage' with 'apricot'
     response = self.client.post(self.url, postdata, follow=True)
     version_list = reversion.get_for_object(self.lex1)
     assert len(version_list) == 1

    def testCanGetForObject(self):
        # Can get version for proxy model
        proxy_versions = reversion.get_for_object(self.proxy)
        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(self.concrete)
        self.assertEqual(list(concrete_versions), list(proxy_versions))

 def moderate_accept(self, user):
     self.on_moderate_accept()
     self.moderation_status = MODERATION_STATUS['OK']
     self.moderation_user = user
     if reversion.get_for_object(self).count():
         self.moderation_last_ok_revision = reversion.get_for_object(self)[0]
     else:
         self.moderation_last_ok_revision = None
     super(Moderated, self).save()
     content_type = ContentType.objects.get_for_model(self)  # get(app_label="unravelling", model="item")
     LogEntry.objects.log_action(user.id, content_type.id, self.id, unicode(self), CHANGE, "MODERATION ACCEPT")

 def testCanSaveAutoInitialOnChange(self):
     self.assertEqual(reversion.get_for_object(self.test11).count(), 0)
     with reversion.create_revision():
         reversion.set_auto_initial(True, [ReversionTestModel1, ReversionTestModel2])
         self.test11.name = "model1 instance1 version2"
         self.test11.save()
         self.test12.save()
         self.test21.save()
         self.test22.save()
     # Test that an initial is save because there's a data change and no previous revision
     self.assertEqual(reversion.get_for_object(self.test11).count(), 2)

 def testCanGetForObject(self):
     # Test a model with an int pk.
     versions = reversion.get_for_object(self.test11)
     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(self.test21)
     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")