Python reversion.create_revision函数代码示例

    def save(self, *args, **kwargs):
        if not self.pk:
            created = True
        else:
            created = False

        try:
            if not self.creator and not self.pk:
                self.creator = self.prescription.creator
            if not self.modifier:
                self.modifier = self.prescription.modifier
        except ObjectDoesNotExist:
            if self.prescription:
                self.creator = self.prescription.creator
                self.modifier = self.prescription.modifier
            else:
                raise Exception("Cannot set object.creator: {}".format(self))

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

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

 def testGetForObjectUniqueMiss(self):
     with reversion.create_revision():
         obj = TestModel.objects.create()
     with reversion.create_revision():
         obj.name = "v2"
         obj.save()
     self.assertEqual(len(list(Version.objects.get_for_object(obj).get_unique())), 2)

 def testGetDeleted(self):
     with reversion.create_revision():
         obj = TestModel.objects.create()
     with reversion.create_revision():
         obj.save()
     obj.delete()
     self.assertEqual(Version.objects.get_deleted(TestModel).count(), 1)

 def handle(self, *args, **options):
     if len(args) != 2:
         print('Usage: ./manage.py create_wordlist <wordlist> </path/to/wordlist.txt>')
         quit()
     
     with open(args[1], 'rU') as handle:
         words = self.parse(handle, options['create'] )
     sys.stdout.write("%d words loaded from %s" % (len(words), args[1]))
     
     if 'run' in options and options['run']:
         ed = User.objects.get(pk=1)
         # create wordlist.
         with reversion.create_revision():
             wl = Wordlist.objects.create(
                 editor=ed, 
                 name=args[0]
             )
             wl.save()
         
         # go through words and add them to wordlist
         for order in sorted(words):
             with reversion.create_revision():
                 m = WordlistMember(wordlist=wl, word=words[order], order=order)
                 m.save()
         
         if wl.words.count() != len(words):
             raise AssertionError(
                 "Number of words in wordlist doesn't match expected (%d != %d)" % \
                 (wl.words.count(), len(words))
             )
         sys.stdout.write("Wordlist %s created with %d entries" % (wl, wl.words.count()))
     else:
         sys.stdout.write("Dry-run complete. Use --run to save changes. Rolling back.")

