def signup(request):
status = False
if request.method == 'POST':
form = SignUpForm(request.POST)
if form.is_valid():
user = form.save(commit=False)
user.is_active = status
user.save()
if status == False: #IF ACTIVE STATUS FALSE IT WILL SEND MAIL TO THE USER TO ACTIVATE
current_site = get_current_site(request)
subject = 'Activate Your MySite Account'
message = render_to_string(
'account/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) #MAIL SEND HERE
return render(request, 'account/account_activation_sent.html',
{'Title': 'Activate Account'})
else:
messages.success(request,
"Your account is Created sucessfully..!")
return redirect('login')
else: # redirect signup form
form = SignUpForm()
return render(request, 'account/signup.html', {
'form': form,
'Title': 'Sign up'
})
def register(request):
if request.method == 'POST':
form = AccountForm(request.POST)
if form.is_valid():
email = form.cleaned_data['email']
password = form.cleaned_data['password1']
form.save()
user = authenticate(username=email, password=password)
current_site = get_current_site(request)
subject = 'Activate Your Phytochem Database Account'
message = render_to_string(
'email_verification/email_verification.html', {
'user': user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': account_activation_token.make_token(user),
})
user.is_active = False
user.save()
if user.email_user(subject, message) == 1:
messages.success(
request,
'Please check your email and confirm the link to complete registration.'
)
else:
messages.warning(request, 'Failed to confirm email')
return redirect('user:register')
else:
return render(request, 'account/register.html', {'form': form})
else:
form = AccountForm()
return render(request, 'account/register.html', {'form': form})
def signup(request):
if request.method == 'POST':
form = SignUpForm(request.POST)
if form.is_valid():
user = form.save(commit=False)
user.is_active = False
user.save()
current_site = get_current_site(request)
mail_subject = 'فعالسازی حساب کاربری'
message = render_to_string(
'registration/activate_account.html', {
'user': user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': account_activation_token.make_token(user),
})
to_email = form.cleaned_data.get('email')
email = EmailMessage(mail_subject, message, to=[to_email])
email.send()
return render(request, 'registration/activation_confirm.html')
else:
form = SignUpForm()
if request.user.is_authenticated:
print(check_password('m1419844322', request.user.password))
return render(request, 'registration/register.html', {'form': form})
def activate_account(user, request):
try:
to = user.email
uid = str(urlsafe_base64_encode(force_bytes(user.pk)))
uid = uid[2:len(uid)-1]
data = {'domain_fron': 'app.ezonseller.com',
'url': settings.URL,
#'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'uid': uid,
'token': account_activation_token.make_token(user),
'username': user.username,
'msg': 'Account verification'
}
subject, from_email = data['msg'], EMAIL_HOST_USER
text_content = render_to_string("email/user_verification.html", data)
html_content = render_to_string("email/user_verification.html", data)
send = EmailMultiAlternatives(subject, text_content, from_email, [to],
headers={'From': 'Ezonseller <'+from_email+'>',
'Reply-to': 'Ezonseller <'+from_email+'>'})
send.attach_alternative(html_content, "text/html")
send.send()
return True
except Exception as e:
print(e)
return False
def register(request):
if request.method == 'POST':
user_form = UserRegistrationForm(request.POST)
if user_form.is_valid():
new_user = user_form.save(commit=False)
new_user.set_password(
user_form.cleaned_data['password']
)
new_user.is_active = False
new_user.save()
current_site = get_current_site(request)
subject = 'Activate Your Gurustack Account'
message = render_to_string('email/account_activation_email.html', {
'user': new_user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(new_user.pk)),
'token': account_activation_token.make_token(new_user),
})
new_user.email_user(subject, message)
messages.success(request, 'Please confirm your email to complete registration')
form = LoginForm
return render(request, 'registration/login.html', {'html_title': 'Gurustack_Login',
'form': form})
else:
messages.error(request, f'{user_form.errors}')
return redirect('account:register')
# raise user_form.errors
else:
form = UserRegistrationForm()
return render(request, 'account/register.html', {'html_title': 'Join Gurustack Now',
'form': form})
def forgotPasswordView(request):
template_name = 'account/forgotpass.html'
form = MyForgotPassForm()
context = {}
context['form'] = form
if request.method == "POST":
form = MyForgotPassForm(request.POST)
print("inside post")
print(form.errors)
if form.is_valid():
print("inside is valid forgot")
to_email = form.cleaned_data.get('email')
print("to email : ", to_email)
user = Account.objects.get(email=to_email)
current_site = get_current_site(request)
mail_subject = "Reset Password"
message = render_to_string('account/pass_reset_email.html', {
'user': user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': account_activation_token.make_token(user),
})
email = EmailMessage(
mail_subject, message, to=[to_email]
)
email.send()
print("forgot pass email send")
return redirect("forgotConfirm")
else:
print("email send failed forgot")
context['form'] = form
return render(request, template_name, context)
return render(request, template_name, context)
def register_view(request):
"""
register here... send email verification link..
"""
template_name = 'account/registration.html'
context = {}
form = RegistrationForm()
context['form'] = form
if request.method == 'POST':
form = RegistrationForm(data=request.POST,
files=request.FILES)
if form.is_valid():
print("isvalid")
user = form.save(commit=False)
user.is_active = False
user.save()
current_site = get_current_site(request)
mail_subject = 'Activate your account.'
message = render_to_string('account/acc_active_email.html', {
'user': user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': account_activation_token.make_token(user),
})
print("user.PK value", user.pk)
print(urlsafe_base64_encode(force_bytes(user.pk)))
print(account_activation_token.make_token(user))
to_email = form.cleaned_data.get('email')
email = EmailMessage(
mail_subject, message, to=[to_email]
)
email.send()
print("email sent success")
return redirect("regconfirm")
else:
print("email sent failed")
print("invalid else POST method")
context['form'] = form
return render(request, 'account/registration.html', context)
return render(request, template_name, context)
def register(request):
if request.method == 'POST':
first_name = request.POST['first_name']
username = request.POST['username']
password1 = request.POST['password1']
password2 = request.POST['password2']
email = request.POST['email']
if password1 == password2:
if User.objects.filter(username=username).exists():
messages.info(request, 'Username Taken')
return redirect('register')
elif User.objects.filter(email=email).exists():
messages.info(request, 'Email Taken')
return redirect('register')
else:
user = User.objects.create_user(username=username,
password=password1,
email=email,
first_name=first_name)
user.is_active = False
user.save()
current_site = get_current_site(request)
subject = 'Activate Your Account'
message = render_to_string(
'activate_account.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,
EMAIL_HOST_USER,
[email],
fail_silently=False,
)
return redirect('login')
else:
messages.info(request, 'password not matching..')
return redirect('register')
return redirect('/')
else:
return render(request, 'register.html')
def post(self, request):
form = PlayerRegistrationForm(request.POST)
group = Group.objects.get(name='Piłkarze')
if form.is_valid():
new_user = form.save(commit=False)
new_user.set_password(form.cleaned_data['password'])
new_user.is_active = False
new_user.save()
group.user_set.add(new_user)
current_site = get_current_site(request)
mail_subject = 'Aktywacja konta w Akademii Piłkarskiej Hutnika Kraków.'
message = render_to_string(
'account/acc_active_email.html',
{
'user': new_user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(new_user.id)),
# 'uid': form.cleaned_data['username'],
'token': account_activation_token.make_token(new_user),
})
to_email = form.cleaned_data.get('email')
message = strip_tags(message)
email = EmailMessage(mail_subject, message, to=[to_email])
email.send()
my_profile = Profile()
my_profile.user = new_user
my_profile.role = 0
my_profile.date_of_birth = form.cleaned_data['date_of_birth']
my_profile.phone_number = form.cleaned_data['phone_number']
my_profile.team = form.cleaned_data['team']
my_profile.position = form.cleaned_data['position']
my_profile.slug = slugify(new_user.first_name + "-" +
new_user.last_name)
my_profile.rodo = form.cleaned_data['rodo']
my_profile.save()
return render(request,
"registration/activate_send.html",
context={
'user': new_user,
})
else:
PlayerRegistrationForm()
messages.error(request,
'Wystąpił błąd podczas rejestracji użytkownika.')
return render(request,
"account/register_player.html",
context={
'form': form,
})
def registration_view(request):
if request.method == 'POST':
data = {}
email = request.data.get('email', '0').lower()
if validate_email(email) != None:
data['error_message'] = 'That email is already in use.'
data['response'] = 'Error'
data['key'] = 'email.inuse'
return Response(data, status=status.HTTP_422_UNPROCESSABLE_ENTITY)
username = request.data.get('username', '0')
if validate_username(username) != None:
data['error_message'] = 'That username is already in use.'
data['response'] = 'Error'
data['key'] = 'username.inuse'
return Response(data, status=status.HTTP_422_UNPROCESSABLE_ENTITY)
serializer = RegistrationSerializer(data=request.data)
if serializer.is_valid():
account = serializer.save()
data['response'] = 'successfully registered new user.'
data['email'] = account.email
data['username'] = account.username
# data['pk'] = account.pk
token = Token.objects.get(user=account).key
# data['token'] = token
data['is_active'] = account.is_active
current_site = get_current_site(request)
subject = 'Activate Your Taneman Account'
# url = 'http://192.168.43.243:8000' + reverse('confirm_email', kwargs={'user_id': user_id, 'token': token})
message = render_to_string(
'account_activation_email.html', {
'user': account,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(account.pk)),
'token': account_activation_token.make_token(account),
})
mail = EmailMessage(subject,
message,
to=[account.email],
from_email=settings.EMAIL_HOST_USER)
mail.content_subtype = 'html'
mail.send()
# account.email_account(subject, message)
else:
data = serializer.errors
return Response(data, )
def register_view(request, *args, **kwargs):
user = request.user
if user.is_authenticated:
return HttpResponse("you are already authenticated as" +
str(user.email))
context = {}
if request.method == "POST" or request.POST:
form = RegistrationForm(request.POST)
if form.is_valid():
if settings.RUN_DEVELOPEMENT_SERVER:
form.save()
email = form.cleaned_data.get('email').lower()
raw_password = form.cleaned_data.get('password1')
account = authenticate(email=email, password=raw_password)
login(request, account)
return redirect('home:home')
else:
user = form.save(commit=False)
user.is_active = False
user.save()
current_site = get_current_site(request)
subject = 'Activate Your MySite Account'
message = render_to_string(
'account/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),
})
to_email = form.cleaned_data.get('email')
email = EmailMessage(subject, message, to=[to_email])
email.send()
return redirect('accounts:account_activation_sent')
else:
context['registration_form'] = form
else:
form = RegistrationForm()
context['registration_form'] = form
return render(request, 'account/singup.html', context)
def post(self, request):
form = PasswordChangeForm(request.POST)
if form.is_valid():
user = request.user
current_site = get_current_site(request)
subject = 'Activate Your Phytochem Database Account'
message = render_to_string('email_verification/email_verification.html', {
'account': user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': account_activation_token.make_token(user),
})
if user.email_user(subject, message) == 1:
return render(request, 'password_change/password_reset_done.html')
else:
messages.warning(request, 'Failed to confirm email')
return render(request, 'password_change/password_reset_form.html', {'form': form})
def send_sign_up_email_async(user_id):
from account.models import User
user = User.objects.get(id=user_id)
title = 'Sign Up'
uid = urlsafe_base64_encode(force_bytes(user.pk))
token = account_activation_token.make_token(user)
path = reverse('account:activate', args=(uid, token))
url = 'http://127.0.0.1:8000' + path
message = f'Your activation URL: {url}'
send_mail(
title,
message,
settings.DEFAULT_FROM_EMAIL,
[user.email],
fail_silently=False,
)
def post(selfself, request):
try:
user = User.objects.get(email=request.data['email'])
serializer = AccountSerializer(user)
uid = urlsafe_base64_encode(force_bytes(user.id))
token = account_activation_token.make_token(user)
domain = settings.DOMAIN
message = user.username + "님 아래 링크를 클릭해서 비밀번호를 변경해주세요.\n" + "http://" + domain + "/verify/" + uid + "/" + token
to_email = request.data['email']
mail_subject = 'KHUSB email verification'
email = EmailMessage(mail_subject, message, to=[to_email])
email.send()
return Response(serializer.data, status=status.HTTP_200_OK)
except User.DoesNotExist:
return Response({
"status": "error",
"data": "User Not Exist"
},
status=status.HTTP_400_BAD_REQUEST)
def register(request):
if request.method == 'POST':
user_form = UserRegistrationForm(request.POST)
profile_form = ProfileForm(request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save(commit=False)
user.set_password(user_form.cleaned_data['password'])
user.is_active = False
user.save()
profile = profile_form.save(commit=False)
profile.user = user
profile.save()
current_site = get_current_site(request)
subject = 'Activate Your Account'
message = get_template(
'registration/account_activation_email.html').render({
'user':
user,
'domain':
current_site.domain,
'uid':
urlsafe_base64_encode(force_bytes(user.pk)).decode(),
'token':
account_activation_token.make_token(user),
})
to_email = user_form.cleaned_data.get('email')
email = EmailMessage(subject, message, to=[to_email])
email.content_subtype = 'html'
email.send()
messages.success(
request,
'An email has been sent to you,please go and activate your account'
)
return redirect('home:home')
else:
user_form = UserRegistrationForm()
profile_form = ProfileForm()
return render(request, 'account/register.html', {
'user_form': user_form,
'profile_form': profile_form
})
def post(self, request, *args, **kwargs):
form = self.form_class(request.POST or None)
if form.is_valid():
user = form.save(commit=False)
user.is_active = False #set to false bcos user cannot login
user.save()
current_site = get_current_site(request)
subject = 'Activate your ViewingSport account' #Remember to change if name is changed!
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),
})
user.email_user(subject, message) #from user model
return redirect('account:account_activation_sent')
else:
form = UserCreateForm()
return render(request, 'account/signup.html', {'form': form})
def post(selfself, request):
exist_user = User.objects.filter(email=request.data['email'])
if (exist_user.exists()):
print("EXIST?")
if (exist_user[0].active == False):
exist_user[0].delete()
serializer = AccountSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
user = User.objects.get(email=request.data['email'])
uid = urlsafe_base64_encode(force_bytes(user.id))
token = account_activation_token.make_token(user)
domain = settings.DOMAIN
message = user.username + "님 아래 링크를 클릭해서 계정을 활성화 해주세요.\n" + "http://" + domain + "/activate/" + uid + "/" + token
to_email = request.data['email']
mail_subject = 'KHUSB email verification'
email = EmailMessage(mail_subject, message, to=[to_email])
email.send()
return Response(serializer.data, status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def send_activate_mail(self, user, form):
mail_subject = _('Activate your account')
context = {
'user': user,
'uid': force_text(urlsafe_base64_encode(force_bytes(user.id))),
'token': str(account_activation_token.make_token(user)),
}
url = reverse('account:activate', args=[context['uid'], context['token']])
# message = render_to_string('account/mails/verification.html', context,
# request=self.request)
# to_email = form.cleaned_data.get('email')
# email = EmailMessage(
# mail_subject, message, to=[to_email]
# )
# email.send()
send_mail(mail_subject, 'http://*****:*****@ymail.com', [user.email])
messages.success(self.request, _('User has been created. check your email for confirmation mail.'))
def signup(request):
if request.method == 'POST':
form = SignUpForm(request.POST)
if form.is_valid():
user = form.save(commit=False)
user.is_active = False
user.save()
current_site = get_current_site(request)
subject = 'Activate your account by checking email'
message = render_to_string(
'account/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)
return redirect('account:account_activation_sent')
else:
form = SignUpForm()
return render(request, 'account/signup.html', {'form': form})
def post(self, request, *args, **kwargs):
email = self.request.POST.get('email')
username = self.request.POST.get('username')
password = self.request.POST.get('password')
self.request.user.is_active = False
# self.request.user.save()
current_site = get_current_site(self.request)
mail_subject = 'Activate you ©Brooklyn Profile.'
message = render_to_string(
'account/acc_active_email.html', {
'user': self.request.user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(
self.request.user.pk)),
'token': account_activation_token.make_token(
self.request.user),
})
sended_email = EmailMessage(mail_subject, message, to=[email]).send()
return HttpResponse('Cool')
def post(self, request):
form = UserSignUpForm(request.POST or None)
if form.is_valid():
user = form.save(commit=False)
user.active = False
user.confirmation_date = datetime.now()
user.save()
current_site = get_current_site(request)
message = render_to_string('account/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),
})
mail_subject = 'Activate your BuyBook shop account.'
to_email = form.cleaned_data.get('email')
from_email = settings.EMAIL_HOST_USER
email = EmailMessage(from_email=from_email, subject=mail_subject, body=message, to=[to_email])
email.send()
return render(request, 'account/email_is_sent.html')
return render(request, 'account/sign_up.html', {'signup_form': form})
def REGISTER(request):
if 'register' not in request.META.get('HTTP_REFERER', '/'):
request.session['next'] = request.META.get('HTTP_REFERER', '/')
if request.method == 'POST':
form = UserCreationFormExtended(request.POST)
if form.is_valid():
user_form = form.save()
user_form.is_active = False
user_form.save()
current_site = get_current_site(request)
mail_subject = _('Activate your blog account.')
message = render_to_string(
'settings/active_email.html', {
'user':
user_form,
'domain':
current_site.domain,
'uid':
urlsafe_base64_encode(force_bytes(user_form.pk)),
'token':
account_activation_token.make_token(user_form),
'path':
request.session['next']
if 'next' in request.session else None,
})
to_email = form.cleaned_data.get('email')
email = EmailMessage(mail_subject, message, to=[to_email])
email.send()
messages.success(
request,
_('Please, Check Your Email we\'ve sent an activation link for you Profile.'
))
else:
messages.error(request,
_('Please make sure all the inputs are right!'))
context = {'form': UserCreationFormExtended()}
return render(request, 'guest/register.html', context)
def post(self, request):
form = SignupForm(data=request.data)
email = request.data.get("email")
if form.is_valid():
clear_first_name, clear_last_name = get_clearbit_data(email)
form_values = request.data.copy()
form_values["first_name"] = clear_first_name
form_values["last_name"] = clear_last_name
form = SignupForm(form_values)
user = form.save(commit=False)
user.is_active = True
user.save()
current_site = get_current_site(request)
mail_subject = "Activate your blog account."
mail_context = {
"user": user,
"domain": current_site.domain,
"uid": urlsafe_base64_encode(force_bytes(user.pk)),
"token": account_activation_token.make_token(user),
}
message = render_to_string("account/rest_email_activation.html",
mail_context)
to_email = form.cleaned_data.get("email")
email = EmailMessage(mail_subject, message, to=[to_email])
email.send()
return JsonResponse(
{
"status": "success",
"message":
"confirm your email to complete the registration",
},
status=200,
)
return Response(form.errors, status=409)
def signup(request):
if request.method == 'POST':
form = SignUpForm(request.POST)
if form.is_valid():
user = form.save()
user.is_active = False
user.save()
user.refresh_from_db()
user.profile.school_class = form.cleaned_data.get('school_class')
user.profile.save()
current_site = get_current_site(request)
subject = 'Activate Your Bloom Account'
message = render_to_string(
'frontend/account/email/activation.html', {
'user': user,
'domain': request.build_absolute_uri('/'),
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': account_activation_token.make_token(user),
})
user.email_user(subject, message)
return redirect('account:activation_sent')
else:
form = SignUpForm()
return render(request, 'frontend/account/signup.html', {'form': form})
def api_register_user_view(request):
if request.method == 'POST':
data = {}
email = request.data.get('email', None).lower()
username = request.data.get('username', None)
first_name = request.data.get('first_name', None)
last_name = request.data.get('last_name', None)
password = request.data.get('password', None)
password_confirmation = request.data.get('password_confirmation', None)
if email is None or email == '':
data['message'] = MSG_NO_EMAIL
return Response(data, status.HTTP_400_BAD_REQUEST)
if username is None or username == '':
data['message'] = MSG_NO_USERNAME
return Response(data, status.HTTP_400_BAD_REQUEST)
if first_name is None or first_name == '':
data['message'] = MSG_NO_FIRSTNAME
return Response(data, status.HTTP_400_BAD_REQUEST)
if last_name is None or last_name == '':
data['message'] = MSG_NO_LASTNAME
return Response(data, status.HTTP_400_BAD_REQUEST)
if password is None or password == '':
data['message'] = MSG_NO_PASSWORD
return Response(data, status.HTTP_400_BAD_REQUEST)
if password_confirmation is None or password_confirmation == '':
data['message'] = MSG_NO_PASSWORDCONFIRMATION
return Response(data, status.HTTP_400_BAD_REQUEST)
if validate_email(email) is not None:
data['message'] = MSG_DUPLICATE_EMAIL
return Response(data, status.HTTP_400_BAD_REQUEST)
if validate_username(username) is not None:
data['message'] = MSG_DUPLICATE_USERNAME
return Response(data, status.HTTP_400_BAD_REQUEST)
if password != password_confirmation:
data['message'] = MSG_NONMATH_PASSWORDS
return Response(data, status.HTTP_400_BAD_REQUEST)
# lowercase email:
request_data = request.data.copy()
request_data.pop('email', '0')
request_data['email'] = email.lower()
# serializing:
serializer = UserRegisterationSerializer(data=request_data)
if serializer.is_valid():
new_user = serializer.save()
# email verification:
new_user.is_active = False
new_user.save()
current_site = get_current_site(request)
mail_subject = 'Activate Your BookShare Account'
activation_token = account_activation_token.make_token(new_user)
mail_message = render_to_string(
'activate_email_email.html', {
'user': new_user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(new_user.pk)),
'token': activation_token,
})
email_destination = email
EmailMessage(mail_subject, mail_message,
to=[email_destination]).send()
return Response(
{
'message':
'Please confirm your email address to complete the registration.'
},
status=status.HTTP_200_OK)
else:
data = serializer.errors
data['message'] = MSG_INVALID_FIELDS
return Response(data, status.HTTP_400_BAD_REQUEST)
