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})
