def register(request): registered = False if request.method == 'POST': user_form = CustomUserCreationForm(data=request.POST) if user_form.is_valid(): user = user_form.save(commit=False) user.save() registered = True current_site = get_current_site(request) subject = 'Activate Your MySite Account' message = render_to_string( 'account_activation_email.html', { 'user': user, 'domain': current_site.domain, 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'token': account_activation_token.make_token(user), }) send_mail( subject, message, '*****@*****.**', [user.email], ) # user.email_user(subject, message) # return redirect('index') else: print(user_form.errors) else: user_form = CustomUserCreationForm() return render(request, 'signup.html', { 'user_form': user_form, 'registered': registered })
def post(self, request, *args, **kwargs): form = self.form_class( request.POST ) #request.POST will check if form has been filled and submitted and if request.FILES wiil check if photo has been choosen and submitted. if form.is_valid(): user = form.save(commit=False) user.is_active = False # Deactivate account till it is confirmed via email confirmation link when he registers for the first time. user.save() current_site = get_current_site(request) subject = 'Activate Your ParthBook Account' message = render_to_string( 'users/account_activation_email.html', { 'user': user, 'domain': current_site.domain, 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'token': account_activation_token.make_token(user), }) user.email_user(subject, message) messages.info(request, ( 'Please Confirm your email to complete registration. A confirmation link has been sent at your provided email address.' )) return redirect('login-page') return render(request, self.template_name, {'form': form})
def send_verification_email(user_first_name, email, user_id, domain): print('SENDING VERIFICATION EMAIL TO ', email) # TODO Move to .env, is this okay being passed as an arg? # domain = 'https://flyright-api.police.gatech.edu' uidb64 = urlsafe_base64_encode(force_bytes(user_id)) token = account_activation_token.make_token(username) # TODO Remove my email. Make an env variable setting to send 'cc's to the admin. receivers = [email, '*****@*****.**'] link = domain + """/user/activate/""" + uidb64 + """/""" + token sender = '*****@*****.**' message = """From: GTPD Flyright <*****@*****.**> To: """ + user_first_name + """ <""" + receivers[0] + """> Content-type: text/html Subject: GTPD Flyright Email Verification G'day, """ + username + """<br><br> Please click the link below to activate your GTPD Flyright account.<br><br> <a href=""" + link + """>Click here to validate</a><br><br> Kind Regards,<br> Flyright Team.<br> (Sent from tasks.py) """ try: smtpObj = smtplib.SMTP('outbound.mail.gatech.edu') smtpObj.sendmail(sender, receivers, message) print("Successfully sent email") except: print("Error: unable to send email")
def post(self, request, *args, **kwargs): form = self.form_class(request.POST) if form.is_valid(): user = form.save(commit=False) user.is_active = False # Deactivate account till it is confirmed user.save() current_site = get_current_site(request) subject = 'Activate Your MySite Account' message = render_to_string( 'users/account_activation_email.html', { 'user': user, 'domain': current_site.domain, 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'token': account_activation_token.make_token(user), }) user.email_user(subject, message) messages.success( request, ('Please Confirm your email to complete registration.')) return redirect('login') return render(request, self.template_name, {'form': form})
def register(request): """Generates the data for a user registration form which is displayed at /register Uses the register.html template.""" if request.method == 'POST': form = UserRegisterForm(request.POST) if form.is_valid(): user = form.save() user.is_active = False user.save() username = form.cleaned_data.get('username') u_id = user.pk current_site = get_current_site(request) send_mail(subject=f"Please verify your GOSH account", email_template_name= 'catalogue/emails/account_activation_email.txt', context={ 'user': user, 'site_url': current_site.domain, 'uid': urlsafe_base64_encode(force_bytes(u_id)).decode(), 'token': account_activation_token.make_token(user), }, from_email=EMAIL_HOST_USER, to_email=form.cleaned_data.get('email'), html_email_template_name= 'catalogue/emails/account_activation_email.html') return redirect('account_activation_sent') else: form = UserRegisterForm() return render(request, 'users/register.html', {'form': form})
def signup(request): if request.method == 'POST': form = SignUpForm(request.POST) if form.is_valid(): user = form.save() current_site = get_current_site(request) subject = "Activate your OpenPustakalay Account" message = render_to_string( 'users/account_activation.html', { 'user': user, 'domain': current_site.domain, 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'token': account_activation_token.make_token(user), }) user.email_user(subject, message) return redirect('accounts:account_activation_sent') else: form = SignUpForm() context = { "form": form, } return render(request, "users/signup.html", context=context)
def setUp(self): self.user = User.objects.create(first_name='Arthur', last_name='H', email='*****@*****.**') self.user.set_password('1234') self.user.save() self.token = account_activation_token.make_token(self.user) self.data1 = {'first_name': 'Thomas', 'last_name': 'Dutronc', 'email': '*****@*****.**', 'password1': '1234', 'password2': '1234'} self.data2 = {'email': '*****@*****.**', 'password': '******'}
def add_member(request): """ View meant to send an invitation email to an artist through Ajax request. The email will invite the user to click on a link in order to accept whether he/she desires to become member of the band. The link will be validated through `confirm_member` view. The POST request needs to contain following keys: `val`: the email of the artist that needs to be invited `band_id`: the id of the band for which this request is meant. The view response with a JSON containing following keys: `is_executed`: Boolean that tells whether the request executed succesfully. `reason`: contains a error message meant to inform the `user` or the `programmer` of the corresponding error. """ failure=__contains_failure(request, keys=['val']) if failure: return failure email= request.POST.get('val') user_toAdd=User.get_user(email, default=False) if not user_toAdd: return JsonResponse({'is_executed': False, 'reason': 'There is no user with that email address'}) if not user_toAdd.has_artistProfile(): return JsonResponse({'is_executed': False, 'reason': 'Invitation not sent. The user has currently no artist profile'}) band=Band.get_band(request.POST.get('band_id')) if band.is_member(user_toAdd):#tests whether user_toAdd is already an active member return JsonResponse({'is_executed': False, 'reason': 'The user is already member of the band'}) artistToAdd=user_toAdd.get_artist() if band.is_member(user_toAdd, only_active_members=False): #if this is true a Member instance already exists but the artistToAdd is an inactive member m=band.get_member(artistToAdd) else: #in this branch a Member instance don't exists m=band.add_member(role="Insert role specified", artist=artistToAdd, is_active=False) context={'user': user_toAdd, 'band': band, 'http_protocol': getHTTP_Protocol(), 'domain': get_current_site(request).domain, 'token': account_activation_token.make_token(user_toAdd), 'uid': urlsafe_base64_encode(force_bytes(user_toAdd.pk)).decode(), 'mid64': urlsafe_base64_encode(force_bytes(m.pk)).decode() } mail_subject=f"Invitation to Join {band.name}" mail_message_txt = render_to_string('musicians/messages/confirm_band_join.txt', context=context) user_toAdd.send_email(mail_subject=mail_subject, mail_message_txt=mail_message_txt) return JsonResponse({'is_executed': True, 'reason': 'An invitation was send succesfuly'})
def send_activation_email(request, user): site = get_current_site(request).domain uid = urlsafe_base64_encode(force_bytes(user.pk)) token = account_activation_token.make_token(user) url = "http://" + site + reverse("users:activate", args=(uid, token)) send_mail('Easy Jpg Email Verification', f'click here to confirm {url}.', '*****@*****.**', [user.email], fail_silently=False)
def new_mission_registered_email(username, email, user_id, domain): mail_subject = '[Icarus] New Mission Registered' message = render_to_string( 'new_mission_registered.html', { 'user': username, 'domain': domain, 'uid': urlsafe_base64_encode(force_bytes(user_id)).decode(), 'token': account_activation_token.make_token(username), }) email = EmailMessage(mail_subject, message, to=[email]) email.send()
def reset_password_email(username, email, user_id, domain): mail_subject = 'Reset Password' message = render_to_string( 'reset_password.html', { 'user': username, 'domain': domain, 'uid': urlsafe_base64_encode(force_bytes(user_id)).decode(), 'token': account_activation_token.make_token(username), }) email = EmailMessage(mail_subject, message, to=[email]) email.send()
def render_confirmation_email(user: CustomUser, domain: str) -> str: user_name = user.email if user.first_name in ["", " "] else user.first_name return render_to_string( "account_confirmation/confirmation_email.html", { "user_name": user_name, "domain": domain, "encoded_user_id": urlsafe_base64_encode(force_bytes(user.pk)), "token": account_activation_token.make_token(user), }, )
def test_activate(self): user = self.user user.is_active = False user.save() uid = urlsafe_base64_encode(force_bytes(user.pk)) token = account_activation_token.make_token(user) url = reverse('activate', kwargs={'uidb64': uid, 'token': token}) response = self.client.get(url) user.refresh_from_db() self.assertTrue(user.is_active) self.assertEqual(response.status_code, 302)
def send_verification_email(username, email, user_id, domain): mail_subject = 'Activate your Icarus Account' message = render_to_string( 'acc_active_email.html', { 'user': username, 'domain': domain, 'uid': urlsafe_base64_encode(force_bytes(user_id)).decode(), 'token': account_activation_token.make_token(username), }) email = EmailMessage(mail_subject, message, to=[email]) email.send()
def send_register_confirmation_email(user_id, domain, to_email): user = UserModel.objects.get(id=user_id) mail_subject = 'Activate your blog account.' message = render_to_string('users/acc_active_email.html', { 'user': user, 'domain': domain, 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'token': account_activation_token.make_token(user), }) msg = EmailMultiAlternatives(mail_subject, '', 'from_email', [to_email]) msg.attach_alternative(message, "text/html") msg.send()
def send_account_confirmation_email(request, user): # send account confirmation email current_site = get_current_site(request) mail_subject = 'Activate your account.' message = render_to_string( 'users/acc_active_email.html', { 'user': user, 'domain': current_site.domain, 'userid': user.pk, 'token': account_activation_token.make_token(user), }) to_email = user.email email = EmailMessage(mail_subject, message, to=[to_email]) email.send()
def send_reply_notification(msg, user, site): subject = msg.subject body = msg.body token = account_activation_token.make_token(user) uid = urlsafe_base64_encode(force_bytes(user.id)) to_email = [user.email] login_path = reverse("emaillogin", kwargs=dict(uidb64=uid, token=token)) login_url = f"https://{site}{login_path}" message = render_to_string("emails/reply_email.html", { "user": user, "body": body, "loginurl": login_url }) send_mail(subject, message, settings.DEFAULT_OWNER_EMAIL, to_email)
def prepare_to_save(self, request): data = request.data if self.avatar and data.get('avatar'): self.avatar.delete() if self.email != data.get('email'): from users.tokens import account_activation_token from core.tasks import send_confirmation_email self.email_confirmed = False email_token = account_activation_token.make_token(self) domain = get_current_site(request).domain send_confirmation_email.delay(user_pk=self.pk, domain=domain, token=email_token, user_email=data.get('email'))
def test_activate_view(client, django_user_model): path = reverse('activate', kwargs={'uidb64': 1, 'token': 1}) response = client.post(path, follow=True) assert response.status_code == 200 user = django_user_model.objects.create_user(username='******', password='******', email='*****@*****.**') token = account_activation_token.make_token(user) uid = urlsafe_base64_encode(force_bytes(user.id)) path = reverse('activate', kwargs={'uidb64': uid, 'token': token}) client.force_login(user) response = client.post(path, follow=True) assert response.status_code == 200
def test_registered_user_must_activate_account_by_activation_link(self): with freeze_time("2019-06-07 07:07:07"): self.assertEqual(CustomUser.objects.all().count(), 0) response = self._register_user_using_signup_view() self.assertEqual(response.status_code, 302) self.assertEqual(CustomUser.objects.get(email=self.user.email).is_active, False) user = CustomUser.objects.get(email=self.user.email) url = reverse( "activate", args=(urlsafe_base64_encode(force_bytes(user.pk)), account_activation_token.make_token(user)), ) response = self.client.get(path=url) self.assertEqual(response.status_code, 200) self.assertEqual(CustomUser.objects.get(email=self.user.email).is_active, True)
def user_register(request): registered = False if request.method == 'POST': user_form = UserForm(data=request.POST) profile_form = UserProfileForm(data=request.POST) if user_form.is_valid() and profile_form.is_valid(): user = user_form.save(commit=False) user.is_active = False user.set_password(user.password) user.save() profile = profile_form.save(commit=False) profile.user = user if 'picture' in request.FILES: profile.picture = request.FILES['picture'] if 'bio' in request.POST: profile.bio = request.POST['bio'] profile.save() registered = True # send account confirmation email current_site = get_current_site(request) mail_subject = 'Activate your account.' message = render_to_string( 'users/acc_active_email.html', { 'user': user, 'domain': current_site.domain, 'userid': user.pk, 'token': account_activation_token.make_token(user), }) to_email = user_form.cleaned_data.get('email') email = EmailMessage(mail_subject, message, to=[to_email]) email.send() else: print(user_form.errors, profile_form.errors) else: user_form = UserForm() profile_form = UserProfileForm() return render( request, 'users/register.html', { 'user_form': user_form, 'profile_form': profile_form, 'registered': registered })
def send_account_confirmation(request, user, to_email): subject = "Activate your Bookx account." token = account_activation_token.make_token(user) uid = urlsafe_base64_encode(force_bytes(user.pk)) message = render_to_string( "emails/acc_activate_email.html", { "user": user, "activate_url": request.build_absolute_uri( reverse("activate", kwargs=dict(uidb64=uid, token=token))), }, ) send_mail(subject, message, settings.DEFAULT_OWNER_EMAIL, to_email)
def send_activation_email(self, domain, user): try: mail_subject = 'Activate your account.' message = render_to_string('emails/activate_user.html', { 'user': user, 'domain': domain, 'uid': urlsafe_base64_encode(force_bytes(user['id'])), 'token': account_activation_token.make_token(user), }) to_email = user['email'] email = EmailMessage( mail_subject, message, to=[to_email] ) email.send() except AnymailRequestsAPIError as exc: self.retry(exc=exc, countdown=180)
def send_confirm_email(domain, user_pk): user = User.objects.get(pk=user_pk) context = { 'user': user.email, 'domain': domain, 'uid': urlsafe_base64_encode(force_bytes(user_pk)), 'token': account_activation_token.make_token(user) } confirm_message = render_to_string('users/account_confirm_email.html', context=context) send_mail(subject='CONFIRM YOUR ACCOUNT', message=confirm_message, html_message=confirm_message, from_email=settings.DEFAULT_FROM_EMAIL, recipient_list=[user.email], fail_silently=True)
def send_confirmation_mail(user_id, current_domain): UserModel = get_user_model() try: user = UserModel.objects.get(pk=user_id) mail_subject = 'Activate your account.' message = render_to_string( 'users/account_active_email.html', { 'user': user, 'domain': current_domain, 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'token': account_activation_token.make_token(user), }) send_email.delay(mail_subject, message, to=[user.email]) except UserModel.DoesNotExist: logging.warning( f"Tried to send verification email to non-existing user {user_id}") except KeyError as e: print(e)
def verification_email_send(user_pk): user = get_or_none(User, pk=user_pk) if not user: return url_params = { 'uid': urlsafe_base64_encode(force_bytes(user_pk)), 'token': account_activation_token.make_token(user) } url = "%s%s" % (Site.objects.get_current().domain, reverse_lazy('users:verify_email', kwargs=url_params)) ctx = { 'verify_url': url, } mail.send(user.email, 'noreply@doc_disco.com', template='Signup verification email', context=ctx)
def register(request): if request.method == 'POST': form = UserregisterForm(request.POST) email = request.POST['email'] if form.is_valid(): user = form.save(commit=False) user.is_active = False user.save() current_site = get_current_site(request) email_body = { 'user': user, 'domain': current_site.domain, 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'token': account_activation_token.make_token(user), } link = reverse('activate', kwargs={ 'uidb64': email_body['uid'], 'token': email_body['token'] }) email_subject = 'Activate your account' activate_url = 'http://' + current_site.domain + link email = EmailMessage( email_subject, 'Hi ' + user.first_name + ', Please the link below to activate your account \n' + activate_url, '*****@*****.**', [email], ) email.send(fail_silently=False) firstname = form.cleaned_data.get('first_name') messages.success( request, f'Your Account has been created! Please Confirm your email to complete registration.' + " " + firstname) return redirect('login') else: form = UserregisterForm() return render(request, 'users/register.html', {'form': form})
def post(self, request, *args, **kwargs): if request.user.is_authenticated: return redirect("home") form = self.form_class(request.POST) if form.is_valid(): if User.objects.filter( email=request.POST["email"].lower()).first(): messages.warning(request, _("User with this credential already exists")) return redirect("user:sign-up") user = form.save() user.refresh_from_db() # Email is case-insensitive user.email = user.email.lower() # Email isn't confirmed user.is_active = False # Profile created in signals user.profile.birth_date = form.cleaned_data.get("birth_date") user.save() content = render_to_string( "users/activation_email.html", { "user": user.first_name, "domain": get_current_site(request).domain, "uid": urlsafe_base64_encode(force_bytes(user.pk)), "token": account_activation_token.make_token(user), }) # Send a confirmation email send_email.delay(subject=str(_("Please Activate Your Account")), email=user.email, content=content) messages.success( request, _("Instructions for activating your account has been emailed to you" )) return redirect("home") return redirect("user:sign-up")
def post(request, *args, **kwargs): # noqa data = request.data user_serializer = RegisterUserSerializer(data=data) user_serializer.is_valid(raise_exception=True) user = User.objects.create_user(**user_serializer.data) notification_message = UserNotification.get_notification_text( UserNotification.SUCCESSFULLY_REGISTERED, username=user.username) UserNotification.objects.create( user=user, notification_type=UserNotification.SUCCESS, message=notification_message, purpose=UserNotification.SUCCESSFULLY_REGISTERED_PURPOSE) token = Token.objects.get(user=user) email_token = account_activation_token.make_token(user) domain = get_current_site(request).domain send_confirmation_email.delay(user_pk=user.id, domain=domain, token=email_token, user_email=user.email) # settings.BASE_DIR ToDo: add default image (situated in static folder) return Response(data={'auth_token': token.key})
def post(self, request, *args, **kwargs): # Get all the data input from the form form = self.form_class(request.POST) if form.is_valid(): # Save the data input from the form to create a new user user = form.save(commit=False) # Get the entered company # vgl. https://docs.djangoproject.com/en/2.2/topics/forms/ company = form.cleaned_data['company'] print('company (view): ', company) user.save() # Add the currently saved user to the company object so that # the given company and the user are related to each other company.user_set.add(user) print('all company`s users: ', company.user_set.all()) print('the users`s company: ', user.company) company.save() current_site = get_current_site(request) subject = 'Activate Your MySite Account' message = render_to_string( 'users/account_activation_email.html', { 'user': user, 'domain': current_site.domain, 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'token': account_activation_token.make_token(user), }) user.email_user(subject, message) messages.success( request, ('Please confirm your email to complete registration.')) return redirect('login') return render(request, self.template_name, {'form': form})