def handle(self, request):
return self.respond('sentry/account/security.html', {
'page': 'security',
'has_2fa': Authenticator.objects.user_has_2fa(request.user),
'AUTH_PROVIDERS': get_auth_providers(),
'has_newsletters': newsletter.is_enabled,
})
def login(request):
from django.conf import settings
if request.user.is_authenticated():
return login_redirect(request)
form = AuthenticationForm(request, request.POST or None,
captcha=bool(request.session.get('needs_captcha')))
if form.is_valid():
login_user(request, form.get_user())
request.session.pop('needs_captcha', None)
return login_redirect(request)
elif request.POST and not request.session.get('needs_captcha'):
request.session['needs_captcha'] = 1
form = AuthenticationForm(request, request.POST or None, captcha=True)
form.errors.pop('captcha', None)
request.session.set_test_cookie()
context = csrf(request)
context.update({
'form': form,
'next': request.session.get('_next'),
'CAN_REGISTER': settings.SENTRY_ALLOW_REGISTRATION or request.session.get('can_register'),
'AUTH_PROVIDERS': get_auth_providers(),
'SOCIAL_AUTH_CREATE_USERS': settings.SOCIAL_AUTH_CREATE_USERS,
})
return render_to_response('sentry/login.html', context, request)
def register(request):
from sentry.conf import settings
if not (settings.ALLOW_REGISTRATION
or request.session.get('can_register')):
return HttpResponseRedirect(reverse('sentry'))
form = RegistrationForm(request.POST or None)
if form.is_valid():
user = form.save()
# can_register should only allow a single registration
request.session.pop('can_register', None)
# HACK: grab whatever the first backend is and assume it works
user.backend = dj_settings.AUTHENTICATION_BACKENDS[0]
login_user(request, user)
return login_redirect(request)
return render_to_response(
'sentry/register.html', {
'form': form,
'AUTH_PROVIDERS': get_auth_providers(),
'SOCIAL_AUTH_CREATE_USERS': dj_settings.SOCIAL_AUTH_CREATE_USERS,
}, request)
def login(request):
from django.contrib.auth import login as login_
from django.contrib.auth.forms import AuthenticationForm
if request.user.is_authenticated():
return login_redirect(request)
form = AuthenticationForm(request, request.POST or None)
if form.is_valid():
login_(request, form.get_user())
return login_redirect(request)
else:
request.session.set_test_cookie()
AUTH_PROVIDERS = get_auth_providers()
context = csrf(request)
context.update({
'form':
form,
'next':
request.session.get('_next'),
'AUTH_PROVIDERS':
AUTH_PROVIDERS,
'SOCIAL_AUTH_CREATE_USERS':
dj_settings.SOCIAL_AUTH_CREATE_USERS,
})
return render_to_response('sentry/login.html', context, request)
def avatar_settings(request):
context = csrf(request)
context.update({
'page': 'avatar',
'AUTH_PROVIDERS': get_auth_providers(),
})
return render_to_response('sentry/account/avatar.html', context, request)
def handle(self, request):
if request.user.is_authenticated():
return self.redirect(get_login_redirect(request))
form = AuthenticationForm(request, request.POST or None, captcha=bool(request.session.get("needs_captcha")))
if form.is_valid():
login(request, form.get_user())
request.session.pop("needs_captcha", None)
return self.redirect(get_login_redirect(request))
elif request.POST and not request.session.get("needs_captcha"):
request.session["needs_captcha"] = 1
form = AuthenticationForm(request, request.POST or None, captcha=True)
form.errors.pop("captcha", None)
request.session.set_test_cookie()
context = {
"form": form,
"next": request.session.get("_next"),
"CAN_REGISTER": features.has("auth:register") or request.session.get("can_register"),
"AUTH_PROVIDERS": get_auth_providers(),
"SOCIAL_AUTH_CREATE_USERS": features.has("social-auth:register"),
}
return self.respond("sentry/login.html", context)
def handle(self, request):
return self.respond(
'sentry/account/security.html', {
'page': 'security',
'has_2fa': Authenticator.objects.user_has_2fa(request.user),
'AUTH_PROVIDERS': get_auth_providers(),
})
def register(request):
from django.conf import settings
if not (settings.SENTRY_ALLOW_REGISTRATION or request.session.get('can_register')):
return HttpResponseRedirect(reverse('sentry'))
form = RegistrationForm(request.POST or None,
captcha=bool(request.session.get('needs_captcha')))
if form.is_valid():
user = form.save()
# can_register should only allow a single registration
request.session.pop('can_register', None)
# HACK: grab whatever the first backend is and assume it works
user.backend = settings.AUTHENTICATION_BACKENDS[0]
login_user(request, user)
request.session.pop('needs_captcha', None)
return login_redirect(request)
elif request.POST and not request.session.get('needs_captcha'):
request.session['needs_captcha'] = 1
form = RegistrationForm(request.POST or None, captcha=True)
form.errors.pop('captcha', None)
return render_to_response('sentry/register.html', {
'form': form,
'AUTH_PROVIDERS': get_auth_providers(),
'SOCIAL_AUTH_CREATE_USERS': settings.SOCIAL_AUTH_CREATE_USERS,
}, request)
def manage_subscriptions(request):
user = request.user
email = UserEmail.get_primary_email(user)
if request.method == 'GET':
context = csrf(request)
context.update(
{
'page': 'subscriptions',
'email': email,
'AUTH_PROVIDERS': auth.get_auth_providers(),
'has_newsletters': newsletter.is_enabled,
'subscriptions': newsletter.get_subscriptions(user),
}
)
return render_to_response('sentry/account/subscriptions.html', context, request)
subscribed = request.POST.get('subscribed') == '1'
try:
list_id = int(request.POST.get('listId', ''))
except ValueError:
return HttpResponse('bad request', status=400)
kwargs = {
'list_id': list_id,
'subscribed': subscribed,
'verified': email.is_verified,
}
if not subscribed:
kwargs['unsubscribed_date'] = timezone.now()
else:
kwargs['subscribed_date'] = timezone.now()
newsletter.create_or_update_subscription(user, **kwargs)
return HttpResponse()
def login(request):
from django.contrib.auth import login as login_
from django.contrib.auth.forms import AuthenticationForm
if request.user.is_authenticated():
return login_redirect(request)
form = AuthenticationForm(request, request.POST or None)
if form.is_valid():
login_(request, form.get_user())
return login_redirect(request)
else:
request.session.set_test_cookie()
AUTH_PROVIDERS = get_auth_providers()
context = csrf(request)
context.update(
{
"form": form,
"next": request.session.get("_next"),
"AUTH_PROVIDERS": AUTH_PROVIDERS,
"SOCIAL_AUTH_CREATE_USERS": dj_settings.SOCIAL_AUTH_CREATE_USERS,
}
)
return render_to_response("sentry/login.html", context, request)
def appearance_settings(request):
from django.conf import settings
options = UserOption.objects.get_all_values(user=request.user, project=None)
form = AppearanceSettingsForm(
request.user,
request.POST or None,
initial={
'language': options.get('language') or request.LANGUAGE_CODE,
'stacktrace_order': int(options.get('stacktrace_order', -1) or -1),
'timezone': options.get('timezone') or settings.SENTRY_DEFAULT_TIME_ZONE,
'clock_24_hours': options.get('clock_24_hours') or False,
}
)
if form.is_valid():
form.save()
messages.add_message(request, messages.SUCCESS, 'Your settings were saved.')
return HttpResponseRedirect(request.path)
context = csrf(request)
context.update(
{
'form': form,
'page': 'appearance',
'AUTH_PROVIDERS': auth.get_auth_providers(),
'has_newsletters': newsletter.is_enabled,
}
)
return render_to_response('sentry/account/appearance.html', context, request)
def appearance_settings(request):
from django.conf import settings
options = UserOption.objects.get_all_values(user=request.user,
project=None)
form = AppearanceSettingsForm(
request.user,
request.POST or None,
initial={
'language': options.get('language') or request.LANGUAGE_CODE,
'stacktrace_order': int(options.get('stacktrace_order', -1) or -1),
'timezone': options.get('timezone')
or settings.SENTRY_DEFAULT_TIME_ZONE,
'clock_24_hours': options.get('clock_24_hours') or False,
})
if form.is_valid():
form.save()
messages.add_message(request, messages.SUCCESS,
'Your settings were saved.')
return HttpResponseRedirect(request.path)
context = csrf(request)
context.update({
'form': form,
'page': 'appearance',
'AUTH_PROVIDERS': auth.get_auth_providers(),
'has_newsletters': newsletter.is_enabled,
})
return render_to_response('sentry/account/appearance.html', context,
request)
def manage_subscriptions(request):
user = request.user
email = UserEmail.get_primary_email(user)
if request.method == 'GET':
context = csrf(request)
context.update({
'page': 'subscriptions',
'email': email,
'AUTH_PROVIDERS': auth.get_auth_providers(),
'has_newsletters': newsletter.is_enabled,
'subscriptions': newsletter.get_subscriptions(user),
})
return render_to_response('sentry/account/subscriptions.html', context,
request)
subscribed = request.POST.get('subscribed') == '1'
try:
list_id = int(request.POST.get('listId', ''))
except ValueError:
return HttpResponse('bad request', status=400)
kwargs = {
'list_id': list_id,
'subscribed': subscribed,
'verified': email.is_verified,
}
if not subscribed:
kwargs['unsubscribed_date'] = timezone.now()
else:
kwargs['subscribed_date'] = timezone.now()
newsletter.create_or_update_subscription(user, **kwargs)
return HttpResponse()
def login(request):
from django.contrib.auth.forms import AuthenticationForm
from sentry.conf import settings
if request.user.is_authenticated():
return login_redirect(request)
form = AuthenticationForm(request, request.POST or None)
if form.is_valid():
login_user(request, form.get_user())
return login_redirect(request)
request.session.set_test_cookie()
context = csrf(request)
context.update({
'form':
form,
'next':
request.session.get('_next'),
'CAN_REGISTER':
settings.ALLOW_REGISTRATION or request.session.get('can_register'),
'AUTH_PROVIDERS':
get_auth_providers(),
'SOCIAL_AUTH_CREATE_USERS':
dj_settings.SOCIAL_AUTH_CREATE_USERS,
})
return render_to_response('sentry/login.html', context, request)
def login(request):
from django.conf import settings
if request.user.is_authenticated():
return login_redirect(request)
form = AuthenticationForm(request, request.POST or None,
captcha=bool(request.session.get('needs_captcha')))
if form.is_valid():
login_user(request, form.get_user())
request.session.pop('needs_captcha', None)
return login_redirect(request)
elif request.POST and not request.session.get('needs_captcha'):
request.session['needs_captcha'] = 1
form = AuthenticationForm(request, request.POST or None, captcha=True)
form.errors.pop('captcha', None)
request.session.set_test_cookie()
context = csrf(request)
context.update({
'form': form,
'next': request.session.get('_next'),
'CAN_REGISTER': settings.SENTRY_ALLOW_REGISTRATION or request.session.get('can_register'),
'AUTH_PROVIDERS': get_auth_providers(),
'SOCIAL_AUTH_CREATE_USERS': settings.SOCIAL_AUTH_CREATE_USERS,
})
return render_to_response('sentry/login.html', context, request)
def handle(self, request):
if request.user.is_authenticated():
return self.redirect(get_login_redirect(request))
form = AuthenticationForm(request, request.POST or None,
captcha=bool(request.session.get('needs_captcha')))
if form.is_valid():
login(request, form.get_user())
request.session.pop('needs_captcha', None)
return self.redirect(get_login_redirect(request))
elif request.POST and not request.session.get('needs_captcha'):
request.session['needs_captcha'] = 1
form = AuthenticationForm(request, request.POST or None, captcha=True)
form.errors.pop('captcha', None)
request.session.set_test_cookie()
context = {
'form': form,
'next': request.session.get('_next'),
'CAN_REGISTER': settings.SENTRY_ALLOW_REGISTRATION or request.session.get('can_register'),
'AUTH_PROVIDERS': get_auth_providers(),
'SOCIAL_AUTH_CREATE_USERS': settings.SOCIAL_AUTH_CREATE_USERS,
}
return self.respond('sentry/login.html', context)
def settings(request):
form = AccountSettingsForm(request.user,
request.POST or None,
initial={
'email': request.user.email,
'username': request.user.username,
'name': request.user.name,
})
if form.is_valid():
old_email = request.user.email
user = form.save()
if user.email != old_email:
UserEmail.objects.get(user=request.user, email=old_email).delete()
try:
with transaction.atomic():
user_email = UserEmail.objects.create(user=user,
email=user.email)
except IntegrityError:
pass
else:
user_email.set_hash()
user_email.save()
user.send_confirm_emails()
messages.add_message(request, messages.SUCCESS,
'Your settings were saved.')
return HttpResponseRedirect(request.path)
context = csrf(request)
context.update({
'form': form,
'page': 'settings',
'has_2fa': Authenticator.objects.user_has_2fa(request.user),
'AUTH_PROVIDERS': get_auth_providers(),
})
return render_to_response('sentry/account/settings.html', context, request)
def settings(request):
form = AccountSettingsForm(request.user, request.POST or None, initial={
'email': request.user.email,
'username': request.user.username,
'name': request.user.name,
})
if form.is_valid():
old_email = request.user.email
user = form.save()
if user.email != old_email:
UserEmail.objects.get(user=request.user, email=old_email).delete()
try:
with transaction.atomic():
user_email = UserEmail.objects.create(user=user, email=user.email)
except IntegrityError:
pass
else:
user_email.set_hash()
user_email.save()
user.send_confirm_emails()
messages.add_message(request, messages.SUCCESS, 'Your settings were saved.')
return HttpResponseRedirect(request.path)
context = csrf(request)
context.update({
'form': form,
'page': 'settings',
'has_2fa': Authenticator.objects.user_has_2fa(request.user),
'AUTH_PROVIDERS': get_auth_providers(),
})
return render_to_response('sentry/account/settings.html', context, request)
def avatar_settings(request):
context = csrf(request)
context.update({
'page': 'avatar',
'AUTH_PROVIDERS': auth.get_auth_providers(),
})
return render_to_response('sentry/account/avatar.html', context, request)
def register(request):
from django.conf import settings
if not (features.has('auth:register') or request.session.get('can_register')):
return HttpResponseRedirect(reverse('sentry'))
form = RegistrationForm(request.POST or None,
captcha=bool(request.session.get('needs_captcha')))
if form.is_valid():
user = form.save()
# can_register should only allow a single registration
request.session.pop('can_register', None)
# HACK: grab whatever the first backend is and assume it works
user.backend = settings.AUTHENTICATION_BACKENDS[0]
login_user(request, user)
request.session.pop('needs_captcha', None)
return login_redirect(request)
elif request.POST and not request.session.get('needs_captcha'):
request.session['needs_captcha'] = 1
form = RegistrationForm(request.POST or None, captcha=True)
form.errors.pop('captcha', None)
return render_to_response('sentry/register.html', {
'form': form,
'AUTH_PROVIDERS': get_auth_providers(),
'SOCIAL_AUTH_CREATE_USERS': features.has('social-auth:register'),
}, request)
def register(request):
from sentry.conf import settings
if not (settings.ALLOW_REGISTRATION or request.session.get("can_register")):
return HttpResponseRedirect(reverse("sentry"))
form = RegistrationForm(request.POST or None)
if form.is_valid():
user = form.save()
# can_register should only allow a single registration
request.session.pop("can_register", None)
# HACK: grab whatever the first backend is and assume it works
user.backend = dj_settings.AUTHENTICATION_BACKENDS[0]
login_user(request, user)
return login_redirect(request)
return render_to_response(
"sentry/register.html",
{
"form": form,
"AUTH_PROVIDERS": get_auth_providers(),
"SOCIAL_AUTH_CREATE_USERS": dj_settings.SOCIAL_AUTH_CREATE_USERS,
},
request,
)
def login(request):
from django.contrib.auth.forms import AuthenticationForm
from sentry.conf import settings
if request.user.is_authenticated():
return login_redirect(request)
form = AuthenticationForm(request, request.POST or None)
if form.is_valid():
login_user(request, form.get_user())
return login_redirect(request)
request.session.set_test_cookie()
context = csrf(request)
context.update(
{
"form": form,
"next": request.session.get("_next"),
"CAN_REGISTER": settings.ALLOW_REGISTRATION or request.session.get("can_register"),
"AUTH_PROVIDERS": get_auth_providers(),
"SOCIAL_AUTH_CREATE_USERS": dj_settings.SOCIAL_AUTH_CREATE_USERS,
}
)
return render_to_response("sentry/login.html", context, request)
def notification_settings(request):
settings_form = NotificationSettingsForm(request.user, request.POST or None)
# TODO(dcramer): this is an extremely bad pattern and we need a more optimal
# solution for rendering this (that ideally plays well with the org data)
project_list = []
organization_list = Organization.objects.get_for_user(
user=request.user,
)
for organization in organization_list:
team_list = Team.objects.get_for_user(
user=request.user,
organization=organization,
)
for team in team_list:
project_list.extend(
Project.objects.get_for_user(
user=request.user,
team=team,
)
)
project_forms = [
(project, ProjectEmailOptionsForm(
project, request.user,
request.POST or None,
prefix='project-%s' % (project.id,)
))
for project in sorted(project_list, key=lambda x: (
x.team.name if x.team else None, x.name))
]
ext_forms = []
for plugin in plugins.all():
for form in safe_execute(plugin.get_notification_forms) or ():
form = safe_execute(form, plugin, request.user, request.POST or None, prefix=plugin.slug)
if not form:
continue
ext_forms.append(form)
if request.POST:
all_forms = list(itertools.chain(
[settings_form], ext_forms, (f for _, f in project_forms)
))
if all(f.is_valid() for f in all_forms):
for form in all_forms:
form.save()
messages.add_message(request, messages.SUCCESS, 'Your settings were saved.')
return HttpResponseRedirect(request.path)
context = csrf(request)
context.update({
'settings_form': settings_form,
'project_forms': project_forms,
'ext_forms': ext_forms,
'page': 'notifications',
'AUTH_PROVIDERS': get_auth_providers(),
})
return render_to_response('sentry/account/notifications.html', context, request)
def avatar_settings(request):
context = csrf(request)
context.update({
'page': 'avatar',
'AUTH_PROVIDERS': auth.get_auth_providers(),
'has_newsletters': newsletter.is_enabled,
})
return render_to_response('sentry/account/avatar.html', context, request)
def notification_settings(request):
settings_form = NotificationSettingsForm(request.user, request.POST
or None)
project_list = list(
Project.objects.filter(
team__organizationmemberteam__organizationmember__user=request.
user,
team__organizationmemberteam__is_active=True,
status=ProjectStatus.VISIBLE,
).distinct())
project_forms = [
(project,
ProjectEmailOptionsForm(project,
request.user,
request.POST or None,
prefix='project-%s' % (project.id, )))
for project in sorted(project_list,
key=lambda x: (x.team.name
if x.team else None, x.name))
]
ext_forms = []
for plugin in plugins.all():
for form in safe_execute(plugin.get_notification_forms,
_with_transaction=False) or ():
form = safe_execute(form,
plugin,
request.user,
request.POST or None,
prefix=plugin.slug,
_with_transaction=False)
if not form:
continue
ext_forms.append(form)
if request.POST:
all_forms = list(
itertools.chain([settings_form], ext_forms,
(f for _, f in project_forms)))
if all(f.is_valid() for f in all_forms):
for form in all_forms:
form.save()
messages.add_message(request, messages.SUCCESS,
'Your settings were saved.')
return HttpResponseRedirect(request.path)
context = csrf(request)
context.update({
'settings_form': settings_form,
'project_forms': project_forms,
'ext_forms': ext_forms,
'page': 'notifications',
'AUTH_PROVIDERS': get_auth_providers(),
})
return render_to_response('sentry/account/notifications.html', context,
request)
def list_identities(request):
from social_auth.models import UserSocialAuth
identity_list = list(UserSocialAuth.objects.filter(user=request.user))
AUTH_PROVIDERS = get_auth_providers()
context = csrf(request)
context.update({"identity_list": identity_list, "page": "identities", "AUTH_PROVIDERS": AUTH_PROVIDERS})
return render_to_response("sentry/account/identities.html", context, request)
def account_settings(request):
user = request.user
form = AccountSettingsForm(
user, request, request.POST or None,
initial={
'email': UserEmail.get_primary_email(user).email,
'username': user.username,
'name': user.name,
},
)
if form.is_valid():
old_email = user.email
form.save()
# remove previously valid email address
# TODO(dcramer): we should maintain validation here when we support
# multiple email addresses
if request.user.email != old_email:
UserEmail.objects.filter(user=user, email=old_email).delete()
try:
with transaction.atomic():
user_email = UserEmail.objects.create(
user=user,
email=user.email,
)
except IntegrityError:
pass
else:
user_email.set_hash()
user_email.save()
user.send_confirm_email_singular(user_email)
msg = _('A confirmation email has been sent to %s.') % user_email.email
messages.add_message(
request,
messages.SUCCESS,
msg)
messages.add_message(
request, messages.SUCCESS, _('Your settings were saved.'))
return HttpResponseRedirect(request.path)
context = csrf(request)
context.update({
'form': form,
'page': 'settings',
'has_2fa': Authenticator.objects.user_has_2fa(request.user),
'AUTH_PROVIDERS': auth.get_auth_providers(),
'email': UserEmail.get_primary_email(user),
'has_newsletters': newsletter.is_enabled,
})
return render_to_response('sentry/account/settings.html', context, request)
def handle(self, request):
settings_form = self.notification_settings_form(
request.user, request.POST or None)
reports_form = NotificationReportSettingsForm(
request.user, request.POST or None,
prefix='reports')
project_list = list(Project.objects.filter(
team__organizationmemberteam__organizationmember__user=request.user,
team__organizationmemberteam__is_active=True,
status=ProjectStatus.VISIBLE,
).distinct())
project_forms = [
(project, ProjectEmailOptionsForm(
project, request.user,
request.POST or None,
prefix='project-%s' % (project.id,)
))
for project in sorted(project_list, key=lambda x: (
x.organization.name, x.name))
]
ext_forms = []
for plugin in plugins.all():
for form in safe_execute(plugin.get_notification_forms, _with_transaction=False) or ():
form = safe_execute(form, plugin, request.user, request.POST or None, prefix=plugin.slug,
_with_transaction=False)
if not form:
continue
ext_forms.append(form)
if request.POST:
all_forms = list(itertools.chain(
[settings_form, reports_form],
ext_forms,
(f for _, f in project_forms)
))
if all(f.is_valid() for f in all_forms):
for form in all_forms:
form.save()
messages.add_message(request, messages.SUCCESS, 'Your settings were saved.')
return HttpResponseRedirect(request.path)
context = csrf(request)
context.update({
'settings_form': settings_form,
'project_forms': project_forms,
'reports_form': reports_form,
'ext_forms': ext_forms,
'page': 'notifications',
'AUTH_PROVIDERS': get_auth_providers(),
})
return render_to_response('sentry/account/notifications.html', context, request)
def list_identities(request):
identity_list = list(UserSocialAuth.objects.filter(user=request.user))
AUTH_PROVIDERS = auth.get_auth_providers()
context = csrf(request)
context.update({
'identity_list': identity_list,
'page': 'identities',
'AUTH_PROVIDERS': AUTH_PROVIDERS,
})
return render_to_response('sentry/account/identities.html', context, request)
def list_identities(request):
identity_list = list(UserSocialAuth.objects.filter(user=request.user))
AUTH_PROVIDERS = auth.get_auth_providers()
context = csrf(request)
context.update({
'identity_list': identity_list,
'page': 'identities',
'AUTH_PROVIDERS': AUTH_PROVIDERS,
})
return render_to_response('sentry/account/identities.html', context, request)
def settings(request):
form = AccountSettingsForm(request.user, request.POST or None, initial={
'email': request.user.email,
'username': request.user.username,
'name': request.user.name,
})
if form.is_valid():
form.save()
messages.add_message(request, messages.SUCCESS, 'Your settings were saved.')
return HttpResponseRedirect(request.path)
context = csrf(request)
context.update({
'form': form,
'page': 'settings',
'AUTH_PROVIDERS': get_auth_providers(),
})
return render_to_response('sentry/account/settings.html', context, request)
def notification_settings(request):
settings_form = NotificationSettingsForm(request.user, request.POST or None)
project_list = Project.objects.get_for_user(request.user, access=MEMBER_USER)
project_forms = [
(project, ProjectEmailOptionsForm(
project, request.user,
request.POST or None,
prefix='project-%s' % (project.id,)
))
for project in sorted(project_list, key=lambda x: (x.team.name, x.name))
]
ext_forms = []
for plugin in plugins.all():
for form in safe_execute(plugin.get_notification_forms) or ():
form = safe_execute(form, plugin, request.user, request.POST or None, prefix=plugin.slug)
if not form:
continue
ext_forms.append(form)
if request.POST:
all_forms = list(itertools.chain(
[settings_form], ext_forms, (f for _, f in project_forms)
))
if all(f.is_valid() for f in all_forms):
for form in all_forms:
form.save()
messages.add_message(request, messages.SUCCESS, 'Your settings were saved.')
return HttpResponseRedirect(request.path)
context = csrf(request)
context.update({
'settings_form': settings_form,
'project_forms': project_forms,
'ext_forms': ext_forms,
'page': 'notifications',
'AUTH_PROVIDERS': get_auth_providers(),
})
return render_to_response('sentry/account/notifications.html', context, request)
def login(request):
from django.conf import settings
from django.contrib.auth.forms import AuthenticationForm
if request.user.is_authenticated():
return login_redirect(request)
form = AuthenticationForm(request, request.POST or None)
if form.is_valid():
login_user(request, form.get_user())
return login_redirect(request)
request.session.set_test_cookie()
context = csrf(request)
context.update({
'form': form,
'next': request.session.get('_next'),
'CAN_REGISTER': settings.SENTRY_ALLOW_REGISTRATION or request.session.get('can_register'),
'AUTH_PROVIDERS': get_auth_providers(),
'SOCIAL_AUTH_CREATE_USERS': settings.SOCIAL_AUTH_CREATE_USERS,
})
return render_to_response('sentry/login.html', context, request)
def handle(self, request):
settings_form = self.notification_settings_form(
request.user, request.POST or None)
reports_form = NotificationReportSettingsForm(
request.user, request.POST or None,
prefix='reports')
org_list = list(Organization.objects.filter(
status=OrganizationStatus.VISIBLE,
member_set__user=request.user,
).distinct())
org_list = [
o for o in org_list if features.has(
'organizations:release-commits',
o,
actor=request.user
)
]
org_forms = [
(org, NotificationDeploySettingsForm(
request.user,
org,
request.POST or None,
prefix='deploys-org-%s' % (org.id,)
))
for org in sorted(org_list, key=lambda o: o.name)
]
project_list = list(Project.objects.filter(
team__organizationmemberteam__organizationmember__user=request.user,
team__organizationmemberteam__is_active=True,
status=ProjectStatus.VISIBLE,
).distinct())
project_forms = [
(project, ProjectEmailOptionsForm(
project, request.user,
request.POST or None,
prefix='project-%s' % (project.id,)
))
for project in sorted(project_list, key=lambda x: (
x.organization.name, x.name))
]
ext_forms = []
for plugin in plugins.all():
for form in safe_execute(plugin.get_notification_forms, _with_transaction=False) or ():
form = safe_execute(form, plugin, request.user, request.POST or None, prefix=plugin.slug,
_with_transaction=False)
if not form:
continue
ext_forms.append(form)
if request.POST:
all_forms = list(itertools.chain(
[settings_form, reports_form],
ext_forms,
(f for _, f in project_forms),
(f for _, f in org_forms)
))
if all(f.is_valid() for f in all_forms):
for form in all_forms:
form.save()
messages.add_message(request, messages.SUCCESS, 'Your settings were saved.')
return HttpResponseRedirect(request.path)
context = csrf(request)
context.update({
'settings_form': settings_form,
'project_forms': project_forms,
'org_forms': org_forms,
'reports_form': reports_form,
'ext_forms': ext_forms,
'page': 'notifications',
'AUTH_PROVIDERS': get_auth_providers(),
})
return render_to_response('sentry/account/notifications.html', context, request)
def has_auth_configured(self, **kwargs):
if not self.auth_provider:
return True
return self.auth_provider in get_auth_providers()
def show_emails(request):
user = request.user
emails = user.emails.all()
email_form = EmailForm(user, request.POST or None)
primary_email = UserEmail.get_primary_email(user)
alt_emails = emails.exclude(email=primary_email.email)
if 'remove' in request.POST:
email = request.POST.get('email')
del_email = UserEmail.objects.filter(user=user, email=email)
del_email.delete()
logger.info('user.email.remove',
extra={
'user_id': user.id,
'ip_address': request.META['REMOTE_ADDR'],
'email': email,
})
return HttpResponseRedirect(request.path)
if 'primary' in request.POST:
new_primary = request.POST['new_primary_email'].lower().strip()
if User.objects.filter(
Q(email__iexact=new_primary)
| Q(username__iexact=new_primary)).exclude(
id=user.id).exists():
messages.add_message(
request, messages.ERROR,
_("That email is already in use for another user"))
elif new_primary != user.email:
# update notification settings for those set to primary email with new primary email
alert_email = UserOption.objects.get_value(user=user,
key='alert_email')
if alert_email == user.email:
UserOption.objects.set_value(user=user,
key='alert_email',
value=new_primary)
options = UserOption.objects.filter(user=user, key='mail:email')
for option in options:
if option.value != user.email:
continue
option.value = new_primary
option.save()
has_new_username = user.email == user.username
user.email = new_primary
msg = _('Your settings were saved')
messages.add_message(request, messages.SUCCESS, msg)
if has_new_username and not User.objects.filter(
username__iexact=new_primary).exists():
user.username = user.email
user.save()
return HttpResponseRedirect(request.path)
if email_form.is_valid():
alternative_email = email_form.cleaned_data['alt_email'].lower().strip(
)
# check if this alternative email already exists for user
if alternative_email and not UserEmail.objects.filter(
user=user, email__iexact=alternative_email).exists():
# create alternative email for user
try:
with transaction.atomic():
new_email = UserEmail.objects.create(
user=user, email=alternative_email)
except IntegrityError:
pass
else:
new_email.set_hash()
new_email.save()
user.send_confirm_email_singular(new_email)
# Update newsletter subscription and mark as unverified
newsletter.update_subscription(
user=user,
verified=False,
)
logger.info('user.email.add',
extra={
'user_id': user.id,
'ip_address': request.META['REMOTE_ADDR'],
'email': new_email.email,
})
msg = _('A confirmation email has been sent to %s.'
) % new_email.email
messages.add_message(request, messages.SUCCESS, msg)
messages.add_message(request, messages.SUCCESS,
_('Your settings were saved.'))
return HttpResponseRedirect(request.path)
context = csrf(request)
context.update({
'email_form': email_form,
'primary_email': primary_email,
'alt_emails': alt_emails,
'page': 'emails',
'AUTH_PROVIDERS': auth.get_auth_providers(),
'has_newsletters': newsletter.is_enabled,
})
return render_to_response('sentry/account/emails.html', context, request)
def show_emails(request):
user = request.user
primary_email = UserEmail.get_primary_email(user)
alt_emails = user.emails.all().exclude(email=primary_email.email)
email_form = EmailForm(user, request.POST or None,
initial={
'primary_email': primary_email.email,
},
)
if 'remove' in request.POST:
email = request.POST.get('email')
del_email = UserEmail.objects.filter(user=user, email=email)
del_email.delete()
return HttpResponseRedirect(request.path)
if email_form.is_valid():
old_email = user.email
email_form.save()
if user.email != old_email:
useroptions = UserOption.objects.filter(user=user, value=old_email)
for option in useroptions:
option.value = user.email
option.save()
UserEmail.objects.filter(user=user, email=old_email).delete()
try:
with transaction.atomic():
user_email = UserEmail.objects.create(
user=user,
email=user.email,
)
except IntegrityError:
pass
else:
user_email.set_hash()
user_email.save()
user.send_confirm_emails()
alternative_email = email_form.cleaned_data['alt_email']
# check if this alternative email already exists for user
if alternative_email and not UserEmail.objects.filter(user=user, email=alternative_email):
# create alternative email for user
try:
with transaction.atomic():
new_email = UserEmail.objects.create(
user=user,
email=alternative_email
)
except IntegrityError:
pass
else:
new_email.set_hash()
new_email.save()
# send confirmation emails to any non verified emails
user.send_confirm_emails()
messages.add_message(
request, messages.SUCCESS, 'Your settings were saved.')
return HttpResponseRedirect(request.path)
context = csrf(request)
context.update({
'email_form': email_form,
'primary_email': primary_email,
'alt_emails': alt_emails,
'page': 'emails',
'AUTH_PROVIDERS': auth.get_auth_providers(),
})
return render_to_response('sentry/account/emails.html', context, request)
def show_emails(request):
user = request.user
emails = user.emails.all()
email_form = EmailForm(user, request.POST or None)
primary_email = UserEmail.get_primary_email(user)
alt_emails = emails.exclude(email=primary_email.email)
if 'remove' in request.POST:
email = request.POST.get('email')
del_email = UserEmail.objects.filter(user=user, email=email)
del_email.delete()
logger.info(
'user.email.remove',
extra={
'user_id': user.id,
'ip_address': request.META['REMOTE_ADDR'],
'email': email,
}
)
user.clear_lost_passwords()
return HttpResponseRedirect(request.path)
if 'primary' in request.POST:
new_primary = request.POST['new_primary_email'].lower().strip()
if User.objects.filter(Q(email__iexact=new_primary) | Q(username__iexact=new_primary)
).exclude(id=user.id).exists():
messages.add_message(
request, messages.ERROR, _("That email is already in use for another user")
)
elif new_primary != user.email:
new_primary_email = UserEmail.objects.get(user=user, email__iexact=new_primary)
if not new_primary_email.is_verified:
messages.add_message(
request, messages.ERROR, _(
"Cannot make an unverified address your primary email")
)
return HttpResponseRedirect(request.path)
# update notification settings for those set to primary email with new primary email
alert_email = UserOption.objects.get_value(user=user, key='alert_email')
if alert_email == user.email:
UserOption.objects.set_value(user=user, key='alert_email', value=new_primary)
options = UserOption.objects.filter(user=user, key='mail:email')
for option in options:
if option.value != user.email:
continue
option.value = new_primary
option.save()
has_new_username = user.email == user.username
user.email = new_primary
msg = _('Your settings were saved')
messages.add_message(request, messages.SUCCESS, msg)
if has_new_username and not User.objects.filter(username__iexact=new_primary).exists():
user.username = user.email
user.save()
user.clear_lost_passwords()
return HttpResponseRedirect(request.path)
if email_form.is_valid():
alternative_email = email_form.cleaned_data['alt_email'].lower().strip()
# check if this alternative email already exists for user
if alternative_email and not UserEmail.objects.filter(
user=user, email__iexact=alternative_email
).exists():
# create alternative email for user
try:
with transaction.atomic():
new_email = UserEmail.objects.create(user=user, email=alternative_email)
except IntegrityError:
pass
else:
new_email.set_hash()
new_email.save()
user.send_confirm_email_singular(new_email)
logger.info(
'user.email.add',
extra={
'user_id': user.id,
'ip_address': request.META['REMOTE_ADDR'],
'email': new_email.email,
}
)
msg = _('A confirmation email has been sent to %s.') % new_email.email
messages.add_message(request, messages.SUCCESS, msg)
user.clear_lost_passwords()
messages.add_message(request, messages.SUCCESS, _('Your settings were saved.'))
return HttpResponseRedirect(request.path)
context = csrf(request)
context.update(
{
'email_form': email_form,
'primary_email': primary_email,
'alt_emails': alt_emails,
'page': 'emails',
'AUTH_PROVIDERS': auth.get_auth_providers(),
'has_newsletters': newsletter.is_enabled,
}
)
return render_to_response('sentry/account/emails.html', context, request)
def has_auth_configured(self, **kwargs):
if not self.auth_provider:
return True
return self.auth_provider in get_auth_providers()
def show_emails(request):
user = request.user
primary_email = UserEmail.get_primary_email(user)
alt_emails = user.emails.all().exclude(email=primary_email.email)
email_form = EmailForm(
user,
request.POST or None,
initial={
'primary_email': primary_email.email,
},
)
if 'remove' in request.POST:
email = request.POST.get('email')
del_email = UserEmail.objects.filter(user=user, email=email)
del_email.delete()
return HttpResponseRedirect(request.path)
if email_form.is_valid():
old_email = user.email
email_form.save()
if user.email != old_email:
useroptions = UserOption.objects.filter(user=user, value=old_email)
for option in useroptions:
option.value = user.email
option.save()
UserEmail.objects.filter(user=user, email=old_email).delete()
try:
with transaction.atomic():
user_email = UserEmail.objects.create(
user=user,
email=user.email,
)
except IntegrityError:
pass
else:
user_email.set_hash()
user_email.save()
user.send_confirm_emails()
alternative_email = email_form.cleaned_data['alt_email']
# check if this alternative email already exists for user
if alternative_email and not UserEmail.objects.filter(
user=user, email=alternative_email):
# create alternative email for user
try:
with transaction.atomic():
new_email = UserEmail.objects.create(
user=user, email=alternative_email)
except IntegrityError:
pass
else:
new_email.set_hash()
new_email.save()
# send confirmation emails to any non verified emails
user.send_confirm_emails()
messages.add_message(request, messages.SUCCESS,
'Your settings were saved.')
return HttpResponseRedirect(request.path)
context = csrf(request)
context.update({
'email_form': email_form,
'primary_email': primary_email,
'alt_emails': alt_emails,
'page': 'emails',
'AUTH_PROVIDERS': auth.get_auth_providers(),
})
return render_to_response('sentry/account/emails.html', context, request)
def show_emails(request):
user = request.user
primary_email = UserEmail.get_primary_email(user)
alt_emails = user.emails.all().exclude(email=primary_email.email)
email_form = EmailForm(user, request.POST or None,
initial={
'primary_email': primary_email.email,
},
)
if 'remove' in request.POST:
email = request.POST.get('email')
del_email = UserEmail.objects.filter(user=user, email=email)
del_email.delete()
logger.info('user.email.remove', extra={
'user_id': user.id,
'ip_address': request.META['REMOTE_ADDR'],
'email': email,
})
return HttpResponseRedirect(request.path)
if email_form.is_valid():
old_email = user.email
email_form.save()
if user.email != old_email:
useroptions = UserOption.objects.filter(user=user, value=old_email)
for option in useroptions:
option.value = user.email
option.save()
UserEmail.objects.filter(user=user, email=old_email).delete()
try:
with transaction.atomic():
user_email = UserEmail.objects.create(
user=user,
email=user.email,
)
except IntegrityError:
pass
else:
user_email.set_hash()
user_email.save()
user.send_confirm_email_singular(user_email)
# Update newsletter subscription and mark as unverified
newsletter.update_subscription(
user=user,
verified=False,
)
logger.info('user.email.add', extra={
'user_id': user.id,
'ip_address': request.META['REMOTE_ADDR'],
'email': user_email.email,
})
msg = _('A confirmation email has been sent to %s.') % user_email.email
messages.add_message(
request,
messages.SUCCESS,
msg)
alternative_email = email_form.cleaned_data['alt_email']
# check if this alternative email already exists for user
if alternative_email and not UserEmail.objects.filter(user=user, email=alternative_email):
# create alternative email for user
try:
with transaction.atomic():
new_email = UserEmail.objects.create(
user=user,
email=alternative_email
)
except IntegrityError:
pass
else:
new_email.set_hash()
new_email.save()
# send confirmation emails to any non verified emails
user.send_confirm_email_singular(new_email)
logger.info('user.email.add', extra={
'user_id': user.id,
'ip_address': request.META['REMOTE_ADDR'],
'email': new_email.email,
})
msg = _('A confirmation email has been sent to %s.') % new_email.email
messages.add_message(
request,
messages.SUCCESS,
msg)
messages.add_message(
request, messages.SUCCESS, _('Your settings were saved.'))
return HttpResponseRedirect(request.path)
context = csrf(request)
context.update({
'email_form': email_form,
'primary_email': primary_email,
'alt_emails': alt_emails,
'page': 'emails',
'AUTH_PROVIDERS': auth.get_auth_providers(),
'has_newsletters': newsletter.is_enabled,
})
return render_to_response('sentry/account/emails.html', context, request)
def has_auth_configured(self, **kwargs):
from sentry.utils.auth import get_auth_providers # Django 1.9 setup issue
if not self.auth_provider:
return True
return self.auth_provider in get_auth_providers()
