Python reversion.get_deleted函数代码示例

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

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

    def historic_tags_for_episodes(cls, episodes):
        """
        Given a list of episodes, return a dict indexed by episode id
        that contains historic tags for those episodes.
        """
        episode_ids = [e.id for e in episodes]
        teams = {t.id: t.name for t in Team.objects.all()}
        deleted = reversion.get_deleted(cls)
        historic = collections.defaultdict(dict)
        for d in deleted:
            data = json.loads(d.serialized_data)[0]["fields"]
            if data["episode"] in episode_ids:
                if "team" in data:
                    if data["team"] in teams:
                        tag_name = teams[data["team"]]
                    else:
                        print "Team has been deleted since it was serialised."
                        print "We ignore these for now."
                        continue
                else:
                    try:
                        tag_name = data["tag_name"]
                    except KeyError:
                        print json.dumps(data, indent=2)
                        raise exceptions.FTWLarryError("Can't find the team in this data :(")

                historic[data["episode"]][tag_name] = True
        return historic

    def historic_episodes_for_tag(cls, tag):
        """
        Given a TAG return a list of episodes that have historically been
        tagged with it.
        """
        teams = {t.id: t.name for t in Team.objects.all()}
        deleted = reversion.get_deleted(cls)
        eids = set()
        for d in deleted:
            data = json.loads(d.serialized_data)[0]["fields"]
            try:
                team_index = data["team"]
                if team_index not in teams:
                    print "Can't find deleted team by index - we think the team has been deleted? "
                    print "DATA:"
                    print json.dumps(data, indent=2)
                    print "TEAMS:"
                    print json.dumps(teams, indent=2)
                    continue
                tag_name = teams[team_index]

            except KeyError:
                tag_name = data["tag_name"]

            if tag_name == tag:
                eids.add(data["episode"])

        historic = Episode.objects.filter(id__in=eids)
        return historic

def clear_deleted_restaurateurs(request):
    if not request.user.is_authenticated() or not request.user.is_superuser:
        return HttpResponseRedirect("/comptes/login")
		
    deleted_revisions = reversion.get_deleted(Restaurateur).select_related('revision')
    
    for deleted_revision in deleted_revisions:
        Revision.objects.filter(id=deleted_revision.revision_id).delete()

 def test_commands_DELETE(self):
     assert len(reversion.get_deleted(Lexicon)) == 0
     assert Lexicon.objects.get(pk=self.lex_b.id)  # exists?
     form_data = self.form_data
     form_data['c-%d' % self.lex_b.id] = "!DELETE"
     response = self.AuthenticatedClient.post(self.url, form_data, follow=True)
     with self.assertRaises(Lexicon.DoesNotExist):
         Lexicon.objects.get(pk=self.lex_b.id)

 def get_users(pk_list):
     users = []
     for pk in pk_list:
         try:
             u = HAWCUser.objects.get(pk=pk)
         except:
             deleted_users = reversion.get_deleted(HAWCUser)
             u = deleted_users.get(pk=pk)
         users.append(u.get_full_name())
     return '<br>'.join(sorted(users))

 def test_that_can_safely_restore_deleted_object(self):
     model = None
     amount = Money(100, 'GHS')
     with reversion.create_revision():
         model = RevisionedModel.objects.create(amount=amount)
         model.save()
     model.delete()
     version = reversion.get_deleted(RevisionedModel)[0]
     version.revision.revert()
     model = RevisionedModel.objects.get(pk=1)
     self.assertEquals(model.amount, amount)

def undo_last_delete(request):
    if not request.user.is_authenticated() or not request.user.is_superuser:
        return HttpResponseRedirect("/comptes/login")

    delete_list = reversion.get_deleted(Restaurant)

    if delete_list:
        restaurantId = delete_list[0].object_id
        delete_version = delete_list.latest('revision')
        delete_version.revision.revert()

        return HttpResponse('{"success": true, "id": ' + str(restaurantId) + '}')

 def testCanSaveAutoInitialOnDelete(self):
     self.assertEqual(Version.objects.count(), 0)
     with reversion.create_revision():
         reversion.set_auto_initial(True, [ReversionTestModel1])
         self.test11.delete()
     # Test that an initial is saved on delete
     versions = reversion.get_deleted(ReversionTestModel1)
     self.assertEqual(len(versions), 1)
     self.assertEqual(Version.objects.filter(type=VERSION_ADD).count(), 1)
     self.assertEqual(Version.objects.filter(type=VERSION_CHANGE).count(), 0)
     self.assertEqual(Version.objects.filter(type=VERSION_DELETE).count(), 1)
     self.assertEqual(reversion.get_for_object(self.test12).count(), 0)
     with reversion.create_revision():
         reversion.set_auto_initial(True, [ReversionTestModel1])
         self.test12.name = "model1 instance2 version2"
         self.test12.delete()
     # Test that an initial is saved on delete
     versions = reversion.get_deleted(ReversionTestModel1)
     self.assertEqual(len(versions), 2)
     self.assertEqual(Version.objects.filter(type=VERSION_ADD).count(), 2)
     self.assertEqual(Version.objects.filter(type=VERSION_CHANGE).count(), 0)
     self.assertEqual(Version.objects.filter(type=VERSION_DELETE).count(), 2)

 def test_creates_reversion(self):
     form_data = self.form_data
     form_data['c-%d' % self.lex_b.id] = "%s" % self.cogset1.id
     form_data['c-%d' % self.lex_a.id] = "-%s" % self.cogset1.id
     response = self.AuthenticatedClient.post(self.url, form_data, follow=True)
     
     version_list = reversion.get_for_object(self.cogset1)
     assert len(version_list) == 1, "Cognate Version List Missing"
     
     version_list = reversion.get_for_object(self.lex_b)
     assert len(version_list) == 1, "Lex B Version List Missing"
     
     assert len(reversion.get_deleted(Cognate)) == 1

