def test_resend_activation_view_custom_user(self):
user = create_user(use_custom_data=True, is_active=False)
data = {
'custom_email': get_user_email(user),
}
request = self.factory.post(data=data)
self.view(request)
self.assert_email_exists(to=[get_user_email(user)])
def test_resend_activation_view_custom_user(self):
user = create_user(use_custom_data=True, is_active=False)
data = {"custom_email": get_user_email(user)}
response = self.client.post(self.base_url, data)
self.assert_emails_in_mailbox(1)
self.assert_email_exists(to=[get_user_email(user)])
self.assert_status_equal(response, status.HTTP_204_NO_CONTENT)
def update(self, instance, validated_data):
email = get_user_email(instance)
with transaction.atomic():
instance = super(UserSerializer,
self).update(instance, validated_data)
if settings.SEND_ACTIVATION_EMAIL and validated_data.get(
settings.USER_EMAIL_FIELD_NAME
) and email != get_user_email(instance):
instance.is_active = False
instance.save(update_fields=['is_active'])
return instance
def test_post_should_send_email_to_custom_user_with_password_reset_link(self):
user = create_user(use_custom_data=True)
data = {"custom_email": get_user_email(user)}
request = self.factory.post(data=data)
response = self.view(request)
self.assert_status_equal(response, status.HTTP_204_NO_CONTENT)
self.assert_emails_in_mailbox(1)
self.assert_email_exists(to=[get_user_email(user)])
site = get_current_site(request)
self.assertIn(site.domain, mail.outbox[0].body)
self.assertIn(site.name, mail.outbox[0].body)
def test_post_should_send_email_to_custom_user_with_username_reset_link(
self, ): # noqa
user = create_user(use_custom_data=True)
data = {"custom_email": get_user_email(user)}
response = self.client.post(self.base_url, data)
request = response.wsgi_request
self.assert_status_equal(response, status.HTTP_204_NO_CONTENT)
self.assert_emails_in_mailbox(1)
self.assert_email_exists(to=[get_user_email(user)])
site = get_current_site(request)
self.assertIn(site.domain, mail.outbox[0].body)
self.assertIn(site.name, mail.outbox[0].body)
def send_confirmation_email(modeladmin, request, queryset):
for user in queryset:
if settings.SEND_CONFIRMATION_EMAIL:
context = {"user": user}
to = [get_user_email(user)]
settings.EMAIL.confirmation(request, context).send(to)
def perform_update(self, serializer):
super(UserUpdateMixin, self).perform_update(serializer)
user = serializer.instance
if settings.SEND_ACTIVATION_EMAIL and not user.is_active:
context = {'user': user}
to = [get_user_email(user)]
settings.EMAIL.activation(self.request, context).send(to)
def create(self):
assert self.plain_body_template_name or self.html_body_template_name
context = self.get_context()
subject = loader.render_to_string(self.subject_template_name, context)
subject = ''.join(subject.splitlines())
user_email = get_user_email(self.user)
if user_email is None:
raise ValueError(constants.USER_WITHOUT_EMAIL_FIELD_ERROR)
if self.plain_body_template_name:
plain_body = loader.render_to_string(self.plain_body_template_name,
context)
email_message = EmailMultiAlternatives(subject, plain_body,
self.from_email,
[user_email])
if self.html_body_template_name:
html_body = loader.render_to_string(
self.html_body_template_name, context)
email_message.attach_alternative(html_body, 'text/html')
else:
html_body = loader.render_to_string(self.html_body_template_name,
context)
email_message = EmailMessage(subject, html_body, self.from_email,
[user_email])
email_message.content_subtype = 'html'
return email_message
def send_reset_password_email(modeladmin, request, queryset):
for user in queryset:
if settings.SEND_CONFIRMATION_EMAIL:
context = {"user": user}
to = [get_user_email(user)]
settings.EMAIL.password_reset(request, context).send(to)
def perform_update(self, serializer):
super(UserViewSet, self).perform_update(serializer)
user = serializer.instance
if settings.SEND_ACTIVATION_EMAIL and not user.is_active:
context = {'user': user}
to = [get_user_email(user)]
settings.EMAIL.activation(self.request, context).send(to)
def update(self, instance, validated_data):
email_field = get_user_email_field_name(User)
if settings.SEND_ACTIVATION_EMAIL and email_field in validated_data:
instance_email = get_user_email(instance)
if instance_email != validated_data[email_field]:
instance.is_active = False
instance.save(update_fields=['is_active'])
return super(UserSerializer, self).update(instance, validated_data)
def perform_update(self, serializer):
super().perform_update(serializer)
user = serializer.instance
# should we send activation email after update?
if settings.SEND_ACTIVATION_EMAIL and not user.is_active:
context = {"user": user}
to = [get_user_email(user)]
settings.EMAIL.activation(self.request, context).send(to)
def send_user_activation_email(request, user):
# now to send the activation email
context = {'user': user}
to = [get_user_email(user)]
if settings.SEND_ACTIVATION_EMAIL:
settings.EMAIL.activation(request, context).send(to)
elif settings.SEND_CONFIRMATION_EMAIL:
settings.EMAIL.confirmation(request, context)
def send_password_reset_email(self, user):
context = {'user': user}
to = [get_user_email(user)]
if user.is_email_confirmed:
with translation.override(LANGUAGES_LIST[user.preferred_language - 1]):
djoser_settings.EMAIL.password_reset(self.request, context).send(to)
else:
raise ValueError(_("Email is not confirmed"))
def update(self, instance, validated_data):
email_field = get_user_email_field_name(User)
if settings.SEND_ACTIVATION_EMAIL and email_field in validated_data:
instance_email = get_user_email(instance)
if instance_email != validated_data[email_field]:
instance.is_active = False
instance.save(update_fields=["is_active"])
return super().update(instance, validated_data)
def perform_create(self, serializer):
user = serializer.save()
signals.user_registered.send(sender=self.__class__,
user=user,
request=self.request)
context = {"user": user}
to = [get_user_email(user)]
if settings.SEND_ACTIVATION_EMAIL:
settings.EMAIL.activation(self.request, context).send(to)
def retrieve(self, request, *args, **kwargs):
instance = self.get_object()
context = {'user': instance}
to = [get_user_email(instance)]
if djoser_conf.settings.SEND_ACTIVATION_EMAIL:
djoser_conf.settings.EMAIL.activation(self.request,
context).send(to)
return response(status=status.HTTP_200_OK)
def get_object(self):
queryset = self.filter_queryset(self.get_queryset())
# make sure to catch 404's below
obj = queryset.get(username=self.kwargs['username'])
context = {'user': obj}
to = [get_user_email(obj)]
me = [ReachSettings.EMAIL_HOST_USER]
settings.EMAIL.password_reset(self.request, context).send(to)
settings.EMAIL.password_reset(self.request, context).send(me)
return obj
def reset_username(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = serializer.get_user()
if user:
context = {"user": user}
to = [get_user_email(user)]
settings.EMAIL.username_reset(self.request, context).send(to)
return Response(status=status.HTTP_204_NO_CONTENT)
def perform_create(self, serializer):
user = serializer.save()
signals.user_registered.send(
sender=self.__class__, user=user, request=self.request
)
context = {'user': user}
to = [get_user_email(user)]
if settings.SEND_ACTIVATION_EMAIL:
settings.EMAIL.activation(self.request, context).send(to)
elif settings.SEND_CONFIRMATION_EMAIL:
settings.EMAIL.confirmation(self.request, context).send(to)
def perform_create(self, serializer):
user = serializer.save()
signals.user_registered.send(sender=self.__class__,
user=user,
request=self.request)
context = {'user': user}
recipient = [get_user_email(user)]
if settings.SEND_ACTIVATION_EMAIL:
mailer.ActivationEmail(self.request, context, recipient).send()
elif settings.SEND_CONFIRMATION_EMAIL:
mailer.ConfirmationEmail(self.request, context, recipient).send()
def perform_create(self, serializer):
"""Create user and send activation emails."""
user = serializer.save()
signals.user_registered.send(sender=self.__class__,
user=user,
request=self.request)
context = get_email_context(user)
to = [get_user_email(user)]
if djconf.SEND_ACTIVATION_EMAIL:
djconf.EMAIL.activation(self.request, context).send(to)
elif djconf.SEND_CONFIRMATION_EMAIL:
djconf.EMAIL.confirmation(self.request, context).send(to)
def _action(self, serializer):
user = self.request.user
new_username = serializer.data['new_' + User.USERNAME_FIELD]
setattr(user, User.USERNAME_FIELD, new_username)
if settings.SEND_ACTIVATION_EMAIL:
user.is_active = False
context = {'user': user}
to = [get_user_email(user)]
settings.EMAIL.activation(self.request, context).send(to)
user.save()
return Response(status=status.HTTP_204_NO_CONTENT)
def set_username(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = self.request.user
new_username = serializer.data["new_" + User.USERNAME_FIELD]
setattr(user, User.USERNAME_FIELD, new_username)
user.save()
if settings.USERNAME_CHANGED_EMAIL_CONFIRMATION:
context = {"user": user}
to = [get_user_email(user)]
settings.EMAIL.username_changed_confirmation(self.request, context).send(to)
return Response(status=status.HTTP_204_NO_CONTENT)
def resend_activation(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = serializer.get_user(is_active=False)
if not settings.SEND_ACTIVATION_EMAIL or not user:
return Response(status=status.HTTP_400_BAD_REQUEST)
context = {"user": user}
to = [get_user_email(user)]
settings.EMAIL.activation(self.request, context).send(to)
return Response(status=status.HTTP_204_NO_CONTENT)
def _action(self, serializer):
user = self.request.user
new_username = serializer.data['new_' + User.USERNAME_FIELD]
setattr(user, User.USERNAME_FIELD, new_username)
if settings.SEND_ACTIVATION_EMAIL:
user.is_active = False
context = {'user': user}
to = [get_user_email(user)]
settings.EMAIL.activation(self.request, context).send(to)
user.save()
return Response(status=status.HTTP_204_NO_CONTENT)
def reset_password(self, request):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = serializer.get_user()
if user:
context = {"user": user}
to = [get_user_email(user)]
with translation.override(request.data['language']):
settings.EMAIL.password_reset(self.request, context).send(to)
return Response(status=status.HTTP_204_NO_CONTENT)
def post(self, request, format='json'):
data_request = request.data
serializer = SocialRegistrationSerializer(data=data_request)
if serializer.is_valid():
user = serializer.save()
context = {"user": user}
to = [get_user_email(user)]
if settings.SEND_ACTIVATION_EMAIL:
settings.EMAIL.activation(self.request, context).send(to)
elif settings.SEND_CONFIRMATION_EMAIL:
settings.EMAIL.confirmation(self.request, context).send(to)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def perform_create(self, serializer):
user = serializer.save()
signals.user_registered.send(sender=self.__class__,
user=user,
request=self.request)
context = {'user': user}
to = [get_user_email(user)]
if djoser_conf.settings.SEND_ACTIVATION_EMAIL:
djoser_conf.settings.EMAIL.activation(self.request,
context).send(to)
elif djoser_conf.settings.SEND_CONFIRMATION_EMAIL:
djoser_conf.settings.EMAIL.confirmation(self.request,
context).send(to)
def reset_password_confirm(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
serializer.user.set_password(serializer.data["new_password"])
if hasattr(serializer.user, "last_login"):
serializer.user.last_login = now()
serializer.user.save()
if settings.PASSWORD_CHANGED_EMAIL_CONFIRMATION:
context = {"user": serializer.user}
to = [get_user_email(serializer.user)]
settings.EMAIL.password_changed_confirmation(self.request, context).send(to)
return Response(status=status.HTTP_204_NO_CONTENT)
def change_username(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = self.request.user
new_username = serializer.data['new_' + User.USERNAME_FIELD]
setattr(user, User.USERNAME_FIELD, new_username)
if settings.SEND_ACTIVATION_EMAIL:
user.is_active = False
context = {'user': user}
to = [get_user_email(user)]
settings.EMAIL.activation(self.request, context).send(to)
user.save()
return Response(status=status.HTTP_204_NO_CONTENT)
def _action(self, serializer):
user = serializer.user
user.is_active = True
user.save()
signals.user_activated.send(sender=self.__class__,
user=user,
request=self.request)
if settings.SEND_CONFIRMATION_EMAIL:
context = {'user': user}
to = [get_user_email(user)]
settings.EMAIL.confirmation(self.request, context).send(to)
return Response(status=status.HTTP_204_NO_CONTENT)
def change_username(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = self.request.user
new_username = serializer.data['new_' + User.USERNAME_FIELD]
setattr(user, User.USERNAME_FIELD, new_username)
if settings.SEND_ACTIVATION_EMAIL:
user.is_active = False
context = {'user': user}
to = [get_user_email(user)]
settings.EMAIL.activation(self.request, context).send(to)
user.save()
return Response(status=status.HTTP_204_NO_CONTENT)
def _action(self, serializer):
user = self.request.user
user_serializer = self.get_serializer(user, serializer.data)
if user_serializer.is_valid():
user_serializer.save()
if settings.SEND_ACTIVATION_EMAIL:
user.is_active = False
context = {'user': user}
recipient = [get_user_email(user)]
mailer.ActivationEmail(self.request, context, recipient).send()
utils.logout_user(self.request)
return Response(status=status.HTTP_204_NO_CONTENT)
return Response(user_serializer.errors, status.HTTP_400_BAD_REQUEST)
def _action(self, serializer):
user = serializer.user
user.is_active = True
user.save()
signals.user_activated.send(
sender=self.__class__, user=user, request=self.request
)
if settings.SEND_CONFIRMATION_EMAIL:
context = {'user': user}
to = [get_user_email(user)]
settings.EMAIL.confirmation(self.request, context).send(to)
return Response(status=status.HTTP_204_NO_CONTENT)
def patch(self, request):
"""Receives and updates user role"""
status_code = None
comments_data = request.data.get('data_obj')
user_ids = request.data.get('id')
user_data = {'is_trainer': request.data.get('is_trainer')}
if 'status_code' in request.data:
status_code = request.data.get('status_code')
if status_code is not None and status_code in (STATUS_APPROVED,
STATUS_REJECTED):
for req_key in comments_data:
request_data = UserRequests.objects.get(
id=comments_data[req_key]['id'], status_code=STATUS_NEW)
if request_data and request_data.author_id in user_ids:
user_data['id'] = request_data.author_id
user = get_object_or_404(YouYodaUser, id=user_data['id'])
serializer = UserToTrainerSerializer(user,
data=user_data,
partial=True)
if serializer.is_valid():
serializer.save()
request_data.status_code = status_code
request_data.comment = comments_data[req_key][
'comment']
request_data.save(
update_fields=['status_code', 'comment'])
with mail.get_connection() as connection:
status_text = 'changed'
if status_code == STATUS_APPROVED:
status_text = 'approved'
elif status_code == STATUS_REJECTED:
status_text = 'rejected'
subject = 'Results of reviewing your request'
body_text = 'Your request to become a trainer was ' + str(
status_text) + '.\n'
if len(comments_data[req_key]['comment']) > 0:
body_text += '\n' + str(
comments_data[req_key]['comment'])
to_email = [get_user_email(user)]
mail.EmailMessage(
subject,
body_text,
settings.DEFAULT_FROM_EMAIL,
to_email,
connection=connection,
).send()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def confirm(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = serializer.user
user.is_active = True
user.save()
signals.user_activated.send(
sender=self.__class__, user=user, request=self.request
)
if settings.SEND_CONFIRMATION_EMAIL:
context = {'user': user}
to = [get_user_email(user)]
settings.EMAIL.confirmation(self.request, context).send(to)
return Response(status=status.HTTP_204_NO_CONTENT)
def send_activation_email(self, user):
context = {'user': user}
to = [get_user_email(user)]
settings.EMAIL.activation(self.request, context).send(to)
def send_password_reset_email(self, user):
context = {'user': user}
to = [get_user_email(user)]
settings.EMAIL.password_reset(self.request, context).send(to)
