def test_regression_1083(self):
        with reversion.create_revision():
            alice = Person.objects.create_user(
                username='alice', personal='Alice', family='Jones',
                email='[email protected]')

        with reversion.create_revision():
            bob = Person.objects.create_user(
                username='bob', personal='Bob', family='Smith',
                email='[email protected]')

        with reversion.create_revision():
            alice.family = 'Williams'
            alice.save()
            bob.family = 'Brown'
            bob.save()

        res = self.app.get(reverse('person_details', args=[bob.pk]), user='admin')

        revision = res.click('Last modified on')
        self.assertIn('Smith', revision)
        self.assertIn('Brown', revision)

        back_to_person_view = revision.click('View newest')
        self.assertIn('Brown', back_to_person_view)

 def testCanRevertRevisionWithDeletedVersions(self):
     self.assertEqual(ReversionTestModel1.objects.count(), 2)
     self.assertEqual(ReversionTestModel2.objects.count(), 2)
     with 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 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.
     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.
     get_for_object(self.test11)[2].revision.revert()
     self.assertEqual(ReversionTestModel1.objects.count(), 2)
     self.assertEqual(ReversionTestModel2.objects.count(), 2)

    def create_Simple_data(self):
        with reversion.create_revision():
            item1 = SimpleModel.objects.create(text="version one")

        if self.verbose:
            print("version 1:", item1)

        with reversion.create_revision():
            item1.text = "version two"
            item1.save()
            reversion.set_comment("simply change the CharField text.")

        if self.verbose:
            print("version 2:", item1)

        for no in range(5):
            with reversion.create_revision():
                if no==0:
                    item2 = SimpleModel.objects.create(text="v0")
                    reversion.set_comment("create v%i" % no)
                else:
                    item2.text = "v%i" % no
                    item2.save()
                    reversion.set_comment("change to v%i" % no)

        return item1, item2

 def testRevertWithDelete(self):
     with create_revision():
         test23 = ReversionTestModel2.objects.create(
             name = "model2 instance3 version1",
         )
         self.follow1.test_model_2s.add(test23)
         self.follow1.save()
     self.assertEqual(get_for_object(test23).count(), 1)
     self.assertEqual(self.follow1.test_model_2s.all().count(), 3)
     # Test that a revert with delete works.
     test23_pk = test23.pk
     self.assertEqual(ReversionTestModel2.objects.count(), 3)
     with create_revision():
         get_for_object(self.follow1)[1].revision.revert(delete=True)
     self.assertEqual(ReversionTestModel1.objects.get(id=self.test11.pk).name, "model1 instance1 version1")
     self.assertEqual(ReversionTestModel2.objects.get(id=self.test22.pk).name, "model2 instance2 version1")
     self.assertEqual(ReversionTestModel2.objects.get(id=self.test22.pk).name, "model2 instance2 version1")
     self.assertEqual(ReversionTestModel2.objects.count(), 2)
     self.assertRaises(ReversionTestModel2.DoesNotExist, lambda: ReversionTestModel2.objects.get(id=test23_pk))
     # Roll back to the revision where all models were present.
     get_for_object(self.follow1)[1].revision.revert()
     self.assertEqual(self.follow1.test_model_2s.all().count(), 3)
     # Roll back to a revision where a delete flag is present.
     get_for_object(self.follow1)[0].revision.revert(delete=True)
     self.assertEqual(self.follow1.test_model_2s.all().count(), 2)

    def test_deleted_objects(self):
        """
        for:
        https://github.com/jedie/django-reversion-compare/commit/ba22008130f4c16a32eeb900381c2d82ca6fdd9e
        https://travis-ci.org/jedie/django-reversion-compare/builds/72317520
        """
        with reversion.create_revision():
            factory1 = Factory.objects.create(name="factory one")
            car = Car.objects.create(
                name="car",
                manufacturer=factory1
            )

        with reversion.create_revision():
            factory2 = Factory.objects.create(name="factory two")
            car.manufacturer=factory2
            car.save()

        with reversion.create_revision():
            factory1.delete()

        queryset = get_for_object(car)
        version_ids = queryset.values_list("pk", flat=True)  # [3, 2]
        # print("\n", version_ids)

        # response = self.client.get("/admin/tests/car/%s/history/" % car.pk)
        # debug_response(response) # from django-tools

        response = self.client.get(
            "/admin/tests/car/%s/history/compare/" % car.pk,
            data={"version_id2":version_ids[0], "version_id1":version_ids[1]}
        )

    def test_gets_mine_only(self):
        # an episode tagged with 'mine' should return
        # only episodes that I have tagged with mine
        team_query = [dict(
            column="tagging",
            field='mine',
            combine='and',
            query=None,
            lookup_list=[],
            queryType=None
        )]

        other_user = User.objects.create(username="other")
        _, other_users_episode = self.new_patient_and_episode_please()

        with transaction.atomic(), reversion.create_revision():
            episode = self.patient.create_episode()
            episode.set_tag_names(['mine'], self.user)
            other_users_episode.set_tag_names(['mine'], other_user)
            query = queries.DatabaseQuery(self.user, team_query)

        self.assertEqual([episode], query.get_episodes())

        with transaction.atomic(), reversion.create_revision():
            episode.set_tag_names([], self.user)

        self.assertEqual([episode], query.get_episodes())

 def testContextManager(self):
     # New revision should be created.
     with create_revision():
         with create_revision():
             self.test11.name = "model1 instance1 version2"
             self.test11.save()
     self.assertEqual(Revision.objects.count(), 2)
     self.assertEqual(Version.objects.count(), 5)

 def testRevisionContextAbandonedOnError(self):
     with create_revision():
         try:
             with create_revision():
                 self.test11.name = "model1 instance1 version2"
                 self.test11.save()
                 raise Exception("Foo")
         except:
             pass
     self.assertEqual(Revision.objects.count(), 1)
     self.assertEqual(Version.objects.count(), 4)

    def setUp(self):
        self._setUpUsersAndLogin()
        self._setUpHosts()

        with create_revision():
            self.event = Event.objects.create(host=self.host_alpha,
                                              slug='event')

        with create_revision():
            self.person = Person.objects.create(username='gh',
                                                personal='Hermione',
                                                family='Granger')

 def testRecoverDeleted(self):
     # Delete the test model.
     with create_revision():
         self.test11.delete()
     self.assertEqual(TestFollowModel.objects.count(), 0)
     self.assertEqual(ReversionTestModel1.objects.count(), 1)
     # Recover the test model.
     with create_revision():
         get_deleted(ReversionTestModel1)[0].revision.revert()
     # Make sure it was recovered.
     self.assertEqual(TestFollowModel.objects.count(), 1)
     self.assertEqual(ReversionTestModel1.objects.count(), 2)

    def save(self, *args, **kwargs):
        """
        This falls back on using an admin user if a thread request object wasn't found
        """
        User = get_user_model()
        _locals = threading.local()

        if not hasattr(_locals, "request") or _locals.request.user.is_anonymous():
            if hasattr(_locals, "user"):
                user = _locals.user
            else:
                try:
                    user = User.objects.get(pk=_locals.request.user.pk)
                except Exception:
                    user = User.objects.get(id=1)
                _locals.user = user
        else:
            try:
                user = User.objects.get(pk=_locals.request.user.pk)
            except Exception:
                user = User.objects.get(id=1)

        # If saving a new model, set the creator.
        if not self.pk:
            try:
                self.creator
            except ObjectDoesNotExist:
                self.creator = user

            try:
                self.modifier
            except ObjectDoesNotExist:
                self.modifier = user

            created = True
        else:
            created = False
            self.modifier = user

        super(Audit, self).save(*args, **kwargs)

        if created:
            with create_revision():
                set_comment("Initial version.")
        else:
            if self.has_changed():
                comment = "Changed " + ", ".join(self.changed_data) + "."
                with create_revision():
                    set_comment(comment)
            else:
                with create_revision():
                    set_comment("Nothing changed.")

    def check_is_duplicate(self):
        """Method to check whether there already is a Range object defined with the exact
        same "cidr" value. If so also check for duplicates_allowed flag and act on it."""

        all_dupes_same_mask = self.__class__.objects.filter(address=self.address, mask=self.mask).exclude(id=self.id)

        if not all_dupes_same_mask:
            return False
        logger.debug("made it past here!")

        all_dupes = self.objects.filter(address=self.address, mask=self.mask).exclude(id=self.id)

        if not all_dupes:
            return False

        logger.debug("and here!")

        if not self.duplicates_allowed:
            raise ValidationError(_(
                "Range already exists but duplicates_allowed is set to False on this Range."))

        duplicates_allowed_list = []
        duplicates_forbidden_id_list = []

        for dupe in all_dupes:
            if self.id == dupe.id:
                pass
            else:
                if dupe.duplicates_allowed:
                    duplicates_allowed_list.append(dupe)
                else:
                    duplicates_forbidden_id_list.append(dupe.id)

        if duplicates_forbidden_id_list:
            raise ValidationError(_(
                """Range already exists and at least one existing entry does not allow
                duplicates. Check: """ + unicode(duplicates_forbidden_id_list)))

        with transaction.atomic(), reversion.create_revision():
            reversion.set_comment("set is_duplicate to True while adding")
            self.is_duplicate = True
            self.save()

        for dupe in all_dupes:
            if not dupe.is_duplicate:
                with transaction.atomic(), reversion.create_revision():
                    reversion.set_comment("set is_duplicate to True while adding " + unicode(self.id))
                    dupe.is_duplicate = True
                    dupe.save()

        return True

    def test_admin_user_can_compare_statuses(self):
        self.login_editor()

        from reversion import revisions as reversion

        with reversion.create_revision():
            self.item1.name = "change 1"
            reversion.set_comment("change 1")
            self.item1.save()

        old_count = self.item1.statuses.count()

        self.make_review_request(self.item1, self.registrar)

        with reversion.create_revision():
            self.item1.name = "change 2"
            reversion.set_comment("change 2")
            self.ra.register(
                item=self.item1,
                state=models.STATES.incomplete,
                user=self.registrar
            )
            self.item1.save()
        self.assertTrue(self.item1.statuses.count() == old_count + 1)

        from reversion.models import Version
        revisions = Version.objects.get_for_object(self.item1)

        response = self.client.get(
            reverse(
                "admin:%s_%s_compare"%(
                    self.itemType._meta.app_label,self.itemType._meta.model_name
                ),
                args=[self.item1.pk]
            ),
            {'version_id1' : revisions.first().pk,
            'version_id2' : revisions.last().pk
            }
        )
        self.assertResponseStatusCodeEqual(response,200)
        self.assertContains(response, "change 2")
        self.assertContains(response, 'statuses')

        self.item1 = self.itemType.objects.get(pk=self.item1.pk) #decache
        self.assertTrue(self.item1.name == "change 2")
        for s in self.item1.statuses.all():
            self.assertContains(
                response,
                '%s is %s'%(self.item1.name,s.get_state_display())
            )

	def setUpTestData(cls):
		cls.user = mommy.make(UserProfile, is_superuser=True)

		cls.poll = mommy.prepare(Poll, text='text', start_date=datetime.date.today(), end_date=datetime.date.today())
		with transaction.atomic(), revisions.create_revision():
			cls.poll.save()
			revisions.set_user(cls.user)
			revisions.set_comment('test version')

		cls.poll.text = 'very goood and nice text'
		with transaction.atomic(), revisions.create_revision():
			cls.poll.save()
			revisions.set_user(cls.user)
			revisions.set_comment('change text')

    def create_PersonIdentity_data(self):
        with reversion.create_revision():
            person = Person.objects.create(name="Dave")
            identity = Identity.objects.create(id_numer="1234", person=person)

        if self.verbose:
            print("version 1:", person, identity)

        with reversion.create_revision():
            person.name = "John"
            person.save()
            reversion.set_comment("version 2: change person name.")

        return person, identity

	def setUp(self):
		self.user = mommy.make(UserProfile, is_superuser=True)

		document = mommy.prepare(Document, text="text")
		with transaction.atomic(), revisions.create_revision():
				document.save()
				revisions.set_user(self.user)
				revisions.set_comment('test version')

		# create a second version
		document.text += '\nmore text'
		with transaction.atomic(), revisions.create_revision():
				document.save()
				revisions.set_user(self.user)
				revisions.set_comment('added more text')

 def testReverseRelationsFollowed(self):
     self.assertEqual(Revision.objects.count(), 1)
     self.assertEqual(Version.objects.count(), 5)
     with create_revision():
         self.test11.save()
     self.assertEqual(Revision.objects.count(), 2)
     self.assertEqual(Version.objects.count(), 9)

 def test_revision_is_created_on_job_category_object_create(self):
     with transaction.atomic():
         with create_revision():
             job_category = JobCategory.objects.create(
                 app_config=self.app_config,
                 **self.category_values_raw['en'])
     self.assertEqual(len(get_for_object(job_category)), 1)

    def testMultiTableInheritanceProxyModel(self):
        register(ReversionTestModel1Child, follow=("reversiontestmodel1_ptr",))
        register(ReversionTestModel1ChildProxy, follow=("reversiontestmodel1_ptr",))

        with create_revision():
            concrete = ReversionTestModel1Child.objects.create(name="modelchild1 instance1 version 1")

        proxy = ReversionTestModel1ChildProxy.objects.get(pk=concrete.pk)
        with create_revision():
            proxy.name = "proxy model"
            proxy.save()

        proxy_versions = get_for_object(proxy)

        self.assertEqual(proxy_versions[0].field_dict["name"], proxy.name)
        self.assertEqual(proxy_versions[1].field_dict["name"], concrete.name)

