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 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 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 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 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 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 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 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 comment(request, instance): """A RESTful view for deleting/editing comments. :param request: The HTTP request that was made. :type request: ``django.http.HttpRequest`` :param instance: The comment that is to be operated on. :type instance: ``politics.apps.comments.models.Comment`` """ # The client must be the author of the comment. if request.user != instance.author: return HttpResponse(status=403) if request.method == "DELETE": with reversion.create_revision(): instance.is_deleted = True instance.save() return HttpResponse(json.dumps(instance.to_json())) elif request.method == "PUT": # Deleted comments can't be edited. if instance.is_deleted: return HttpResponseBadRequest() form = CommentForm(request.PUT, instance=instance) if form.is_valid(): with reversion.create_revision(): instance = form.save() return HttpResponse(json.dumps(instance.to_json())) else: return HttpResponseBadRequest() # Method Not Allowed return HttpResponse(status=405)
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 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 testCreateRevisionIgnoreDuplicates(self): reversion.register(TestModel, ignore_duplicates=True) with reversion.create_revision(): obj = TestModel.objects.create() with reversion.create_revision(): obj.save() self.assertSingleRevision((obj,))
def testAddMetaMultDb(self): with reversion.create_revision(using="mysql"), reversion.create_revision(using="postgres"): obj = TestModel.objects.create() reversion.add_meta(TestMeta, name="meta v1") self.assertNoRevision() self.assertSingleRevision((obj,), meta_names=("meta v1",), using="mysql") self.assertSingleRevision((obj,), meta_names=("meta v1",), using="postgres")
def testGetForObjectReferenceFiltering(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_reference(TestModel, obj_1.pk).get().object, obj_1) self.assertEqual(Version.objects.get_for_object_reference(TestModel, obj_2.pk).get().object, obj_2)
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_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 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 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 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 form_valid(self, form): version_list = reversion.get_unique_for_object(self.object) if version_list: version = version_list[0] # get difference between last version and new version diff = {} for k,v in version.field_dict.iteritems(): if v not in form.cleaned_data.values(): if k != u"id": diff[k] = form.cleaned_data[k] # get the help_text of the field using name for k,v in diff.items(): for field in Passport._meta.fields: if field.name == k: diff[smart_text(field.help_text)] = v del diff[k] with reversion.create_revision(): form.save() changed = u"Изменено: " for k, v in diff.items(): changed += u" %s -> %s | " % (k, v) reversion.set_comment(changed) else: with reversion.create_revision(): form.save() return super(PassportUpdateView, self).form_valid(form)
def testGetForObjectOrdering(self): with reversion.create_revision(): obj = TestModel.objects.create() with reversion.create_revision(): obj.name = "v2" obj.save() self.assertEqual(Version.objects.get_for_object(obj)[0].field_dict["name"], "v2") self.assertEqual(Version.objects.get_for_object(obj)[1].field_dict["name"], "v1")
def setUp(self): super(AdminRevisionViewTest, self).setUp() with reversion.create_revision(): self.obj = TestModelParent.objects.create() with reversion.create_revision(): self.obj.name = "v2" self.obj.parent_name = "parent v2" self.obj.save()
def testContextManager(self): # New revision should be created. with reversion.create_revision(): with reversion.create_revision(): self.test11.name = "model1 instance1 version2" self.test11.save() self.assertEqual(Revision.objects.count(), 2) self.assertEqual(Version.objects.count(), 5)
def testRevert(self): with reversion.create_revision(): obj = TestModel.objects.create() with reversion.create_revision(): obj.name = "v2" obj.save() Version.objects.get_for_object(obj)[1].revert() obj.refresh_from_db() self.assertEqual(obj.name, "v1")
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 testNestedContextManagerRaisingException(self): # New revision should be created. try: with reversion.create_revision(db='default'): with reversion.create_revision(db='shard_a'): self.test11.name = "model1 instance1 version2" self.test11.save() self.fail('Nested manager with different dbs was supposed to raise an exception...') except RevisionManagementError, rme: pass
def testRevisionContextAbandonedOnError(self): with reversion.create_revision(): try: with reversion.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 testGetDeletedOrdering(self): with reversion.create_revision(): obj_1 = TestModel.objects.create() with reversion.create_revision(): obj_2 = TestModel.objects.create() pk_1 = obj_1.pk obj_1.delete() pk_2 = obj_2.pk obj_2.delete() self.assertEqual(Version.objects.get_deleted(TestModel)[0].object_id, force_text(pk_2)) self.assertEqual(Version.objects.get_deleted(TestModel)[1].object_id, force_text(pk_1))
def _save(self, *args, **kwargs): ''' This falls back on using an admin user if a thread request object wasn't found ''' import ipdb; ipdb.set_trace() 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 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 test_consent_required(rf): activate("en") shop = factories.get_default_shop() user = factories.create_random_user() page = ensure_gdpr_privacy_policy(shop) assert page gdpr_settings = GDPRSettings.get_for_shop(shop) assert not gdpr_settings.enabled assert gdpr_settings.privacy_policy_page == page assert not should_reconsent_privacy_policy(shop, user) assert is_documents_consent_in_sync(shop, user) # settings not enabled assert page in get_possible_consent_pages(shop) # enable gpdr gdpr_settings.enabled = True gdpr_settings.save() assert gdpr_settings.privacy_policy_page == get_privacy_policy_page(shop) assert not is_documents_consent_in_sync(shop, user) # create revisioned page hidden_page = Page.objects.create(shop=shop, available_from=None) assert hidden_page not in Page.objects.visible(shop=shop) assert gdpr_settings.privacy_policy_page == get_privacy_policy_page(shop) assert hidden_page in get_possible_consent_pages(shop) with reversion.create_revision(): page.save() create_user_consent_for_all_documents(shop, user) assert GDPRUserConsent.objects.filter(user=user, shop=shop).count() == 1 consent = GDPRUserConsent.objects.get(user=user, shop=shop) pages = [c.page for c in consent.documents.all()] assert page in pages assert hidden_page not in pages # not there due not visible with reversion.create_revision(): page.save() # add a new (visible) page available_page = Page.objects.create(shop=shop, available_from=now()) assert available_page in Page.objects.visible(shop=shop) create_user_consent_for_all_documents(shop, user) consent = GDPRUserConsent.objects.get(user=user, shop=shop) pages = [c.page for c in consent.documents.all()] assert page in pages assert hidden_page not in pages # not there due not visible assert available_page not in pages # not there due defined in settings assert available_page in get_possible_consent_pages(shop) assert available_page not in get_active_consent_pages(shop) gdpr_settings.consent_pages.add(available_page) gdpr_settings.refresh_from_db() assert gdpr_settings.privacy_policy_page assert gdpr_settings.consent_pages.count() == 1 assert available_page in get_active_consent_pages(shop) assert consent.documents.count() == 1 create_user_consent_for_all_documents(shop, user) consent = GDPRUserConsent.objects.get(user=user, shop=shop) assert consent.documents.count() == 2 assert is_documents_consent_in_sync(shop, user) pages = [c.page for c in consent.documents.all()] assert page in pages assert hidden_page not in pages # not there due not visible assert available_page in pages
field = Field.objects.get(key=item).toDict() if field['type'] == 'Template': template = Template(field['args'].get('template')) context = Context({'case': case}) templates.append(template.render(context)) return templates @permission_required('core.can_manage_cases', raise_exception=True) def delete_case(request, case_id): case = get_object_or_404(Case, pk=case_id) if request.method == 'POST': with reversion.create_revision(): case.delete() reversion.set_user(request.user) messages.add_message(request, messages.INFO, _('De zaak is verwijderd.')) return redirect('cases') return render(request, 'cases/delete.html', { 'page_title': case, 'case': case, }) @require_http_methods(['POST']) @permission_required('core.can_manage_cases', raise_exception=True)
def testGetForObjectReference(self): with reversion.create_revision(): obj = TestModel.objects.create() self.assertEqual(Version.objects.get_for_object_reference(TestModel, obj.pk).count(), 1)
def testGetForObjectModelDb(self): with reversion.create_revision(): obj = TestModel.objects.db_manager("postgres").create() self.assertEqual(Version.objects.get_for_object(obj).count(), 0) self.assertEqual(Version.objects.get_for_object(obj, model_db="postgres").count(), 1)
def migrate_ixlan_id(self, ixlan, ixlans, trigger=None, tmp_id=False): """ Migrate an ixlan id so it matches the parent exchange id """ # ids already match, nothind to do here if ixlan.id == ixlan.ix.id: return ix = ixlan.ix new_id = ix.id old_id = ixlan.id # indicates that we want to migrate this ixlan to a temporary # id for now, so we override new_id with a temporary id if tmp_id: new_id = self.tmp_id # targeted ixlan id currently claimed by another ixlan (that is not this ixlan) if ixlans.get(new_id) and ixlans.get(new_id) != ixlan: # migrate conflicting ixlan id if not trigger or trigger.id != new_id: self.migrate_ixlan_id(ixlans[new_id], ixlans, trigger=ixlan) else: # this ixlan id migration was triggered by the same ixlan # we are trying to resolve the conflict for, so to avoid # and endless loop we migrate to a temporary id self.migrate_ixlan_id( ixlans[new_id], ixlans, trigger=ixlan, tmp_id=True ) # migrate ixlan id (in memory) ixlan.id = new_id if not tmp_id: ixlans[new_id] = ixlan if ixlans.get(old_id) == ixlan: del ixlans[old_id] # if ixlan was migrated to a temporary id during conflict # resolving above: old_id needs to be updated to temporary id if hasattr(ixlan, "tmp_id"): old_id = ixlan.tmp_id elif tmp_id: ixlan.tmp_id = new_id # update migration report if not tmp_id: self.report_migration(old_id, new_id, ixlan) self.log( "Migrated [{}] ixlan id {} -> {} - Exchange: {}".format( ixlan.status, old_id, new_id, ix.name ) ) # migrate ixlan id (database) self.migrate_ixlan_id_sql(old_id, ixlan.id) # create reversion revision for all updated entities if self.commit: # on deleted exchanges we also need to save the ix # and the org so it will be available in the api's incrememental # update response if ixlan.ix.status == "deleted": ixlan.ix.save() ixlan.ix.org.save() with reversion.create_revision(): reversion.set_comment( "Migrated to new ixlan id: {} -> {} (script, #21)".format( old_id, ixlan.id ) ) reversion.add_to_revision(ixlan) for netixlan in ixlan.netixlan_set.all(): reversion.add_to_revision(netixlan) # on deleted netixlan networks # we also need to save the netixlan's network and org # so they will be available in api's incremental update # responses if netixlan.network.status == "deleted": netixlan.network.save() netixlan.network.org.save() for ixpfx in ixlan.ixpfx_set.all(): reversion.add_to_revision(ixpfx) # if old_id still points to this ixlan in our ixlans collection # delete it so we know the old id is now available if ixlans.get(old_id) == ixlan: del ixlans[old_id] # update migration stats self.stats[f"migrated_{ixlan.status}"] += 1
def testRevertBadFormat(self): with reversion.create_revision(): obj = TestModel.objects.create() Version.objects.get_for_object(obj).update(format="boom") with self.assertRaises(reversion.RevertError): Version.objects.get_for_object(obj).get().revert()
def testGetForObjectUnique(self): with reversion.create_revision(): obj = TestModel.objects.create() with reversion.create_revision(): obj.save() self.assertEqual(len(list(Version.objects.get_for_object(obj).get_unique())), 1)
def testCreateRevisionNested(self): with reversion.create_revision(): with reversion.create_revision(): obj = TestModel.objects.create() self.assertSingleRevision((obj,))
def setUp(self): super(AdminRecoverViewTest, self).setUp() with reversion.create_revision(): obj = TestModelParent.objects.create() obj.delete()
def testGetForObject(self): with reversion.create_revision(): obj = TestModel.objects.create() self.assertEqual(Version.objects.get_for_object(obj).count(), 1)
def ensure_gdpr_privacy_policy(shop, force_update=False): from shuup.gdpr.models import GDPRSettings from shuup.simple_cms.models import Page gdpr_document = get_privacy_policy_page(shop) current_language = get_language() if force_update or not gdpr_document: now_date = now() company_name = (shop.public_name or shop.name) address = shop.contact_address full_address = "" if address: full_address = ", ".join([ item for item in [ company_name, address.street, address.city, address. region_code, address.postal_code, address.country.code ] if item ]) context = { "last_updated": format_datetime(now(), "LLLL dd, YYYY").capitalize(), "company_name": company_name, "full_address": full_address, "store_email": address.email if address else "" } content = loader.render_to_string( template_name="shuup/admin/gdpr/privacy_policy_page.jinja", context=context) created = False if not gdpr_document: with create_revision(): gdpr_document = Page.objects.create( shop=shop, content=content, available_from=now_date, title=force_text(_("Privacy Policy")), url=settings.GDPR_PRIVACY_POLICY_PAGE_URLS.get( current_language, "privacy-policy")) created = True gdpr_settings = GDPRSettings.get_for_shop(shop) gdpr_settings.privacy_policy_page = gdpr_document gdpr_settings.save() # update only if it was created if created or force_update: for code, language in settings.LANGUAGES: if code == current_language: continue url = settings.GDPR_PRIVACY_POLICY_PAGE_URLS.get(code) if not url: continue activate(code) content = loader.render_to_string( template_name="shuup/admin/gdpr/privacy_policy_page.jinja", context=context) gdpr_document.set_current_language(code) gdpr_document.title = force_text(_("Privacy Policy")) gdpr_document.url = url gdpr_document.content = content gdpr_document.save() # return to old language activate(current_language) gdpr_document.set_current_language(current_language) return gdpr_document
def testGetUserDefault(self): with reversion.create_revision(): self.assertEqual(reversion.get_user(), None)
def testGetForModel(self): with reversion.create_revision(): obj = TestModel.objects.create() self.assertEqual(Version.objects.get_for_model(obj.__class__).count(), 1)
def testGetDateCreatedDefault(self): with reversion.create_revision(): self.assertAlmostEqual(reversion.get_date_created(), timezone.now(), delta=timedelta(seconds=1))
def editInclusionOrder(request, dss_id, inc_type): if inc_type not in ['cluster', 'data_element']: raise Http404 item = get_object_or_404(models.DataSetSpecification, pk=dss_id) if not user_can_edit(request.user, item): if request.user.is_anonymous(): return redirect( reverse('friendly_login') + '?next=%s' % request.path) else: raise PermissionDenied item_type, field_name = { 'cluster': (models.DSSClusterInclusion, 'child'), 'data_element': (models.DSSDEInclusion, 'data_element'), }.get(inc_type) num_values = item_type.objects.filter(dss=item.id).count() if num_values > 0: extra = 0 else: extra = 1 ValuesFormSet = modelformset_factory(item_type, formset=HiddenOrderModelFormSet, can_order=True, fields=('id', ), extra=extra) if request.method == 'POST': formset = ValuesFormSet(request.POST, request.FILES) if formset.is_valid(): with transaction.atomic(), reversion.create_revision(): item.save( ) # do this to ensure we are saving reversion records for the DSS, not just the values formset.save(commit=False) for form in formset.forms: if form['id'].value() not in [ deleted_record['id'].value() for deleted_record in formset.deleted_forms ]: inc = item_type.objects.get(pk=form['id'].value()) if inc.dss != item: raise PermissionDenied inc.order = form['ORDER'].value() # inc.maximum_occurances = form['maximum_occurances'].value() # value = form.save(commit=False) #Don't immediately save, we need to attach the value domain # value.dss = item inc.save() for obj in formset.deleted_objects: obj.delete() reversion.set_user(request.user) reversion.set_comment( construct_change_message(request, None, [ formset, ])) return redirect(reverse("aristotle_mdr:item", args=[item.id])) else: formset = ValuesFormSet( queryset=item_type.objects.filter(dss=item.id), ) return render( request, "aristotle_dse/actions/edit_inclusion_order.html", { 'item': item, 'formset': formset, 'include_type': inc_type, 'value_model': item_type, })
def testSetDateCreated(self): date_created = timezone.now() - timedelta(days=20) with reversion.create_revision(): reversion.set_date_created(date_created) obj = TestModel.objects.create() self.assertSingleRevision((obj,), date_created=date_created)
def testGetForModelDbMySql(self): with reversion.create_revision(using="mysql"): obj = TestModel.objects.create() self.assertEqual(Version.objects.using("mysql").get_for_model(obj.__class__).count(), 1)
def save(self, *args, **kwargs): if self.pk and self.page_type == PageType.REVISIONED: with reversion.create_revision(): super(Page, self).save(*args, **kwargs) super(Page, self).save(*args, **kwargs)
def testCreateRevisionEmpty(self): with reversion.create_revision(): pass self.assertNoRevision()
def testGetDeletedModelDb(self): with reversion.create_revision(): obj = TestModel.objects.db_manager("postgres").create() obj.delete() self.assertEqual(Version.objects.get_deleted(TestModel).count(), 0) self.assertEqual(Version.objects.get_deleted(TestModel, model_db="postgres").count(), 1)
def testAddMeta(self): with reversion.create_revision(): reversion.add_meta(TestMeta, name="meta v1") obj = TestModel.objects.create() self.assertSingleRevision((obj,), meta_names=("meta v1",))
def testGetDeletedDbMySql(self): with reversion.create_revision(using="mysql"): obj = TestModel.objects.create() obj.delete() self.assertEqual(Version.objects.get_deleted(TestModel).count(), 0) self.assertEqual(Version.objects.using("mysql").get_deleted(TestModel).count(), 1)
def testGetDateCreated(self): date_created = timezone.now() - timedelta(days=20) with reversion.create_revision(): reversion.set_date_created(date_created) self.assertEqual(reversion.get_date_created(), date_created)
def testGetDeletedEmpty(self): with reversion.create_revision(): TestModel.objects.create() self.assertEqual(Version.objects.get_deleted(TestModel).count(), 0)
def testGetForObjectReferenceModelDbMySql(self): with reversion.create_revision(): obj = TestModel.objects.db_manager("mysql").create() self.assertEqual(Version.objects.get_for_object_reference(TestModel, obj.pk).count(), 0) self.assertEqual(Version.objects.get_for_object_reference(TestModel, obj.pk, model_db="mysql").count(), 1)
def testGetForObjectReferenceModelDb(self): with reversion.create_revision(using="postgres"): obj = TestModel.objects.create() self.assertEqual(Version.objects.get_for_object_reference(TestModel, obj.pk).count(), 0) self.assertEqual(Version.objects.using("postgres").get_for_object_reference(TestModel, obj.pk).count(), 1)
def _save(self, *args, **kwargs): ''' This falls back on using an admin user if a thread request object wasn't found ''' #import ipdb; ipdb.set_trace() 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, created = User.objects.get_or_create( username='******', defaults={ 'is_active': 'False', 'first_name': 'Admin', 'last_name': 'Admin', 'email': 'admin@{}'.format(settings.INTERNAL_EMAIL[0]) }) _locals.user = user else: try: user = User.objects.get(pk=_locals.request.user.pk) except Exception: user, created = User.objects.get_or_create( username='******', defaults={ 'is_active': 'False', 'first_name': 'Admin', 'last_name': 'Admin', 'email': 'admin@{}'.format(settings.INTERNAL_EMAIL[0]) }) # 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 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 testGetForObjectDbMySql(self): with reversion.create_revision(using="mysql"): obj = TestModel.objects.create() self.assertEqual(Version.objects.get_for_object(obj).count(), 0) self.assertEqual(Version.objects.using("mysql").get_for_object(obj).count(), 1)
def create_version(self): with reversion.create_revision(): self.object_class.definition = 'No longer a human being' self.object_class.name = 'New Person' self.object_class.save()
def testGetUser(self): with reversion.create_revision(): reversion.set_user(self.user) self.assertEqual(reversion.get_user(), self.user)