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)
