def done(self, form_list, **kwargs):
oc = self.get_object_class()
pr = self.get_property()
dec = None
for form in form_list:
saved_item = form.save()
if type(saved_item) == MDR.Property:
pr = saved_item
messages.success(self.request,
mark_safe(_("New Property '{name}' Saved - <a href='{url}'>id:{id}</a>").format(
url=url_slugify_concept(saved_item),
name=saved_item.name,id=saved_item.id
))
)
if type(saved_item) == MDR.ObjectClass:
oc = saved_item
messages.success(self.request,
mark_safe(_("New Object Class '{name}' Saved - <a href='{url}'>id:{id}</a>").format(
url=url_slugify_concept(saved_item),
name=saved_item.name,id=saved_item.id
))
)
if type(saved_item) == MDR.DataElementConcept:
dec = saved_item
messages.success(self.request,
mark_safe(_("New Data Element Concept '{name}' Saved - <a href='{url}'>id:{id}</a>").format(
url=url_slugify_concept(saved_item),
name=saved_item.name,id=saved_item.id
))
)
if dec is not None:
dec.objectClass = oc
dec.property = pr
dec.save()
return HttpResponseRedirect(url_slugify_concept(dec))
def test_stubs_redirect_correctly(self):
self.login_viewer()
response = self.client.get(reverse('aristotle:item',args=[self.item1.id]))
self.assertRedirects(response,url_slugify_concept(self.item1))
response = self.client.get(reverse('aristotle:item',args=[self.item1.id])+"/not-a-model/fake-name")
self.assertRedirects(response,url_slugify_concept(self.item1))
response = self.client.get(reverse('aristotle:item',args=[self.item1.id])+"/this-isnt-even-a-proper-stub")
self.assertRedirects(response,url_slugify_concept(self.item1))
def test_stubs_redirect_correctly(self):
self.login_viewer()
response = self.client.get(reverse('aristotle:item',args=[self.item1.id]))
self.assertRedirects(response,url_slugify_concept(self.item1))
response = self.client.get(reverse('aristotle:item',args=[self.item1.id])+"/not-a-model/fake-name")
self.assertRedirects(response,url_slugify_concept(self.item1))
response = self.client.get(reverse('aristotle:item',args=[self.item1.id])+"/this-isnt-even-a-proper-stub")
self.assertRedirects(response,url_slugify_concept(self.item1))
def deprecate(request, iid):
item = get_object_or_404(MDR._concept, pk=iid).item
if not (item and user_can_edit(request.user, item)):
if request.user.is_anonymous():
return redirect(reverse("friendly_login") + "?next=%s" % request.path)
else:
raise PermissionDenied
qs = item.__class__.objects.filter().editable(request.user)
if request.method == "POST": # If the form has been submitted...
form = MDRForms.DeprecateForm(
request.POST, user=request.user, item=item, qs=qs
) # A form bound to the POST data
if form.is_valid():
# Check use the itemset as there are permissions issues and we want to remove some:
# Everything that was superseded, but isn't in the returned set
# Everything that was in the returned set, but isn't already superseded
# Everything left over can stay the same, as its already superseded
# or wasn't superseded and is staying that way.
with transaction.atomic(), reversion.revisions.create_revision():
reversion.revisions.set_user(request.user)
for i in item.supersedes.all():
if i not in form.cleaned_data["olderItems"] and user_can_edit(request.user, i):
item.supersedes.remove(i)
for i in form.cleaned_data["olderItems"]:
if user_can_edit(request.user, i): # Would check item.supersedes but its a set
item.supersedes.add(i)
return HttpResponseRedirect(url_slugify_concept(item))
else:
form = MDRForms.DeprecateForm(user=request.user, item=item, qs=qs)
return render(request, "aristotle_mdr/actions/deprecateItems.html", {"item": item, "form": form})
def render_if_condition_met(request, condition, objtype, iid, model_slug=None, name_slug=None, subpage=None):
item = get_object_or_404(objtype, pk=iid).item
if item._meta.model_name != model_slug or not slugify(item.name).startswith(str(name_slug)):
return redirect(url_slugify_concept(item))
if not condition(request.user, item):
if request.user.is_anonymous():
return redirect(reverse('friendly_login') + '?next=%s' % request.path)
else:
raise PermissionDenied
# We add a user_can_edit flag in addition to others as we have odd rules around who can edit objects.
isFavourite = request.user.is_authenticated() and request.user.profile.is_favourite(item)
last_edit = default_revision_manager.get_for_object_reference(
item.__class__,
item.pk,
).first()
default_template = "%s/concepts/%s.html" % (item.__class__._meta.app_label, item.__class__._meta.model_name)
template = select_template([default_template, item.template])
context = RequestContext(
request,
{
'item': item,
# 'view': request.GET.get('view', '').lower(),
'isFavourite': isFavourite,
'last_edit': last_edit
}
)
return HttpResponse(template.render(context))
def test_viewer_can_request_review(self):
self.login_editor()
response = self.client.get(
reverse('aristotle:request_review', args=[self.item3.id]))
self.assertEqual(response.status_code, 200)
response = self.client.get(
reverse('aristotle:request_review', args=[self.item2.id]))
self.assertEqual(response.status_code, 403)
response = self.client.get(
reverse('aristotle:request_review', args=[self.item1.id]))
self.assertEqual(response.status_code, 200)
form = response.context['form']
self.assertEqual(self.item1.review_requests.count(), 0)
response = self.client.post(
reverse('aristotle:request_review', args=[self.item1.id]), {
'registration_authority': [str(self.ra.id)],
'state': self.ra.public_state,
'cascade_registration': 0,
'message': "Please review this",
'registration_date': datetime.date(2010, 1, 1)
})
self.assertRedirects(response, url_slugify_concept(self.item1))
self.assertEqual(self.item1.review_requests.count(), 1)
def edit_item(request, iid, *args, **kwargs):
item = get_object_or_404(MDR._concept, pk=iid).item
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
base_form = MDRForms.wizards.subclassed_edit_modelform(item.__class__)
if request.method == 'POST': # If the form has been submitted...
form = base_form(request.POST, instance=item, user=request.user)
new_wg = request.POST.get('workgroup', None)
workgroup_changed = not(str(item.workgroup.pk) == (new_wg))
if form.is_valid():
workgroup_changed = item.workgroup.pk != form.cleaned_data['workgroup'].pk
with transaction.atomic(), reversion.revisions.create_revision():
change_comments = form.data.get('change_comments', None)
item = form.save()
reversion.revisions.set_user(request.user)
if not change_comments:
change_comments = construct_change_message(request, form, None)
reversion.revisions.set_comment(change_comments)
return HttpResponseRedirect(url_slugify_concept(item))
else:
form = base_form(instance=item, user=request.user)
return render(request, "aristotle_mdr/actions/advanced_editor.html", {"item": item, "form": form})
def test_toggle_favourite_off_view(self):
primtag = models.Tag.objects.create(
profile=self.editor.profile,
name='',
primary=True
)
models.Favourite.objects.create(
tag=primtag,
item=self.timtam
)
self.login_editor()
self.check_favourite(self.editor, self.timtam, True)
response = self.reverse_get(
'aristotle_favourites:toggleFavourite',
reverse_args=[self.timtam.id],
status_code=302
)
self.assertEqual(response.url, url_slugify_concept(self.timtam))
messages = list(get_messages(response.wsgi_request))
self.assertTrue(messages[1].message.startswith('Tim Tam removed from favourites'))
self.check_favourite(self.editor, self.timtam, False)
def deprecate(request, iid):
item = get_object_or_404(MDR._concept, pk=iid).item
if not (item and user_can_edit(request.user, item)):
if request.user.is_anonymous():
return redirect(reverse('friendly_login') + '?next=%s' % request.path)
else:
raise PermissionDenied
qs=item.__class__.objects.filter().editable(request.user)
if request.method == 'POST': # If the form has been submitted...
form = MDRForms.DeprecateForm(request.POST, user=request.user, item=item, qs=qs) # A form bound to the POST data
if form.is_valid():
# Check use the itemset as there are permissions issues and we want to remove some:
# Everything that was superseded, but isn't in the returned set
# Everything that was in the returned set, but isn't already superseded
# Everything left over can stay the same, as its already superseded
# or wasn't superseded and is staying that way.
with transaction.atomic(), reversion.revisions.create_revision():
reversion.revisions.set_user(request.user)
for i in item.supersedes.all():
if i not in form.cleaned_data['olderItems'] and user_can_edit(request.user, i):
item.supersedes.remove(i)
for i in form.cleaned_data['olderItems']:
if user_can_edit(request.user, i): # Would check item.supersedes but its a set
item.supersedes.add(i)
return HttpResponseRedirect(url_slugify_concept(item))
else:
form = MDRForms.DeprecateForm(user=request.user, item=item, qs=qs)
return render(request, "aristotle_mdr/actions/deprecateItems.html", {"item": item, "form": form})
def clone_item(request, iid, *args, **kwargs):
item_to_clone = get_object_or_404(MDR._concept, pk=iid).item
if not user_can_edit(request.user, item_to_clone):
if request.user.is_anonymous():
return redirect(
reverse('friendly_login') + '?next=%s' % request.path)
else:
raise PermissionDenied
base_form = MDRForms.wizards.subclassed_modelform(item_to_clone.__class__)
if request.method == 'POST': # If the form has been submitted...
form = base_form(request.POST, user=request.user)
if form.is_valid():
with transaction.atomic(), reversion.revisions.create_revision():
new_clone = form.save()
reversion.revisions.set_user(request.user)
reversion.revisions.set_comment(
"Cloned from %s (id: %s)" %
(item_to_clone.name, str(item_to_clone.pk)))
return HttpResponseRedirect(url_slugify_concept(new_clone))
else:
form = base_form(initial=concept_to_clone_dict(item_to_clone),
user=request.user)
return render(request, "aristotle_mdr/create/clone_item.html", {
"item": item_to_clone,
"form": form
})
def test_viewer_can_favourite(self):
self.login_viewer()
self.assertTrue(perms.user_can_view(self.viewer,self.item1))
response = self.client.post(reverse('django.contrib.auth.views.login'), {'username': '******', 'password': '******'})
self.assertEqual(response.status_code,302)
self.assertEqual(self.viewer.profile.favourites.count(),0)
response = self.client.get(reverse('aristotle:toggleFavourite', args=[self.item1.id]))
self.assertRedirects(response,url_slugify_concept(self.item1))
self.assertEqual(self.viewer.profile.favourites.count(),1)
self.assertEqual(self.viewer.profile.favourites.first().item,self.item1)
response = self.client.get(reverse('aristotle:toggleFavourite', args=[self.item1.id]))
self.assertRedirects(response,url_slugify_concept(self.item1))
self.assertEqual(self.viewer.profile.favourites.count(),0)
def post(self, request, *args, **kwargs):
form = self.get_form()
slot_formset = None
if form.is_valid():
with transaction.atomic(), reversion.revisions.create_revision():
item = form.save(commit=False)
slot_formset = self.get_slots_formset()(request.POST,
request.FILES,
item.concept)
if slot_formset.is_valid():
# Save the slots
slot_formset.save()
# Save the change comments
reversion.revisions.set_user(request.user)
change_comments = form.data.get('change_comments', None)
if not change_comments:
change_comments = construct_change_message(
request, form, [slot_formset])
reversion.revisions.set_comment(change_comments)
item.save()
return HttpResponseRedirect(url_slugify_concept(self.item))
return self.form_invalid(form, slot_formset)
def test_toggle_favourite_off_view(self):
primtag = models.Tag.objects.create(
profile=self.editor.profile,
name='',
primary=True
)
models.Favourite.objects.create(
tag=primtag,
item=self.timtam
)
self.login_editor()
self.check_favourite(self.editor, self.timtam, True)
response = self.reverse_get(
'aristotle_favourites:toggleFavourite',
reverse_args=[self.timtam.id],
status_code=302
)
self.assertEqual(response.url, url_slugify_concept(self.timtam))
messages = list(get_messages(response.wsgi_request))
self.assertTrue(messages[1].message.startswith('Tim Tam removed from favourites'))
self.check_favourite(self.editor, self.timtam, False)
def test_registrar_can_change_status(self):
self.login_registrar()
self.assertFalse(perms.user_can_view(self.registrar,self.item1))
self.item1.readyToReview = True
self.item1.save()
self.item1 = self.itemType.objects.get(pk=self.item1.pk)
self.assertTrue(perms.user_can_view(self.registrar,self.item1))
self.assertTrue(perms.user_can_change_status(self.registrar,self.item1))
response = self.client.get(reverse('aristotle:changeStatus',args=[self.item1.id]))
self.assertEqual(response.status_code,200)
self.assertEqual(self.item1.statuses.count(),0)
response = self.client.post(reverse('aristotle:changeStatus',args=[self.item1.id]),
{ 'registrationAuthorities': [str(self.ra.id)],
'state': self.ra.public_state,
'changeDetails': "testing",
'cascadeRegistration': 0, #no
}
)
self.assertRedirects(response,url_slugify_concept(self.item1))
self.item1 = self.itemType.objects.get(pk=self.item1.pk)
self.assertEqual(self.item1.statuses.count(),1)
self.assertTrue(self.item1.is_registered)
self.assertTrue(self.item1.is_public())
def test_weak_editor_during_create(self):
self.login_editor()
item_name = self.post_first_step()
step_2_data = {
self.wizard_form_name+'-current_step': 'results',
'initial-name':item_name,
'results-name':item_name,
'results-definition':"Test Definition",
}
valuemeaning_formset_data = [
{'name': 'Test1', 'definition': 'test defn', 'start_date': '1999-01-01', 'end_date': '2090-01-01', 'ORDER': 0},
{'name': 'Test2', 'definition': 'test defn', 'start_date': '1999-01-01', 'end_date': '2090-01-01', 'ORDER': 1}
]
step_2_data.update(self.get_formset_postdata(valuemeaning_formset_data, 'value_meaning', 0))
step_2_data.update(self.get_formset_postdata([], 'slots'))
response = self.client.post(self.wizard_url, step_2_data)
self.assertEqual(response.status_code, 302)
self.assertTrue(self.model.objects.filter(name=item_name).exists())
self.assertEqual(self.model.objects.filter(name=item_name).count(),1)
item = self.model.objects.filter(name=item_name).first()
self.assertRedirects(response,url_slugify_concept(item))
vms = item.valuemeaning_set.all()
self.assertEqual(len(vms), 2)
self.assertEqual(vms[0].name, 'Test1')
self.assertEqual(vms[1].name, 'Test2')
def render_if_condition_met(request, condition, objtype, iid, model_slug=None, name_slug=None, subpage=None):
item = get_object_or_404(objtype, pk=iid).item
if item._meta.model_name != model_slug or not slugify(item.name).startswith(str(name_slug)):
return redirect(url_slugify_concept(item))
if not condition(request.user, item):
if request.user.is_anonymous():
return redirect(reverse("friendly_login") + "?next=%s" % request.path)
else:
raise PermissionDenied
# We add a user_can_edit flag in addition
# to others as we have odd rules around who can edit objects.
isFavourite = request.user.is_authenticated() and request.user.profile.is_favourite(item)
from reversion.models import Version
last_edit = Version.objects.get_for_object(item).first()
default_template = "%s/concepts/%s.html" % (item.__class__._meta.app_label, item.__class__._meta.model_name)
template = select_template([default_template, item.template])
context = RequestContext(
request,
{
"item": item,
# 'view': request.GET.get('view', '').lower(),
"isFavourite": isFavourite,
"last_edit": last_edit,
},
)
return HttpResponse(template.render(context))
def post(self, request, *args, **kwargs):
form = self.get_form()
slot_formset = None
if form.is_valid():
with transaction.atomic(), reversion.revisions.create_revision():
item = form.save(commit=False)
slot_formset = self.get_slots_formset()(request.POST, request.FILES, item.concept)
if slot_formset.is_valid():
# Save the slots
slot_formset.save()
# Save the change comments
reversion.revisions.set_user(request.user)
change_comments = form.data.get('change_comments', None)
if not change_comments:
change_comments = construct_change_message(request, form, [slot_formset])
reversion.revisions.set_comment(change_comments)
item.save()
return HttpResponseRedirect(url_slugify_concept(self.item))
return self.form_invalid(form, slot_formset)
def scoped_identifier_redirect(request, ns_prefix, iid, version=None):
objs = _concept.objects.filter(
identifiers__namespace__shorthand_prefix=ns_prefix,
identifiers__identifier=iid)
if version:
objs.filter(identifiers__version=version)
if objs.count() == 0:
raise Http404
elif objs.count() == 1:
return redirect(url_slugify_concept(objs.first().item))
else:
item = objs.order_by(
'version').last() # lets hope there is an order to the versions.
return redirect(url_slugify_concept(item.item))
def done(self, form_list, **kwargs):
reversion.set_user(self.request.user)
reversion.set_comment("Added via concept wizard")
saved_item = None
for form in form_list:
saved_item = form.save(commit=False)
if saved_item is not None:
saved_item.submitter = self.request.user
saved_item.save()
form.save_m2m()
if 'results_postdata' in self.request.session:
extra_formsets = self.get_extra_formsets(
item=self.model,
postdata=self.request.session['results_postdata'])
formsets_invalid = self.validate_formsets(extra_formsets)
if not formsets_invalid:
final_formsets = []
for info in extra_formsets:
info['saveargs']['item'] = saved_item
final_formsets.append(info)
self.save_formsets(final_formsets)
self.request.session.pop('results_postdata')
return HttpResponseRedirect(url_slugify_concept(saved_item))
def test_propose_supersede(self):
self.login_editor()
self.assertTrue(perms.user_can_edit(self.editor, self.item1))
# Get formset postdata for single supersedes
postdata = self.get_formset_postdata(
[{
'older_item': self.item2.id,
'registration_authority': self.ra.id,
'message': '',
'date_effective': ''
}],
prefix='superseded_items_relation_set')
response = self.reverse_post(
'aristotle:proposed_supersede',
postdata,
reverse_args=[self.item1.id],
)
self.assertRedirects(response, url_slugify_concept(self.item1))
self.assertEqual(self.item1.superseded_items_relation_set.count(), 1)
ss = self.item1.superseded_items_relation_set.first()
self.assertTrue(ss.proposed)
def test_viewer_can_request_review(self):
self.login_editor()
response = self.client.get(reverse("aristotle:request_review", args=[self.item3.id]))
self.assertEqual(response.status_code, 200)
response = self.client.get(reverse("aristotle:request_review", args=[self.item2.id]))
self.assertEqual(response.status_code, 403)
response = self.client.get(reverse("aristotle:request_review", args=[self.item1.id]))
self.assertEqual(response.status_code, 200)
form = response.context["form"]
self.assertEqual(self.item1.review_requests.count(), 0)
response = self.client.post(
reverse("aristotle:request_review", args=[self.item1.id]),
{
"registration_authority": [str(self.ra.id)],
"state": self.ra.public_state,
"message": "Please review this",
},
)
self.assertRedirects(response, url_slugify_concept(self.item1))
self.assertEqual(self.item1.review_requests.count(), 1)
def edit_item(request,iid,*args,**kwargs):
item = get_object_or_404(MDR._concept,pk=iid).item
if not user_can_edit(request.user, item):
if request.user.is_anonymous():
return redirect(reverse('django.contrib.auth.views.login')+'?next=%s' % request.path)
else:
raise PermissionDenied
base_form = MDRForms.wizards.subclassed_edit_modelform(item.__class__)
if request.method == 'POST': # If the form has been submitted...
form = base_form(request.POST,instance=item,user=request.user)
if form.is_valid():
with transaction.atomic(), reversion.create_revision():
change_comments = form.data.get('change_comments',None)
item = form.save()
reversion.set_user(request.user)
if not change_comments:
change_comments = construct_change_message(request,form,None)
reversion.set_comment(change_comments)
return HttpResponseRedirect(url_slugify_concept(item))
else:
form = base_form(instance=item,user=request.user)
return render(request,"aristotle_mdr/actions/advanced_editor.html",
{"item":item,
"form":form,
}
)
def scoped_identifier_redirect(request, ns_prefix, iid, version=None):
objs = _concept.objects.filter(
identifiers__namespace__shorthand_prefix=ns_prefix,
identifiers__identifier=iid
)
if version:
objs.filter(identifiers__version=version)
if objs.count() == 0:
raise Http404
elif objs.count() == 1:
return redirect(url_slugify_concept(objs.first().item))
else:
item = objs.order_by('version').last() # lets hope there is an order to the versions.
return redirect(url_slugify_concept(item.item))
def render_if_condition_met(request,condition,objtype,iid,model_slug=None,name_slug=None,subpage=None):
item = get_object_or_404(objtype,pk=iid).item
if item._meta.model_name != model_slug or not slugify(item.name).startswith(str(name_slug)):
return redirect(url_slugify_concept(item))
if not condition(request.user, item):
if request.user.is_anonymous():
return redirect(reverse('django.contrib.auth.views.login')+'?next=%s' % request.path)
else:
raise PermissionDenied
# We add a user_can_edit flag in addition to others as we have odd rules around who can edit objects.
isFavourite = request.user.is_authenticated () and request.user.profile.is_favourite(item)
last_edit = default_revision_manager.get_for_object_reference(
item.__class__,
item.pk,
).first()
default_template = "%s/concepts/%s.html"%(item.__class__._meta.app_label,item.__class__._meta.model_name)
template = select_template([default_template,item.template])
context = RequestContext(request,
{'item':item,
#'view':request.GET.get('view','').lower(),
'isFavourite': isFavourite,
'last_edit': last_edit
}
)
return HttpResponse(template.render(context))
def supersede(request, iid):
item = get_object_or_404(MDR._concept, pk=iid).item
if not (item and user_can_edit(request.user, item)):
if request.user.is_anonymous():
return redirect(
reverse('friendly_login') + '?next=%s' % request.path)
else:
raise PermissionDenied
qs = item.__class__.objects.all()
if request.method == 'POST': # If the form has been submitted...
form = MDRForms.SupersedeForm(request.POST,
user=request.user,
item=item,
qs=qs) # A form bound to the POST data
if form.is_valid():
with transaction.atomic(), reversion.revisions.create_revision():
reversion.revisions.set_user(request.user)
item.superseded_by = form.cleaned_data['newerItem']
item.save()
return HttpResponseRedirect(url_slugify_concept(item))
else:
form = MDRForms.SupersedeForm(item=item, user=request.user, qs=qs)
return render(request, "aristotle_mdr/actions/supersedeItem.html", {
"item": item,
"form": form
})
def test_registrar_can_change_status(self):
self.login_registrar()
self.assertFalse(perms.user_can_view(self.registrar,self.item1))
self.item1.readyToReview = True
self.item1.save()
self.item1 = self.itemType.objects.get(pk=self.item1.pk)
self.assertTrue(perms.user_can_view(self.registrar,self.item1))
self.assertTrue(perms.user_can_change_status(self.registrar,self.item1))
response = self.client.get(reverse('aristotle:changeStatus',args=[self.item1.id]))
self.assertEqual(response.status_code,200)
self.assertEqual(self.item1.statuses.count(),0)
response = self.client.post(
reverse('aristotle:changeStatus',args=[self.item1.id]),
{
'registrationAuthorities': [str(self.ra.id)],
'state': self.ra.public_state,
'changeDetails': "testing",
'cascadeRegistration': 0, # no
}
)
self.assertRedirects(response,url_slugify_concept(self.item1))
self.item1 = self.itemType.objects.get(pk=self.item1.pk)
self.assertEqual(self.item1.statuses.count(),1)
self.assertTrue(self.item1.is_registered)
self.assertTrue(self.item1.is_public())
def test_editor_can_make_object(self):
self.login_editor()
step_1_data = {
self.wizard_form_name+'-current_step': 'initial',
}
response = self.client.post(self.wizard_url, step_1_data)
wizard = response.context['wizard']
self.assertEqual(wizard['steps'].current, 'initial')
self.assertTrue('name' in wizard['form'].errors.keys())
# must submit a name
step_1_data.update({'initial-name':"Test Item"})
# success!
response = self.client.post(self.wizard_url, step_1_data)
wizard = response.context['wizard']
self.assertEqual(response.status_code, 200)
self.assertEqual(wizard['steps'].current, 'results')
self.do_test_for_issue333(response)
step_2_data = {
self.wizard_form_name+'-current_step': 'results',
'results-name':"Test Item",
}
management_forms = utils.get_management_forms(self.model, item_is_model=True, slots=True)
step_2_data.update(management_forms)
step_2_data.update(self.extra_step2_data)
response = self.client.post(self.wizard_url, step_2_data)
wizard = response.context['wizard']
self.assertTrue('definition' in wizard['form'].errors.keys())
# NOWG self.assertTrue('workgroup' in wizard['form'].errors.keys())
# no "test item" yet.
self.assertFalse(models._concept.objects.filter(name="Test Item").exists())
# must submit a definition at this step. But we are using a non-permitted workgroup.
step_2_data.update({
'results-definition':"Test Definition",
'results-workgroup':self.wg2.id
})
response = self.client.post(self.wizard_url, step_2_data)
self.assertEqual(response.status_code, 200)
wizard = response.context['wizard']
self.assertTrue('workgroup' in wizard['form'].errors.keys())
# must submit a definition at this step. With the right workgroup
step_2_data.update({
'results-definition':"Test Definition",
'results-workgroup':self.wg1.id
})
response = self.client.post(self.wizard_url, step_2_data)
self.assertEqual(response.status_code, 302)
self.assertTrue(models._concept.objects.filter(name="Test Item").exists())
self.assertEqual(models._concept.objects.filter(name="Test Item").count(),1)
item = models._concept.objects.filter(name="Test Item").first()
self.assertRedirects(response,url_slugify_concept(item))
def test_editor_can_make_object(self):
self.login_editor()
step_1_data = {
self.wizard_form_name + '-current_step': 'initial',
}
response = self.client.post(self.wizard_url, step_1_data)
wizard = response.context['wizard']
self.assertEqual(wizard['steps'].current, 'initial')
self.assertTrue('name' in wizard['form'].errors.keys())
# must submit a name
step_1_data.update({'initial-name': "Test Item"})
# success!
response = self.client.post(self.wizard_url, step_1_data)
wizard = response.context['wizard']
self.assertEqual(response.status_code, 200)
self.assertEqual(wizard['steps'].current, 'results')
self.do_test_for_issue333(response)
step_2_data = {
self.wizard_form_name + '-current_step': 'results',
'results-name': "Test Item",
}
response = self.client.post(self.wizard_url, step_2_data)
wizard = response.context['wizard']
self.assertTrue('definition' in wizard['form'].errors.keys())
# NOWG self.assertTrue('workgroup' in wizard['form'].errors.keys())
# no "test item" yet.
self.assertFalse(
models._concept.objects.filter(name="Test Item").exists())
# must submit a definition at this step. But we are using a non-permitted workgroup.
step_2_data.update({
'results-definition': "Test Definition",
'results-workgroup': self.wg2.id
})
response = self.client.post(self.wizard_url, step_2_data)
self.assertEqual(response.status_code, 200)
wizard = response.context['wizard']
self.assertTrue('workgroup' in wizard['form'].errors.keys())
# must submit a definition at this step. With the right workgroup
step_2_data.update({
'results-definition': "Test Definition",
'results-workgroup': self.wg1.id
})
response = self.client.post(self.wizard_url, step_2_data)
self.assertEqual(response.status_code, 302)
self.assertTrue(
models._concept.objects.filter(name="Test Item").exists())
self.assertEqual(
models._concept.objects.filter(name="Test Item").count(), 1)
item = models._concept.objects.filter(name="Test Item").first()
self.assertRedirects(response, url_slugify_concept(item))
def test_weak_editor_during_create(self):
self.login_editor()
item_name = 'My New Relation'
step_1_data = {
self.wizard_form_name + '-current_step': 'initial',
'initial-name': item_name,
}
response = self.client.post(self.wizard_url, step_1_data)
wizard = response.context['wizard']
self.assertEqual(response.status_code, 200)
self.assertEqual(wizard['steps'].current, 'results')
step_2_data = {
self.wizard_form_name + '-current_step': 'results',
'initial-name': item_name,
'results-name': item_name,
'results-definition': "Test Definition",
}
step_2_data.update(self.get_formset_postdata([], 'slots'))
step_2_data.update(self.get_formset_postdata([], 'org_records'))
role_formset_data = [{
'name': 'parent',
'definition': 'ok',
'multiplicity': 1,
'ORDER': 0
}, {
'name': 'child',
'definition': 'good',
'multiplicity': 1,
'ORDER': 1
}]
step_2_data.update(
self.get_formset_postdata(role_formset_data, 'roles'))
response = self.client.post(self.wizard_url, step_2_data)
self.assertEqual(response.status_code, 302)
self.assertTrue(self.model.objects.filter(name=item_name).exists())
self.assertEqual(self.model.objects.filter(name=item_name).count(), 1)
item = self.model.objects.filter(name=item_name).first()
self.assertRedirects(response, url_slugify_concept(item))
roles = item.relationrole_set.all().order_by('ordinal')
self.assertEqual(roles[0].ordinal, 0)
self.assertEqual(roles[0].name, 'parent')
self.assertEqual(roles[0].definition, 'ok')
self.assertEqual(roles[0].multiplicity, 1)
self.assertEqual(roles[1].ordinal, 1)
self.assertEqual(roles[1].name, 'child')
self.assertEqual(roles[1].definition, 'good')
self.assertEqual(roles[1].multiplicity, 1)
def test_weak_editor_during_create(self):
self.de1 = MDR.DataElement.objects.create(name='DE1 - visible',definition="my definition",workgroup=self.wg1)
self.de2 = MDR.DataElement.objects.create(name='DE2 - visible',definition="my definition",workgroup=self.wg1)
self.de3 = MDR.DataElement.objects.create(name='DE3 - visible',definition="my definition",workgroup=self.wg1)
self.oc1 = MDR.ObjectClass.objects.create(name='OC1 - visible',definition="my definition",workgroup=self.wg1)
self.oc2 = MDR.ObjectClass.objects.create(name='OC2 - visible',definition="my definition",workgroup=self.wg1)
self.oc3 = MDR.ObjectClass.objects.create(name='OC3 - visible',definition="my definition",workgroup=self.wg1)
self.login_editor()
item_name = 'My Fancy New Distribution'
step_1_data = {
self.wizard_form_name+'-current_step': 'initial',
'initial-name': item_name,
}
response = self.client.post(self.wizard_url, step_1_data)
wizard = response.context['wizard']
self.assertEqual(response.status_code, 200)
self.assertEqual(wizard['steps'].current, 'results')
step_2_data = {
self.wizard_form_name+'-current_step': 'results',
'initial-name':item_name,
'results-name':item_name,
'results-definition':"Test Definition",
}
step_2_data.update(self.get_formset_postdata([], 'slots'))
ddep_formset_data = [
{'data_element': self.de1.pk, 'logical_path': '/garbage/file', 'specialisation_classes': [self.oc1.pk, self.oc3.pk], 'ORDER': 0},
{'data_element': self.de3.pk, 'logical_path': '/garbage/file', 'specialisation_classes': [self.oc2.pk, self.oc3.pk], 'ORDER': 1},
]
step_2_data.update(self.get_formset_postdata(ddep_formset_data, 'data_elements'))
response = self.client.post(self.wizard_url, step_2_data)
self.assertEqual(response.status_code, 302)
self.assertTrue(self.model.objects.filter(name=item_name).exists())
self.assertEqual(self.model.objects.filter(name=item_name).count(),1)
item = self.model.objects.filter(name=item_name).first()
self.assertRedirects(response,url_slugify_concept(item))
ddeps = item.distributiondataelementpath_set.all().order_by('order')
self.assertEqual(ddeps[0].order, 0)
self.assertEqual(ddeps[0].data_element, self.de1)
self.assertEqual(ddeps[0].logical_path, '/garbage/file')
self.assertEqual(ddeps[0].specialisation_classes.count(), 2)
self.assertTrue(self.oc1 in ddeps[0].specialisation_classes.all())
self.assertTrue(self.oc3 in ddeps[0].specialisation_classes.all())
self.assertEqual(ddeps[1].order, 1)
self.assertEqual(ddeps[1].data_element, self.de3)
self.assertEqual(ddeps[1].logical_path, '/garbage/file')
self.assertEqual(ddeps[1].specialisation_classes.count(), 2)
self.assertTrue(self.oc2 in ddeps[1].specialisation_classes.all())
self.assertTrue(self.oc3 in ddeps[1].specialisation_classes.all())
def done(self, form_list, **kwargs):
reversion.set_user(self.request.user)
reversion.set_comment("Added via concept wizard")
item = None
for form in form_list:
item = form.save()
return HttpResponseRedirect(url_slugify_concept(item))
def test_weak_editor_during_create(self):
self.de1 = MDR.DataElement.objects.create(name='DE1 - visible',definition="my definition",workgroup=self.wg1)
self.de2 = MDR.DataElement.objects.create(name='DE2 - visible',definition="my definition",workgroup=self.wg1)
self.de3 = MDR.DataElement.objects.create(name='DE3 - visible',definition="my definition",workgroup=self.wg1)
self.oc1 = MDR.ObjectClass.objects.create(name='OC1 - visible',definition="my definition",workgroup=self.wg1)
self.oc2 = MDR.ObjectClass.objects.create(name='OC2 - visible',definition="my definition",workgroup=self.wg1)
self.oc3 = MDR.ObjectClass.objects.create(name='OC3 - visible',definition="my definition",workgroup=self.wg1)
self.login_editor()
item_name = 'My Fancy New Distribution'
step_1_data = {
self.wizard_form_name+'-current_step': 'initial',
'initial-name': item_name,
}
response = self.client.post(self.wizard_url, step_1_data)
wizard = response.context['wizard']
self.assertEqual(response.status_code, 200)
self.assertEqual(wizard['steps'].current, 'results')
step_2_data = {
self.wizard_form_name+'-current_step': 'results',
'initial-name':item_name,
'results-name':item_name,
'results-definition':"Test Definition",
}
ddep_formset_data = [
{'data_element': self.de1.pk, 'logical_path': '/garbage/file', 'specialisation_classes': [self.oc1.pk, self.oc3.pk], 'ORDER': 0},
{'data_element': self.de3.pk, 'logical_path': '/garbage/file', 'specialisation_classes': [self.oc2.pk, self.oc3.pk], 'ORDER': 1},
]
step_2_data.update(self.get_formset_postdata(ddep_formset_data, 'data_elements'))
response = self.client.post(self.wizard_url, step_2_data)
self.assertEqual(response.status_code, 302)
self.assertTrue(self.model.objects.filter(name=item_name).exists())
self.assertEqual(self.model.objects.filter(name=item_name).count(),1)
item = self.model.objects.filter(name=item_name).first()
self.assertRedirects(response,url_slugify_concept(item))
ddeps = item.distributiondataelementpath_set.all().order_by('order')
self.assertEqual(ddeps[0].order, 0)
self.assertEqual(ddeps[0].data_element, self.de1)
self.assertEqual(ddeps[0].logical_path, '/garbage/file')
self.assertEqual(ddeps[0].specialisation_classes.count(), 2)
self.assertTrue(self.oc1 in ddeps[0].specialisation_classes.all())
self.assertTrue(self.oc3 in ddeps[0].specialisation_classes.all())
self.assertEqual(ddeps[1].order, 1)
self.assertEqual(ddeps[1].data_element, self.de3)
self.assertEqual(ddeps[1].logical_path, '/garbage/file')
self.assertEqual(ddeps[1].specialisation_classes.count(), 2)
self.assertTrue(self.oc2 in ddeps[1].specialisation_classes.all())
self.assertTrue(self.oc3 in ddeps[1].specialisation_classes.all())
def test_visible_item(self):
wg = models.Workgroup.objects.create(name="Setup WG")
ra = models.RegistrationAuthority.objects.create(name="Test RA")
wg.registrationAuthorities.add(ra)
item = models.ObjectClass.objects.create(name="Test OC",workgroup=wg)
s = models.Status.objects.create(
concept=item,
registrationAuthority=ra,
registrationDate=timezone.now(),
state=ra.locked_state
)
home = self.client.get(url_slugify_concept(item))
# Anonymous users requesting a hidden page will be redirected to login
self.assertEqual(home.status_code,302)
s.state = ra.public_state
s.save()
home = self.client.get(url_slugify_concept(item))
self.assertEqual(home.status_code,200)
def test_visible_item(self):
wg = models.Workgroup.objects.create(name="Setup WG")
ra = models.RegistrationAuthority.objects.create(name="Test RA")
wg.registrationAuthorities.add(ra)
item = models.ObjectClass.objects.create(name="Test OC",workgroup=wg)
s = models.Status.objects.create(
concept=item,
registrationAuthority=ra,
registrationDate=timezone.now(),
state=ra.locked_state
)
home = self.client.get(url_slugify_concept(item))
#Anonymous users requesting a hidden page will be redirected to login
self.assertEqual(home.status_code,302)
s.state = ra.public_state
s.save()
home = self.client.get(url_slugify_concept(item))
self.assertEqual(home.status_code,200)
def done(self, form_list, **kwargs):
reversion.set_user(self.request.user)
reversion.set_comment("Added via data element concept wizard")
oc = self.get_object_class()
pr = self.get_property()
dec = None
for form in form_list:
saved_item = form.save(commit=False)
if saved_item is not None:
saved_item.submitter = self.request.user
saved_item.save()
if type(saved_item) == MDR.Property:
pr = saved_item
messages.success(
self.request,
mark_safe(
_("New Property '{name}' Saved - <a href='{url}'>id:{id}</a>"
).format(url=url_slugify_concept(saved_item),
name=saved_item.name,
id=saved_item.id)))
if type(saved_item) == MDR.ObjectClass:
oc = saved_item
messages.success(
self.request,
mark_safe(
_("New Object Class '{name}' Saved - <a href='{url}'>id:{id}</a>"
).format(url=url_slugify_concept(saved_item),
name=saved_item.name,
id=saved_item.id)))
if type(saved_item) == MDR.DataElementConcept:
dec = saved_item
messages.success(
self.request,
mark_safe(
_("New Data Element Concept '{name}' Saved - <a href='{url}'>id:{id}</a>"
).format(url=url_slugify_concept(saved_item),
name=saved_item.name,
id=saved_item.id)))
if dec is not None:
dec.objectClass = oc
dec.property = pr
dec.save()
return HttpResponseRedirect(url_slugify_concept(dec))
def test_reverse_slugs(self):
item = models.ObjectClass.objects.create(name=" ",definition="my definition",submitter=None)
ra = models.RegistrationAuthority.objects.create(name=" ",definition="my definition")
org = models.Organization.objects.create(name=" ",definition="my definition")
wg = models.Workgroup.objects.create(name=" ",definition="my definition")
self.assertTrue('--' in utils.url_slugify_concept(item))
self.assertTrue('--' in utils.url_slugify_workgroup(wg))
self.assertTrue('--' in utils.url_slugify_registration_authoritity(ra))
self.assertTrue('--' in utils.url_slugify_organization(org))
def done(self, form_list, **kwargs):
reversion.set_user(self.request.user)
reversion.set_comment("Added via data element concept wizard")
oc = self.get_object_class()
pr = self.get_property()
dec = self.save_foreignkey_components(form_list, oc, pr).get('dec')
return HttpResponseRedirect(url_slugify_concept(dec))
def test_weak_editor_during_create(self):
self.login_editor()
item_name = 'My Shiny New Value Domain'
step_1_data = {
self.wizard_form_name+'-current_step': 'initial',
'initial-name': item_name,
}
response = self.client.post(self.wizard_url, step_1_data)
wizard = response.context['wizard']
self.assertEqual(response.status_code, 200)
self.assertEqual(wizard['steps'].current, 'results')
step_2_data = {
self.wizard_form_name+'-current_step': 'results',
'initial-name': item_name,
'results-name': item_name,
'results-definition': "Test Definition",
}
step_2_data.update(self.get_formset_postdata([], 'slots'))
step_2_data.update(self.get_formset_postdata([], 'org_records'))
permissible_formset_data = [
{'value': 'Test1', 'meaning': 'Test1', 'start_date': '1999-01-01', 'end_date': '2090-01-01', 'ORDER': 0},
{'value': 'Test2', 'meaning': 'Test2', 'start_date': '1999-01-01', 'end_date': '2090-01-01', 'ORDER': 1}
]
step_2_data.update(self.get_formset_postdata(permissible_formset_data, 'permissible_values', 0))
supplementary_formset_data = [
{'value': 'Test3', 'meaning': 'Test3', 'start_date': '1999-01-01', 'end_date': '2090-01-01', 'ORDER': 0},
{'value': 'Test4', 'meaning': 'Test4', 'start_date': '1999-01-01', 'end_date': '2090-01-01', 'ORDER': 1}
]
step_2_data.update(self.get_formset_postdata(supplementary_formset_data, 'supplementary_values', 0))
response = self.client.post(self.wizard_url, step_2_data)
self.assertEqual(response.status_code, 302)
self.assertTrue(self.model.objects.filter(name=item_name).exists())
self.assertEqual(self.model.objects.filter(name=item_name).count(), 1)
item = self.model.objects.filter(name=item_name).first()
self.assertRedirects(response, url_slugify_concept(item))
supvals = item.supplementaryvalue_set.all()
permvals = item.permissiblevalue_set.all()
self.assertEqual(len(supvals), 2)
self.assertEqual(supvals[0].value, 'Test3')
self.assertEqual(supvals[1].value, 'Test4')
self.assertEqual(len(permvals), 2)
self.assertEqual(permvals[0].value, 'Test1')
self.assertEqual(permvals[1].value, 'Test2')
def toggleFavourite(request, iid):
item = get_object_or_404(MDR._concept, pk=iid).item
if not user_can_view(request.user, item):
if request.user.is_anonymous():
return redirect(reverse('friendly_login') + '?next=%s' % request.path)
else:
raise PermissionDenied
request.user.profile.toggleFavourite(item)
if request.GET.get('next', None):
return redirect(request.GET.get('next'))
return redirect(url_slugify_concept(item))
def post(self, request, *args, **kwargs):
form = self.get_form()
if form.is_valid():
with transaction.atomic(), reversion.revisions.create_revision():
new_clone = form.save()
reversion.revisions.set_user(self.request.user)
reversion.revisions.set_comment("Cloned from %s (id: %s)" % (self.item_to_clone.name, str(self.item_to_clone.pk)))
return HttpResponseRedirect(url_slugify_concept(new_clone))
else:
return self.form_invalid(form)
def test_viewer_can_favourite(self):
self.login_viewer()
self.assertTrue(perms.user_can_view(self.viewer,self.item1))
response = self.client.post(reverse('friendly_login'), {'username': '******', 'password': '******'})
self.assertEqual(response.status_code,302)
self.assertEqual(self.viewer.profile.favourites.count(),0)
response = self.client.get(reverse('aristotle:toggleFavourite', args=[self.item1.id]))
self.assertRedirects(response,url_slugify_concept(self.item1))
self.assertEqual(self.viewer.profile.favourites.count(),1)
self.assertEqual(self.viewer.profile.favourites.first().item,self.item1)
response = self.client.get(reverse('aristotle:toggleFavourite', args=[self.item1.id]))
self.assertRedirects(response,url_slugify_concept(self.item1))
self.assertEqual(self.viewer.profile.favourites.count(),0)
response = self.client.get(reverse('aristotle:toggleFavourite', args=[self.item2.id]))
self.assertEqual(response.status_code,403)
self.assertEqual(self.viewer.profile.favourites.count(),0)
def test_submitter_can_save_via_clone_page(self):
self.login_editor()
response = self.client.get(reverse('aristotle:clone_item',args=[self.item1.id]))
self.assertEqual(response.status_code,200)
updated_item = utils.model_to_dict(response.context['item'])
updated_name = updated_item['name'] + " cloned!"
updated_item['name'] = updated_name
response = self.client.post(reverse('aristotle:clone_item',args=[self.item1.id]), updated_item)
most_recent = self.itemType.objects.order_by('-created').first()
self.assertRedirects(response,url_slugify_concept(most_recent))
self.assertEqual(most_recent.name,updated_name)
def done(self, form_list, **kwargs):
reversion.set_user(self.request.user)
reversion.set_comment("Added via concept wizard")
saved_item = None
for form in form_list:
saved_item = form.save(commit=False)
if saved_item is not None:
saved_item.submitter = self.request.user
saved_item.save()
return HttpResponseRedirect(url_slugify_concept(saved_item))
def toggleFavourite(request, iid):
item = get_object_or_404(MDR._concept,pk=iid).item
if not user_can_view(request.user, item):
if request.user.is_anonymous():
return redirect(reverse('django.contrib.auth.views.login')+'?next=%s' % request.path)
else:
raise PermissionDenied
request.user.profile.toggleFavourite(item)
if request.GET.get('next',None):
return redirect(request.GET.get('next'))
return redirect(url_slugify_concept(item))
def test_weak_editor_during_create(self):
self.login_editor()
item_name = 'My Shiny New Value Domain'
step_1_data = {
self.wizard_form_name+'-current_step': 'initial',
'initial-name': item_name,
}
response = self.client.post(self.wizard_url, step_1_data)
wizard = response.context['wizard']
self.assertEqual(response.status_code, 200)
self.assertEqual(wizard['steps'].current, 'results')
step_2_data = {
self.wizard_form_name+'-current_step': 'results',
'initial-name':item_name,
'results-name':item_name,
'results-definition':"Test Definition",
}
step_2_data.update(self.get_formset_postdata([], 'slots'))
permissible_formset_data = [
{'value': 'Test1', 'meaning': 'Test1', 'start_date': '1999-01-01', 'end_date': '2090-01-01', 'ORDER': 0},
{'value': 'Test2', 'meaning': 'Test2', 'start_date': '1999-01-01', 'end_date': '2090-01-01', 'ORDER': 1}
]
step_2_data.update(self.get_formset_postdata(permissible_formset_data, 'permissible_values', 0))
supplementary_formset_data = [
{'value': 'Test3', 'meaning': 'Test3', 'start_date': '1999-01-01', 'end_date': '2090-01-01', 'ORDER': 0},
{'value': 'Test4', 'meaning': 'Test4', 'start_date': '1999-01-01', 'end_date': '2090-01-01', 'ORDER': 1}
]
step_2_data.update(self.get_formset_postdata(supplementary_formset_data, 'supplementary_values', 0))
response = self.client.post(self.wizard_url, step_2_data)
self.assertEqual(response.status_code, 302)
self.assertTrue(self.model.objects.filter(name=item_name).exists())
self.assertEqual(self.model.objects.filter(name=item_name).count(),1)
item = self.model.objects.filter(name=item_name).first()
self.assertRedirects(response,url_slugify_concept(item))
supvals = item.supplementaryvalue_set.all()
permvals = item.permissiblevalue_set.all()
self.assertEqual(len(supvals), 2)
self.assertEqual(supvals[0].value, 'Test3')
self.assertEqual(supvals[1].value, 'Test4')
self.assertEqual(len(permvals), 2)
self.assertEqual(permvals[0].value, 'Test1')
self.assertEqual(permvals[1].value, 'Test2')
def test_redirect_with_version(self):
response = self.client.get(
reverse(
'aristotle_identifiers:scoped_identifier_redirect_version',
args=[
self.meta_jl_id_2.namespace.shorthand_prefix,
self.meta_jl_id_2.identifier,
self.meta_jl_id_2.version
]
)
)
self.assertRedirects(response, url_slugify_concept(self.meta), fetch_redirect_response=False)
def test_submitter_can_save_via_edit_page(self):
from django.forms import model_to_dict
self.login_editor()
response = self.client.get(reverse('aristotle:edit_item',args=[self.item1.id]))
self.assertEqual(response.status_code,200)
updated_item = dict((k,v) for (k,v) in model_to_dict(response.context['item']).items() if v is not None)
updated_name = updated_item['name'] + " updated!"
updated_item['name'] = updated_name
response = self.client.post(reverse('aristotle:edit_item',args=[self.item1.id]), updated_item)
self.item1 = self.itemType.objects.get(pk=self.item1.pk)
self.assertRedirects(response,url_slugify_concept(self.item1))
self.assertEqual(self.item1.name,updated_name)
def test_submitter_can_save_via_edit_page(self):
self.login_editor()
response = self.client.get(reverse('aristotle:edit_item',args=[self.item1.id]))
self.assertEqual(response.status_code,200)
updated_item = utils.modeL_to_dict_with_change_time(response.context['item'])
updated_name = updated_item['name'] + " updated!"
updated_item['name'] = updated_name
response = self.client.post(reverse('aristotle:edit_item',args=[self.item1.id]), updated_item)
self.item1 = self.itemType.objects.get(pk=self.item1.pk)
self.assertRedirects(response,url_slugify_concept(self.item1))
self.assertEqual(self.item1.name,updated_name)
def test_redirect_with_version(self):
response = self.client.get(
reverse(
'aristotle_identifiers:scoped_identifier_redirect_version',
args=[
self.meta_jl_id_2.namespace.shorthand_prefix,
self.meta_jl_id_2.identifier,
self.meta_jl_id_2.version
]
)
)
self.assertRedirects(response, url_slugify_concept(self.meta), fetch_redirect_response=False)
def json_list(request):
item_ids = []
for iid in request.GET.getlist('items'):
try:
iid = int(iid)
item_ids.append(iid)
except:
return JsonResponse({"error": "Glossary IDs must be integers"})
items = [{'id':obj.id,'url':url_slugify_concept(obj),'name':obj.name,'definition':obj.definition}
for obj in models.GlossaryItem.objects.visible(request.user).filter(id__in=item_ids)
]
return JsonResponse({"items": items})
def test_editor_can_use_ready_to_review(self):
self.login_editor()
response = self.client.get(reverse('aristotle:mark_ready_to_review',args=[self.item1.id]))
self.assertEqual(response.status_code,200)
response = self.client.get(reverse('aristotle:mark_ready_to_review',args=[self.item2.id]))
self.assertEqual(response.status_code,403)
response = self.client.get(reverse('aristotle:mark_ready_to_review',args=[self.item3.id]))
self.assertEqual(response.status_code,200)
self.assertFalse(self.item1.readyToReview)
response = self.client.post(reverse('aristotle:mark_ready_to_review',args=[self.item1.id]))
self.assertRedirects(response,url_slugify_concept(self.item1))
self.item1 = self.itemType.objects.get(id=self.item1.id) # Stupid cache
self.assertTrue(self.item1.readyToReview)
def test_weak_editor_during_create(self):
self.login_editor()
item_name = 'My New Relation'
step_1_data = {
self.wizard_form_name+'-current_step': 'initial',
'initial-name': item_name,
}
response = self.client.post(self.wizard_url, step_1_data)
wizard = response.context['wizard']
self.assertEqual(response.status_code, 200)
self.assertEqual(wizard['steps'].current, 'results')
step_2_data = {
self.wizard_form_name+'-current_step': 'results',
'initial-name':item_name,
'results-name':item_name,
'results-definition':"Test Definition",
}
step_2_data.update(self.get_formset_postdata([], 'slots'))
role_formset_data = [
{'name': 'parent', 'definition': 'ok', 'multiplicity': 1, 'ORDER': 0},
{'name': 'child', 'definition': 'good', 'multiplicity': 1, 'ORDER': 1}
]
step_2_data.update(self.get_formset_postdata(role_formset_data, 'roles'))
response = self.client.post(self.wizard_url, step_2_data)
self.assertEqual(response.status_code, 302)
self.assertTrue(self.model.objects.filter(name=item_name).exists())
self.assertEqual(self.model.objects.filter(name=item_name).count(),1)
item = self.model.objects.filter(name=item_name).first()
self.assertRedirects(response,url_slugify_concept(item))
roles = item.relationrole_set.all().order_by('ordinal')
self.assertEqual(roles[0].ordinal, 0)
self.assertEqual(roles[0].name, 'parent')
self.assertEqual(roles[0].definition, 'ok')
self.assertEqual(roles[0].multiplicity, 1)
self.assertEqual(roles[1].ordinal, 1)
self.assertEqual(roles[1].name, 'child')
self.assertEqual(roles[1].definition, 'good')
self.assertEqual(roles[1].multiplicity, 1)
def get_redirect(self):
if not self.modelslug_arg:
model_correct = True
else:
model_slug = self.kwargs.get(self.modelslug_arg, '')
model_correct = (self.item._meta.model_name == model_slug)
name_slug = self.kwargs.get(self.nameslug_arg, '')
# name_correct = (slugify(self.item.name) == name_slug)
name_present = (name_slug is not None)
if not model_correct or not name_present:
return True, url_slugify_concept(self.item)
else:
return False, ''
def test_toggle_favourite_on_view(self):
self.login_editor()
self.check_favourite(self.editor, self.timtam, False)
response = self.reverse_get(
'aristotle_favourites:toggleFavourite',
reverse_args=[self.timtam.id],
status_code=302
)
self.assertEqual(response.url, url_slugify_concept(self.timtam))
messages = list(get_messages(response.wsgi_request))
self.assertTrue(messages[1].message.startswith('Tim Tam added to favourites'))
self.check_favourite(self.editor, self.timtam, True)
def toggleFavourite(request, iid):
item = get_object_or_404(MDR._concept, pk=iid).item
if not user_can_view(request.user, item):
if request.user.is_anonymous():
return redirect(reverse("friendly_login") + "?next=%s" % request.path)
else:
raise PermissionDenied
request.user.profile.toggleFavourite(item)
if request.GET.get("next", None):
return redirect(request.GET.get("next"))
if item.concept in request.user.profile.favourites.all():
message = _("%s added to favourites.") % (item.name)
else:
message = _("%s removed from favourites.") % (item.name)
message = _(message + " Review your favourites from the user menu.")
messages.add_message(request, messages.SUCCESS, message)
return redirect(url_slugify_concept(item))