def process_batch(key, batch_info, iv):
    """Loops through items in a batch and processes them."""
    batch_info = pickle.loads(decrypt(key, batch_info, iv.decode('hex')))
    success = True


    if 'dependencies' in batch_info:
        dependencies = serializers.deserialize('json', batch_info['dependencies'])
        for dep in dependencies:
            dep.save()

    if 'update' in batch_info:
        updates = serializers.deserialize('json', batch_info['update'])
        for item in updates:
            with reversion.create_revision():
                item.save()

    if 'deletions' in batch_info:
        deletions = json.loads(batch_info['deletions'])
        for deletion in deletions:
            app_label, model_label, object_id = deletion
            ct = ContentType.objects.get_by_natural_key(app_label, model_label)
            for result in ct.model_class().objects.filter(pk=object_id):
                with reversion.create_revision():
                    result.delete()
                    
    return success

    def test_04_published_version(self):
        # Should not be any published versions yet
        self.assertEqual(self.article.published_version, None)
        
        with create_revision():
            Article.publishing.publish(self.article)
                
        # Should be one published versions now
        self.assertEqual(self.article.published_version, self.article)
        
        # Lets make another version but set it to draft
        self.article.title = "%s - Changed" % self.article.title
        # Setting the status to draft is nessesary here because we 
        # want to ensure we receive the correct published version
        self.article.publishing_status = DRAFT_STATUS
        
        with create_revision():
            self.article.save()
            
        # This test will ensure that our title change is not part of the 
        # published version of the article.
        self.assertEqual(self.article.published_version.title, "Article 001")
        
        # Ensure the gallery's method works
        self.assertEqual(self.gallery.published_version, None)
        
        with create_revision():
            Gallery.publishing.publish(self.gallery)

        # Should be one published versions now
        self.assertEqual(self.gallery.published_version, self.gallery)

 def test_03_admin_publishing(self):
     
     from django.contrib.formtools.tests import DummyRequest
     request = DummyRequest(POST={'_publishing_publish': ''})
     
     # Get the article admin
     article_admin = admin.site._registry[Article]
     
     self.assertEqual(self.article.published_version, None)
     # Call the save model, which should trigger the publishing of the article.
     with create_revision():
         article_admin.save_model(request, self.article, None, None)
     self.assertEqual(self.article.published_version, self.article)
     
     # Do the same thing with the gallery model
     gallery_admin = admin.site._registry[Gallery]
     
     self.assertEqual(self.gallery.published_version, None)
     with create_revision():
         gallery_admin.save_model(request, self.gallery, None, None)
     self.assertEqual(self.gallery.published_version, self.gallery)
     
     # Do the same thing with the story model
     story_admin = admin.site._registry[Story]
     
     self.assertEqual(self.story.published_version, None)
     with create_revision():
         story_admin.save_model(request, self.story, None, None)
     self.assertEqual(self.story.published_version, self.story)
     
     

    def save(self, *args, **kwargs):
        """Set creator and modifier to current user or superuser.

        This method uses pythia.middleware.get_current_user to retrieve either
        the request.user from thread local storage (as injected by
        pythia.middleware.ThreadLocals) or the superuser in case the thread
        was not a request (e.g. run through shell or unit tests).
        """
        user = get_current_user()

        # If saving a new model, set the creator.
        if not self.pk:
            self.creator = user
            created = True
        else:
            created = False

        self.modifier = user
        super(Audit, self).save(*args, **kwargs)

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

 def split_and_replace(self, obj):
     if '/' in obj.entry:
         components = obj.entry.split("/")
     elif ',' in obj.entry:
         components = obj.entry.split(",")
     pks = []
     for c in components:
         c = c.strip()
         assert len(c) > 0, "Unable to split properly - zero length component"
         self._print("Splitting: %s -> %s" % (obj.entry, c))
         with reversion.create_revision():
             o = Lexicon.objects.create(
                 language=obj.language, 
                 word=obj.word,
                 source=obj.source,
                 editor=obj.editor,
                 entry=c
             )
             reversion.set_comment("Automatic split_entries has created this from: %d" % obj.id)
             pks.append(o.id)
     
     # now delete old entry
     with reversion.create_revision():
         obj.delete()
         reversion.set_comment("Automatic split_entries has moved this item to: %s" % ",".join([str(p) for p in pks]))

 def testGetForObjectFiltering(self):
     with reversion.create_revision():
         obj_1 = TestModel.objects.create()
     with reversion.create_revision():
         obj_2 = TestModel.objects.create()
     self.assertEqual(Version.objects.get_for_object(obj_1).get().object, obj_1)
     self.assertEqual(Version.objects.get_for_object(obj_2).get().object, obj_2)

 def testGetDeletedMySQL(self):
     with reversion.create_revision(using="mysql"):
         obj = TestModel.objects.using("mysql").create()
     with reversion.create_revision(using="mysql"):
         obj.save()
     obj.delete()
     self.assertEqual(Version.objects.using("mysql").get_deleted(TestModel, model_db="mysql").count(), 1)

 def testRevertWithDelete(self):
     with reversion.create_revision():
         test23 = ReversionTestModel2.objects.create(
             name = "model2 instance3 version1",
         )
         self.follow1.test_model_2s.add(test23)
         self.follow1.save()
     self.assertEqual(reversion.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 reversion.create_revision():
         reversion.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.
     reversion.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.
     reversion.get_for_object(self.follow1)[0].revision.revert(delete=True)
     self.assertEqual(self.follow1.test_model_2s.all().count(), 2)

def alternate_accepted(alternate):
    # This is called by the alternate_accept endpoint
    # The alternate gets there via a private link sent to their slack
    season = alternate.season_player.season
    round_ = current_round(season)
    # Validate that the alternate is in the correct state
    if alternate.status != 'contacted':
        return False
    # Validate that the alternate doesn't already have a game in the round
    # Players can sometimes play multiple games (e.g. playing up a board), but that isn't done through the alternates manager
    if (TeamPlayerPairing.objects.filter(team_pairing__round=round_, white=alternate.season_player.player) | \
        TeamPlayerPairing.objects.filter(team_pairing__round=round_, black=alternate.season_player.player)).nocache().exists():
        return False
    # Find an open spot to fill, prioritized by the time the search started
    active_searches = AlternateSearch.objects.filter(round=round_, board_number=alternate.board_number, is_active=True) \
                                             .order_by('date_created').select_related('team').nocache()
    for search in active_searches:
        if search.still_needs_alternate():
            with reversion.create_revision():
                reversion.set_comment('Alternate assigned')
                assignment, _ = AlternateAssignment.objects.update_or_create(round=round_, team=search.team, board_number=search.board_number, \
                                                                         defaults={'player': alternate.season_player.player, 'replaced_player': None})
            with reversion.create_revision():
                reversion.set_comment('Alternate assigned')
                alternate.status = 'accepted'
                alternate.save()
            with reversion.create_revision():
                reversion.set_comment('Alternate search completed')
                search.status = 'completed'
                search.save()
            signals.alternate_assigned.send(sender=alternate_accepted, season=season, alt_assignment=assignment)
            return True
    return False

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

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

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

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

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

        return item1, item2

 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)