def test_issue_53(admin_client):
    pytest.importorskip("reversion")
    import reversion as revisions

    with revisions.create_revision():
        instance = ReversionConcurrentModel.objects.create()
    pk = instance.pk

    with revisions.create_revision():
        instance.delete()

    version_list = revisions.get_deleted(ReversionConcurrentModel)
    deleted_pk = version_list[0].pk
    admin_client.post('/admin/demo/reversionconcurrentmodel/recover/{}/'.format(deleted_pk),
                      {'username': 'aaaa'})
    assert ReversionConcurrentModel.objects.filter(id=pk).exists()

 def testDontSaveAutoInitialOnDelete(self):
     self.assertEqual(Version.objects.count(), 0)
     with reversion.create_revision():
         self.test11.save()
         self.test12.save()
         self.test21.save()
         self.test22.save()
     self.assertEqual(reversion.get_for_object(self.test11).count(), 1)
     with reversion.create_revision():
         reversion.set_auto_initial(True, [ReversionTestModel1])
         self.test11.delete()
     # Test that no initial is saved on delete
     versions = reversion.get_deleted(ReversionTestModel1)
     self.assertEqual(len(versions), 1)
     self.assertEqual(Version.objects.filter(type=VERSION_ADD).count(), 0)
     self.assertEqual(Version.objects.filter(type=VERSION_CHANGE).count(), 4)
     self.assertEqual(Version.objects.filter(type=VERSION_DELETE).count(), 1)

    def get_many_to_something(self, ids, related_model, is_reverse=False):

        # get instance of reversion.models.Revision():
        # A group of related object versions.
        old_revision = self.version.revision

        # Get a queryset with all related objects.
        versions = old_revision.version_set.filter(
            content_type=ContentType.objects.get_for_model(related_model),
            object_id__in=ids
        )

        if self.has_int_pk:
            # The primary_keys would be stored in a text field -> convert it to integers
            # This is interesting in different places!
            for version in versions:
                version.object_id = int(version.object_id)

        missing_objects = []
        missing_ids = []

        if self.field_name not in self.adapter.follow:
            # This models was not registered with follow relations
            # Try to fill missing related objects
            target_ids = set(ids)
            actual_ids = set([version.object_id for version in versions])
            missing_ids1 = target_ids.difference(actual_ids)

            # logger.debug(self.field_name, "target: %s - actual: %s - missing: %s" % (target_ids, actual_ids, missing_ids1))
            if missing_ids1:
                missing_objects = related_model.objects.all().filter(pk__in=missing_ids1)
                missing_ids = list(target_ids.difference(set(missing_objects.values_list('pk', flat=True))))

        deleted = []
        if is_reverse:
            true_missing_objects = []
            for o in missing_objects:
                for ver in reversion.get_for_object(o):
                    # An object can only be missing if it actually existed prior to this version
                    # Otherwise its a new item
                    if ver.revision.date_created < version.revision.date_created:
                        true_missing_objects.append(o)
            missing_objects = true_missing_objects
            deleted = [d for d in reversion.get_deleted(related_model) if d.revision == old_revision]
        return versions, missing_objects, missing_ids, deleted

def post_delete_hook(sender, instance, **kwargs):
    """Custom post-delete hook.

    We want to know who was responsible for an object deletion.
    """
    from reversion.models import Version

    if not reversion.is_registered(sender):
        return
    del_list = reversion.get_deleted(sender)
    try:
        version = del_list.get(object_id=instance.id)
    except Version.DoesNotExist:
        return
    logger = logging.getLogger("modoboa.admin")
    msg = _("%(object)s '%(name)s' %(action)s by user %(user)s") % {
        "object": unicode(version.content_type).capitalize(),
        "name": version.object_repr, "action": _("deleted"),
        "user": version.revision.user.username
    }
    logger.critical(msg)