def register_view(request):
if request.method == 'GET':
form = UserCreationForm()
return render(request, 'register.html', {'form':form})
elif request.method == 'POST':
form = UserCreationForm(data=request.POST)
if form.is_valid():
user = User(username=form.cleaned_data['username'])
user = User(
username=form.cleaned_data['username'],
email=form.cleaned_data['email'],
is_active=False #user не активный до подтверждения email
)
user.set_password(form.cleaned_data['password'])
user.save()
Profile.objects.create(user=user)
#токен для активации, его сложнее угадать, чем pk user
token = Token.objects.create(user=user)
activation_url=HOST_NAME + reverse('accounts:user_activate') + \
'?token={}'.format(token)
#отправка письма на email пользователя
user.email_user('Registration on the site localhost',
'To activate, follow the link: {}'.format(activation_url))
return redirect('webapp:index')
else:
return render(request, 'register.html', {'form':form})
def __add_user_to_db(post, active, host):
user = User()
user.username = post['email_username']
user.email = post['email_username']
user.set_password(post['password'])
user.first_name = post['realname']
user.is_active = active
user.save()
#为user创建mail统计记录
mail_statistic = MailStatistic()
mail_statistic.user = user
mail_statistic.save()
profile = Profile()
profile.user = user
if active == 0:
from Captcha.Base import randomIdentifier
profile.activate_code = randomIdentifier()[:20]
profile.save()
if active == 0:
url = profile.activate_code + str(profile.id)
mail_content = '''
请通过访问此链接http://%s/login/activate/%s/ 激活您的ClubHome账户。
''' % (host, url)
try:
user.email_user('ClubHome账户激活', mail_content)
except Exception, e:
profile.delete()
mail_statistic.delete()
user.delete()
return False
def send_email_confirmation(user: User, request: HttpRequest, temporary_access: bool = False, send_to: str = None):
subject = 'Activation de votre compte Nantral Platform'
current_site = get_current_site(request)
# load a template like get_template()
# and calls its render() method immediately.
template = 'account/mail/activation_request.html'
if temporary_access:
template = 'account/mail/activation_temporary_request.html'
message = render_to_string(template, {
'user': user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
# method will generate a hash value with user related data
'token': account_activation_token.make_token(user),
})
if send_to is not None:
send_mail(subject, message, None,
html_message=message, recipient_list=[send_to])
else:
user.email_user(
subject, message, html_message=message)
if temporary_access:
messages.success(
request, 'Un mail vous a été envoyé pour confirmer votre adresse mail personnelle.')
else:
messages.success(
request, 'Un mail vous a été envoyé pour confirmer votre adresse mail Centrale Nantes.\n\
Vous pouvez accéder à votre boîte mail école <a href="https://webmail.ec-nantes.fr">ici</a>.')
def register_view(request):
if request.method == 'GET':
form = UserCreationForm()
return render(request, 'register.html', {'form': form})
elif request.method == 'POST':
form = UserCreationForm(data=request.POST)
if form.is_valid():
user = User(
username=form.cleaned_data['username'],
email=form.cleaned_data['email'],
is_active=False # user не активный до подтверждения email
)
user.set_password(form.cleaned_data['password'])
user.save()
# токен для активации, его сложнее угадать, чем pk user-а.
token = Token.objects.create(user=user)
activation_url = HOST_NAME + reverse('accounts:user_activate') + \
'?token={}'.format(token)
# отправка письма на email пользователя
user.email_user(
'Регистрация на сайте localhost',
'Для активации перейдите по ссылке: {}'.format(activation_url))
print(activation_url)
return redirect("webapp:todo_index")
else:
return render(request, 'register.html', {'form': form})
def register_view(request):
if request.method == 'GET':
form = UserCreationForm()
return render(request, 'user_create.html', {'form': form})
elif request.method == 'POST':
form = UserCreationForm(data=request.POST)
if form.is_valid():
user = User(username=form.cleaned_data['username'],
email=form.cleaned_data['email'],
first_name=form.cleaned_data['first_name'],
last_name=form.cleaned_data['last_name'],
is_active=False)
user.set_password(form.cleaned_data['password'])
user.save()
Profile.objects.create(user=user)
token = Token.objects.create(user=user)
activation_url = HOST_NAME + reverse(
'accounts:user_activate') + '?token={}'.format(token)
user.email_user(
'Регистрация на сайте localhost',
'Для активации перейдите по ссылке: {}'.format(activation_url))
return redirect("webapp:index")
else:
return render(request, 'user_create.html', {'form': form})
def register_view(request):
if request.method == 'GET':
form = SignUpForm()
return render(request, 'register.html', context={'form': form})
elif request.method == 'POST':
form = SignUpForm(data=request.POST)
if form.is_valid():
user = User(
username=form.cleaned_data.get('username'),
first_name=form.cleaned_data.get('first_name'),
last_name=form.cleaned_data.get('last_name'),
email=form.cleaned_data.get('email'),
is_active=False
)
user.set_password(form.cleaned_data.get('password'))
user.save()
Profile.objects.create(user=user)
token = Token.objects.create(user=user)
activation_url = HOST_NAME + reverse('accounts:user_activate', kwargs={'token': token})
print(activation_url)
try:
user.email_user(
'Вы зарегистрировались на сайте localhost:8000.',
'Для активации перейдите по ссылке: ' + activation_url
)
except ConnectionRefusedError:
print('Could not send email. Server error.')
return redirect('webapp:index')
else:
return render(request, 'register.html', context={'form': form})
def thank_you(request):
cart = request.session.get('cart', {})
cartDictionary = printCart(cart)
product = cartDictionary["product"]
numberOfItems = cartDictionary["numberOfItems"]
orderTotal = cartDictionary["orderTotal"]
response = HttpResponseRedirect('thank_you')
usernamed = str(request.user)
cookie_name = "cart-" + usernamed
if request.method == 'POST':
#email for checkout confirmation
try:
u = User.objects.get(username=usernamed)
subject = 'Order Confirmation'
message = 'Dear ' + usernamed + ',\n \n'
message += 'Your order is complete and items are going to be dispatched soon. \n \n'
message += 'Please see your order details below: \n'
for p in product:
message += str(p[1]) + ', ' + str(p[3]) + ' (' + str(
p[2]) + '$)' + '\n'
message += ' Total amount paid: ' + str(orderTotal) + '$ \n \n'
message += 'Kind regards, \n Free Trade Fruit And Veg Team'
from_email = '*****@*****.**'
User.email_user(u, subject, message, from_email)
except User.DoesNotExist:
print("USER DOES NOT EXIST")
#empting the cart
cart = {}
request.session['cart'] = cart
if (request.COOKIES.get(cookie_name) is not None):
#delete cookie
response.delete_cookie(cookie_name)
return response
else:
print("THERES NO COOKIE")
return render(
request, 'sitepages/thankyou.html', {
"product": product,
"numberOfItems": numberOfItems,
"orderTotal": orderTotal,
"message": "Please Find your recipt at your email."
})
else:
return render(
request, 'sitepages/thankyou.html',
{"message_reload": "Please Find your recipt at your email."})
def create_user(self, name, email, password, site='', send_email=True, openid=None):
"""
Create a new User, activate it, send email about password
You can disable email_sending in settings: DISABLE_REGISTRATION_EMAIL=True
"""
send_email = send_email and not getattr(settings, 'DISABLE_REGISTRATION_EMAIL', False)
# Create the user.
if openid:
username = openid[7:37]
else:
username = email.replace('@', '-')
try:
while True:
User.objects.get(username=username)
username = username[:-2] + str(random.randrange(10, 100))
except User.DoesNotExist:
pass
new_user = User(username=username, email=email, first_name=name)
new_user.set_password(password)
new_user.is_active = True
new_user.site = site
new_user.save()
if send_email:
current_domain = Site.objects.get_current().domain
subject = "Your new account at %s has been created" % current_domain
message_template = loader.get_template('accounts/created_email.txt')
message_context = Context({'site_url': '%s://%s' % (settings.SITE_PROTOCOL, current_domain),
'password': password,
'user': new_user})
message = message_template.render(message_context)
new_user.email_user(subject, message, settings.DEFAULT_FROM_EMAIL)
return new_user
def create_inactive_user(self,
name,
email,
password,
site='',
send_email=True):
"""
Creates a new User and a new ActionRecord for that
User, generates an activation key, and mails it.
Pass ``send_email=False`` to disable sending the email.
You can disable email_sending in settings: DISABLE_REGISTRATION_EMAIL=True
"""
send_email = not getattr(settings, 'DISABLE_REGISTRATION_EMAIL', False)
# Create the user.
new_user = User(username=email.replace('@', '-'),
email=email,
first_name=name)
new_user.set_password(password)
new_user.is_active = False
new_user.save()
from accounts.models import UserProfile
UserProfile(user=new_user, site=site).save()
# Generate a salted SHA1 hash to use as a key.
salt = sha.new(str(random.random())).hexdigest()[:5]
action_key = sha.new(salt + slugify(new_user.email)).hexdigest()
# And finally create the record.
new_record = self.create(user=new_user,
action_key=action_key,
type='A')
if send_email:
current_domain = Site.objects.get_current().domain
subject = "Activate your new account at %s" % current_domain
message_template = loader.get_template(
'accounts/activation_email.txt')
message_context = Context({
'site_url':
'%s://%s' % (settings.SITE_PROTOCOL, current_domain),
'action_key':
action_key,
'expiration_days':
settings.ACTION_RECORD_DAYS,
'password':
password,
'user':
new_user
})
message = message_template.render(message_context)
new_user.email_user(subject, message, settings.DEFAULT_FROM_EMAIL)
return new_user
def send_confirmation_email(user: User):
t = get_template("confirm.html")
user.email_user(
subject="Fandogh Email-address confirmation",
message="",
from_email=getattr(settings, "EMAIL_FROM"),
html_message=t.render({
"activation_link": _get_activation_link(user),
}),
)
def send_recovery_token(user: User):
t = get_template("recovery.html")
user.email_user(
subject="Fandogh account recovery",
message="",
from_email=getattr(settings, "EMAIL_FROM"),
html_message=t.render({
"account_recovery":
_get_account_recovery_link(user),
}),
)
def register(request):
context = {}
# Just display the registration form if this is a GET request
if request.method == 'GET':
context['form'] = RegistrationForm()
return render(request, 'registration/register.html', context)
new_user = User()
form = RegistrationForm(request.POST, instance=new_user)
# Checks the validity of the form data
if not form.is_valid():
context['form'] = form
return render(request, 'registration/register.html', context)
# Hack to hash password
password = new_user.password
new_user.set_password(password)
if not settings.EMAIL_CONFIRM:
form.save()
new_user = authenticate(username=new_user.username, password=password)
login(request, new_user)
return redirect('home')
new_user.is_active = False
form.save()
# generate secret token
secret_token = SecretToken(
user=new_user,
token=getrandbits(63))
secret_token.save()
# send an email with the confirmation link
link = request.build_absolute_uri(
reverse('confirm email', args=(new_user.username, secret_token.token))
)
subject = 'Degree Planner: email confirmation link'
message = (
'Welcome ' + new_user.username + ' on Degree Planner.\n'
'Please click on the following link to confirm your email address:\n\n'
+ link
)
new_user.email_user(subject, message)
context['email'] = new_user.email
return render(request, 'registration/confirmation_sent.html', context)
def create_user(self,
name,
email,
password,
site='',
send_email=True,
openid=None):
"""
Create a new User, activate it, send email about password
You can disable email_sending in settings: DISABLE_REGISTRATION_EMAIL=True
"""
send_email = send_email and not getattr(
settings, 'DISABLE_REGISTRATION_EMAIL', False)
# Create the user.
if openid:
username = openid[7:37]
else:
username = email.replace('@', '-')
try:
while True:
User.objects.get(username=username)
username = username[:-2] + str(random.randrange(10, 100))
except User.DoesNotExist:
pass
new_user = User(username=username, email=email, first_name=name)
new_user.set_password(password)
new_user.is_active = True
new_user.site = site
new_user.save()
if send_email:
current_domain = Site.objects.get_current().domain
subject = "Your new account at %s has been created" % current_domain
message_template = loader.get_template(
'accounts/created_email.txt')
message_context = Context({
'site_url':
'%s://%s' % (settings.SITE_PROTOCOL, current_domain),
'password':
password,
'user':
new_user
})
message = message_template.render(message_context)
new_user.email_user(subject, message, settings.DEFAULT_FROM_EMAIL)
return new_user
def create_inactive_user(self, name, email, password, site='', send_email=True):
"""
Creates a new User and a new ActionRecord for that
User, generates an activation key, and mails it.
Pass ``send_email=False`` to disable sending the email.
You can disable email_sending in settings: DISABLE_REGISTRATION_EMAIL=True
"""
from django.contrib.auth.models import User
send_email = not getattr(settings, 'DISABLE_REGISTRATION_EMAIL', False)
# Create the user.
new_user = User(username=email.replace('@', '-'), email=email, first_name=name)
new_user.set_password(password)
new_user.is_active = False
new_user.site = site
new_user.save()
# Generate a salted SHA1 hash to use as a key.
salt = sha.new(str(random.random())).hexdigest()[:5]
activation_key = sha.new(salt+slugify(new_user.email)).hexdigest()
# And finally create the record.
new_record = self.create(user=new_user,
activation_key=activation_key,
type='A')
if send_email:
if Site._meta.installed:
current_site = Site.objects.get_current()
else:
current_site = RequestSite(request) #TODO import Site/RequestSite ?
current_domain = current_site.domain
subject = "Activate your new account at %s" % current_domain
message_template = loader.get_template('accounts/activation_email.txt')
message_context = Context({ 'site_url': '%s://%s' % (settings.SITE_PROTOCOL, current_domain),
'activation_key': activation_key,
'expiration_days': settings.ACTION_RECORD_DAYS,
'password': password,
'user': new_user})
message = message_template.render(message_context)
new_user.email_user(subject, message, settings.DEFAULT_FROM_EMAIL)
return new_user
def register(request):
if request.method == 'POST':
data = request.POST
password = data['password']
repeated_password = data['repeatedPassword']
# Проверяем тождество паролей, после чего либо работа продолжается,
# либо пользователь пойдёт отождествлять пароли.
if password != repeated_password:
return HttpResponse('Пароли не совпадают')
username = data['username']
email = data['email']
# Проверка на существуещего пользователя
if User.objects.filter(username=username).exists():
# Если есть пользователь с таким именем,
# возвращается уведомление об этом.
return HttpResponse(
'Пользователь с таким именем пользователя уже существует')
elif User.objects.filter(email=email).exists():
return HttpResponse('Пользователь с таким email-ом уже существует')
else:
# Регистрируется один пользователь
user = User(username=username, email=email)
user.set_password(password)
user.save()
# Создаются аккаунты для двух игр
MinecraftUser(user=user).save()
server = 'Minecraft'
subject = 'Успешная регистрация'
message = 'Вы зарегистрировались под логином — %s, на %s сервере нашего проекта.' \
'Удачной охоты!' % (username, server)
user.email_user(subject, message)
# Возвращается ответ об успешной регистрации.
return HttpResponse('Вы успешно прошли регистрацию')
# Посылается сообщение об успехе на почту
return HttpResponse('Что-то пошло не так...')
def test_email_user(self):
# valid send_mail parameters
kwargs = {
"fail_silently": False,
"auth_user": None,
"auth_password": None,
"connection": None,
"html_message": None,
}
user = User(email='*****@*****.**')
user.email_user(subject="Subject here",
message="This is a message",
from_email="*****@*****.**",
**kwargs)
self.assertEqual(len(mail.outbox), 1)
message = mail.outbox[0]
self.assertEqual(message.subject, "Subject here")
self.assertEqual(message.body, "This is a message")
self.assertEqual(message.from_email, "*****@*****.**")
self.assertEqual(message.to, [user.email])
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 MySite Account'
message = render_to_string(
'app/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)
User.email_user(user, subject, message)
return redirect('account_activation_sent')
else:
form = SignUpForm()
return render(request, 'app/signup.html', {'form': form})
def register_view(request):
if request.method == 'GET':
form = UserCreationForm()
return render(request, 'register.html', {'form': form})
elif request.method == 'POST':
form = UserCreationForm(data=request.POST)
if form.is_valid():
user = User(username=form.cleaned_data['username'],
email=form.cleaned_data['email'],
is_active=False)
user.set_password(form.cleaned_data['password'])
user.save()
token = Token.objects.create(user=user)
activation_url = HOST_NAME + reverse(
'accounts:user_activate') + '?token={}'.format(token)
user.email_user(
'Register on localhost',
'To activate, follow the link: {}'.format(activation_url))
return redirect("webapp:index")
else:
return render(request, 'register.html', {'form': form})
def update_user_profile(sender, instance, created, **kwargs):
if created:
current_site = 'http://127.0.0.1:8000'
subject = "Account Activation"
user = User(username=instance.username,
email=instance.email,
is_active=False)
user.set_password(str(instance.password))
user.profile = instance
user.save()
subject = 'Activate Your {} Account'.format(current_site)
message_txt = render_to_string(
'registration/account_activation_email.txt', {
'user': user,
'Subject': subject,
'password': instance.password,
'email': instance.email,
'domain': current_site,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': account_activation_token.make_token(user),
})
message_html = render_to_string(
'registration/account_activation_email.html', {
'user': user,
'Subject': subject,
'password': instance.password,
'email': instance.email,
'domain': current_site,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': account_activation_token.make_token(user),
})
user.email_user(subject,
message_txt,
'*****@*****.**',
html_message=message_html)
instance.user = user
instance.save()
instance.user.save()
def register_view(request):
if request.method == 'POST':
form = UserCreationForm(data=request.POST)
if form.is_valid():
user_1 = User(
email=form.cleaned_data['email'],
is_active=False)
user = form.save()
token = Token.objects.create(user=user)
user.save()
Profile.objects.create(user=user)
activation_url = HOST_NAME + reverse('user_activate') + '?token={}'.format(token)
user_1.email_user('Регистрация на сайте localhost',
'Для активаций перейдите по ссылке:{}'.format(activation_url))
login(request, user)
user.save()
Profile.objects.create(user=user)
Profile.objects.all.create(user=user)
return redirect('index')
else:
form = UserCreationForm()
return render(request, 'register.html', context={'form': form})
def create_accounts(request):
if request.method == 'GET':
csv_form = GetCSVForm()
return render(request, 'registration/create_accounts.html',{
'form':csv_form
})
try:
my_csv = request.FILES["csv_file"]
# Ensures a CSV file
if not my_csv.name.endswith('.csv'):
messages.add_message(request, messages.ERROR, "You must upload a .csv file")
return HttpResponseRedirect(reverse('elections:create_accounts'))
# Ensures file is not too big
if my_csv.multiple_chunks():
messages.add_message(request, messages.ERROR, "Your file size is too big")
return HttpResponseRedirect(reverse('elections:create_accounts'))
# Turns CSV into useable data
file_data = my_csv.read().decode("utf-8")
lines = file_data.split("\r\n")
pprint(lines)
pprint(lines[1:-1])
if 'teachers_button' in request.POST:
for line in lines[1:-1]:
fields = line.split(",")
new_user = User()
new_user.username = fields[3].split("@")[0]
new_user.first_name = fields[1]
new_user.last_name = fields[0]
new_user.email = fields[3]
password_string = get_random_string(15)
new_user.set_password(password_string)
new_user.is_active = False
new_user.save()
new_user.refresh_from_db()
if fields[2] == "Male":
new_user.profile.Gender = "M"
elif fields[2] == "Female":
new_user.profile.Gender = "F"
new_user.profile.UserTypeID = UserType.objects.get(UserType="Teacher")
new_user.profile.EmailConfirmed = False
new_user.save()
current_site = get_current_site(request)
subject = "Activate your DC-Elects account"
message = render_to_string('registration/account_activation_email.html', {
'user': new_user,
'password': password_string,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(new_user.id)),
'token': account_activation_token.make_token(new_user),
})
new_user.email_user(subject, message)
elif 'students_button' in request.POST:
for line in lines[1:-1]:
fields = line.split(",")
if fields[3][0:2] in ['12','13'] and len(fields[3]) == 3:
new_user = User()
new_user.username = fields[4].split("@")[0]
new_user.first_name = fields[1]
new_user.last_name = fields[0]
new_user.email = fields[4]
password_string = get_random_string(15)
new_user.set_password(password_string)
new_user.is_active = False
new_user.save()
new_user.refresh_from_db()
new_user.profile.Gender = fields[2]
if fields[3][0:2] == '12':
new_user.profile.UserTypeID = UserType.objects.get(UserType="Year12")
elif fields[3][0:2] == '13':
new_user.profile.UserTypeID = UserType.objects.get(UserType="Year13")
new_user.profile.EmailConfirmed = False
new_user.save()
current_site = get_current_site(request)
subject = "Activate your Elect-DC account"
message = render_to_string('registration/account_activation_email.html', {
'user': new_user,
'password': password_string,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(new_user.id)),
'token': account_activation_token.make_token(new_user),
})
new_user.email_user(subject, message)
messages.add_message(request, messages.SUCCESS, "Accounts created successfully")
except Exception as e:
messages.add_message(request, messages.ERROR, "An error occured: "+repr(e))
return HttpResponseRedirect(reverse('elections:create_accounts'))
def import_user_submit(request):
# http://www.cnblogs.com/yijun-boxing/archive/2011/04/18/2020155.html
CONTRACT_CVS_COL_CONTRACT_ID=0
CONTRACT_CVS_COL_DISTRICT_ID=1
CONTRACT_CVS_COL_EMAIL=2
CONTRACT_CVS_COL_USERNAME=3
CONTRACT_CVS_COUNT_COL=4
message={}
n=0
if request.method == 'POST':
f=request.FILES['file']
dialect = csv.Sniffer().sniff(f.read(1024), delimiters=";,")
f.seek(0)
r=csv.reader(f,dialect)
try:
for i,line in enumerate(r):
n=n+1
contract_id=line[CONTRACT_CVS_COL_CONTRACT_ID]
district_id=line[CONTRACT_CVS_COL_DISTRICT_ID]
email=line[CONTRACT_CVS_COL_EMAIL]
username=line[CONTRACT_CVS_COL_USERNAME]
for value in line:
if len(value.strip())==0:
raise Exception("Catch csv line with empty fields line")
if len(line) != CONTRACT_CVS_COUNT_COL:
raise Exception("Catch csv line of wrong fields count")
user = User(username=username, email=email, is_active=True)
user.set_password(username)
registration = Registration()
try:
user.save()
except IntegrityError:
if len(User.objects.filter(username=username)) > 0:
raise Exception("An account with the Public Username '{username}' already exists.".format(username=username))
if len(User.objects.filter(email=email)) > 0:
raise Exception("An account with the Email '{email}' already exists.".format(email=email))
registration.register(user)
profile=UserProfile(user=user)
profile.contract_id=contract_id
profile.district_id=district_id
profile.email=email
profile.username=username
profile.save()
reg = Registration.objects.get(user=user)
d = {'name': profile.name, 'key': reg.activation_key}
subject = render_to_string('emails/activation_email_subject.txt', d)
subject = ''.join(subject.splitlines())
message = render_to_string('emails/activation_email.txt', d)
try:
_res = user.email_user(subject, message, settings.DEFAULT_FROM_EMAIL)
except:
log.warning('Unable to send reactivation email', exc_info=True)
return HttpResponse(json.dumps({'success': False, 'error': _('Unable to send reactivation email')}))
message={'success': True, "message":"Success! %s users imported." % (n)}
except Exception as e:
transaction.rollback()
message={'success': False,'message':'Import error: %s, At cvs line: %s' % (e,n)}
# title = forms.CharField(max_length=50)
# file = forms.FileField()
return HttpResponse(json.dumps(message))
def inscription(request):
message = ""
if request.method == 'POST':
first_name = request.POST.get('firstname')
last_name = request.POST.get('lastname')
username = request.POST.get('name')
email = request.POST.get('email')
genre = request.POST.get('genre')
passe = request.POST.get('pass')
repass = request.POST.get('repass')
if passe != repass:
message = "mot de passe incorrect "
print("mot de passe incorrect")
else:
message = "correct"
print("success")
try:
print("3")
validate_email(email)
isemail = True
if isemail and not email.isspace(
) and first_name is not None and not first_name.isspace(
) and last_name is not None and passe is not None and repass is not None:
try:
print("2")
try:
exist_user = User.objects.get(username=username)
except:
exist_user = User.objects.get(email=email)
message = "un utilisateur avec le même username ..."
except Exception as e:
print("1", e)
user = User(first_name=first_name,
last_name=last_name,
username=username,
email=email,
is_active=False)
user.save()
user.password = passe
user.set_password(user.password)
user.save()
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':
token_.account_activation_token.make_token(
user),
})
user.email_user(subject, message)
message = " merci de vérifier votre email pour la confirmation de votre compte"
try:
us = authenticate(username=username,
password=passe)
if us.is_active:
login(request, us)
return redirect('index')
except Exception as e:
print("4", e)
except Exception as e:
print("5", e)
message = "l'inscription a échoué"
print("inscription echoué")
datas = {
"message": message,
}
return render(request, "inscription.html", datas)
