def login(self, request, extra_context=None):
"""
Displays the login form for the given HttpRequest.
"""
if request.method == 'GET' and self.has_permission(request):
# Already logged-in, redirect to admin index
index_path = reverse('admin:index', current_app=self.name)
return HttpResponseRedirect(index_path)
from django.contrib.auth.views import login
# Since this module gets imported in the application's root package,
# it cannot import models from other applications at the module level,
# and django.contrib.admin.forms eventually imports User.
from django.contrib.admin.forms import AdminAuthenticationForm
context = dict(
self.each_context(request),
title=_('Log in'),
app_path=request.get_full_path(),
)
if (REDIRECT_FIELD_NAME not in request.GET and
REDIRECT_FIELD_NAME not in request.POST):
context[REDIRECT_FIELD_NAME] = reverse('admin:index', current_app=self.name)
context.update(extra_context or {})
defaults = {
'extra_context': context,
'authentication_form': self.login_form or AdminAuthenticationForm,
'template_name': self.login_template or 'admin/login.html',
}
request.current_app = self.name
return login(request, **defaults)
def permissions(request, title):
document = get_object_or_404(Document, url_title=title)
content_type = ContentType.objects.get_for_model(document)
check_permissions(document, request.user, [document.edit_permission_name])
if not document.show_permissions_editor():
raise PermissionDenied()
PermissionForm = get_permission_form(document)
PermissionFormset = formset_factory(get_permission_form(document), extra=0)
initial_data = PermissionForm.prepare_initial_data(Group.objects.all(), content_type, document)
formset = PermissionFormset(request.POST or None, initial=initial_data)
if request.POST and formset.is_valid():
for form in formset:
form.save(document)
messages.success(request, _("Permissions have been changed successfully."))
if request.user.has_perm(document.edit_permission_name, document):
return HttpResponseRedirect(reverse(document.get_permissions_url_name(), args=[document.url_title]))
if request.user.has_perm(document.view_permission_name, document):
return HttpResponseRedirect(reverse(document.get_view_url_name(), args=[document.url_title]))
return HttpResponseRedirect(reverse('index'))
return render(request, 'documents_permissions.html', {
'document': document,
'formset_header': PermissionForm.header(content_type),
'formset': formset,
'active_page': 'permissions',
'permission_overview': document_permission_overview(request.user, document),
})
def autodoc(url_root, username, id_string):
urla = url_root + reverse('sms_submission_api',
kwargs={'username': username,
'service': 'twilio'})
urlb = url_root + reverse('sms_submission_form_api',
kwargs={'username': username,
'id_string': id_string,
'service': 'twilio'})
doc = (u'<p>' +
_(u"%(service)s Instructions:")
% {'service': u'<a href="https://twilio.com">'
u'Twilio\'s SMS Request</a>'} +
u'</p><ol><li>' +
_(u"Sign in to Twilio.com and go your Application.") +
u'</li><li>' +
_(u"Follow instructions to add one of the following URLs, "
u"selecting the HTTP POST method:") +
u'<br /><span class="sms_autodoc_example">%(urla)s' +
u'<br />%(urlb)s</span><br />' +
u'</li></ol><p>' +
_(u"That's it. Now Send an SMS Formhub submission to your Twilio"
u" phone number. It will create a submission on Formhub.") +
u'</p>') % {'urla': urla, 'urlb': urlb}
return doc
def test_user_change_password(self):
user_change_url = reverse('auth_test_admin:auth_user_change', args=(self.admin.pk,))
password_change_url = reverse('auth_test_admin:auth_user_password_change', args=(self.admin.pk,))
response = self.client.get(user_change_url)
# Test the link inside password field help_text.
rel_link = re.search(
r'you can change the password using <a href="([^"]*)">this form</a>',
force_text(response.content)
).groups()[0]
self.assertEqual(
os.path.normpath(user_change_url + rel_link),
os.path.normpath(password_change_url)
)
response = self.client.post(
password_change_url,
{
'password1': 'password1',
'password2': 'password1',
}
)
self.assertRedirects(response, user_change_url)
row = LogEntry.objects.latest('id')
self.assertEqual(row.get_change_message(), 'Changed password.')
self.logout()
self.login(password='******')
def test_my_albums(self):
url = reverse('albums:mine')
self._test_login_required(url)
AlbumFactory.create(user=self.user, trash=True)
album1 = AlbumFactory.create(user=self.user, public=True)
album2 = AlbumFactory.create(user=self.user, public=False)
albumgroup1 = AlbumGroupFactory.create(users=[self.user])
albumgroup2 = AlbumGroupFactory.create(album__user=self.user)
my_albums_list = self.app.get(url, user=self.user)
self.assertEqual(my_albums_list.status_code, 200)
tabs = my_albums_list.context['tabcontent']
self.assertQuerysetEqual(tabs['public'], [repr(album1), repr(albumgroup2.album)])
self.assertQuerysetEqual(tabs['private'], [repr(album2)])
self.assertQuerysetEqual(tabs['shared-with-me'], [repr(albumgroup1.album)])
self.assertQuerysetEqual(tabs['shared-by-me'], [repr(albumgroup2.album)])
# assert that the edit urls are visible
for album in [album1, album2, albumgroup2.album]:
edit_url = reverse('albums:update', kwargs={'pk': album.pk})
self.assertContains(my_albums_list, edit_url)
# other owner, edit url may not be visible
edit_url = reverse('albums:update', kwargs={'pk': albumgroup1.album.pk})
self.assertNotContains(my_albums_list, edit_url)
def test_topic_move_complete(self):
topic = Topic(name='xtopic', forum=self.forum, user=self.user)
topic.save()
post = Post(topic=topic, user=self.user, body='one')
post.save()
topic_merge_url = reverse('pybb:topic_move')
self.login_as(self.staff)
name = 'new name for a topic'
response = self.client.post(topic_merge_url, data={
'topic_ids': [topic.pk],
'form-TOTAL_FORMS': 1,
'form-INITIAL_FORMS': 0,
'form-0-name': name,
'form-0-forum': self.forum.pk,
'form-0-redirection_type': TopicRedirection.TYPE_PERMANENT_REDIRECT,
'submit': 1
})
self.assertRedirects(response, reverse('pybb:index'))
topic = Topic.objects.get(pk=topic.pk)
self.assertTrue(topic.redirect)
self.failUnless(topic.redirection is not None)
redirection = topic.redirection
new_topic = redirection.to_topic
self.assertEqual(new_topic.name, name)
self.assertEqual(new_topic.post_count, 1)
def test_topics_delete_complete(self):
topic2 = Topic.objects.create(name='Topic 2', forum=self.forum, user=self.superuser)
post2 = Post(topic=topic2, user=self.superuser, body='post on topic2')
post2.save()
topics_delete_url = reverse('pybb:topics_delete')
self.login_as(self.staff)
response = self.client.post(topics_delete_url, data={
'topic_ids': [self.topic.pk, topic2.pk],
'form-TOTAL_FORMS': 2,
'form-INITIAL_FORMS': 0,
'form-0-topic': self.topic.pk,
'form-0-confirm': True,
'form-1-topic': topic2.pk,
'form-1-confirm': True,
'submit': 1
})
topic2 = Topic.objects.get(pk=topic2.pk)
self.assertTrue(self.topic.delete)
self.assertTrue(topic2.delete)
self.assertRedirects(response, reverse('pybb:index'))
def test_claim(self):
url = reverse("channels.types.facebook.claim")
self.login(self.admin)
# check that claim page URL appears on claim list page
response = self.client.get(reverse("channels.channel_claim"))
self.assertContains(response, url)
# can fetch the claim page
response = self.client.get(url)
self.assertContains(response, "Connect Facebook")
token = "x" * 200
post_data = response.context["form"].initial
post_data["page_access_token"] = token
post_data["page_id"] = "123456"
post_data["page_name"] = "Temba"
response = self.client.post(url, post_data, follow=True)
# assert our channel got created
channel = Channel.objects.get(address="123456")
self.assertEqual(channel.config[Channel.CONFIG_AUTH_TOKEN], token)
self.assertEqual(channel.config[Channel.CONFIG_PAGE_NAME], "Temba")
self.assertEqual(channel.address, "123456")
# should be on our configuration page displaying our secret
self.assertContains(response, channel.config[Channel.CONFIG_SECRET])
def test_switch_superuser001_editor001(self):
"""
Test switching from superuser001 to Editor001
That should work.
"""
original_user = User.objects.get(username="******")
target_user = User.objects.get(username="******")
self.client.login(username="******", password="******")
response = self.client.get("%s?redirect=%s" % (reverse("grp_switch_user", args=[target_user.id]), reverse("admin:grappelli_category_changelist")), follow=True)
self.assertEqual(response.status_code, 200)
self.assertEqual(self.client.session.get("original_user", None), {"id": original_user.id, "username": original_user.username})
self.assertEqual(int(self.client.session['_auth_user_id']), target_user.pk)
# templatetag (Superuser001, Editor001, Editor002)
# now we have an additional list element with the original user, Superuser001
t = switch_user_dropdown(response.context)
t_cmp = '<li><a href="/grappelli/switch/user/1/?redirect=/admin/grappelli/category/" class="grp-switch-user-is-original">Superuser001</a></li><li><a href="/grappelli/switch/user/3/?redirect=/admin/grappelli/category/" class="grp-switch-user-is-target">Editor001</a></li><li><a href="/grappelli/switch/user/4/?redirect=/admin/grappelli/category/" class="grp-switch-user-is-target">Editor002</a></li>'
self.assertEqual(t, t_cmp)
# switch back to superuser
response = self.client.get("%s?redirect=%s" % (reverse("grp_switch_user", args=[original_user.id]), reverse("admin:grappelli_category_changelist")), follow=True)
self.assertEqual(response.status_code, 200)
self.assertEqual(self.client.session.get("original_user", None), None)
self.assertEqual(int(self.client.session['_auth_user_id']), original_user.pk)
def test_login_and_registration_form_signin_not_preserves_params(self, theme, url_name):
params = [
('course_id', 'edX/DemoX/Demo_Course'),
('enrollment_action', 'enroll'),
]
# The response should not have a "Sign In" button with the URL
# that preserves the querystring params
with with_comprehensive_theme_context(theme):
response = self.client.get(reverse(url_name), params, HTTP_ACCEPT="text/html")
expected_url = '/login?{}'.format(self._finish_auth_url_param(params + [('next', '/dashboard')]))
self.assertNotContains(response, expected_url)
# Add additional parameters:
params = [
('course_id', 'edX/DemoX/Demo_Course'),
('enrollment_action', 'enroll'),
('course_mode', CourseMode.DEFAULT_MODE_SLUG),
('email_opt_in', 'true'),
('next', '/custom/final/destination')
]
# Verify that this parameter is also preserved
with with_comprehensive_theme_context(theme):
response = self.client.get(reverse(url_name), params, HTTP_ACCEPT="text/html")
expected_url = '/login?{}'.format(self._finish_auth_url_param(params))
self.assertNotContains(response, expected_url)
def test_create_rule_post(self, exc):
snapshot = test_data.snapshot
self.mock_object(
api_manila, "share_snapshot_get", mock.Mock(return_value=snapshot))
url = reverse(
'horizon:project:share_snapshots:share_snapshot_rule_add',
args=[snapshot.id])
self.mock_object(
api_manila, "share_snapshot_allow",
mock.Mock(side_effect=exc))
formData = {
'access_type': 'user',
'method': u'CreateForm',
'access_to': 'someuser',
}
res = self.client.post(url, formData)
self.assertEqual(res.status_code, 302)
api_manila.share_snapshot_allow.assert_called_once_with(
mock.ANY, snapshot.id, access_type=formData['access_type'],
access_to=formData['access_to'])
self.assertRedirectsNoFollow(
res,
reverse(
'horizon:project:share_snapshots:share_snapshot_manage_rules',
args=[snapshot.id])
)
def test_index_permission_protected_project(self):
project = Project.objects.create(
active=True,
custom_permissions=True,
login_required=True,
name='MY_TEMPLATE_NAME',
)
batch = Batch.objects.create(project=project, name='MY_BATCH_NAME')
Task.objects.create(batch=batch)
in_user = User.objects.create_user('in_user', password='******')
User.objects.create_user('out_user', password='******')
group = Group.objects.create(name='testgroup')
in_user.groups.add(group)
assign_perm('can_work_on', group, project)
in_client = django.test.Client()
in_client.login(username='******', password='******')
response = in_client.get(reverse('index'))
self.assertEqual(response.status_code, 200)
self.assertFalse(b'No Tasks available' in response.content)
self.assertTrue(b'MY_TEMPLATE_NAME' in response.content)
self.assertTrue(b'MY_BATCH_NAME' in response.content)
out_client = django.test.Client()
out_client.login(username='******', password='******')
response = out_client.get(reverse('index'))
self.assertEqual(response.status_code, 200)
self.assertTrue(b'No Tasks available' in response.content)
self.assertFalse(b'MY_TEMPLATE_NAME' in response.content)
self.assertFalse(b'MY_BATCH_NAME' in response.content)
def test_index_unprotected_template(self):
project_unprotected = Project(
active=True,
login_required=False,
name='MY_TEMPLATE_NAME',
)
project_unprotected.save()
batch = Batch(project=project_unprotected, name='MY_BATCH_NAME')
batch.save()
Task(batch=batch).save()
anon_client = django.test.Client()
response = anon_client.get(reverse('index'))
self.assertEqual(response.status_code, 200)
self.assertFalse(b'No Tasks available' in response.content)
self.assertTrue(b'MY_TEMPLATE_NAME' in response.content)
self.assertTrue(b'MY_BATCH_NAME' in response.content)
known_client = django.test.Client()
User.objects.create_superuser('admin', '*****@*****.**', 'secret')
known_client.login(username='******', password='******')
response = known_client.get(reverse('index'))
self.assertEqual(response.status_code, 200)
self.assertFalse(b'No Tasks available' in response.content)
self.assertTrue(b'MY_TEMPLATE_NAME' in response.content)
self.assertTrue(b'MY_BATCH_NAME' in response.content)
def test_resource_name_precendence(self, client, monkeypatch):
# default
response = client.get(reverse("comment-list"))
data = response.json()['data'][0]
assert (data.get('type') == 'comments'), (
'resource_name from model incorrect on list')
# model > default
models.Comment.__bases__ += (_PatchedModel,)
response = client.get(reverse("comment-list"))
data = response.json()['data'][0]
assert (data.get('type') == 'resource_name_from_JSONAPIMeta'), (
'resource_name from model incorrect on list')
# serializer > model
monkeypatch.setattr(
serializers.CommentSerializer.Meta,
'resource_name',
'resource_name_from_serializer',
False
)
response = client.get(reverse("comment-list"))
data = response.json()['data'][0]
assert (data.get('type') == 'resource_name_from_serializer'), (
'resource_name from serializer incorrect on list')
# view > serializer > model
monkeypatch.setattr(views.CommentViewSet, 'resource_name', 'resource_name_from_view', False)
response = client.get(reverse("comment-list"))
data = response.json()['data'][0]
assert (data.get('type') == 'resource_name_from_view'), (
'resource_name from view incorrect on list')
def test_accordion_state(self):
"""
Verify the accordion remembers which chapter you were last viewing.
"""
email, password = self.STUDENT_INFO[0]
self.login(email, password)
self.enroll(self.course, True)
self.enroll(self.test_course, True)
# Now we directly navigate to a section in a chapter other than 'Overview'.
section_url = reverse(
'courseware_section',
kwargs={
'course_id': text_type(self.course.id),
'chapter': 'factory_chapter',
'section': 'factory_section',
}
)
self.assert_request_status_code(200, section_url)
# And now hitting the courseware tab should redirect to 'factory_chapter'
url = reverse(
'courseware',
kwargs={'course_id': text_type(self.course.id)}
)
resp = self.client.get(url)
self.assertRedirects(resp, section_url)
def _test_return_login(self, user_is_activated=True, previous_session_timed_out=False):
""" Test logging in to an account that is already linked. """
# Make sure we're not logged in:
dashboard_response = self.client.get(reverse('dashboard'))
self.assertEqual(dashboard_response.status_code, 302)
# The user goes to the login page, and sees a button to login with this provider:
provider_login_url = self._check_login_page()
# The user clicks on the provider's login button:
try_login_response = self.client.get(provider_login_url)
# The user should be redirected to the provider:
self.assertEqual(try_login_response.status_code, 302)
login_response = self.do_provider_login(try_login_response['Location'])
# If the previous session was manually logged out, there will be one weird redirect
# required to set the login cookie (it sticks around if the main session times out):
if not previous_session_timed_out:
self.assertEqual(login_response.status_code, 302)
self.assertEqual(login_response['Location'], self.complete_url + "?")
# And then we should be redirected to the dashboard:
login_response = self.client.get(login_response['Location'])
self.assertEqual(login_response.status_code, 302)
if user_is_activated:
url_expected = reverse('dashboard')
else:
url_expected = reverse('third_party_inactive_redirect') + '?next=' + reverse('dashboard')
self.assertEqual(login_response['Location'], url_expected)
# Now we are logged in:
dashboard_response = self.client.get(reverse('dashboard'))
self.assertEqual(dashboard_response.status_code, 200)
def test_station_redirect_to_latest(self):
kwargs = {'station_number': self.station.number}
response = self.client.get(reverse('status:station:summary', kwargs=kwargs))
self.assertEqual(302, response.status_code)
kwargs = {'station_number': self.station.number}
kwargs.update(date_as_kwargs(self.summary.date))
self.assertEqual(reverse('status:station:summary', kwargs=kwargs), response['Location'])
def test_hosting(self):
"""Test for hosting form with enabled hosting."""
self.get_user()
self.client.login(username='******', password='******')
response = self.client.get(reverse('hosting'))
self.assertContains(response, 'id="id_message"')
# Sending message
response = self.client.post(
reverse('hosting'),
{
'name': 'Test',
'email': '*****@*****.**',
'project': 'HOST',
'url': 'http://example.net',
'repo': 'https://github.com/WeblateOrg/weblate.git',
'mask': 'po/*.po',
'message': 'Hi\n\nI want to use it!',
}
)
self.assertRedirects(response, reverse('home'))
# Verify message
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(
mail.outbox[0].subject,
'[Weblate] Hosting request for HOST'
)
self.assertIn(
'testuser',
mail.outbox[0].body,
)
self.assertEqual(mail.outbox[0].to, ['*****@*****.**'])
def _test_login(self):
"""
The user goes to the login page, and sees a button to login with the provider.
"""
self.user = UserFactory.create()
provider_login_url = self._check_login_page()
# The user clicks on the provider's button:
try_login_response = self.client.get(provider_login_url)
# The user should be redirected to the provider's login page:
self.assertEqual(try_login_response.status_code, 302)
complete_response = self.do_provider_login(try_login_response['Location'])
# We should be redirected to the login screen since this account is not linked to an edX account:
self.assertEqual(complete_response.status_code, 302)
self.assertEqual(complete_response['Location'], self.login_page_url)
login_response = self.client.get(self.login_page_url)
tpa_context = login_response.context["data"]["third_party_auth"]
self.assertEqual(tpa_context["errorMessage"], None)
# Check that the "You've successfully signed into [PROVIDER_NAME]" message is shown.
self.assertEqual(tpa_context["currentProvider"], self.PROVIDER_NAME)
# Now the user enters their username and password.
# The AJAX on the page will log them in:
ajax_login_response = self.client.post(
reverse('user_api_login_session'),
{'email': self.user.email, 'password': '******'}
)
self.assertEqual(ajax_login_response.status_code, 200)
# Then the AJAX will finish the third party auth:
continue_response = self.client.get(tpa_context["finishAuthUrl"])
# And we should be redirected to the dashboard:
self.assertEqual(continue_response.status_code, 302)
self.assertEqual(continue_response['Location'], reverse('dashboard'))
# Now check that we can login again:
self.client.logout()
self._test_return_login()
def test_denied_owner_delete(self):
"""Test that deleting last owner does not work."""
self.project.add_user(self.user, '@Administration')
self.client.post(
reverse('set-groups', kwargs=self.kw_project),
{
'user': self.second_user.username,
'group': self.admin_group.pk,
'action': 'remove',
}
)
self.assertTrue(
User.objects.all_admins(self.project).filter(
username=self.user.username
).exists()
)
self.client.post(
reverse('set-groups', kwargs=self.kw_project),
{
'user': self.user.username,
'group': self.admin_group.pk,
'action': 'remove',
}
)
self.assertTrue(
User.objects.all_admins(self.project).filter(
username=self.user.username
).exists()
)
def test_contact_rate_window(self):
"""Test for contact form rate limiting."""
message = 'Too many messages sent, please try again later!'
response = self.client.post(reverse('contact'), CONTACT_DATA)
self.assertNotContains(response, message)
response = self.client.post(reverse('contact'), CONTACT_DATA)
self.assertNotContains(response, message)
def submit_bundle(request, doc_id):
bundle = Bundle(document=Document2.objects.get(id=doc_id))
ParametersFormSet = formset_factory(ParameterForm, extra=0)
if request.method == 'POST':
params_form = ParametersFormSet(request.POST)
if params_form.is_valid():
mapping = dict([(param['name'], param['value']) for param in params_form.cleaned_data])
job_id = _submit_bundle(request, bundle, mapping)
jsonify = request.POST.get('format') == 'json'
if jsonify:
return JsonResponse({'status': 0, 'job_id': job_id, 'type': 'bundle'}, safe=False)
else:
request.info(_('Bundle submitted.'))
return redirect(reverse('oozie:list_oozie_bundle', kwargs={'job_id': job_id}))
else:
request.error(_('Invalid submission form: %s' % params_form.errors))
else:
parameters = bundle.find_all_parameters()
initial_params = ParameterForm.get_initial_params(dict([(param['name'], param['value']) for param in parameters]))
params_form = ParametersFormSet(initial=initial_params)
popup = render('editor2/submit_job_popup.mako', request, {
'params_form': params_form,
'name': bundle.name,
'action': reverse('oozie:editor_submit_bundle', kwargs={'doc_id': bundle.id}),
'return_json': request.GET.get('format') == 'json',
'show_dryrun': False
}, force_template=True).content
return JsonResponse(popup, safe=False)
def dispatch1(self, request, article, *args, **kwargs):
"""Deleted view needs to access this method without a decorator,
therefore it is separate."""
urlpath = kwargs.get('urlpath', None)
# Where to go after deletion...
self.next = ""
self.cannot_delete_root = False
if urlpath and urlpath.parent:
self.next = reverse(
'wiki:get',
kwargs={
'path': urlpath.parent.path})
elif urlpath:
# We are a urlpath with no parent. This is the root
self.cannot_delete_root = True
else:
# We have no urlpath. Get it if a urlpath exists
for art_obj in article.articleforobject_set.filter(is_mptt=True):
if art_obj.content_object.parent:
self.next = reverse(
'wiki:get', kwargs={
'article_id': art_obj.content_object.parent.article.id})
else:
self.cannot_delete_root = True
return super().dispatch(request, article, *args, **kwargs)
def test_edit_alert(self):
"""Can we edit the alert and see the message about it being edited?"""
user = User.objects.get(username='******')
alert = Alert(
user=user,
name=self.alert_params['name'],
query=self.alert_params['query'],
rate=self.alert_params['rate'],
)
alert.save()
# Pan tries to edit their alert
self.browser.get(
'{url}{path}?{q}&edit_alert={pk}'.format(
url=self.server_url,
path=reverse('show_results'),
q=alert.query,
pk=alert.pk,
))
# But winds up at the sign in form
self.assertIn(reverse('sign-in'), self.browser.current_url)
# So Pan signs in.
self.browser.find_element_by_id('username').send_keys('pandora')
self.browser.find_element_by_id('password').send_keys('password' + '\n')
# And gets redirected to the SERP where they see a notice about their
# alert being edited.
self.assert_text_in_body("editing your alert")
def get_api(self, obj):
return {
"avatar": reverse("misago:api:user-avatar", kwargs={"pk": obj.pk}),
"data_downloads": reverse(
"misago:api:user-data-downloads", kwargs={"pk": obj.pk}
),
"details": reverse("misago:api:user-details", kwargs={"pk": obj.pk}),
"change_email": reverse(
"misago:api:user-change-email", kwargs={"pk": obj.pk}
),
"change_password": reverse(
"misago:api:user-change-password", kwargs={"pk": obj.pk}
),
"edit_details": reverse(
"misago:api:user-edit-details", kwargs={"pk": obj.pk}
),
"options": reverse("misago:api:user-forum-options", kwargs={"pk": obj.pk}),
"request_data_download": reverse(
"misago:api:user-request-data-download", kwargs={"pk": obj.pk}
),
"username": reverse("misago:api:user-username", kwargs={"pk": obj.pk}),
"delete": reverse(
"misago:api:user-delete-own-account", kwargs={"pk": obj.pk}
),
}
def get(self, request, *args, **kwargs):
#获取客户端传来的参数PK
pk = kwargs.get('pk')
if settings.AUTH_LDAP:
try:
ldap_tool = LDAPTool()
status = ldap_tool.ldap_get_user(pk, isdict=True)
if status:
msg = "用户:%s 获取成功" % pk
data = status
form = self.form_class(initial=data)
context = {'form': form, 'app': _('Users'), 'action': _('LDAP Update user')}
return render(request, self.template_name, context)
else:
msg = "未获取用户:%s" % pk
messages.add_message(self.request, messages.WARNING, msg)
return redirect(reverse('users:ldap-user-list'))
except Exception as e:
msg = "用户:%s 获取失败，原因:%s" % (pk, str(e))
messages.add_message(self.request, messages.ERROR, msg)
return redirect(reverse('users:ldap-user-list'))
else:
msg = '请系统先支持ldap'
messages.add_message(self.request, messages.WARNING, msg)
return redirect(reverse('users:ldap-user-list'))
def page_context(self):
from corehq.apps.reports.standard.sms import (
ScheduleInstanceReport,
MessageLogReport,
MessagingEventsReport,
)
scheduled_events_url = reverse(ScheduleInstanceReport.dispatcher.name(), args=[],
kwargs={'domain': self.domain, 'report_slug': ScheduleInstanceReport.slug})
context = {
'scheduled_events_url': scheduled_events_url,
'message_log_url': reverse(
MessageLogReport.dispatcher.name(), args=[],
kwargs={'domain': self.domain, 'report_slug': MessageLogReport.slug}
),
'messaging_history_url': reverse(
MessagingEventsReport.dispatcher.name(), args=[],
kwargs={'domain': self.domain, 'report_slug': MessagingEventsReport.slug}
),
}
context['messaging_history_errors_url'] = self.get_messaging_history_errors_url(
context['messaging_history_url']
)
return context
def post(self, *args, **kwargs):
"""
A ``POST`` to mark as unread discussions.
POST can have the following keys:
``discussions_ids``
List of discussion id's that should be marked as unread.
"""
discussion_ids = self.request.POST.getlist("discussion_ids")
if discussion_ids:
recipients = Recipient.objects.filter(
discussion__in=self.valid_ids(discussion_ids), user=self.request.user
).exclude(status=Recipient.STATUS.unread)
for recipient in recipients:
recipient.mark_as_unread()
folder_id = self.kwargs.get("folder_id")
if folder_id:
return redirect(
reverse("discussions_list", kwargs={"folder_id": folder_id})
)
return redirect(reverse("discussions_list"))
def get_context_data(self, **kwargs):
data = ''
pk = kwargs.get('pk')
if settings.AUTH_LDAP:
try:
ldap_tool = LDAPTool()
status = ldap_tool.ldap_get_user(pk, isdict=True)
if status:
msg = "用户:%s 获取成功" % pk
data = status
# messages.add_message(self.request, messages.SUCCESS, msg)
else:
msg = "未获取用户:%s" % pk
messages.add_message(self.request, messages.WARNING, msg)
return redirect(reverse('users:ldap-user-list'))
except Exception as e:
msg = "用户:%s 获取失败，原因:%s" % (pk, str(e))
messages.add_message(self.request, messages.ERROR, msg)
return redirect(reverse('users:ldap-user-list'))
else:
msg = '请系统先支持ldap'
messages.add_message(self.request, messages.WARNING, msg)
return redirect(reverse('users:ldap-user-list'))
context = super().get_context_data(**kwargs)
context['user'] = data
context.update({
'app': _('Users'),
'action': _('LDAP User Detail'),
})
return context
def test_add_owner(self):
"""Adding and removing owner from the ACL project.
"""
self.add_user()
self.client.post(
reverse('set-groups', kwargs=self.kw_project),
{
'user': self.second_user.username,
'group': self.admin_group.pk,
'action': 'add',
}
)
self.assertTrue(
User.objects.all_admins(self.project).filter(
username=self.second_user.username
).exists()
)
self.client.post(
reverse('set-groups', kwargs=self.kw_project),
{
'user': self.second_user.username,
'group': self.admin_group.pk,
'action': 'remove',
}
)
self.assertFalse(
User.objects.all_admins(self.project).filter(
username=self.second_user.username
).exists()
)
self.remove_user()
def logout_view(request):
logout(request)
return HttpResponseRedirect(reverse("index"))
def logout_user(request):
logout(request)
return redirect(reverse('binder:home'))
def search(request, project=None, component=None, lang=None):
"""Perform site-wide search on units."""
is_ratelimited = not check_rate_limit('search', request)
search_form = SiteSearchForm(request.GET)
context = {
'search_form': search_form,
}
search_kwargs = {}
if component:
obj = get_component(request, project, component)
context['component'] = obj
context['project'] = obj.project
context['back_url'] = obj.get_absolute_url()
search_kwargs = {'component': obj}
elif project:
obj = get_project(request, project)
context['project'] = obj
context['back_url'] = obj.get_absolute_url()
search_kwargs = {'project': obj}
else:
obj = None
context['back_url'] = None
if lang:
s_language = get_object_or_404(Language, code=lang)
context['language'] = s_language
search_kwargs = {'language': s_language}
if obj:
if component:
context['back_url'] = obj.translation_set.get(
language=s_language
).get_absolute_url()
else:
context['back_url'] = reverse(
'project-language',
kwargs={
'project': project,
'lang': lang,
}
)
else:
context['back_url'] = s_language.get_absolute_url()
if not is_ratelimited and request.GET and search_form.is_valid():
# Filter results by ACL
if component:
units = Unit.objects.filter(translation__component=obj)
elif project:
units = Unit.objects.filter(translation__component__project=obj)
else:
allowed_projects = request.user.allowed_projects
units = Unit.objects.filter(
translation__component__project__in=allowed_projects
)
units = units.search(
search_form.cleaned_data,
**search_kwargs
)
if lang:
units = units.filter(
translation__language=context['language']
)
units = get_paginator(request, units.order())
context['show_results'] = True
context['page_obj'] = units
context['title'] = _('Search for %s') % (
search_form.cleaned_data['q']
)
context['query_string'] = search_form.urlencode()
context['search_query'] = search_form.cleaned_data['q']
elif is_ratelimited:
messages.error(
request, _('Too many search queries, please try again later.')
)
elif request.GET:
messages.error(request, _('Invalid search query!'))
show_form_errors(request, search_form)
return render(
request,
'search.html',
context
)
def delete_topic(request, topic_id):
topic = get_object_or_404(Topic, id=topic_id)
check_topic_user(request, topic)
topic.delete()
return HttpResponseRedirect(reverse('learning_logs:topics'))
def test_boundaries(self):
self.login(self.admin)
# clear our country on our org
self.org.country = None
self.org.save()
# try stripping path on our country, will fail
with self.assertRaises(Exception):
AdminBoundary.strip_last_path("Rwanda")
# normal strip
self.assertEqual(AdminBoundary.strip_last_path("Rwanda > Kigali City"),
"Rwanda")
# get the aliases for our user org
response = self.client.get(reverse("locations.adminboundary_alias"))
# should be a redirect to our org home
self.assertRedirect(response, reverse("orgs.org_home"))
# now set it to rwanda
self.org.country = self.country
self.org.save()
# our country is set to rwanda, we should get it as the main object
response = self.client.get(reverse("locations.adminboundary_alias"))
self.assertEqual(self.country, response.context["object"])
# ok, now get the geometry for rwanda
response = self.client.get(
reverse("locations.adminboundary_geometry",
args=[self.country.osm_id]))
# should be json
response_json = response.json()
# should have features in it
self.assertIn("features", response_json)
# should have our two top level states
self.assertEqual(2, len(response_json["features"]))
# now get it for one of the sub areas
response = self.client.get(
reverse("locations.adminboundary_geometry",
args=[self.district1.osm_id]))
response_json = response.json()
# should have features in it
self.assertIn("features", response_json)
# should have our single district in it
self.assertEqual(1, len(response_json["features"]))
# now grab our aliases
response = self.client.get(
reverse("locations.adminboundary_boundaries",
args=[self.country.osm_id]))
response_json = response.json()
# should just be kigali, without any aliases
self.assertEqual(2, len(response_json))
self.assertEqual("Eastern Province", response_json[0]["name"])
self.assertEqual("Kigali City", response_json[1]["name"])
self.assertEqual("", response_json[1]["aliases"])
# update our alias for kigali
response = self.client.post(
reverse("locations.adminboundary_boundaries",
args=[self.country.osm_id]),
json.dumps([dict(osm_id=self.state1.osm_id, aliases="kigs\nkig")]),
content_type="application/json",
)
self.assertEqual(200, response.status_code)
# fetch our aliases again
response = self.client.get(
reverse("locations.adminboundary_boundaries",
args=[self.country.osm_id]))
response_json = response.json()
# now have kigs as an alias
self.assertEqual("Kigali City", response_json[1]["name"])
self.assertEqual("kig\nkigs", response_json[1]["aliases"])
# test nested admin level aliases update
geo_data = [
dict(
osm_id=self.state2.osm_id,
aliases="Eastern P",
children=[
dict(
osm_id=self.district1.osm_id,
aliases="Gatsibo",
children=[
dict(osm_id=self.ward1.osm_id,
aliases="Kageyo Gat")
],
)
],
)
]
response = self.client.post(
reverse("locations.adminboundary_boundaries",
args=[self.country.osm_id]),
json.dumps(geo_data),
content_type="application/json",
)
self.assertEqual(200, response.status_code)
# exact match
boundary = self.org.find_boundary_by_name("kigali city",
AdminBoundary.LEVEL_STATE,
self.country)
self.assertEqual(len(boundary), 1)
self.assertEqual(boundary[0], self.state1)
# try to find the location by alias
boundary = self.org.find_boundary_by_name("kigs",
AdminBoundary.LEVEL_STATE,
self.country)
self.assertEqual(len(boundary), 1)
self.assertEqual(boundary[0], self.state1)
# also try with no parent
boundary = self.org.find_boundary_by_name("kigs",
AdminBoundary.LEVEL_STATE,
None)
self.assertEqual(len(boundary), 1)
self.assertEqual(boundary[0], self.state1)
# test no match
boundary = self.org.find_boundary_by_name("foobar",
AdminBoundary.LEVEL_STATE,
None)
self.assertFalse(boundary)
# fetch aliases again
response = self.client.get(
reverse("locations.adminboundary_boundaries",
args=[self.country.osm_id]))
response_json = response.json()
self.assertEqual(response_json[0].get("name"), self.state2.name)
self.assertEqual(response_json[0].get("aliases"), "Eastern P")
self.assertIn("Kageyo Gat", response_json[0].get("match"))
# trigger wrong request data using bad json
response = self.client.post(
reverse("locations.adminboundary_boundaries",
args=[self.country.osm_id]),
"""{"data":"foo \r\n bar"}""",
content_type="application/json",
)
response_json = response.json()
self.assertEqual(400, response.status_code)
self.assertEqual(response_json.get("status"), "error")
# Get geometry of admin boundary without sub-levels, should return one feature
response = self.client.get(
reverse("locations.adminboundary_geometry",
args=[self.ward3.osm_id]))
self.assertEqual(200, response.status_code)
response_json = response.json()
self.assertEqual(len(response_json.get("features")), 1)
def student_dashboard(request): # lint-amnesty, pylint: disable=too-many-statements
"""
Provides the LMS dashboard view
TODO: This is lms specific and does not belong in common code.
Note:
To load the all courses set course_limit=None as parameter in GET. If its not None then default course
limit will be used that is set in configuration
Arguments:
request: The request object.
Returns:
The dashboard response.
"""
user = request.user
if not UserProfile.objects.filter(user=user).exists():
return redirect(reverse('account_settings'))
platform_name = configuration_helpers.get_value("platform_name", settings.PLATFORM_NAME)
enable_verified_certificates = configuration_helpers.get_value(
'ENABLE_VERIFIED_CERTIFICATES',
settings.FEATURES.get('ENABLE_VERIFIED_CERTIFICATES')
)
display_course_modes_on_dashboard = configuration_helpers.get_value(
'DISPLAY_COURSE_MODES_ON_DASHBOARD',
settings.FEATURES.get('DISPLAY_COURSE_MODES_ON_DASHBOARD', True)
)
activation_email_support_link = configuration_helpers.get_value(
'ACTIVATION_EMAIL_SUPPORT_LINK', settings.ACTIVATION_EMAIL_SUPPORT_LINK
) or settings.SUPPORT_SITE_LINK
hide_dashboard_courses_until_activated = configuration_helpers.get_value(
'HIDE_DASHBOARD_COURSES_UNTIL_ACTIVATED',
settings.FEATURES.get('HIDE_DASHBOARD_COURSES_UNTIL_ACTIVATED', False)
)
empty_dashboard_message = configuration_helpers.get_value(
'EMPTY_DASHBOARD_MESSAGE', None
)
disable_course_limit = request and 'course_limit' in request.GET
course_limit = get_dashboard_course_limit() if not disable_course_limit else None
# Get the org whitelist or the org blacklist for the current site
site_org_whitelist, site_org_blacklist = get_org_black_and_whitelist_for_site()
course_enrollments = list(get_course_enrollments(user, site_org_whitelist, site_org_blacklist, course_limit))
# Get the entitlements for the user and a mapping to all available sessions for that entitlement
# If an entitlement has no available sessions, pass through a mock course overview object
(course_entitlements,
course_entitlement_available_sessions,
unfulfilled_entitlement_pseudo_sessions) = get_filtered_course_entitlements(
user,
site_org_whitelist,
site_org_blacklist
)
# Record how many courses there are so that we can get a better
# understanding of usage patterns on prod.
monitoring_utils.accumulate('num_courses', len(course_enrollments))
# Sort the enrollment pairs by the enrollment date
course_enrollments.sort(key=lambda x: x.created, reverse=True)
# Retrieve the course modes for each course
enrolled_course_ids = [enrollment.course_id for enrollment in course_enrollments]
__, unexpired_course_modes = CourseMode.all_and_unexpired_modes_for_courses(enrolled_course_ids)
course_modes_by_course = {
course_id: {
mode.slug: mode
for mode in modes
}
for course_id, modes in unexpired_course_modes.items()
}
# Check to see if the student has recently enrolled in a course.
# If so, display a notification message confirming the enrollment.
enrollment_message = _create_recent_enrollment_message(
course_enrollments, course_modes_by_course
)
course_optouts = Optout.objects.filter(user=user).values_list('course_id', flat=True)
# Display activation message
activate_account_message = ''
if not user.is_active:
activate_account_message = Text(_(
"Check your {email_start}{email}{email_end} inbox for an account activation link from {platform_name}. "
"If you need help, contact {link_start}{platform_name} Support{link_end}."
)).format(
platform_name=platform_name,
email_start=HTML("<strong>"),
email_end=HTML("</strong>"),
email=user.email,
link_start=HTML("<a target='_blank' href='{activation_email_support_link}'>").format(
activation_email_support_link=activation_email_support_link,
),
link_end=HTML("</a>"),
)
enterprise_message = get_dashboard_consent_notification(request, user, course_enrollments)
recovery_email_message = recovery_email_activation_message = None
if is_secondary_email_feature_enabled():
try:
pending_email = PendingSecondaryEmailChange.objects.get(user=user) # lint-amnesty, pylint: disable=unused-variable
except PendingSecondaryEmailChange.DoesNotExist:
try:
account_recovery_obj = AccountRecovery.objects.get(user=user) # lint-amnesty, pylint: disable=unused-variable
except AccountRecovery.DoesNotExist:
recovery_email_message = Text(
_(
"Add a recovery email to retain access when single-sign on is not available. "
"Go to {link_start}your Account Settings{link_end}.")
).format(
link_start=HTML("<a href='{account_setting_page}'>").format(
account_setting_page=reverse('account_settings'),
),
link_end=HTML("</a>")
)
else:
recovery_email_activation_message = Text(
_(
"Recovery email is not activated yet. "
"Kindly visit your email and follow the instructions to activate it."
)
)
# Disable lookup of Enterprise consent_required_course due to ENT-727
# Will re-enable after fixing WL-1315
consent_required_courses = set()
# Account activation message
account_activation_messages = [
message for message in messages.get_messages(request) if 'account-activation' in message.tags
]
# Global staff can see what courses encountered an error on their dashboard
staff_access = False
errored_courses = {}
if has_access(user, 'staff', 'global'):
# Show any courses that encountered an error on load
staff_access = True
errored_courses = modulestore().get_errored_courses()
show_courseware_links_for = {
enrollment.course_id: has_access(request.user, 'load', enrollment.course_overview)
for enrollment in course_enrollments
}
# Find programs associated with course runs being displayed. This information
# is passed in the template context to allow rendering of program-related
# information on the dashboard.
meter = ProgramProgressMeter(request.site, user, enrollments=course_enrollments)
ecommerce_service = EcommerceService()
inverted_programs = meter.invert_programs()
urls, programs_data = {}, {}
bundles_on_dashboard_flag = LegacyWaffleFlag(experiments_namespace, 'bundles_on_dashboard', __name__) # lint-amnesty, pylint: disable=toggle-missing-annotation
# TODO: Delete this code and the relevant HTML code after testing LEARNER-3072 is complete
if bundles_on_dashboard_flag.is_enabled() and inverted_programs and list(inverted_programs.items()):
if len(course_enrollments) < 4:
for program in inverted_programs.values():
try:
program_uuid = program[0]['uuid']
program_data = get_programs(uuid=program_uuid)
program_data = ProgramDataExtender(program_data, request.user).extend()
skus = program_data.get('skus')
checkout_page_url = ecommerce_service.get_checkout_page_url(*skus)
program_data['completeProgramURL'] = checkout_page_url + '&bundle=' + program_data.get('uuid')
programs_data[program_uuid] = program_data
except: # pylint: disable=bare-except
pass
# Construct a dictionary of course mode information
# used to render the course list. We re-use the course modes dict
# we loaded earlier to avoid hitting the database.
course_mode_info = {
enrollment.course_id: complete_course_mode_info(
enrollment.course_id, enrollment,
modes=course_modes_by_course[enrollment.course_id]
)
for enrollment in course_enrollments
}
# Determine the per-course verification status
# This is a dictionary in which the keys are course locators
# and the values are one of:
#
# VERIFY_STATUS_NEED_TO_VERIFY
# VERIFY_STATUS_SUBMITTED
# VERIFY_STATUS_APPROVED
# VERIFY_STATUS_MISSED_DEADLINE
#
# Each of which correspond to a particular message to display
# next to the course on the dashboard.
#
# If a course is not included in this dictionary,
# there is no verification messaging to display.
verify_status_by_course = check_verify_status_by_course(user, course_enrollments)
cert_statuses = {
enrollment.course_id: cert_info(request.user, enrollment)
for enrollment in course_enrollments
}
# only show email settings for Mongo course and when bulk email is turned on
show_email_settings_for = frozenset(
enrollment.course_id for enrollment in course_enrollments if (
is_bulk_email_feature_enabled(enrollment.course_id)
)
)
# Verification Attempts
# Used to generate the "you must reverify for course x" banner
verification_status = IDVerificationService.user_status(user)
verification_errors = get_verification_error_reasons_for_display(verification_status['error'])
# Gets data for midcourse reverifications, if any are necessary or have failed
statuses = ["approved", "denied", "pending", "must_reverify"]
reverifications = reverification_info(statuses)
enrolled_courses_either_paid = frozenset(
enrollment.course_id for enrollment in course_enrollments
if enrollment.is_paid_course()
)
# Checks if a course enrollment redeemed using a voucher is refundable
enrolled_courses_voucher_refundable = frozenset(
enrollment.course_id for enrollment in course_enrollments
if enrollment.is_order_voucher_refundable()
)
# If there are *any* denied reverifications that have not been toggled off,
# we'll display the banner
denied_banner = any(item.display for item in reverifications["denied"])
# get list of courses having pre-requisites yet to be completed
courses_having_prerequisites = frozenset(
enrollment.course_id for enrollment in course_enrollments
if enrollment.course_overview.pre_requisite_courses
)
courses_requirements_not_met = get_pre_requisite_courses_not_completed(user, courses_having_prerequisites)
if 'notlive' in request.GET:
redirect_message = _("The course you are looking for does not start until {date}.").format(
date=request.GET['notlive']
)
elif 'course_closed' in request.GET:
redirect_message = _("The course you are looking for is closed for enrollment as of {date}.").format(
date=request.GET['course_closed']
)
elif 'access_response_error' in request.GET:
# This can be populated in a generalized way with fields from access response errors
redirect_message = request.GET['access_response_error']
else:
redirect_message = ''
all_integrity_enabled = True
if not course_enrollments:
all_integrity_enabled = is_integrity_signature_enabled(None)
for enrollment in course_enrollments:
if not is_integrity_signature_enabled(enrollment.course_id):
all_integrity_enabled = False
break
valid_verification_statuses = ['approved', 'must_reverify', 'pending', 'expired']
display_sidebar_on_dashboard = not all_integrity_enabled and \
verification_status['status'] in valid_verification_statuses and \
verification_status['should_display']
# Filter out any course enrollment course cards that are associated with fulfilled entitlements
for entitlement in [e for e in course_entitlements if e.enrollment_course_run is not None]:
course_enrollments = [
enr for enr in course_enrollments if entitlement.enrollment_course_run.course_id != enr.course_id
]
show_account_activation_popup = request.COOKIES.get(settings.SHOW_ACTIVATE_CTA_POPUP_COOKIE_NAME, None)
context = {
'urls': urls,
'programs_data': programs_data,
'enterprise_message': enterprise_message,
'consent_required_courses': consent_required_courses,
'enrollment_message': enrollment_message,
'redirect_message': Text(redirect_message),
'account_activation_messages': account_activation_messages,
'activate_account_message': activate_account_message,
'course_enrollments': course_enrollments,
'course_entitlements': course_entitlements,
'course_entitlement_available_sessions': course_entitlement_available_sessions,
'unfulfilled_entitlement_pseudo_sessions': unfulfilled_entitlement_pseudo_sessions,
'course_optouts': course_optouts,
'staff_access': staff_access,
'errored_courses': errored_courses,
'show_courseware_links_for': show_courseware_links_for,
'all_course_modes': course_mode_info,
'cert_statuses': cert_statuses,
'credit_statuses': _credit_statuses(user, course_enrollments),
'show_email_settings_for': show_email_settings_for,
'reverifications': reverifications,
'verification_display': verification_status['should_display'],
'verification_status': verification_status['status'],
'verification_expiry': verification_status['verification_expiry'],
'verification_status_by_course': verify_status_by_course,
'verification_errors': verification_errors,
'denied_banner': denied_banner,
'billing_email': settings.PAYMENT_SUPPORT_EMAIL,
'show_account_activation_popup': show_account_activation_popup,
'user': user,
'logout_url': reverse('logout'),
'platform_name': platform_name,
'enrolled_courses_either_paid': enrolled_courses_either_paid,
'enrolled_courses_voucher_refundable': enrolled_courses_voucher_refundable,
'provider_states': [],
'courses_requirements_not_met': courses_requirements_not_met,
'nav_hidden': True,
'inverted_programs': inverted_programs,
'show_program_listing': ProgramsApiConfig.is_enabled(),
'show_dashboard_tabs': True,
'disable_courseware_js': True,
'display_course_modes_on_dashboard': enable_verified_certificates and display_course_modes_on_dashboard,
'display_sidebar_on_dashboard': display_sidebar_on_dashboard,
'display_sidebar_account_activation_message': not(user.is_active or hide_dashboard_courses_until_activated),
'display_dashboard_courses': (user.is_active or not hide_dashboard_courses_until_activated),
'empty_dashboard_message': empty_dashboard_message,
'recovery_email_message': recovery_email_message,
'recovery_email_activation_message': recovery_email_activation_message,
'show_load_all_courses_link': show_load_all_courses_link(user, course_limit, course_enrollments),
# TODO START: clean up as part of REVEM-199 (START)
'course_info': get_dashboard_course_info(user, course_enrollments),
# TODO START: clean up as part of REVEM-199 (END)
}
# Include enterprise learner portal metadata and messaging
enterprise_learner_portal_context = get_enterprise_learner_portal_context(request)
context.update(enterprise_learner_portal_context)
context_from_plugins = get_plugins_view_context(
ProjectType.LMS,
COURSE_DASHBOARD_PLUGIN_VIEW_NAME,
context
)
context.update(context_from_plugins)
notice_url = check_for_unacknowledged_notices(context)
if notice_url:
return redirect(notice_url)
course = None
context.update(
get_experiment_user_metadata_context(
course,
user,
)
)
if ecommerce_service.is_enabled(request.user):
context.update({
'use_ecommerce_payment_flow': True,
'ecommerce_payment_page': ecommerce_service.payment_page_url(),
})
# Gather urls for course card resume buttons.
resume_button_urls = ['' for entitlement in course_entitlements]
for url in get_resume_urls_for_enrollments(user, course_enrollments).values():
resume_button_urls.append(url)
# There must be enough urls for dashboard.html. Template creates course
# cards for "enrollments + entitlements".
context.update({
'resume_button_urls': resume_button_urls
})
response = render_to_response('dashboard.html', context)
if show_account_activation_popup:
response.delete_cookie(
settings.SHOW_ACTIVATE_CTA_POPUP_COOKIE_NAME,
domain=settings.SESSION_COOKIE_DOMAIN,
path='/',
)
return response
def _build_import_url(self, model):
ct = ContentType.objects.get_for_model(model)
return reverse('creme_core__mass_import', args=(ct.id,))
def change_att(request, att_id):
a = get_object_or_404(Attendance, id=att_id)
a.status = not a.status
a.save()
return HttpResponseRedirect(reverse('t_attendance_detail', args=(a.student.USN, a.course_id)))
def copy_report(self):
return '<a href="{0}"><img style="width: 26px; margin: -6px" src="{1}report_builder/img/copy.svg"/></a>'.format(
reverse('report_builder_create_copy', args=[self.id]),
getattr(settings, 'STATIC_URL', '/static/'),
)
def cancel_class(request, ass_c_id):
assc = get_object_or_404(AttendanceClass, id=ass_c_id)
assc.status = 2
assc.save()
return HttpResponseRedirect(reverse('t_class_date', args=(assc.assign_id,)))
def test_past_question(self):
past_question = create_question(question_text='Past Question', days=-5)
url = reverse('polls:detail', args=(past_question.id, ))
response = self.client.get(url)
self.assertContains(response, past_question.question_text)
def test_list_view(self):
"""ranks list view returns 200"""
response = self.client.get(reverse('misago:admin:users:ranks:index'))
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Team')
def test_two_past_questions(self):
create_question(question_text="Past question 1.", days=-30)
create_question(question_text="Past question 2.", days=-5)
response = self.client.get(reverse('polls:index'))
self.assertQuerysetEqual(response.context['latest_question_list'],
['<Question: Past question 2.>', '<Question: Past question 1.>'])
def logout_view(request):
logout(request)
return HttpResponseRedirect(reverse('accounts:login'))
def test_future_question(self):
create_question(question_text="Future question.", days=30)
response = self.client.get(reverse('polls:index'))
self.assertContains(response, "No polls are available.")
self.assertQuerysetEqual(response.context['latest_question_list'], [])
def test_future_question(self):
future_question = create_question(question_text='Future question.', days=5)
url = reverse('polls:detail', args=(future_question.id, ))
response = self.client.get(url)
self.assertEqual(response.status_code, 404)
def index(request):
# if no user is signed in then return login page
if not request.user.is_authenticated:
return HttpResponseRedirect(reverse("login"))
return render(request, "users/user.html")
def test_future_question_and_past_question(self):
create_question(question_text="Past question.", days=-30)
create_question(question_text="Future question", days=30)
response = self.client.get(reverse('polls:index'))
self.assertQuerysetEqual(response.context['latest_question_list'], ['<Question: Past question.>'])
def setUp(self):
self.url = reverse('plate-create')
def test_no_questions(self):
response = self.client.get(reverse('polls:index'))
self.assertEqual(response.status_code, 200)
self.assertContains(response, "No polls are available.")
self.assertQuerysetEqual(response.context['latest_question_list'], [])
def setUp(self):
self.url = reverse('plate-create')
self.nora = self.create_user(username='******', is_staff=True)
self.setup_logged_in_client()
def setUp(self):
self.nora = self.create_user(username='******', is_staff=True)
self.setup_logged_in_client()
self.plate = Plate.objects.create(owner=self.nora, name="test")
self.url = reverse('plate-update', kwargs={'pk': self.plate.id})
def get_absolute_url(self):
return reverse("inventory_row", kwargs={"row_slug": self.slug})
def test_successful_deletion(self):
self.assertEqual(Plate.objects.all().count(), 1)
response = self.client.get(self.url, follow=True)
self.assertRedirects(response, "%s" % (reverse('plate-list')))
self.assertEqual(Plate.objects.all().count(), 0)
def get_absolute_url(self):
return reverse("inventory_jar", kwargs={"jar_slug": self.slug})
def url(self):
return reverse('creatures:creature', kwargs={'section_slug': self.section.slug, 'creature_slug': self.slug})
def get_absolute_url(self):
return reverse("inventory_bin", kwargs={"bin_slug": self.slug})
def get_absolute_url(self):
return reverse("inventory_warehouse",
kwargs={"warehouse_slug": self.slug})
def get_absolute_url(self):
return reverse("inventory_shelf", kwargs={"shelf_slug": self.slug})
def get_absolute_url(self):
return reverse("inventory_crate", kwargs={"crate_slug": self.slug})
