def signup(request, template="accounts/account_signup.html"):
"""
Signup form.
"""
profile_form = get_profile_form()
form = profile_form(request.POST or None, request.FILES or None)
if request.method == "POST" and form.is_valid():
new_user = form.save()
if not new_user.is_active:
if settings.ACCOUNTS_APPROVAL_REQUIRED:
send_approve_mail(request, new_user)
info(
request,
_("Thanks for signing up! You'll receive "
"an email when your account is activated."))
else:
send_verification_mail(request, new_user, "signup_verify")
info(
request,
_("A verification email has been sent with "
"a link for activating your account."))
return redirect(request.GET.get("next", "/"))
else:
info(request, _("Successfully signed up"))
auth_login(request, new_user)
return login_redirect(request)
else:
log.debug('Form is not valid. Errors: %s' % form.errors)
context = {
"form": form,
"title": _("Create an Account"),
"submit_label": "Next Step"
}
return render(request, template, context)
def account(request, template="account.html"):
"""
Display and handle both the login and signup forms.
"""
login_form = LoginForm(request)
signup_form = SignupForm(request)
if request.method == "POST":
posted_form = None
message = ""
if request.POST.get("login") is not None:
login_form = LoginForm(request, request.POST)
if login_form.is_valid():
posted_form = login_form
message = _("Successfully logged in")
else:
signup_form = SignupForm(request, request.POST)
if signup_form.is_valid():
new_user = signup_form.save()
if not new_user.is_active:
send_verification_mail(request, new_user)
info(request, _("A verification email has been sent with " "a link for activating your account."))
else:
posted_form = signup_form
message = _("Successfully signed up")
if posted_form is not None:
posted_form.login(request)
info(request, message)
return redirect(request.GET.get("next", "/"))
context = {"login_form": login_form, "signup_form": signup_form}
return render(request, template, context)
def signup(request,
template="accounts/account_signup.html",
extra_context=None):
"""
Signup form.
"""
profile_form = get_profile_form()
form = profile_form(request.POST or None, request.FILES or None)
if request.method == "POST" and form.is_valid():
new_user = form.save()
if not new_user.is_active:
if settings.ACCOUNTS_APPROVAL_REQUIRED:
send_approve_mail(request, new_user)
info(
request,
_("Thanks for signing up! You'll receive "
"an email when your account is activated."))
else:
send_verification_mail(request, new_user, "signup_verify")
info(
request,
_("A verification email has been sent with "
"a link for activating your account."))
return redirect(next_url(request) or "/")
else:
info(request, _("Successfully signed up"))
auth_login(request, new_user)
return login_redirect(request)
context = {"form": form, "title": _("Sign up")}
context.update(extra_context or {})
return TemplateResponse(request, template, context)
def retail_signup(request, template="accounts/retail_signup.html"):
form = ProfileForm(request.POST or None)
if request.method == "POST" and form.is_valid():
new_user = form.save()
# Add to campaign monitor
if bool(form.cleaned_data.get("optin")):
cm_api = CampaignMonitorApi(settings.CM_API_KEY, settings.CM_CLIENT_ID)
listid = settings.CM_RETAIL_LIST_ID
custom_fields = {}
#try:
cm_api.subscriber_add(
listid,
form.cleaned_data.get("email"),
form.cleaned_data.get("first_name") + ' ' + form.cleaned_data.get("last_name"),
custom_fields=custom_fields)
#except:
# pass
if not new_user.is_active:
send_verification_mail(request, new_user, "signup_verify")
info(request, "A verification email has been sent with a link for activating your account.")
else:
info(request, "Successfully signed up")
auth_login(request, new_user)
return my_login_redirect(request)
context = {"form": form, "title": "Customer Registration"}
return render(request, template, context)
def signup(request, template="accounts/account_signup.html"):
"""
Signup form.
"""
profile_form = get_profile_form()
form = profile_form(request.POST or None, request.FILES or None)
if request.method == "POST" and form.is_valid():
new_user = form.save()
if not new_user.is_active:
if settings.ACCOUNTS_APPROVAL_REQUIRED:
send_approve_mail(request, new_user)
info(request, _("Thanks for signing up! You'll receive "
"an email when your account is activated."))
else:
send_verification_mail(request, new_user, "signup_verify")
info(request, _("A verification email has been sent with "
"a link for activating your account."))
return redirect(request.GET.get("next", "/"))
else:
info(request, _("Successfully signed up"))
auth_login(request, new_user)
return login_redirect(request)
else:
log.debug('Form is not valid. Errors: %s' % form.errors)
context = {"form": form, "title": _("Create an Account"), "submit_label": "Next Step"}
return render(request, template, context)
def signup(request, template="accounts/account_signup.html"):
"""
Signup form.
"""
profile_form = UserRegistrationLeadForm
form = profile_form(request.POST or None, request.FILES or None)
if request.method == "POST" and form.is_valid():
data = form.cleaned_data.copy()
# ensure user is not a robot
honeypot = data.pop('superpriority')
if honeypot:
raise PermissionDenied
# save the user
new_user = form.save()
if not new_user.is_active:
if settings.ACCOUNTS_APPROVAL_REQUIRED:
send_approve_mail(request, new_user)
info(request, _("Thanks for signing up! You'll receive "
"an email when your account is activated."))
else:
send_verification_mail(request, new_user, "signup_verify")
info(request, _("A verification email has been sent with "
"a link for activating your account."))
return redirect(next_url(request) or "/")
else:
info(request, _("Successfully signed up"))
auth_login(request, new_user)
return login_redirect(request)
context = {"form": form, "title": _("Sign up")}
return render(request, template, context)
def signup(request, template="accounts/account_signup.html",
extra_context=None):
"""
Signup form.
"""
#Staat in admin_forms
form = NewUserCreationForm(request.POST or None, request.FILES or None)
if request.method == "POST" and form.is_valid():
new_user = form.save()
if not new_user.is_active:
if settings.ACCOUNTS_APPROVAL_REQUIRED:
send_approve_mail(request, new_user)
info(request, _("Thanks for signing up! You'll receive "
"an email when your account is activated."))
else:
send_verification_mail(request, new_user, "signup_verify")
info(request, _("A verification email has been sent with "
"a link for activating your account."))
return redirect(next_url(request) or "/")
else:
info(request, _("Successfully signed up"))
auth_login(request, new_user)
return login_redirect(request)
context = {"form": form, "title": _("Sign up")}
context.update(extra_context or {})
return render(request, template, context)
def register_user(request):
print("registrando um novo usuário")
profile_form = get_profile_form()
form = profile_form(request.POST or None, request.FILES or None)
print(form)
print(dir(form))
print(form.is_valid())
if request.method == "POST" and form.is_valid():
print("Método post e form válido")
new_user = form.save()
if not new_user.is_active:
if settings.ACCOUNTS_APPROVAL_REQUIRED:
print('Usuário cadastrado, aguardando aprovação')
send_approve_mail(request, new_user)
info(
request, "Obrigado por se cadastrar! Você receberá um "
"email quando sua conta for ativada.")
else:
print('Usuário cadastrado, aguardando confirmação')
send_verification_mail(request, new_user, "signup_verify")
info(
request, "Um email de verificação foi enviado com um "
"link para ativação de sua conta.")
return redirect(next_url(request) or "/")
else:
print('usuário cadastrado com sucesso')
info(request, "Cadastro realizado com sucesso")
login(request, new_user)
return login_redirect(request)
else:
error(request, form)
return redirect(request.META['HTTP_REFERER'] + "#cadastro",
kwargs={'registration_form': form})
return redirect(next_url(request) or request.META['HTTP_REFERER'])
def password_reset(request, template="accounts/account_password_reset.html"):
form = PasswordResetForm(request.POST or None)
if request.method == "POST" and form.is_valid():
user = form.save()
send_verification_mail(request, user, "password_reset_verify")
info(request, _("A verification email has been sent with " "a link for resetting your password."))
context = {"form": form, "title": _("Password Reset")}
return render(request, template, context)
def password_reset(request, template="accounts/account_password_reset.html"):
form = PasswordResetForm(request.POST or None)
if request.method == "POST" and form.is_valid():
user = form.save()
send_verification_mail(request, user, "password_reset_verify")
info(request, _("A verification email has been sent with "
"a link for resetting your password."))
context = {"form": form, "title": _("Password Reset")}
return render(request, template, context)
def signup(request,
template="accounts/account_signup.html",
extra_context=None):
"""
Signup form. Overriding mezzanine's view function for signup submit
"""
form = SignupForm(request, request.POST, request.FILES)
if request.method == "POST" and form.is_valid():
try:
new_user = form.save()
except ValidationError as e:
messages.error(request, e.message)
return HttpResponseRedirect(request.META['HTTP_REFERER'])
else:
if not new_user.is_active:
if settings.ACCOUNTS_APPROVAL_REQUIRED:
send_approve_mail(request, new_user)
info(
request,
_("Thanks for signing up! You'll receive "
"an email when your account is activated."))
else:
send_verification_mail(request, new_user, "signup_verify")
info(
request,
_("A verification email has been sent to " +
new_user.email +
" with a link that must be clicked prior to your account "
"being activated. If you do not receive this email please "
"check that you entered your address correctly, or your "
"spam folder as sometimes the email gets flagged as spam. "
"If you entered an incorrect email address, please request "
"an account again."))
return redirect(next_url(request) or "/")
else:
info(request, _("Successfully signed up"))
auth_login(request, new_user)
return login_redirect(request)
# remove the key 'response' from errors as the user would have no idea what it means
form.errors.pop('response', None)
messages.error(request, form.errors)
# TODO: User entered data could be retained only if the following
# render function would work without messing up the css
# context = {
# "form": form,
# "title": _("Sign up"),
# }
# context.update(extra_context or {})
# return render(request, template, context)
# This one keeps the css but not able to retained user entered data.
return HttpResponseRedirect(request.META['HTTP_REFERER'])
def password_reset(request, template="accounts/account_password_reset.html",
form_class=PasswordResetForm, extra_context=None):
form = form_class(request.POST or None)
if request.method == "POST" and form.is_valid():
user = form.save()
send_verification_mail(request, user, "password_reset_verify")
info(request, _("A verification email has been sent with "
"a link for resetting your password."))
context = {"form": form, "title": _("Password Reset")}
context.update(extra_context or {})
return TemplateResponse(request, template, context)
def signup(request, template="accounts/account_signup.html", extra_context=None):
"""
Signup form. Overriding mezzanine's view function for signup submit
"""
form = SignupForm(request, request.POST, request.FILES)
if request.method == "POST" and form.is_valid():
try:
new_user = form.save()
except ValidationError as e:
if e.message == "Email already in use.":
messages.error(request, '<p>An account with this email already exists. Log in '
'or click <a href="' + reverse("mezzanine_password_reset") +
'" >here</a> to reset password',
extra_tags="html")
else:
messages.error(request, e.message)
return HttpResponseRedirect(request.META['HTTP_REFERER'])
else:
if not new_user.is_active:
if settings.ACCOUNTS_APPROVAL_REQUIRED:
send_approve_mail(request, new_user)
info(request, _("Thanks for signing up! You'll receive "
"an email when your account is activated."))
else:
send_verification_mail(request, new_user, "signup_verify")
info(request, _("A verification email has been sent to " + new_user.email +
" with a link that must be clicked prior to your account "
"being activated. If you do not receive this email please "
"check that you entered your address correctly, or your "
"spam folder as sometimes the email gets flagged as spam. "
"If you entered an incorrect email address, please request "
"an account again."))
return redirect(next_url(request) or "/")
else:
info(request, _("Successfully signed up"))
auth_login(request, new_user)
return login_redirect(request)
# remove the key 'response' from errors as the user would have no idea what it means
form.errors.pop('response', None)
messages.error(request, form.errors)
# TODO: User entered data could be retained only if the following
# render function would work without messing up the css
# context = {
# "form": form,
# "title": _("Sign up"),
# }
# context.update(extra_context or {})
# return render(request, template, context)
# This one keeps the css but not able to retained user entered data.
return HttpResponseRedirect(request.META['HTTP_REFERER'])
def password_reset(request, template="accounts/account_password_reset.html",
form_class=PasswordResetForm, extra_context=None):
form = form_class(request.POST or None)
if request.method == "POST" and form.is_valid():
user = form.save()
send_verification_mail(request, user, "password_reset_verify")
info(request, _("A verification email has been sent with "
"a link for resetting your password."))
return redirect("/forum")
context = {"form": form, "title": _("Password Reset")}
context.update(extra_context or {})
return TemplateResponse(request, template, context)
def resend_verification_email(request, email):
user = User.objects.filter(email=email).first()
if user is None:
user = User.objects.filter(username=email).first()
if user is None:
messages.error(request, _("Could not find user or email " + email))
return redirect(reverse("login"))
if user.is_active :
messages.error(request, _("User with email " + user.email + " is already active"))
return redirect(reverse("login"))
send_verification_mail(request, user, "signup_verify")
messages.error(request, _("Resent verification email to " + user.email))
return redirect(request.META['HTTP_REFERER'])
def resend_verification_email(request, email):
user = User.objects.filter(email=email).first()
if user is None:
user = User.objects.filter(username=email).first()
if user is None:
messages.error(request, _("Could not find user or email " + email))
return redirect(reverse("login"))
if user.is_active:
messages.error(
request, _("User with email " + user.email + " is already active"))
return redirect(reverse("login"))
send_verification_mail(request, user, "signup_verify")
messages.error(request, _("Resent verification email to " + user.email))
return redirect(request.META['HTTP_REFERER'])
def signup(request, template="accounts/account_signup.html"):
"""
Signup form.
"""
profile_form = UserRegistrationLeadForm
form = profile_form(request.POST or None, request.FILES or None)
if request.method == "POST" and form.is_valid():
data = form.cleaned_data.copy()
# ensure user is not a robot
honeypot = data.pop('superpriority')
if honeypot:
raise PermissionDenied
# save the user
new_user = form.save()
# Generate Salesforce Lead
# Pop non-Salesforce Fields
for field in ['password1', 'password2']:
data.pop(field)
for k, v in SALESFORCE_FIELD_MAPPINGS.items():
data[v] = data.pop(k)
data['oid'] = '00DU0000000IrgO'
# As we're doing the Salesforce POST in the background here,
# `retURL` is never visited/seen by the user. I believe it
# is required by Salesforce though, so it should hang around
# as a placeholder (with a valid URL, just in case).
data['retURL'] = (request.build_absolute_uri())
r = requests.post('https://www.salesforce.com/servlet/'
'servlet.WebToLead?encoding=UTF-8', data)
if not new_user.is_active:
if settings.ACCOUNTS_APPROVAL_REQUIRED:
send_approve_mail(request, new_user)
info(request, _("Thanks for signing up! You'll receive "
"an email when your account is activated."))
else:
send_verification_mail(request, new_user, "signup_verify")
info(request, _("A verification email has been sent with "
"a link for activating your account."))
return redirect(next_url(request) or "/")
else:
info(request, _("Successfully signed up"))
auth_login(request, new_user)
return login_redirect(request)
context = {"form": form, "title": _("Sign up")}
return render(request, template, context)
def signup(request, template="accounts/account_signup.html"):
"""
Signup form.
"""
form = ProfileForm(request.POST or None)
if request.method == "POST" and form.is_valid():
new_user = form.save()
if not new_user.is_active:
send_verification_mail(request, new_user, "signup_verify")
info(request, _("A verification email has been sent with "
"a link for activating your account."))
else:
info(request, _("Successfully signed up"))
auth_login(request, new_user)
return login_redirect(request)
context = {"form": form, "title": _("Signup")}
return render(request, template, context)
def signup(request, template="accounts/account_signup.html"):
"""
Signup form.
"""
profile_form = get_profile_form()
form = profile_form(request.POST or None, request.FILES or None)
if request.method == "POST" and form.is_valid():
new_user = form.save()
if not new_user.is_active:
if settings.ACCOUNTS_APPROVAL_REQUIRED:
send_approve_mail(request, new_user)
info(request, _("Thanks for signing up! You'll receive "
"an email when your account is activated."))
else:
send_verification_mail(request, new_user, "signup_verify")
info(request, _("A verification email has been sent with "
"a link for activating your account."))
# return redirect(request.GET.get("next", "/"))
return redirect(next_url(request) or "/")
else:
info(request, _("Successfully signed up"))
auth_login(request, new_user)
customer = request.user.get_profile()
customer_address = customer.address + ', ' + customer.zip_code
loc = location_utils.getLocation(customer_address)
correct_address = location_utils.getAddress(loc[0],loc[1])
customer.location = loc
customer.address = correct_address
customer.save()
request.session['location'] = (loc[0],loc[1])
request.session['age'] = True
request.session['address'] = correct_address
request.session['map'] = True
avail_store_ids, avail_store_names, avail_liquor_types, loc, store_locs = new_location_get_ids(request, loc)
# return login_redirect(request)
if 'cart loaded' in request.session:
return redirect('/shop/cart/')
else:
return redirect('/shop/')
context = {"form": form, "title": _("Sign up")}
return render(request, template, context)
def signup(request, template="accounts/account_signup.html"):
"""
Signup form.
"""
profile_form = get_profile_form()
form = profile_form(request.POST or None)
if request.method == "POST" and form.is_valid():
new_user = form.save()
if not new_user.is_active:
send_verification_mail(request, new_user, "signup_verify")
info(request, _("A verification email has been sent with "
"a link for activating your account."))
return redirect(request.GET.get("next", "/"))
else:
info(request, _("Successfully signed up"))
auth_login(request, new_user)
return login_redirect(request)
context = {"form": form, "title": _("Signup")}
return render(request, template, context)
def wholesale_signup(request, template="accounts/wholesale_signup.html"):
form = ProfileForm(request.POST or None)
if request.method == "POST" and form.is_valid():
new_user = form.save()
g = Group.objects.get(name='Wholesale Customers')
g.user_set.add(new_user)
# Add to campaign monitor
if bool(form.cleaned_data.get("optin")):
cm_api = CampaignMonitorApi(settings.CM_API_KEY, settings.CM_CLIENT_ID)
listid = settings.CM_WHOLESALE_LIST_ID
usertype = ""
if form.cleaned_data.get("user_type"):
try:
usertype = USER_TYPE_CHOICES[form.cleaned_data.get("user_type")]
except:
pass
elif form.cleaned_data.get("user_type_other"):
usertype = form.cleaned_data.get("user_type_other")
custom_fields = {"CustomerType": usertype}
try:
cm_api.subscriber_add(
listid,
form.cleaned_data.get("email"),
form.cleaned_data.get("first_name") + ' ' + form.cleaned_data.get("last_name"),
custom_fields=custom_fields)
except:
pass
if not new_user.is_active:
send_verification_mail(request, new_user, "signup_verify")
info(request, "A verification email has been sent with a link for activating your account.")
else:
info(request, "Successfully signed up")
auth_login(request, new_user)
send_registration_confirmation_email(request)
return my_login_redirect(request, wholesale=True)
context = {"form": form, "title": "Wholesale Customer Registration"}
return render(request, template, context)
def signup(request, template="accounts/account_signup.html"):
"""
Signup form.
"""
profile_form = UserRegistrationLeadForm
form = profile_form(request.POST or None, request.FILES or None)
if request.method == "POST" and form.is_valid():
data = form.cleaned_data.copy()
# ensure user is not a robot
honeypot = data.pop('superpriority')
if honeypot:
raise PermissionDenied
# save the user
new_user = form.save()
if not new_user.is_active:
if settings.ACCOUNTS_APPROVAL_REQUIRED:
send_approve_mail(request, new_user)
info(
request,
_("Thanks for signing up! You'll receive "
"an email when your account is activated."))
else:
send_verification_mail(request, new_user, "signup_verify")
info(
request,
_("A verification email has been sent with "
"a link for activating your account."))
return redirect(next_url(request) or "/")
else:
info(request, _("Successfully signed up"))
auth_login(request, new_user)
return login_redirect(request)
context = {"form": form, "title": _("Sign up")}
return render(request, template, context)
def save_model(self, request, obj, form, change):
"""
If the ``ACCOUNTS_APPROVAL_REQUIRED`` setting is ``True``,
send a notification email to the user being saved if their
``active`` status has changed to ``True``.
If the ``ACCOUNTS_VERIFICATION_REQUIRED`` setting is ``True``,
send a verification email instead.
"""
must_send_verification_mail_after_save = False
if change and settings.ACCOUNTS_APPROVAL_REQUIRED:
if obj.is_active and not User.objects.get(id=obj.id).is_active:
if settings.ACCOUNTS_VERIFICATION_REQUIRED:
# Accounts verification requires an inactive account
obj.is_active = False
# The token generated by send_verification_mail()
# must match the _saved_ User object,
# so postpone send_verification_mail() until later
must_send_verification_mail_after_save = True
else:
send_approved_mail(request, obj)
super(UserProfileAdmin, self).save_model(request, obj, form, change)
if must_send_verification_mail_after_save:
user = User.objects.get(id=obj.id)
send_verification_mail(request, user, "signup_verify")
def save_model(self, request, obj, form, change):
"""
If the ``ACCOUNTS_APPROVAL_REQUIRED`` setting is ``True``,
send a notification email to the user being saved if their
``active`` status has changed to ``True``.
If the ``ACCOUNTS_VERIFICATION_REQUIRED`` setting is ``True``,
send a verification email instead.
"""
must_send_verification_mail_after_save = False
if change and settings.ACCOUNTS_APPROVAL_REQUIRED:
if obj.is_active and not User.objects.get(id=obj.id).is_active:
if settings.ACCOUNTS_VERIFICATION_REQUIRED:
# Accounts verification requires an inactive account
obj.is_active = False
# The token generated by send_verification_mail()
# must match the _saved_ User object,
# so postpone send_verification_mail() until later
must_send_verification_mail_after_save = True
else:
send_approved_mail(request, obj)
super(UserProfileAdmin, self).save_model(request, obj, form, change)
if must_send_verification_mail_after_save:
user = User.objects.get(id=obj.id)
send_verification_mail(request, user, "signup_verify")
