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 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 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 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_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 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 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 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 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 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 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 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))
