def user_signup(request):
if request.method == 'POST':
form = sign_up_form(request.POST)
if form.is_valid():
user = form.save(commit=False)
user.is_active = False
user.save()
Profile.objects.create(user=user)
current_site = get_current_site(request)
subject = "Activate your MovieDB account"
# username = form.cleaned_data.get('username')
message = render_to_string(
'user/acc_activate_email.html', {
'user': user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': account_activation_token.make_token(user),
})
# messages.success(request, f'Account created for {username}!')
# user.email_user(subject, message)
to_email = form.cleaned_data.get('email')
email = EmailMessage(subject=subject, body=message, to=[to_email])
email.send()
return HttpResponse('please confirm your email address')
else:
form = sign_up_form()
return render(request, 'user/signup.html', {'form': form})
def create_template_email_context(self, form, member):
return {
'user': member,
'domain': get_current_site(self.request).domain,
'uid': urlsafe_base64_encode(force_bytes(member.id)),
'token': account_activation_token.make_token(member)
}
def signup(request):
if request.method == 'POST':
form = CustomUserCreationForm(request.POST)
if form.is_valid():
email = form.cleaned_data.get('email')
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(
'registration/signup_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')
send_mail(mail_subject, message, '*****@*****.**',
[to_email])
return redirect('signup_confirm')
else:
form = CustomUserCreationForm()
return render(request, 'registration/signup.html', {
'form': form,
})
def post(self, request, format=None):
serializer = UserCreateSerializer(data = request.data)
serializer.is_valid(raise_exception=True)
if serializer.validated_data["terms_and_condition"] is False:
data = {
"error" : "Please accept the terms and condtions"
}
raise ValidationError(data)
#Hash the password
user = serializer.save(is_active=False, password=make_password(serializer.validated_data["password"]))
current_site = get_current_site(request)
mail_subject = 'Activate your account.'
message = render_to_string('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),
})
to_email = user.email
email = EmailMessage(
mail_subject, message, to=[to_email]
)
email.send()
data = {
"user_details" : serializer.data,
"message" : "A confirmation email has been sent on %s"%(user.email),
}
return Response(data=data)
def dispatch(self, request, *args, **kwargs):
try:
user = AppUser.objects.get(pk=kwargs.get("pk"))
if not kwargs.get("preview", False):
if user.is_active:
return redirect(reverse('login'))
else:
dom = request.META.get("HTTP_REFERER", 'home').split('/')
domain = dom[0] + '//' + dom[2]
activation_link = '{}/user/activate/{}/{}'.format(domain,
urlsafe_base64_encode(force_bytes(user.pk)),
account_activation_token.make_token(user)
)
send_email_to_receiver(
subject='Activate account',
message="Hi {},Please click on the link to confirm your registration, {}".format(user.email,
activation_link
),
receiver=user.email
)
return JsonResponse({"message": 'check your email'})
except Exception as exc:
print("ResendEmailView fail: ", exc)
return JsonResponse({'message': 'something problem'})
return super(ResendEmailView, self).dispatch(request, *args, **kwargs)
def home_view(request):
if not request.user.is_authenticated:
#Getting a random contest to be used in steps section
count = Contest.objects.count()
if count > 0:
random_index = randint(0,count-1)
random_contest = Contest.objects.all()[random_index]
else:
random_contest = None
#Sign up form
form = RegisterForm(data=request.POST or None)
if form.is_valid():
user = form.save(commit=False)
password = form.cleaned_data.get('password1')
user.set_password(password)
user.save()
messages.success(request, "Thank you for joining our community. Explore the best photos on Photash!", extra_tags="alert-success")
#setting language by the IP
client = geoip2.webservice.Client(132292, '9uNrE6xTWGHX')
ip = get_ip(request)
response = client.city('46.218.85.101') # Uzak server'a yüklendiğinde burdaki harcoded ip yerine ip yazılacak. Şu an yazılınca 127.0.0.1 hata çıkartıyor o yüzden yazılmadı
if (response.country.iso_code == "TR"):
user.profile.languagePreference ="tr"
user.save()
# mail verification
token = account_activation_token.make_token(user)
uid = urlsafe_base64_encode(force_bytes(user.pk)).decode()
send_mail(
'Please confirm your photash account',
'Click the link belox \n http://127.0.0.1:8000/user/activate/{}/{}'.format(uid, token),
'*****@*****.**',
[user.email, ],
fail_silently=False,
)
new_user = authenticate(username=user.username, password=password)
login(request, new_user)
context={
'form': form,
'random_contest': random_contest
}
# Guestler için session kontrolü
# Session'da language belirlenmemiş ise önce belirleyelim
if "language" not in request.session:
set_session_for_language_according_to_IP(request)
if (request.session['language'] == "tr"):
return render(request, 'home/home-tr.html', context)
else:
return render(request, 'home/home.html', context)
else:
return render(request, 'home/timeline.html')
def informations(request):
uid = urlsafe_base64_encode(force_bytes(request.user.pk))
token = account_activation_token.make_token(request.user)
roles = request.user.roles.all()
return render(request, 'user/informations.html', {
'user_uid': uid,
'user_token': token,
'roles': list(roles)
})
def setUp(self):
self.email = '*****@*****.**'
self.password = '******'
self.client = Client()
self.user = MaieuclicUser.objects.create_user(email=self.email,
password=self.password)
self.user.is_active = False
self.user.save()
self.token = account_activation_token.make_token(self.user)
self.uid = urlsafe_base64_encode(force_bytes(self.user.pk))
def send_activation_mail(self):
message = render_to_string(
'user/activation_email.html', {
'user': self,
'site_url': settings.SITE_URL,
'uid': urlsafe_base64_encode(force_bytes(self.pk)).decode(),
'token': account_activation_token.make_token(self),
})
email = EmailMessage("Activation email", message, to=[self.email])
email.send()
def send_confirm_email(self, user, current_site, subject_template_name,
email_template_name):
subject = render_to_string(subject_template_name,
{'site_name': current_site.name})
message = render_to_string(
email_template_name, {
'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)
def _send_activation_email(self, form, user):
current_site = get_current_site(self.request)
message = render_to_string(
'acc_active_email.html', {
'user': user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': account_activation.make_token(user),
})
mail_subject = 'Activate your blog account.'
recipient = form.cleaned_data.get('email')
email = EmailMessage(mail_subject, message, to=[recipient])
email.send()
def perform_create(self, serializer):
trainer = serializer.save()
current_site = get_current_site(self.request)
mail_subject = 'Activate your account.'
message = render_to_string(
'trainer_active_email.html', {
'trainer': trainer,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(trainer.pk)),
'token': account_activation_token.make_token(trainer),
})
to_email = trainer.email
email = Email(mail_subject, message, to=[to_email])
email.send()
def log_in(request):
log_in_form = LogInForm()
sing_up_form = SignUpForm()
if request.user.is_authenticated:
return redirect('/')
if request.method == "POST":
if "btn-login" in request.POST:
log_in_form = LogInForm(request.POST)
if log_in_form.is_valid():
username = request.POST.get('username')
password = request.POST.get('password')
user = authenticate(username=username, password=password)
if user is not None:
login(request, user)
user.is_active = True
return redirect("/details")
else:
if request.method == 'POST':
sing_up_form = SignUpForm(request.POST)
if sing_up_form.is_valid():
user = sing_up_form.save(commit=False)
user.is_active = False
user.save()
print(urlsafe_base64_encode(force_bytes(user.pk)).decode())
current_site = get_current_site(request)
message = render_to_string(
'account_activation_email.html', {
'user':
user,
'domain':
current_site.domain,
'uid':
urlsafe_base64_encode(force_bytes(
user.pk)).decode(),
'token':
account_activation_token.make_token(user),
})
mail_subject = 'Activate your account.'
to_email = sing_up_form.cleaned_data.get('email')
email = EmailMessage(mail_subject, message, to=[to_email])
email.send()
return HttpResponse(
'Please confirm your email address to complete the registration'
)
return render(request, 'log_register.html', {
'login_form': log_in_form,
'signup_form': sing_up_form
})
def signup(request):
if request.method == 'POST':
form = SignUpForm(request.POST)
if form.is_valid():
description = form.cleaned_data.get("description")
place = form.cleaned_data.get("place")
language = form.cleaned_data.get("language")
proficiency = form.cleaned_data.get("proficiency")
user = form.save(commit=False)
if User.objects.filter(email=user.email).exists():
return HttpResponseBadRequest("Somebody has already registered with this email")
elif User.objects.filter(username=user.username).exists():
return HttpResponseBadRequest("Somebody has already used this username")
user.is_active = False
user.save()
profile = Profile(
user=user,
description=description,
place=place,
)
profile.save()
user_language = UserLanguage(
user=profile,
language=Language.objects.get(name=language),
proficiency=proficiency,
)
user_language.save()
subject = 'Activate Your Servare Account'
message = render_to_string(
'user/account_activation_email.html',
{
'user': user,
'domain': request.META['HTTP_HOST'],
'uid': urlsafe_base64_encode(force_bytes(user.pk)).decode("utf-8"),
'token': account_activation_token.make_token(user),
})
notify_user(to_email=user.email, message=message, subject=subject)
return redirect('account_activation_sent')
else:
form = SignUpForm()
return render(request, 'user/signup.html', {'form':form})
def test_returns_render_with_args(
self, mock_render
):
response = informations(self.request)
self.assertEqual(response, mock_render.return_value)
mock_render.assert_called_once_with(
self.request,
'user/informations.html',
{
'user_uid':
urlsafe_base64_encode(force_bytes(self.new_user.pk)),
'user_token':
account_activation_token.make_token(self.new_user),
'roles': list(self.new_user.roles.all())
}
)
def signup(request):
"""
authentification sign up view
"""
# if request.user:
# return redirect(reverse('home'))
if request.method == "POST":
form = UserCreationForm(request.POST)
if form.is_valid():
email = form.cleaned_data.get("email", False)
age = form.cleaned_data.get("age", False)
first_name = form.cleaned_data.get("first_name", False)
last_name = form.cleaned_data.get("last_name", False)
password = form.cleaned_data.get("password", False)
user = AppUser.objects.filter(email=email).first()
if not user:
user = AppUser.objects.create(
email=email,
age=age,
first_name=first_name,
last_name=last_name,
is_active=False
)
user.set_password(password)
user.save()
dom = request.META.get("HTTP_REFERER", 'home').split('/')
domain = dom[0] + '//' + dom[2]
print('===', domain)
activaton_link = '{}/user/activate/{}/{}'.format(domain,
urlsafe_base64_encode(force_bytes(user.pk)),
account_activation_token.make_token(user)
)
send_email_to_receiver(
subject='Activate account',
message="Hi {},Please click on the link to confirm your registration, {}".format(user.email,
activaton_link),
receiver=user.email
)
print(activaton_link)
return JsonResponse({'message': 'User create, check your email'})
else:
return JsonResponse({'message': "User with this email exists! Try to log in"})
else:
return JsonResponse({"message": form.errors})
form = UserCreationForm()
return render(request, 'user/registration.html', {"form": form})
def sendUserActiveMail(request, user):
# send user activate mail
current_site = get_current_site(request)
message = render_to_string(
'user_active_mail.html', {
'user': user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': account_activation_token.make_token(user),
})
# Sending activation link in terminal
mail_subject = '[庫存大師] 啟用帳號'
to_email = user.email
email = EmailMessage(mail_subject, message, to=[to_email])
email.content_subtype = 'html'
email.send()
def setUp(self):
self.new_user_data = {
'email': '*****@*****.**',
'password': '******'
}
self.new_user = Profile.objects.create_user(
self.new_user_data['email'],
self.new_user_data['email'],
self.new_user_data['password']
)
self.new_user.is_active = False
self.new_user.save()
self.new_user_data['uid'] = urlsafe_base64_encode(
force_bytes(self.new_user.pk)
)
self.new_user_data['token'] = account_activation_token.make_token(
self.new_user
)
def signup(request):
if request.method == 'POST':
form = SinupForm(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 MySite Account'
message = render_to_string(
'user/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_activation_sent')
else:
form = SinupForm()
return render(request, 'user/register.html', {'form': form})