def change_mark(request, slug):
    if request.method == "POST":
        data = json.loads(request.body.decode("utf-8"))
        grade_system = data.get("grade_system")
        pk = data.get("pk")
        new_comment = data.get("comment")
        new_mark = data.get("mark")
        if grade_system is not None and pk is not None and new_mark is not None:
            with reversion.create_revision():
                mark, old_mark = MarkAPI.set_mark(grade_system, pk, new_mark)
                if mark.problem:
                    assignment_hierarchy = "{0:s}/{1:s}/{2:s}".format(
                        mark.problem.task.assignment.name, mark.problem.task.name, mark.problem.name
                    )
                elif mark.task:
                    assignment_hierarchy = "{0:s}/{1:s}".format(mark.task.assignment.name, mark.task.name)
                else:
                    assignment_hierarchy = "{0:s}".format(mark.assignment.name)
                reversion.set_user(request.user)
                reversion.set_comment(
                    """Mark for '{0:s}' student, for '{1:s}'
                    assignment was changed from '{2:d}' to '{3:d}' by '{4:s}' user """.format(
                        mark.student.username, assignment_hierarchy, old_mark, mark.mark, request.user.username
                    )
                )
        if grade_system is not None and pk is not None and new_comment is not None:
            MarkAPI.set_comment(grade_system, pk, new_comment)
    return HttpResponse()