def change_avatar(request):
if request.method == 'POST':
user_profile = UserProfile.get_for_user(request.user)
form = AvatarPreferencesForm(request.POST, request.FILES, instance=user_profile)
if form.is_valid():
form.save()
messages.success(request, _("Your preferences have been updated successfully!"))
return redirect('wagtailadmin_account_change_avatar')
else:
form = AvatarPreferencesForm(instance=UserProfile.get_for_user(request.user))
return render(request, 'wagtailadmin/account/change_avatar.html', {'form': form})
def current_time_zone(request):
if request.method == 'POST':
form = CurrentTimeZoneForm(request.POST, instance=UserProfile.get_for_user(request.user))
if form.is_valid():
form.save()
messages.success(request, _("Your preferences have been updated."))
return redirect('wagtailadmin_account')
else:
form = CurrentTimeZoneForm(instance=UserProfile.get_for_user(request.user))
return render(request, 'wagtailadmin/account/current_time_zone.html', {
'form': form,
})
def test_uploaded_avatar(self):
user_profile = UserProfile.get_for_user(self.test_user)
user_profile.avatar = get_test_image_file(filename='custom-avatar.png')
user_profile.save()
url = avatar_url(self.test_user)
self.assertIn('custom-avatar', url)
def test_notification_preferences_view_post(self):
"""
This posts to the notification preferences view and checks that the
user's profile is updated
"""
# Post new values to the notification preferences page
post_data = {
'submitted_notifications': 'false',
'approved_notifications': 'false',
'rejected_notifications': 'true',
}
response = self.client.post(
reverse('wagtailadmin_account_notification_preferences'),
post_data)
# Check that the user was redirected to the account page
self.assertRedirects(response, reverse('wagtailadmin_account'))
profile = UserProfile.get_for_user(
get_user_model().objects.get(pk=self.user.pk))
# Check that the notification preferences are as submitted
self.assertFalse(profile.submitted_notifications)
self.assertFalse(profile.approved_notifications)
self.assertTrue(profile.rejected_notifications)
def test_uploaded_avatar(self):
user_profile = UserProfile.get_for_user(self.test_user)
user_profile.avatar = get_test_image_file(filename="custom-avatar.png")
user_profile.save()
url = avatar_url(self.test_user)
self.assertIn("custom-avatar", url)
def language_preferences(request):
if request.method == 'POST':
form = PreferredLanguageForm(request.POST, instance=UserProfile.get_for_user(request.user))
if form.is_valid():
user_profile = form.save()
# This will set the language only for this request/thread
# (so that the 'success' messages is in the right language)
activate(user_profile.get_preferred_language())
messages.success(request, _("Your preferences have been updated."))
return redirect('wagtailadmin_account')
else:
form = PreferredLanguageForm(instance=UserProfile.get_for_user(request.user))
return render(request, 'wagtailadmin/account/language_preferences.html', {
'form': form,
})
def language_preferences(request):
if request.method == 'POST':
form = PreferredLanguageForm(request.POST, instance=UserProfile.get_for_user(request.user))
if form.is_valid():
user_profile = form.save()
# This will set the language only for this request/thread
# (so that the 'success' messages is in the right language)
activate(user_profile.get_preferred_language())
messages.success(request, _("Your preferences have been updated."))
return redirect('wagtailadmin_account')
else:
form = PreferredLanguageForm(instance=UserProfile.get_for_user(request.user))
return render(request, 'wagtailadmin/account/language_preferences.html', {
'form': form,
})
def current_time_zone(request):
if request.method == 'POST':
form = CurrentTimeZoneForm(request.POST,
instance=UserProfile.get_for_user(
request.user))
if form.is_valid():
form.save()
messages.success(request, _("Your preferences have been updated."))
return redirect('wagtailadmin_account')
else:
form = CurrentTimeZoneForm(
instance=UserProfile.get_for_user(request.user))
return render(request, 'wagtailadmin/account/current_time_zone.html', {
'form': form,
})
def get_valid_recipients(self, instance, **kwargs):
"""Filters notification recipients to those allowing the notification type on their UserProfile, and those
with an email address"""
return {recipient for recipient in self.get_recipient_users(instance, **kwargs) if recipient.email and getattr(
UserProfile.get_for_user(recipient),
self.notification + '_notifications'
)}
def change_avatar(request):
if request.method == 'POST':
user_profile = UserProfile.get_for_user(request.user)
form = AvatarPreferencesForm(request.POST,
request.FILES,
instance=user_profile)
if form.is_valid():
form.save()
messages.success(
request, _("Your preferences have been updated successfully!"))
return redirect('wagtailadmin_account_change_avatar')
else:
form = AvatarPreferencesForm(
instance=UserProfile.get_for_user(request.user))
return TemplateResponse(request, 'wagtailadmin/account/change_avatar.html',
{'form': form})
def test_set_custom_avatar_stores_and_get_custom_avatar(self):
response = self.client.post(reverse('wagtailadmin_account_change_avatar'),
{'avatar': self.avatar},
follow=True)
self.assertEqual(response.status_code, 200)
profile = UserProfile.get_for_user(get_user_model().objects.get(pk=self.user.pk))
self.assertIn(os.path.basename(self.avatar.name), profile.avatar.url)
def test_set_custom_avatar_stores_and_get_custom_avatar(self):
response = self.client.post(reverse('wagtailadmin_account_change_avatar'),
{'avatar': self.avatar},
follow=True)
self.assertEqual(response.status_code, 200)
profile = UserProfile.get_for_user(get_user_model().objects.get(pk=self.user.pk))
self.assertIn(os.path.basename(self.avatar.name), profile.avatar.url)
def send_notification(recipient_users, notification, extra_context):
# Get list of email addresses
email_recipients = [
recipient for recipient in recipient_users
if recipient.is_active and recipient.email and getattr(
UserProfile.get_for_user(recipient),
notification + '_notifications'
)
]
# Return if there are no email addresses
if not email_recipients:
return True
# Get template
template_subject = 'wagtailadmin/notifications/' + notification + '_subject.txt'
template_text = 'wagtailadmin/notifications/' + notification + '.txt'
template_html = 'wagtailadmin/notifications/' + notification + '.html'
# Common context to template
context = {
"settings": settings,
}
context.update(extra_context)
connection = get_connection()
with OpenedConnection(connection) as open_connection:
# Send emails
sent_count = 0
for recipient in email_recipients:
try:
# update context with this recipient
context["user"] = recipient
# Translate text to the recipient language settings
with override(recipient.wagtail_userprofile.get_preferred_language()):
# Get email subject and content
email_subject = render_to_string(template_subject, context).strip()
email_content = render_to_string(template_text, context).strip()
kwargs = {}
if getattr(settings, 'WAGTAILADMIN_NOTIFICATION_USE_HTML', False):
kwargs['html_message'] = render_to_string(template_html, context)
# Send email
send_mail(email_subject, email_content, [recipient.email], connection=open_connection, **kwargs)
sent_count += 1
except Exception:
logger.exception(
"Failed to send notification email '%s' to %s",
email_subject, recipient.email
)
return sent_count == len(email_recipients)
def test_set_custom_avatar_stores_and_get_custom_avatar(self):
response = self.post_form({
'avatar-avatar': SimpleUploadedFile('other.png', self.other_avatar.file.getvalue())
})
# Check that the user was redirected to the account page
self.assertRedirects(response, reverse('wagtailadmin_account'))
profile = UserProfile.get_for_user(self.user)
profile.refresh_from_db()
self.assertIn('other.png', profile.avatar.url)
def notification_preferences(request):
if request.method == 'POST':
form = NotificationPreferencesForm(request.POST, instance=UserProfile.get_for_user(request.user))
if form.is_valid():
form.save()
messages.success(request, _("Your preferences have been updated."))
return redirect('wagtailadmin_account')
else:
form = NotificationPreferencesForm(instance=UserProfile.get_for_user(request.user))
# quick-and-dirty catch-all in case the form has been rendered with no
# fields, as the user has no customisable permissions
if not form.fields:
return redirect('wagtailadmin_account')
return render(request, 'wagtailadmin/account/notification_preferences.html', {
'form': form,
})
def notification_preferences(request):
if request.method == 'POST':
form = NotificationPreferencesForm(request.POST, instance=UserProfile.get_for_user(request.user))
if form.is_valid():
form.save()
messages.success(request, _("Your preferences have been updated."))
return redirect('wagtailadmin_account')
else:
form = NotificationPreferencesForm(instance=UserProfile.get_for_user(request.user))
# quick-and-dirty catch-all in case the form has been rendered with no
# fields, as the user has no customisable permissions
if not form.fields:
return redirect('wagtailadmin_account')
return render(request, 'wagtailadmin/account/notification_preferences.html', {
'form': form,
})
def process_request(self, request):
tzname = None
if request.user and not request.user.is_anonymous:
up = UserProfile.get_for_user(request.user)
tzname = up.timezone
if tzname:
timezone.activate(pytz.timezone(tzname))
else:
timezone.deactivate()
def get_valid_recipients(self, instance, **kwargs):
recipients = self.get_recipient_users(instance, **kwargs)
valid_internal_recipients = {recipient for recipient in recipients if recipient.internal and recipient.get_email() and getattr(
UserProfile.get_for_user(recipient.internal),
self.notification + '_notifications'
)}
valid_external_recipients = {recipient for recipient in recipients if recipient.external and recipient.get_email()}
return valid_external_recipients|valid_internal_recipients
def setUp(self):
# Find root page
self.root_page = Page.objects.get(id=2)
# Login
self.user = self.login()
# Create two moderator users for testing 'submitted' email
self.moderator = self.create_superuser(
"moderator", "*****@*****.**", "password"
)
self.moderator2 = self.create_superuser(
"moderator2", "*****@*****.**", "password"
)
# Create a submitter for testing 'rejected' and 'approved' emails
self.submitter = self.create_user(
"submitter", "*****@*****.**", "password"
)
# User profiles for moderator2 and the submitter
self.moderator2_profile = UserProfile.get_for_user(self.moderator2)
self.submitter_profile = UserProfile.get_for_user(self.submitter)
# Create a page and submit it for moderation
self.child_page = SimplePage(
title="Hello world!",
slug="hello-world",
content="hello",
live=False,
)
self.root_page.add_child(instance=self.child_page)
# POST data to edit the page
self.post_data = {
"title": "I've been edited!",
"content": "Some content",
"slug": "hello-world",
"action-submit": "Submit",
}
def setUp(self):
# Find root page
self.root_page = Page.objects.get(id=2)
# Login
self.user = self.login()
# Create two moderator users for testing 'submitted' email
User = get_user_model()
self.moderator = User.objects.create_superuser('moderator',
'*****@*****.**',
'password')
self.moderator2 = User.objects.create_superuser(
'moderator2', '*****@*****.**', 'password')
# Create a submitter for testing 'rejected' and 'approved' emails
self.submitter = User.objects.create_user('submitter',
'*****@*****.**',
'password')
# User profiles for moderator2 and the submitter
self.moderator2_profile = UserProfile.get_for_user(self.moderator2)
self.submitter_profile = UserProfile.get_for_user(self.submitter)
# Create a page and submit it for moderation
self.child_page = SimplePage(
title="Hello world!",
slug='hello-world',
content="hello",
live=False,
)
self.root_page.add_child(instance=self.child_page)
# POST data to edit the page
self.post_data = {
'title': "I've been edited!",
'content': "Some content",
'slug': 'hello-world',
'action-submit': "Submit",
}
def test_change_current_time_zone(self):
response = self.post_form({
'locale-current_time_zone': 'Pacific/Fiji',
})
# Check that the user was redirected to the account page
self.assertRedirects(response, reverse('wagtailadmin_account'))
profile = UserProfile.get_for_user(self.user)
profile.refresh_from_db()
# Check that the current time zone is stored
self.assertEqual(profile.current_time_zone, 'Pacific/Fiji')
def test_unset_current_time_zone(self):
response = self.post_form({
"locale-current_time_zone": "",
})
# Check that the user was redirected to the account page
self.assertRedirects(response, reverse("wagtailadmin_account"))
profile = UserProfile.get_for_user(self.user)
profile.refresh_from_db()
# Check that the current time zone are stored
self.assertEqual(profile.current_time_zone, "")
def test_unset_language_preferences(self):
# Post new values to the language preferences page
post_data = {
'preferred_language': ''
}
response = self.client.post(reverse('wagtailadmin_account_language_preferences'), post_data)
# Check that the user was redirected to the account page
self.assertRedirects(response, reverse('wagtailadmin_account'))
profile = UserProfile.get_for_user(get_user_model().objects.get(pk=self.user.pk))
# Check that the language preferences are stored
self.assertEqual(profile.preferred_language, '')
def test_unset_current_time_zone(self):
# Post new values to the current time zone page
post_data = {'current_time_zone': ''}
response = self.client.post(
reverse('wagtailadmin_account_current_time_zone'), post_data)
# Check that the user was redirected to the account page
self.assertRedirects(response, reverse('wagtailadmin_account'))
profile = UserProfile.get_for_user(
get_user_model().objects.get(pk=self.user.pk))
# Check that the current time zone are stored
self.assertEqual(profile.current_time_zone, '')
def test_unset_current_time_zone(self):
# Post new values to the current time zone page
post_data = {
'current_time_zone': ''
}
response = self.client.post(reverse('wagtailadmin_account_current_time_zone'), post_data)
# Check that the user was redirected to the account page
self.assertRedirects(response, reverse('wagtailadmin_account'))
profile = UserProfile.get_for_user(get_user_model().objects.get(pk=self.user.pk))
# Check that the current time zone are stored
self.assertEqual(profile.current_time_zone, '')
def test_clear_removes_current_avatar(self):
"""
Tests that submitting a blank value for avatar doesn't remove it.
"""
profile = UserProfile.get_for_user(self.user)
profile.avatar = self.avatar
profile.save()
# Upload a new avatar
response = self.post_form({"avatar-clear": "on"})
# Check that the user was redirected to the account page
self.assertRedirects(response, reverse("wagtailadmin_account"))
# Check the avatar was changed
profile.refresh_from_db()
self.assertIn("test.png", profile.avatar.url)
def test_change_language_preferences(self):
response = self.post_form({
"locale-preferred_language": "es",
})
# Check that the user was redirected to the account page
self.assertRedirects(response, reverse("wagtailadmin_account"))
profile = UserProfile.get_for_user(self.user)
profile.refresh_from_db()
# Check that the language preferences are stored
self.assertEqual(profile.preferred_language, "es")
# check that the updated language preference is now indicated in HTML header
response = self.client.get(reverse("wagtailadmin_home"))
self.assertContains(response, '<html lang="es" dir="ltr">')
def test_current_time_zone_view_post(self):
"""
This posts to the current time zone view and checks that the
user profile is updated
"""
# Post new values to the current time zone page
post_data = {
'current_time_zone': 'Pacific/Fiji'
}
response = self.client.post(reverse('wagtailadmin_account_current_time_zone'), post_data)
# Check that the user was redirected to the account page
self.assertRedirects(response, reverse('wagtailadmin_account'))
profile = UserProfile.get_for_user(get_user_model().objects.get(pk=self.user.pk))
# Check that the current time zone is stored
self.assertEqual(profile.current_time_zone, 'Pacific/Fiji')
def test_user_upload_another_image_removes_previous_one(self):
response = self.client.post(reverse('wagtailadmin_account_change_avatar'),
{'avatar': self.avatar},
follow=True)
self.assertEqual(response.status_code, 200)
profile = UserProfile.get_for_user(get_user_model().objects.get(pk=self.user.pk))
old_avatar_path = profile.avatar.path
# Upload a new avatar
new_response = self.client.post(reverse('wagtailadmin_account_change_avatar'),
{'avatar': self.other_avatar},
follow=True)
self.assertEqual(new_response.status_code, 200)
# Check old avatar doesn't exist anymore in filesystem
with self.assertRaises(FileNotFoundError):
open(old_avatar_path)
def test_change_notifications(self):
response = self.post_form({
'submitted_notifications': 'false',
'approved_notifications': 'false',
'rejected_notifications': 'true',
'updated_comments_notifications': 'true',
})
# Check that the user was redirected to the account page
self.assertRedirects(response, reverse('wagtailadmin_account'))
profile = UserProfile.get_for_user(get_user_model().objects.get(pk=self.user.pk))
# Check that the notification preferences are as submitted
self.assertFalse(profile.submitted_notifications)
self.assertFalse(profile.approved_notifications)
self.assertTrue(profile.rejected_notifications)
self.assertTrue(profile.updated_comments_notifications)
def test_user_upload_another_image_removes_previous_one(self):
response = self.client.post(reverse('wagtailadmin_account_change_avatar'),
{'avatar': self.avatar},
follow=True)
self.assertEqual(response.status_code, 200)
profile = UserProfile.get_for_user(get_user_model().objects.get(pk=self.user.pk))
old_avatar_path = profile.avatar.path
# Upload a new avatar
new_response = self.client.post(reverse('wagtailadmin_account_change_avatar'),
{'avatar': self.other_avatar},
follow=True)
self.assertEqual(new_response.status_code, 200)
# Check old avatar doesn't exist anymore in filesystem
with self.assertRaises(FileNotFoundError):
open(old_avatar_path)
def test_current_time_zone_view_post(self):
"""
This posts to the current time zone view and checks that the
user profile is updated
"""
# Post new values to the current time zone page
post_data = {'current_time_zone': 'Pacific/Fiji'}
response = self.client.post(
reverse('wagtailadmin_account_current_time_zone'), post_data)
# Check that the user was redirected to the account page
self.assertRedirects(response, reverse('wagtailadmin_account'))
profile = UserProfile.get_for_user(
get_user_model().objects.get(pk=self.user.pk))
# Check that the current time zone is stored
self.assertEqual(profile.current_time_zone, 'Pacific/Fiji')
def test_unset_language_preferences(self):
profile = UserProfile.get_for_user(self.user)
profile.preferred_language = "en"
profile.save()
response = self.post_form({
"locale-preferred_language": "",
})
# Check that the user was redirected to the account page
self.assertRedirects(response, reverse("wagtailadmin_account"))
# Check that the language preferences are stored
profile.refresh_from_db()
self.assertEqual(profile.preferred_language, "")
# Check that the current language is assumed as English
self.assertEqual(profile.get_preferred_language(), "en")
def save(self, commit=True):
user = super().save(commit=False)
if self.password_enabled:
password = self.cleaned_data['password1']
if password:
user.set_password(password)
if commit:
user.save()
self.save_m2m()
if self.cleaned_data["timezone"]:
profile = UserProfile.get_for_user(user)
profile.timezone = self.cleaned_data["timezone"]
profile.save()
return user
def __init__(self, *args, **kwargs):
instance = kwargs.get('instance')
initial = kwargs.get('initial')
if instance is not None:
if initial is None:
initial = {}
initial['timezone'] = UserProfile.get_for_user(instance).timezone
kwargs['initial'] = initial
super().__init__(*args, **kwargs)
if self.password_enabled:
if self.password_required:
self.fields['password1'].help_text = mark_safe(password_validators_help_text_html())
self.fields['password1'].required = True
self.fields['password2'].required = True
else:
del self.fields['password1']
del self.fields['password2']
def test_user_upload_another_image_removes_previous_one(self):
profile = UserProfile.get_for_user(self.user)
profile.avatar = self.avatar
profile.save()
old_avatar_path = profile.avatar.path
# Upload a new avatar
response = self.post_form({
'avatar-avatar': SimpleUploadedFile('other.png', self.other_avatar.file.getvalue())
})
# Check that the user was redirected to the account page
self.assertRedirects(response, reverse('wagtailadmin_account'))
# Check the avatar was changed
profile.refresh_from_db()
self.assertIn('other.png', profile.avatar.url)
# Check old avatar doesn't exist anymore in filesystem
with self.assertRaises(FileNotFoundError):
open(old_avatar_path)
def test_notification_preferences_view_post(self):
"""
This posts to the notification preferences view and checks that the
user's profile is updated
"""
# Post new values to the notification preferences page
post_data = {
'submitted_notifications': 'false',
'approved_notifications': 'false',
'rejected_notifications': 'true',
}
response = self.client.post(reverse('wagtailadmin_account_notification_preferences'), post_data)
# Check that the user was redirected to the account page
self.assertRedirects(response, reverse('wagtailadmin_account'))
profile = UserProfile.get_for_user(get_user_model().objects.get(pk=self.user.pk))
# Check that the notification preferences are as submitted
self.assertFalse(profile.submitted_notifications)
self.assertFalse(profile.approved_notifications)
self.assertTrue(profile.rejected_notifications)
def test_language_preferences_view_post(self):
"""
This posts to the language preferences view and checks that the
user profile is updated
"""
# Post new values to the language preferences page
post_data = {
'preferred_language': 'es'
}
response = self.client.post(reverse('wagtailadmin_account_language_preferences'), post_data)
# Check that the user was redirected to the account page
self.assertRedirects(response, reverse('wagtailadmin_account'))
profile = UserProfile.get_for_user(get_user_model().objects.get(pk=self.user.pk))
# Check that the language preferences are stored
self.assertEqual(profile.preferred_language, 'es')
# check that the updated language preference is now indicated in HTML header
response = self.client.get(reverse('wagtailadmin_home'))
self.assertContains(response, '<html class="no-js" lang="es">')
def test_language_preferences_view_post(self):
"""
This posts to the language preferences view and checks that the
user profile is updated
"""
# Post new values to the language preferences page
post_data = {
'preferred_language': 'es'
}
response = self.client.post(reverse('wagtailadmin_account_language_preferences'), post_data)
# Check that the user was redirected to the account page
self.assertRedirects(response, reverse('wagtailadmin_account'))
profile = UserProfile.get_for_user(get_user_model().objects.get(pk=self.user.pk))
# Check that the language preferences are stored
self.assertEqual(profile.preferred_language, 'es')
# check that the updated language preference is now indicated in HTML header
response = self.client.get(reverse('wagtailadmin_home'))
self.assertContains(response, '<html class="no-js" lang="es" dir="ltr">')
def wagtailuserbar(context, position="bottom-right"):
# Find request object
try:
request = context["request"]
except KeyError:
return ""
# Don't render without a user because we can't check their permissions
try:
user = request.user
except AttributeError:
return ""
# Don't render if user doesn't have permission to access the admin area
if not user.has_perm("wagtailadmin.access_admin"):
return ""
# Render the userbar using the user's preferred admin language
userprofile = UserProfile.get_for_user(user)
with translation.override(userprofile.get_preferred_language()):
page = get_page_instance(context)
try:
revision_id = request.revision_id
except AttributeError:
revision_id = None
if page and page.id:
if revision_id:
items = [
AdminItem(),
ExplorePageItem(
PageRevision.objects.get(id=revision_id).page),
EditPageItem(
PageRevision.objects.get(id=revision_id).page),
ApproveModerationEditPageItem(
PageRevision.objects.get(id=revision_id)),
RejectModerationEditPageItem(
PageRevision.objects.get(id=revision_id)),
]
else:
# Not a revision
items = [
AdminItem(),
ExplorePageItem(Page.objects.get(id=page.id)),
EditPageItem(Page.objects.get(id=page.id)),
AddPageItem(Page.objects.get(id=page.id)),
]
else:
# Not a page.
items = [AdminItem()]
for fn in hooks.get_hooks("construct_wagtail_userbar"):
fn(request, items)
# Render the items
rendered_items = [item.render(request) for item in items]
# Remove any unrendered items
rendered_items = [item for item in rendered_items if item]
# Render the userbar items
return render_to_string(
"wagtailadmin/userbar/base.html",
{
"request": request,
"items": rendered_items,
"position": position,
"page": page,
"revision_id": revision_id,
},
)
def send_notification(page_revision_id, notification, excluded_user_id):
# Get revision
revision = PageRevision.objects.get(id=page_revision_id)
# Get list of recipients
if notification == 'submitted':
# Get list of publishers
include_superusers = getattr(settings, 'WAGTAILADMIN_NOTIFICATION_INCLUDE_SUPERUSERS', True)
recipients = users_with_page_permission(revision.page, 'publish', include_superusers)
elif notification in ['rejected', 'approved']:
# Get submitter
recipients = [revision.user]
else:
return False
# Get list of email addresses
email_recipients = [
recipient for recipient in recipients
if recipient.email and recipient.pk != excluded_user_id and getattr(
UserProfile.get_for_user(recipient),
notification + '_notifications'
)
]
# Return if there are no email addresses
if not email_recipients:
return True
# Get template
template_subject = 'wagtailadmin/notifications/' + notification + '_subject.txt'
template_text = 'wagtailadmin/notifications/' + notification + '.txt'
template_html = 'wagtailadmin/notifications/' + notification + '.html'
# Common context to template
context = {
"revision": revision,
"settings": settings,
}
# Send emails
sent_count = 0
for recipient in email_recipients:
try:
# update context with this recipient
context["user"] = recipient
# Translate text to the recipient language settings
with override(recipient.wagtail_userprofile.get_preferred_language()):
# Get email subject and content
email_subject = render_to_string(template_subject, context).strip()
email_content = render_to_string(template_text, context).strip()
kwargs = {}
if getattr(settings, 'WAGTAILADMIN_NOTIFICATION_USE_HTML', False):
kwargs['html_message'] = render_to_string(template_html, context)
# Send email
send_mail(email_subject, email_content, [recipient.email], **kwargs)
sent_count += 1
except Exception:
logger.exception(
"Failed to send notification email '%s' to %s",
email_subject, recipient.email
)
return sent_count == len(email_recipients)
def account(request):
# Fetch the user and profile objects once and pass into each panel
# We need to use the same instances for all forms so they don't overwrite each other
user = request.user
profile = UserProfile.get_for_user(user)
# Panels
panels = [
NameEmailSettingsPanel(request, user, profile),
AvatarSettingsPanel(request, user, profile),
NotificationsSettingsPanel(request, user, profile),
LocaleSettingsPanel(request, user, profile),
ChangePasswordPanel(request, user, profile),
]
for fn in hooks.get_hooks("register_account_settings_panel"):
panel = fn(request, user, profile)
if panel and panel.is_active():
panels.append(panel)
panels = [panel for panel in panels if panel.is_active()]
# Get tabs and order them
tabs = list({panel.tab for panel in panels})
tabs.sort(key=lambda tab: tab.order)
# Get dict of tabs to ordered panels
panels_by_tab = OrderedDict([(tab, []) for tab in tabs])
for panel in panels:
panels_by_tab[panel.tab].append(panel)
for tab, tab_panels in panels_by_tab.items():
tab_panels.sort(key=lambda panel: panel.order)
panel_forms = [panel.get_form() for panel in panels]
if request.method == "POST":
if all(form.is_valid() or not form.is_bound for form in panel_forms):
with transaction.atomic():
for form in panel_forms:
if form.is_bound:
form.save()
log(user, "wagtail.edit")
# Prevent a password change from logging this user out
update_session_auth_hash(request, user)
# Override the language when creating the success message
# If the user has changed their language in this request, the message should
# be in the new language, not the existing one
with override(profile.get_preferred_language()):
messages.success(
request,
_("Your account settings have been changed successfully!"))
return redirect("wagtailadmin_account")
media = Media()
for form in panel_forms:
media += form.media
# Menu items
menu_items = []
for fn in hooks.get_hooks("register_account_menu_item"):
item = fn(request)
if item:
menu_items.append(item)
return TemplateResponse(
request,
"wagtailadmin/account/account.html",
{
"panels_by_tab": panels_by_tab,
"menu_items": menu_items,
"media": media,
},
)
def send_notification(page_revision_id, notification, excluded_user_id):
# Get revision
revision = PageRevision.objects.get(id=page_revision_id)
# Get list of recipients
if notification == 'submitted':
# Get list of publishers
include_superusers = getattr(
settings, 'WAGTAILADMIN_NOTIFICATION_INCLUDE_SUPERUSERS', True)
recipients = users_with_page_permission(revision.page, 'publish',
include_superusers)
elif notification in ['rejected', 'approved']:
# Get submitter
recipients = [revision.user]
else:
return False
# Get list of email addresses
email_recipients = [
recipient for recipient in recipients
if recipient.email and recipient.pk != excluded_user_id
and getattr(UserProfile.get_for_user(recipient), notification +
'_notifications')
]
# Return if there are no email addresses
if not email_recipients:
return True
# Get template
template_subject = 'wagtailadmin/notifications/' + notification + '_subject.txt'
template_text = 'wagtailadmin/notifications/' + notification + '.txt'
template_html = 'wagtailadmin/notifications/' + notification + '.html'
# Common context to template
context = {
"revision": revision,
"settings": settings,
}
# Send emails
sent_count = 0
for recipient in email_recipients:
try:
# update context with this recipient
context["user"] = recipient
# Translate text to the recipient language settings
with override(
recipient.wagtail_userprofile.get_preferred_language()):
# Get email subject and content
email_subject = render_to_string(template_subject,
context).strip()
email_content = render_to_string(template_text,
context).strip()
kwargs = {}
if getattr(settings, 'WAGTAILADMIN_NOTIFICATION_USE_HTML', False):
kwargs['html_message'] = render_to_string(
template_html, context)
# Send email
send_mail(email_subject, email_content, [recipient.email],
**kwargs)
sent_count += 1
except Exception:
logger.exception("Failed to send notification email '%s' to %s",
email_subject, recipient.email)
return sent_count == len(email_recipients)
