def test_regression_1083(self): with reversion.create_revision(): alice = Person.objects.create_user( username='******', personal='Alice', family='Jones', email='*****@*****.**') with reversion.create_revision(): bob = Person.objects.create_user( username='******', personal='Bob', family='Smith', email='*****@*****.**') 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='******') 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 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 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 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_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 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 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 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 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='******', personal='Hermione', family='Granger')
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 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 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 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 process_post_and_save(request, task, formset): """Extracted common code to process a form.""" if 'refresh' in request.POST: task_log(request, task=task, message="Refreshed Task") elif 'submit' in request.POST: # # fill if necessary if formset.is_valid(): for form in formset: if form.is_valid() and len(form.changed_data): # if form is valid and some fields have changed # two stages here to set default fields with reversion.create_revision(): obj = form.save(commit=False) obj.editor = request.user obj.save() with reversion.create_revision(): task.lexicon.add(obj) task_log(request, task=task, message="Submitted valid Task") # update task if needed. if task.completable == True: with reversion.create_revision(): task.done = True task.save() task_log(request, task=task, message="Completed Task") # if we have a file saved and a language then add it to the attachments... if task.language and task.source and (task.image or task.file): from website.apps.core.models import Attachment if task.image: a = Attachment.objects.create( editor = request.user, language = task.language, source = task.source, file = task.image ) if task.file: a = Attachment.objects.create( editor = request.user, language = task.language, source = task.source, file = task.file ) return True task_log(request, task=task, message="Submitted incomplete") return False
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 handle(self, *args, **options): if len(args) == 0: args = ('empty', 'dedupe', 'tidy', 'star') if 't' in args or 'tidy' in args: tidier = self.tidy() for (obj, new) in tidier: self._print( 'Tidied: %s (%r) - %s (%r)' % (obj.entry, obj.entry, new, new), options.get('quiet', False)) if 'save' in options and options['save']: with reversion.create_revision(): obj.entry = new obj.save() if 'e' in args or 'empty' in args or 'empties' in args: empties = self.find_empty() for obj in empties: self._print('Empty: %d - %r' % (obj.id, obj.entry), options.get('quiet', False)) if 'save' in options and options['save']: self.delete(empties) if 'd' in args or 'dupes' in args or 'dedupe' in args: duplicates = self.find_duplicates() for obj in duplicates: self._print( 'Duplicate: %d/%d/%d/%d - %s, %s = %r' % (obj.id, obj.language.id, obj.source.id, obj.word.id, obj.language, obj.word, obj.entry), options.get('quiet', False)) if 'save' in options and options['save']: self.delete(duplicates) if 's' in args or 'star' in args: unstarred_forms = self.find_unstarred() for obj in self.find_unstarred(): new = '*%s' % obj.entry self._print( 'Starred: %s - %s (%r) - %s (%r)' % (obj.language, obj.entry, obj.entry, new, new), options.get('quiet', False)) if 'save' in options and options['save']: with reversion.create_revision(): obj.entry = new obj.save()
def test_search_delete_signal(self): self.login_superuser() with reversion.create_revision(): cable = models.ObjectClass.objects.create(name="cable",definition="known xman",workgroup=self.xmen_wg) self.ra.register(cable,models.STATES.standard,self.su) cable.save() self.assertTrue(cable.is_public()) response = self.client.get(reverse('aristotle:search')+"?q=cable") self.assertEqual(response.status_code,200) self.assertEqual(len(response.context['page'].object_list),1) with reversion.create_revision(): cable.delete() response = self.client.get(reverse('aristotle:search')+"?q=cable") self.assertEqual(response.status_code,200) self.assertEqual(len(response.context['page'].object_list),0)
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 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() review = models.ReviewRequest.objects.create(requester=self.su,registration_authority=self.ra) review.concepts.add(self.item1) with reversion.create_revision(): self.item1.name = "change 2" reversion.set_comment("change 2") r = 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) revisions = reversion.default_revision_manager.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.assertTrue("change 2" in response.content) self.assertTrue('statuses' in response.content) 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 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 testCanSaveIgnoringDuplicates(self): with create_revision(): self.test11.save() self.test12.save() self.test21.save() self.test22.save() self.assertFalse(get_ignore_duplicates()) set_ignore_duplicates(True) self.assertTrue(get_ignore_duplicates()) self.assertEqual(get_for_object(self.test11).count(), 2) # Save a non-duplicate revision. with create_revision(): self.test11.save() self.assertFalse(get_ignore_duplicates()) set_ignore_duplicates(True) self.assertEqual(get_for_object(self.test11).count(), 3)
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 test_current_statuses_only_in_search_results_and_index(self): # See issue #327 self.logout() response = self.client.post(reverse('friendly_login'), {'username': '******', 'password': '******'}) self.assertEqual(response.status_code,302) # logged in self.assertTrue(perms.user_is_registrar(self.registrar,self.ra)) with reversion.create_revision(): dp = models.ObjectClass.objects.create(name="deadpool", definition="not really an xman, no matter how much he tries", workgroup=self.xmen_wg,readyToReview=True) dp = models.ObjectClass.objects.get(pk=dp.pk) # Un-cache self.assertTrue(perms.user_can_view(self.registrar,dp)) self.assertFalse(dp.is_public()) from django.utils import timezone import datetime self.ra.register(dp,models.STATES.incomplete,self.registrar, registrationDate=timezone.now()+datetime.timedelta(days=-7) ) self.ra.register(dp,models.STATES.standard,self.registrar, registrationDate=timezone.now()+datetime.timedelta(days=-1) ) response = self.client.get(reverse('aristotle:search')+"?q=deadpool") self.assertEqual(len(response.context['page'].object_list),1) dp_result = response.context['page'].object_list[0] self.assertTrue(dp_result.object.name=="deadpool") self.assertTrue(len(dp_result.statuses) == 1) self.assertTrue(int(dp_result.statuses[0]) == int(models.STATES.standard))
def testNoVersionForObjectCreatedAndDeleted(self): with create_revision(): new_object = ReversionTestModel1.objects.create() new_object.delete() # No Revision and no Version should have been created. self.assertEqual(Revision.objects.count(), 1) self.assertEqual(Version.objects.count(), 4)
def form_valid(self, form): problem = self.object languages = problem.allowed_languages.all() language_limits = problem.language_limits.all() organizations = problem.organizations.all() types = problem.types.all() old_code = problem.code problem.pk = None problem.is_public = False problem.ac_rate = 0 problem.user_count = 0 problem.code = form.cleaned_data['code'] with revisions.create_revision(atomic=True): problem.save() problem.authors.add(self.request.profile) problem.allowed_languages.set(languages) problem.language_limits.set(language_limits) problem.organizations.set(organizations) problem.types.set(types) revisions.set_user(self.request.user) revisions.set_comment(_('Cloned problem from %s') % old_code) return HttpResponseRedirect( reverse('admin:judge_problem_change', args=(problem.id, )))
def game_mechanic_add(request, *args, **kwargs): game = get_object_or_404(models.Game, pk=kwargs.get('game_pk')) if request.method == 'POST': with revisions.create_revision(): mechanic = models.Mechanic() mechanic.game = game form = forms.MechanicForm(request.POST, instance=mechanic, game=game) if form.is_valid(): mechanic = form.save() mechanic.save() revisions.set_user(request.user) return HttpResponseRedirect( reverse('core:game_mechanic_detail', args=[game.id, mechanic.id])) else: return render(request, 'core/game_mechanic_add.html', { 'form': form, 'game': game }) else: form = forms.MechanicForm(game=game) return render(request, 'core/game_mechanic_add.html', { 'form': form, 'game': game })
def test_facet_search(self): self.logout() with reversion.create_revision(): dec = models.DataElementConcept.objects.create( name="Pokemon-CP", definition="a Pokemons combat power" ) de = models.DataElement.objects.create( name="Pokemon-CP, Go", definition="a Pokemons combat power as recorded in the Pokemon-Go scale", dataElementConcept=dec ) self.login_superuser() from aristotle_mdr.forms.search import PermissionSearchQuerySet response = self.client.get(reverse('aristotle:search')+"?q=pokemon") objs = response.context['page'].object_list self.assertDelayedEqual(len(objs),2) extra_facets = response.context['form'].extra_facet_fields self.assertTrue(len(extra_facets) == 1) self.assertTrue(extra_facets[0][0] == 'data_element_concept') psqs = PermissionSearchQuerySet() psqs = psqs.auto_query('pokemon').apply_permission_checks(self.su) self.assertDelayedEqual(len(psqs),2) response = self.client.get(reverse('aristotle:search')+"?q=pokemon&f=data_element_concept::%s"%dec.pk) objs = response.context['page'].object_list self.assertDelayedEqual(len(objs),1) self.assertTrue(objs[0].object.pk,de.pk)
def test_editor_can_make_object__where_item_already_has_similar_details( self): from reversion.revisions import create_revision with create_revision(): # Need to wrap this in a revision to make sure the search is updated self.item_existing = self.model.objects.create( name='Almost the same', definition="This item already exists", workgroup=self.wg1) # Need to make sure its public self.ra.register(item=self.item_existing, state=models.STATES.standard, user=self.su) self.login_editor() self.assertTrue(self.item_existing.can_view(self.editor)) form_data = { self.wizard_form_name + '-current_step': 'initial', 'initial-name': "Already exists", } # success! response = self.client.post(self.wizard_url, form_data) wizard = response.context['wizard'] self.assertTrue(len(wizard['form'].errors.keys()) == 0) self.assertFalse('duplicate_items' in response.context.keys()) self.assertTrue( self.item_existing.pk in [x.object.pk for x in response.context['similar_items']]) # Existing item should show up in the "similar results page" self.assertContains(response, self.item_existing.definition)
def create_revisions(self): # works that are missing revisions ct = ContentType.objects.get_for_model(Work) query = Work.objects.exclude(id__in=Version.objects.filter( content_type=ct.pk).values_list('object_id_int', flat=True)) date = None def on_revision_commit(**kwargs): # update the revision with the date of the last update kwargs['revision'].date_created = date kwargs['revision'].save() reversion.post_revision_commit.connect(on_revision_commit) for work in query: user = work.updated_by_user or work.created_by_user if user: work.updated_by_user = work.updated_by_user or user with reversion.create_revision(): reversion.set_user(user) date = work.updated_at or work.created_at work.save() self.stdout.write( self.style.SUCCESS("Created revision for {}".format(work))) else: self.stdout.write( self.style.NOTICE( "Work {} doesn't have a user".format(work)))
def game_mechanic_edit(request, *args, **kwargs): mechanic = get_object_or_404(models.Mechanic, pk=kwargs.get('mechanic_pk')) if request.method == 'POST': with revisions.create_revision(): form = forms.MechanicForm(request.POST, instance=mechanic, game=mechanic.game) if form.is_valid(): form.save() revisions.set_user(request.user) messages.success(request, 'Mecânica alterada com sucesso') return HttpResponseRedirect( reverse('core:game_mechanic_detail', args=[mechanic.game.id, mechanic.id])) else: return render(request, 'core/game_mechanic_edit.html', { 'form': form, 'game': mechanic.game }) else: form = forms.MechanicForm(instance=mechanic, game=mechanic.game) return render(request, 'core/game_mechanic_edit.html', { 'form': form, 'game': mechanic.game })
def game_mechanic_remove(request, *args, **kwargs): game = get_object_or_404(models.Game, pk=kwargs.get('game_pk')) mechanic = get_object_or_404(models.Mechanic, pk=kwargs.get('mechanic_pk')) with revisions.create_revision(): mechanic.delete() revisions.set_user(request.user) return HttpResponseRedirect(reverse('core:game_detail', args=[game.id]))
def post(self, request, *args, **kwargs): self.object = self.get_object() page = self.get_comment_page() if self.is_comment_locked(): return HttpResponseForbidden() parent = request.POST.get('parent') if parent: if len(parent) > 10: return HttpResponseBadRequest() try: parent = int(parent) except ValueError: return HttpResponseNotFound() else: if not Comment.objects.filter( hidden=False, id=parent, page=page).exists(): return HttpResponseNotFound() form = CommentForm(request, request.POST) if form.is_valid(): comment = form.save(commit=False) comment.author = request.profile comment.page = page with LockModel(write=(Comment, Revision, Version), read=(ContentType, )), revisions.create_revision(): revisions.set_user(request.user) revisions.set_comment(_('Posted comment')) comment.save() return HttpResponseRedirect(request.path) context = self.get_context_data(object=self.object, comment_form=form) return self.render_to_response(context)
def handle(self, *app_labels, **options): verbosity = options["verbosity"] using = options["using"] model_db = options["model_db"] comment = options["comment"] batch_size = options["batch_size"] meta = options["meta"] meta_models = [] for label in meta.keys(): try: model = apps.get_model(label) meta_models.append(model) except LookupError: raise CommandError("Unknown model: {}".format(label)) meta_values = meta.values() # Create revisions. using = using or router.db_for_write(Revision) with transaction.atomic(using=using): for model in self.get_models(options): # Check all models for empty revisions. if verbosity >= 1: self.stdout.write("Creating revisions for {name}".format( name=model._meta.verbose_name, )) created_count = 0 live_objs = _safe_subquery( "exclude", model._default_manager.using(model_db), model._meta.pk.name, Version.objects.using(using).get_for_model( model, model_db=model_db, ), "object_id", ) # Save all the versions. ids = list(live_objs.values_list("pk", flat=True).order_by()) total = len(ids) for i in range(0, total, batch_size): chunked_ids = ids[i:i+batch_size] objects = live_objs.in_bulk(chunked_ids) for obj in objects.values(): with create_revision(using=using): if meta: for model, values in zip(meta_models, meta_values): add_meta(model, **values) set_comment(comment) add_to_revision(obj, model_db=model_db) created_count += 1 reset_queries() if verbosity >= 2: self.stdout.write("- Created {created_count} / {total}".format( created_count=created_count, total=total, )) # Print out a message, if feeling verbose. if verbosity >= 1: self.stdout.write("- Created {total} / {total}".format( total=total, ))
def game_level_edit(request, *args, **kwargs): level = get_object_or_404(models.Level, pk=kwargs.get('level_pk')) if request.method == 'POST': with revisions.create_revision(): form = forms.LevelForm(request.POST, instance=level, game=level.game) if form.is_valid(): form.save() revisions.set_user(request.user) messages.success(request, 'Fase alterada com sucesso') return HttpResponseRedirect( reverse('core:game_level_detail', args=[level.game.id, level.id])) else: return render(request, 'core/game_level_edit.html', { 'form': form, 'game': level.game }) else: form = forms.LevelForm(instance=level, game=level.game) return render(request, 'core/game_level_edit.html', { 'form': form, 'game': level.game })
def game_character_edit(request, *args, **kwargs): character = get_object_or_404(models.Character, pk=kwargs.get('character_pk')) if request.method == 'POST': with revisions.create_revision(): form = forms.CharacterForm(request.POST, instance=character, game=character.game) if form.is_valid(): form.save() revisions.set_user(request.user) messages.success(request, 'Personagem alterado com sucesso') return HttpResponseRedirect( reverse('core:game_character_detail', args=[character.game.id, character.id])) else: return render(request, 'core/game_character_edit.html', { 'form': form, 'game': character.game }) else: form = forms.CharacterForm(instance=character, game=character.game) return render(request, 'core/game_character_edit.html', { 'form': form, 'game': character.game })
def test_model_search(self): self.logout() with reversion.create_revision(): dec = models.DataElementConcept.objects.create( name="Pokemon-CP", definition="a Pokemons combat power") de = models.DataElement.objects.create( name="Pokemon-CP, Go", definition= "a Pokemons combat power as recorded in the Pokemon-Go scale", dataElementConcept=dec) self.login_superuser() response = self.client.get(reverse('aristotle:search') + "?q=pokemon") objs = response.context['page'].object_list self.assertDelayedEqual(len(objs), 2) response = self.client.get( reverse('aristotle:search') + "?q=pokemon&models=aristotle_mdr.dataelement") objs = response.context['page'].object_list self.assertDelayedEqual(len(objs), 1) self.assertTrue(objs[0].object.pk, de.pk)
def test_text_diff(self): with reversion.create_revision(): reversion.set_user(self.profile) self.event.notes = "An old note on the event" # Simple text self.event.save() # Find the most recent version currentVersion = versioning.RIGSVersion.objects.get_for_object( self.event).latest(field_name='revision__date_created') # Check the diff is correct self.assertEqual(currentVersion.changes.field_changes[0].diff, [{ 'type': 'equal', 'text': "A" }, { 'type': 'delete', 'text': " new" }, { 'type': 'insert', 'text': "n old" }, { 'type': 'equal', 'text': " note on the event" }])
def testRevisionSignals(self): pre_revision_receiver_called = [] def pre_revision_receiver(**kwargs): self.assertEqual(kwargs["instances"], [self.test11]) self.assertTrue(isinstance(kwargs["revision"], Revision)) self.assertEqual(len(kwargs["versions"]), 1) pre_revision_receiver_called.append(True) post_revision_receiver_called = [] def post_revision_receiver(**kwargs): self.assertEqual(kwargs["instances"], [self.test11]) self.assertTrue(isinstance(kwargs["revision"], Revision)) self.assertEqual(len(kwargs["versions"]), 1) post_revision_receiver_called.append(True) pre_revision_commit.connect(pre_revision_receiver) post_revision_commit.connect(post_revision_receiver) # Create a revision. with create_revision(): self.test11.save() # Check the signals were called. self.assertTrue(pre_revision_receiver_called) self.assertTrue(post_revision_receiver_called)
def test_registrar_search_after_adding_new_status_request(self): self.logout() response = self.client.post(reverse('friendly_login'), { 'username': '******', 'password': '******' }) steve_rogers = models.ObjectClass.objects.get(name="captainAmerica") self.assertFalse(perms.user_can_view(self.registrar, steve_rogers)) with reversion.create_revision(): steve_rogers.save() self.make_review_request(steve_rogers, self.registrar) self.assertTrue(perms.user_can_view(self.registrar, steve_rogers)) response = self.client.get( reverse('aristotle:search') + "?q=captainAmerica") self.assertEqual(len(response.context['page'].object_list), 1) self.assertEqual(response.context['page'].object_list[0].object.item, steve_rogers) self.assertTrue( perms.user_can_view( self.registrar, response.context['page'].object_list[0].object))
def form_valid(self, form): contest = self.object tags = contest.tags.all() organizations = contest.organizations.all() private_contestants = contest.private_contestants.all() view_contest_scoreboard = contest.view_contest_scoreboard.all() contest_problems = contest.contest_problems.all() old_key = contest.key contest.pk = None contest.is_visible = False contest.user_count = 0 contest.locked_after = None contest.key = form.cleaned_data['key'] with revisions.create_revision(atomic=True): contest.save() contest.tags.set(tags) contest.organizations.set(organizations) contest.private_contestants.set(private_contestants) contest.view_contest_scoreboard.set(view_contest_scoreboard) contest.authors.add(self.request.profile) for problem in contest_problems: problem.contest = contest problem.pk = None ContestProblem.objects.bulk_create(contest_problems) revisions.set_user(self.request.user) revisions.set_comment(_('Cloned contest from %s') % old_key) return HttpResponseRedirect(reverse('admin:judge_contest_change', args=(contest.id,)))
def setUp(self): super(MultiTableInheritanceApiTest, self).setUp() register(ReversionTestModel1Child, follow=("reversiontestmodel1_ptr", )) with create_revision(): self.testchild1 = ReversionTestModel1Child.objects.create( name="modelchild1 instance1 version 1", )
def setUp(self): super(MultiTableInheritanceApiTest, self).setUp() register(ReversionTestModel1Child, follow=("reversiontestmodel1_ptr",)) with create_revision(): self.testchild1 = ReversionTestModel1Child.objects.create( name = "modelchild1 instance1 version 1", )
def form_valid(self, form): form.instance.updated_by_user = self.request.user form.instance.created_by_user = self.request.user with reversion.create_revision(): reversion.set_user(self.request.user) return super(AddWorkView, self).form_valid(form)
def test_revision_is_created_on_job_opening_object_created(self): with transaction.atomic(): with create_revision(): job_opening = JobOpening.objects.create( category=self.default_category, **self.opening_values_raw['en']) self.assertEqual(len(get_for_object(job_opening)), 1)
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()
def obj_create(self, bundle, **kwargs): ''' created objects should automatically have a status of Human Created ''' status_update = StatusUpdate.objects.get(status_en='Human Created') username = bundle.request.GET['username'] user = User.objects.filter(username=username)[0] status_id = status_update.id if can_assign_users(user) is False and 'assigned_user' in bundle.data: del(bundle.data['assigned_user']) comment_uri = self.create_comment( bundle.data['comment'], status_id, user ) bundle.data['actor_comments'] = [ comment_uri ] with reversion.create_revision(): bundle = super(ActorResource, self)\ .obj_create(bundle, **kwargs) reversion.add_meta( VersionStatus, status='created', user=user ) reversion.set_user(user) reversion.set_comment(bundle.data['comment']) update_object.delay(username) return bundle
def create(self, request, *args, **kwargs): data = request.data if 'concept_type' in request.data.keys(): # We've been passed a single object manifest = {'metadata': [data]} else: manifest = data try: output = [] with transaction.atomic(): for s in Deserializer(manifest): with reversion.create_revision(): output.append({ 'uuid': s.object.uuid, 'url': s.object.get_absolute_url() }) s.submitter = request.user s.object.recache_states() reversion.set_user(request.user) reversion.set_comment(_("Imported using API")) s.save() return Response({'created': output}) #stuff except Exception as e: if 'explode' in request.query_params.keys(): raise return Response({'error': str(e)})
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 handle(self, *app_labels, **options): verbosity = options["verbosity"] using = options["using"] model_db = options["model_db"] comment = options["comment"] batch_size = options["batch_size"] meta = options["meta"] meta_models = [] for label in meta.keys(): try: model = apps.get_model(label) meta_models.append(model) except LookupError: raise CommandError("Unknown model: {}".format(label)) meta_values = meta.values() # Create revisions. using = using or router.db_for_write(Revision) with transaction.atomic(using=using): for model in self.get_models(options): # Check all models for empty revisions. if verbosity >= 1: self.stdout.write("Creating revisions for {name}".format( name=model._meta.verbose_name, )) created_count = 0 live_objs = _safe_subquery( "exclude", model._default_manager.using(model_db), model._meta.pk.name, Version.objects.using(using).get_for_model( model, model_db=model_db, ), "object_id", ) # Save all the versions. ids = list(live_objs.values_list("pk", flat=True).order_by()) total = len(ids) for i in range(0, total, batch_size): chunked_ids = ids[i:i + batch_size] objects = live_objs.in_bulk(chunked_ids) for obj in objects.values(): with create_revision(using=using): if meta: for model, values in zip( meta_models, meta_values): add_meta(model, **values) set_comment(comment) add_to_revision(obj, model_db=model_db) created_count += 1 reset_queries() if verbosity >= 2: self.stdout.write( "- Created {created_count} / {total}".format( created_count=created_count, total=total, )) # Print out a message, if feeling verbose. if verbosity >= 1: self.stdout.write("- Created {total} / {total}".format( total=total, ))
def game_level_remove(request, *args, **kwargs): game = get_object_or_404(models.Game, pk=kwargs.get('game_pk')) level = get_object_or_404(models.Level, pk=kwargs.get('level_pk')) with revisions.create_revision(): level.delete() revisions.set_user(request.user) return HttpResponseRedirect(reverse('core:game_detail', args=[game.id]))
def remove_trainees(self, trainees): with reversion.create_revision() and transaction.atomic(): if reversion.is_active(): reversion.set_comment('Removed trainees') for trainee in trainees: self.trainees.remove(trainee) self.save()
def test_registrar_search_after_adding_new_status_request(self): self.logout() response = self.client.post(reverse('friendly_login'), {'username': '******', 'password': '******'}) steve_rogers = models.ObjectClass.objects.get(name="captainAmerica") self.assertFalse(perms.user_can_view(self.registrar,steve_rogers)) review = models.ReviewRequest.objects.create( requester=self.su,registration_authority=self.ra, state=self.ra.public_state, registration_date=datetime.date(2010,1,1) ) review.concepts.add(steve_rogers) with reversion.create_revision(): steve_rogers.save() review = models.ReviewRequest.objects.create( requester=self.su,registration_authority=self.ra, state=self.ra.public_state, registration_date=datetime.date(2010,1,1) ) review.concepts.add(steve_rogers) self.assertTrue(perms.user_can_view(self.registrar,steve_rogers)) response = self.client.get(reverse('aristotle:search')+"?q=captainAmerica") self.assertEqual(len(response.context['page'].object_list),1) self.assertEqual(response.context['page'].object_list[0].object.item,steve_rogers) self.assertTrue(perms.user_can_view(self.registrar,response.context['page'].object_list[0].object))