def post(self, request):
form = RegisterForm(request.POST)
if form.is_valid():
user = form.save()
return redirect(reverse('login'))
return render(request, 'sign-up.html', {'form': form})
def register(request):
if request.method == "POST": # S'il s'agit d'une requête POST
print("IS POST REQUEST")
form = RegisterForm(request.POST) # On récupère les données
if form.is_valid(): # On vérifie que les données envoyées sont valides
new_user = User.objects.create_user(
form.cleaned_data["email"], form.cleaned_data["email"], form.cleaned_data["password"]
)
new_user.first_name = form.cleaned_data["first_name"]
new_user.last_name = form.cleaned_data["last_name"]
new_user.save()
new_profil = Profil()
new_profil.user = new_user
new_profil.save()
envoi = True
return HttpResponseRedirect("/accounts/login/")
else:
error = True
error_message = "Invalid informations"
else: # Si ce n'est pas du POST, c'est probablement une requête GET
form = RegisterForm() # Nous créons un formulaire vide
return render(request, "authentication/register.html", locals())
def post(self, request):
form = RegisterForm(request.POST)
if form.is_valid():
user = User.objects.create_user(**form.cleaned_data)
user.save()
return redirect('login')
return render(request, self.template_name, context={'form': form})
def register(request):
data = request.POST.copy()
register_form = RegisterForm()
if request.POST:
register_form = RegisterForm(data)
if register_form.is_valid():
User.objects.create_user(data['username'], data['password'], data['email'])
user = auth.authenticate(username=data['username'], password=data['password'])
auth.login(request, user)
return redirect(reverse('home'))
objcontext = {'register_form': register_form, 'login_form': LoginForm()}
return render(request, 'authentication/register.html', objcontext)
def test_form_valid_data(self):
form = RegisterForm(
data={
'email': "*****@*****.**",
'first_name': "Test",
'last_name': "Test",
'phone_number': 12345678,
'password': "******"
})
self.assertTrue(form.is_valid())
self.assertEqual(len(form.errors), 0)
# python manage.py test authentication
def login_register_page(request):
# This view checks whether the user is authenticated. If not it shows the login page.
if request.user.is_authenticated:
return redirect(settings.LOGIN_REDIRECT_URL)
else:
context = {'login_form': LoginForm(), 'register_form': RegisterForm()}
return render(request, "registration/login_register.html", context)
def post(self, request):
"""регистрация пользователя"""
postdata = request.POST.copy()
email = postdata.get('email', None)
password = postdata.get('password', None)
username = postdata.get('username', None)
form = RegisterForm(request.POST)
profile_form = StudentProfileForm(request.POST)
if form.is_valid() and profile_form.is_valid():
user = Account.objects.create_user(email, password=password, username=username)
user = populateAccountData(request, user, is_teacher=False)
login(request, user)
profile_form.save(user)
return HttpResponseRedirect('/')
return render_to_response(self.template_name, locals(), context_instance=RequestContext(request))
def registerView(request, template_name="authentication/register.html"):
if request.user.is_authenticated():
return HttpResponseRedirect('/')
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
email = request.POST['email']
password = request.POST['password']
username = email.split("@")[0]
print "..... username: %s" % username
new_user = User.objects.create_user(email=email,
password=password,
username=username)
new_user.backend = 'django.contrib.auth.backends.ModelBackend'
login(request, new_user)
return HttpResponseRedirect('/')
def post(self, request, *args, **kwargs):
data = RequestUtils.get_parameters(request)
form = RegisterForm(data)
if form.is_valid():
user = User.objects.create_user(
form.cleaned_data['username'],
form.cleaned_data['email'],
form.cleaned_data['password'],
)
if form.cleaned_data['first_name']:
user.first_name = form.cleaned_data['first_name']
if form.cleaned_data['last_name']:
user.last_name = form.cleaned_data['last_name']
user.save()
return HttpResponse('user is created')
else:
return HttpResponseBadRequest(str(form.errors))
def get(self, request: HttpRequest):
return render(
request,
"authentication/register.html",
{
"form": RegisterForm(),
"next": request.GET.get("next", "")
},
)
def my_profile(request):
try:
user = Profile.objects.get(pk=request.user.pk)
except Profile.DoesNotExist:
return redirect('login')
form = RegisterForm(instance=user)
my_books = Book.objects.filter(
seller=Profile.objects.get(pk=request.user.pk))
context = {
'user': user,
'form': form,
'my_books': my_books
}
if request.method == 'GET':
if not request.user.is_authenticated:
return redirect('login')
else:
return render(request, 'profilepage/profilepage.html', context)
else:
form = RegisterForm(request.POST, instance=user)
komite = form['komite'].value()
allergies = form['allergies'].value()
graduation_year = form['graduation_year'].value()
print('Komite:', komite)
if allergies:
user.allergies = allergies
if komite:
user.komite = Komite.objects.get(pk=komite)
else:
user.komite = None
if graduation_year:
user.graduation_year = graduation_year
user.save()
if request.POST.get('new-password'):
password = request.POST['new-password']
user.set_password(password)
user.save()
login(request, authenticate(
request, email=user.email, password=user.password))
context['form'] = RegisterForm(instance=user)
return render(request, 'profilepage/profilepage.html', context)
def register(request):
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
data = form.cleaned_data
user = TwitterUser.objects.create_user(
username=data['username'],
password=data['password1']
)
login(request, user)
return HttpResponseRedirect(reverse('homepage'))
else:
form = RegisterForm()
return render(request, 'generic_form.html', {
'form': form
})
def register_view(request):
if request.user.is_authenticated:
return redirect('mainapp:home')
form = RegisterForm()
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
form.save()
messages.success(request,"Account succefully created!!")
return redirect('mainapp:home')
return render(request,'authentication/auth_register.html',{"form":form})
def register():
"""Register a new user."""
form = RegisterForm()
if form.validate_on_submit():
user = User()
form.populate_obj(user)
db_session.add(user)
if session.get("rooms") is not None:
for room in Room.query.filter(Room.id.in_(session["rooms"])).all():
room.participants.append(user)
for answer in Answer.query.filter(
Answer.anonymous_id == session["id"]).all():
answer.anonymous_id = None
answer.user = user
try:
db_session.commit()
except IntegrityError as e:
origin = str(e.orig).lower()
if "unique" in origin:
# this is very likely a unique constraint fail
field = origin.split(":")[-1].split(".")[-1]
return jsonify({field: [unique_constraint_failed]}), 400
elif "duplicate" in origin:
field = origin.split("key")[-1].split('"')[0].strip().strip(
"'")
return jsonify({field: [unique_constraint_failed]}), 400
else:
raise
login_user(user)
return jsonify({}), 201
return jsonify(form.errors), 400
def post(self, request: HttpRequest):
def _render_template(form, next_url):
return render(
request,
"authentication/register.html",
{
"form": form,
"next": next_url
},
)
next_url = request.POST.get("next", "")
form = RegisterForm(request.POST)
if not form.is_valid():
return _render_template(form, next_url)
try:
user = form.save()
assert user is not None
# If any unique field's value wasn't unique
except AssertionError:
form.add_error("", "ثبت کاربر با مشکل مواجه شد")
return _render_template(form, next_url)
# Send confirmation uel
confirm_manager = EmailConfirmationManager(user)
uid_base64 = confirm_manager.get_uid_base64()
token = confirm_manager.get_token()
confirm_url = request.build_absolute_uri(
resolve_url(
"authentication:confirm_email",
uid_base64=uid_base64,
token=token,
))
send_email_result = confirm_manager.send_mail(
"mails/email_confirmation.html",
confirm_url,
settings.DEFAULT_FROM_EMAIL,
)
messages.success(request, "ثبت نام با موفقیت انجام شد")
if send_email_result:
messages.success(
request, "ارسال ایمیل تایید حساب کاربری با موفقیت انجام شد")
else:
messages.error(request,
"ارسال ایمیل تایید حساب کاربری موفقیت آمیز نبود")
# Redirect to login page
login_url = reverse("authentication:login") + "?next=" + next_url
return redirect(login_url)
def login_view(request):
# This view handles the login of the user and checks if the user really exists in the database.
if request.user.is_authenticated:
return redirect(settings.LOGIN_REDIRECT_URL)
error = False
# We use the context because we have several forms in the same page.
context = {
'login_form': LoginForm(request.POST),
'register_form': RegisterForm()
}
# if the method is POST.
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
# We get the cleaned data.
username = form.cleaned_data["username"]
password = form.cleaned_data["password"]
user = authenticate(username=username, password=password)
# data is correct.
if user:
# If the user really exists, we login
login(request, user)
context['error_login'] = error
return redirect(settings.LOGIN_REDIRECT_URL)
else:
# An error will be shown.
error = True
context['error_login'] = error
else:
context['error_message'] = form._errors["password_reg"]
else:
form = LoginForm()
# context['user_is_authenticated'] = request.user.is_authenticated()
return render(request, 'registration/login_register.html', context)
def get(self, request):
return render(request, 'sign-up.html', {'form': RegisterForm()})
def profile_view(request):
# Sletter ugyldige kontraktforespørsler
invalid_requests = Contract.objects.filter(
Q(start_date__lt=datetime.datetime.today().strftime('%Y-%m-%d'))
& (Q(pending=True) | Q(owner_approved=False))).delete()
if request.user.is_authenticated:
my_rented_apartments = Apartment.objects.filter(
Q(contracts__tenant__email__iexact=request.user.email)
| Q(contracts__tenants__contains=request.user.email)).distinct()
has_rented_apartments = my_rented_apartments.count() > 0
owns_apartments = Apartment.objects.filter(
owner=request.user).count() > 0
context = {
'form':
RegisterForm(),
'my_apartments':
Apartment.objects.filter(owner=request.user),
'my_rented_apartments':
my_rented_apartments,
'has_rented_apartments':
has_rented_apartments,
'owns_apartments':
owns_apartments,
'owner_of':
Apartment.objects.filter(
Q(original_owner__iexact=request.user.email))
}
if request.method == 'GET':
if not request.user.is_authenticated:
messages.warning(request, "Du må logge inn først")
return redirect('landing-page')
else:
return render(request, 'profile_page/profile-page.html', context)
else: # POST
contract_id = request.POST.get("contract_id")
if "first_name" in request.POST:
user = Profile.objects.get(pk=request.user.pk)
form = RegisterForm(request.POST, instance=user)
user.first_name = form['first_name'].data
user.last_name = form['last_name'].data
user.phone_number = int(form['phone_number'].data)
try:
image = request.FILES.get("image")
if image is not None:
user.profile_picture = image
user.save()
messages.success(request, 'Brukerinformasjon lagret!')
except:
messages.error(request, 'Noe gikk galt, prøv igjen')
return redirect('profile')
return HttpResponseRedirect('/profile')
elif contract_id is not None:
contract = Contract.objects.get(pk=contract_id)
apartment_id = Apartment.objects.get(contracts__pk=contract_id).pk
# Brukeren er utleier og trykte på godkjenn fremleie
if "accept_owner" in request.POST:
# Godkjenner kontrakten
contract.owner_approved = True
contract.save()
# Brukeren er fremleier og trykte på godkjenn
elif "accept" in request.POST:
# Godkjenner kontrakten
contract.pending = False
start_date_accepted = contract.start_date
end_date_accepted = contract.end_date
contract.save()
Contract.objects.filter(apartment=apartment_id).exclude(
Q(pk=contract_id)).filter(
Q(pending=True)
& (Q(start_date__lte=start_date_accepted)
& Q(end_date__gte=start_date_accepted))
| (Q(start_date__lte=end_date_accepted)
& Q(end_date__gte=end_date_accepted))
| (Q(start_date__gt=start_date_accepted)
& Q(end_date__lt=end_date_accepted))).delete()
# Brukeren trykte på avslå
elif "decline" in request.POST:
contract.delete()
# Viser profilsiden dersom brukeren fremdeles er logget inn
if request.user.is_authenticated:
return render(request, 'profile_page/profile-page.html', context)
else:
messages.warning(request, "Du må logge inn først")
return redirect('landing-page')
def landing_page(request):
create_review_models()
form = RegisterForm()
distinct_cities = Apartment.objects.values('city').distinct().count()
distinct_apartments = Apartment.objects.all().count()
if request.method == 'GET':
context = {
'form': form,
'distinct_cities': distinct_cities,
'distinct_apartments': distinct_apartments
}
return render(request, 'landingpage/landing-page.html', context)
else: # POST
if request.POST.get("first_name"): # Register
print("Registrering")
form = RegisterForm(request.POST, request.FILES or None)
if form.is_valid():
user = form.save(commit=False)
# Cleaned (normalized) data
email = form.cleaned_data['email'].lower()
password = form.cleaned_data['password']
user.set_password(password)
try:
image = request.FILES.get("image")
if image is not None:
user.profile_picture = image
user.save()
except:
messages.error(request, 'Noe gikk galt, prøv igjen')
return redirect('/')
# Returns User objects if credentials are correct
user = authenticate(email=email, password=password)
if user is not None:
if user.is_active:
login(request, user) # User is logged in
messages.success(request,
'Du er nå registrert og logget inn!')
return redirect('/')
else:
messages.warning(request, form.errors)
return render(
request, 'landingpage/landing-page.html', {
'form': form,
'distinct_cities': distinct_cities,
'distinct_apartments': distinct_apartments
})
else:
email = request.POST.get("email").lower()
password = request.POST.get("password")
user = authenticate(request, email=email, password=password)
if user is not None:
login(request, user)
messages.success(request, 'Du er nå logget inn!')
return redirect('landing-page')
else:
messages.error(request,
'Fant dessverre ikke brukeren, prøv på nytt')
return redirect('landing-page')
def get(self, request):
form = RegisterForm()
return render(request, self.template_name, context={'form': form})
def test_form_no_data(self):
form = RegisterForm(data={})
self.assertFalse(form.is_valid())
self.assertEqual(len(form.errors), 5)
def register_view(request):
# This view registers new users.
if request.user.is_authenticated:
return redirect(settings.LOGIN_REDIRECT_URL)
error_register = False
# We use the context because we have two forms in the same page.
context = {
'login_form': LoginForm(),
'register_form': RegisterForm(request.POST),
'error_register': error_register
}
if request.method == "POST":
form = RegisterForm(request.POST)
if form.is_valid():
# Getting the form data.
first_name_reg = form.cleaned_data["first_name_reg"]
last_name_reg = form.cleaned_data["last_name_reg"]
username_reg = form.cleaned_data["username_reg"]
email_reg = form.cleaned_data["email_reg"]
password_reg = form.cleaned_data["password_reg"]
account_type = form.cleaned_data["account_type"]
# Checking if the user already exits.
user = authenticate(username=username_reg, password=password_reg)
if user:
error_register = True
context['error_register'] = error_register
context['error_message'] = '* Username already exists.'
else:
# Creating the new user.
new_user = User.objects.create_user(username_reg, email_reg,
password_reg)
new_user.first_name = first_name_reg
new_user.last_name = last_name_reg
new_user.save()
# Every user has a profile. We create a profile and save it.
new_profile = Profile.objects.create(user=new_user)
new_profile.profile_type = account_type
new_profile.save()
# Authenticating the user.
user = authenticate(username=username_reg,
password=password_reg)
# data is correct (It should be correct in this case).
if user:
login(request, user)
return redirect(settings.LOGIN_REDIRECT_URL)
else:
error_register = True
context['error_register'] = error_register
else:
error_register = True
context['error_register'] = error_register
try:
context['error_message'] = form._errors["password_reg"]
except KeyError:
try:
context['error_message'] = form._errors["email_reg"]
except KeyError:
context['error_message'] = form._errors["username_reg"]
else:
form = RegisterForm()
error_register = True
context['error_register'] = error_register
return render(request, 'registration/login_register.html', context)
def register_form(context, request):
form = RegisterForm()
return {
'form': form,
'request': request,
}
