def register(request):
if request.user != None and request.user.is_authenticated():
return redirect('/')
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
#Create the user
email = form.cleaned_data.get('email')
passwd = form.cleaned_data.get('password1')
user = User(email=email)
user.set_password(passwd)
user.save()
user.username = user.pk
user.save()
user_profile = UserProfile(user=user)
user_profile.save()
user.backend='user_backends.email_username.EmailOrUsernameModelBackend'
#logs the new user
login(request,user)
return redirect('/')
else:
form = RegistrationForm()
return locals()
def post(self, request, *args, **kwargs):
form = RegistrationForm(request.POST)
if form.is_valid():
fname = form.cleaned_data.get('fname')
lname = form.cleaned_data.get('lname')
usrnm = form.cleaned_data.get('usrnm')
email = form.cleaned_data.get('email')
passw = form.cleaned_data.get('pass1')
user = User.objects.create_user(usrnm, email, passw)
user.first_name = fname
user.last_name = lname
user.save()
messages.info(request,
'''Your new account has been created.
You may now login using your username and password.''')
return redirect('account_login')
else:
return self.render_to_response({
'form': form
})
def login(request):
login_form = LoginForm()
register_form = RegistrationForm()
next = request.REQUEST.get('next', settings.LOGIN_REDIRECT_URL)
# Special case next urls that will lead us into redirect loops
if next == settings.LOGIN_URL:
next = settings.LOGIN_REDIRECT_URL
if 'kind' in request.POST:
if request.POST['kind'] == 'register':
register_form = RegistrationForm(request.POST)
if register_form.is_valid():
_backend_hackend(request, register_form.save())
return HttpResponseRedirect(next)
elif request.POST['kind'] == 'login':
login_form = LoginForm(request.POST)
if login_form.is_valid() and login_form.user:
_backend_hackend(request, login_form.user)
return HttpResponseRedirect(next)
context = {
'login_form': login_form,
'register_form': register_form,
'next': next,
}
return render_to_response('accounts/login.html', context,
context_instance=RequestContext(request))
def test_non_matching_passwords(self):
form = RegistrationForm(self.non_matching_passwords)
self.assertFalse(form.is_valid())
self.assertEqual(
form.errors,
{'__all__': [u"Passwords don't match."]}
)
def test_invalid_email(self):
form = RegistrationForm(self.invalid_email)
self.assertFalse(form.is_valid())
self.assertEqual(
form.errors,
{'email': [u'Enter a valid email address.']}
)
def register(request):
code = ""
if request.method == 'POST':
username = request.POST['username']
password = request.POST['password']
email = request.POST['email']
form = RegistrationForm(request.POST)
if form.is_valid():
salt = sha.new(str(random.random())).hexdigest()[:5]
activation_code = sha.new(salt+username).hexdigest()
key_expires = datetime.datetime.today() + datetime.timedelta(7)
user = User.objects.create_user(username=username, email=email, password=password)
user.is_active = False
user.save()
profile = form.save(commit=False)
profile.user = user
profile.activation_code = activation_code
profile.key_expires = key_expires
profile.save()
return render_to_response('accounts/register.html',
{'code':activation_code, 'profile':profile}, context_instance=RequestContext(request))
else:
salt = sha.new(str(random.random())).hexdigest()[:5]
activation_code = sha.new(salt+username).hexdigest()
return render_to_response('accounts/register.html',
{'form':form, 'code':activation_code}, context_instance=RequestContext(request))
else:
form = RegistrationForm()
return render_to_response('accounts/register.html',{'form':form, 'code':code})
def register(request):
"""
用户注册
"""
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
user = User.objects.create_user(
username=form.cleaned_data['username'],
password=form.cleaned_data['password2'],
email=form.cleaned_data['email'],
)
user.save()
#保存用户城市数据
users = Users(
user=user,
city=form.cleaned_data['citycode'],
)
users.save()
#注册成功
return render_to_response('warn.html',{'warning':'注册成功！',}, context_instance=RequestContext(request))
else:
form = RegistrationForm()
return render_to_response('account/register.html',{'form':form,},
context_instance=RequestContext(request))
def WeightloserRegistration(request):
if request.user.is_authenticated():
return HttpResponseRedirect('/profile/')
if request.method=='POST':
form=RegistrationForm(request.POST)
if form.is_valid():
emailtemp=str(form.cleaned_data['emailId'])
name=emailtemp.split("@")[0]
user = User.objects.create_user(username=name, email = form.cleaned_data['emailId'], password = form.cleaned_data['password'])
user.save()
weightloser = WeightLoser(user=user, fname=form.cleaned_data['fname'],lname=form.cleaned_data['lname'], dob=form.cleaned_data['dob'],gender=form.cleaned_data['gender'],emailId=form.cleaned_data['emailId'],currentWeight=form.cleaned_data['currentWeight'])
weightloser.save()
userwloser = authenticate(username=name, password=form.cleaned_data['password'])
login(request, userwloser)
print "user is "+str(request.user.is_authenticated())
return HttpResponseRedirect('/profile/')
else: #display the form when not valid
return render_to_response('RegisterPage.html',{'form':form}, context_instance=RequestContext(request))
else: #Showing the form
'''user is not submitting the form, show them a blank registration form'''
form=RegistrationForm()
context={'form':form}
return render_to_response('RegisterPage.html',context, context_instance=RequestContext(request))
def register(self, request, **kwargs):
"""
Create and immediately log in a new user.
"""
invitation_key = kwargs.get('invitation_key', None)
email = kwargs.get('email', None)
if request.POST:
form = RegistrationForm(request.POST)
if form.is_valid():
user = form.save(commit=False)
user.email = email # email was omitted from form - it's required to use the same email invitation was sent to
user.save() # default groups and all pending accesses are automatically assigned - signal
else:
return None
#username, email, password = kwargs['username'], kwargs['email'], kwargs['password1']
#User.objects.create_user(username, email, password)
# authenticate() always has to be called before login(), and
# will return the user we just created.
new_user = authenticate(username=user.username, password=form.cleaned_data['password1'])
login(request, new_user)
signals.user_registered.send(sender=self.__class__,
user=new_user,
invitation_key=invitation_key,
request=request)
return new_user
def signup(request):
if request.user.is_authenticated():
return HttpResponseRedirect('/profile/')
if request.method=="POST":
form = RegistrationForm(request.POST) #take the form and fill it with what has been POST'ed
if form.is_valid():
user = User.objects.create_user(form.cleaned_data['username'], form.cleaned_data['email'], form.cleaned_data['password'])
user.save()
#possibly might need these lines of code for edit profile
#uprofile = user.get_profile() #remember its set in settings
#uprofile.avatar = form.cleaned_data['avatar']
#uprofile.name = form.cleaned_data['name']
#uprofile.website = form.cleaned_data['website']
#uprofile.bio = form.cleaned_data['bio']
#uprofile.save() #save our UserProfile object, which contains our User extra data or subclass.
"""create UserProfile object manually. uncomment when done in editprofile view"""
# userprofile = UserProfile(user=user, avatar=form.cleaned_data['avatar'],name=form.cleaned_data['name'],)
# userprofile.save()
return HttpResponseRedirect('/a/profile/') # because we have to return HTTP response else error is thrown
else: #in case form isnt valid show the form again. this time possibly with errors and such
return render_to_response('accounts/register.html', {'form':form}, context_instance=RequestContext(request))
else:
form = RegistrationForm()
context = {'form':form}
return render_to_response('accounts/register.html', context, context_instance=RequestContext(request))
class RegisterView(TemplateView):
template_name = "register.html"
def __init__(self):
super(RegisterView, self).__init__()
self.form = RegistrationForm()
def get_context(self, request, *args, **kwargs):
context = {
'form': self.form
}
return context
def get(self, request, *args, **kwargs):
return self.render_to_response(self.get_context(request))
def post(self, request, *args, **kwargs):
self.form = RegistrationForm(request.POST)
if self.form.is_valid():
self.form.save()
user = auth.authenticate(username=self.form.user.email, password=self.form.str_password)
auth.login(request, user)
send([user], 'registration')
return HttpResponseRedirect("/accounts/personal-data-master/")
return self.render_to_response(self.get_context(request))
def register(request):
#create_superuser('*****@*****.**', 'password')
register_success = False
form = RegistrationForm()
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
# Check this, change it to email in html template
# in html, the input element has name as 'username', but we are showing label as email, so we will accept it as 'email'
email = request.POST.get('username')
password = request.POST.get('password1')
# There are errors, if the email gets repeated,
# check, some authentication, if UserValid only then fire a create_user, else, print some error in html
if not user_exists(email):
create_user(email, password)
else: # if user exists, then log him in
# If user created properly, then login
# This login is NOT WORKING, see y?
#import django.contrib.auth.views as v
#v.login(request)
pass
register_success = True
# return HttpResponseRedirect("/")
else:
form = RegistrationForm(request.POST)
d = { 'form': form, "register_success": register_success, }
#return render(request, "registration/register.html", { 'form': form, })
return render(request, 'registration/registration.html', d, context_instance=RequestContext(request))
def register(request):
if request.method == 'POST':
form = RegistrationForm(data=request.POST)
if form.is_valid():
user = form.save()
return redirect('/accounts/register_success')
else:
form = RegistrationForm()
return render(request,'accounts/register.html', {'form':form,})
def register(request,template_name='register/p_register.html'):
if request.user.is_authenticated():
return HttpResponseRedirect(reverse('views.home'))
template_var={}
form = RegistrationForm()
if request.method == 'POST':
form = RegistrationForm(request.POST.copy())
if form.is_valid():
username = form.cleaned_data['username']
email = form.cleaned_data['email']
password = form.cleaned_data['password']
user = User.objects.create_user(username,email,password)
if accounts_settings.USER_ACTIVE_BY_EMAIL == True:
user.is_active = False
user.save()
if accounts_settings.USER_ACTIVE_BY_EMAIL == False:
#if it's unnecessary to active by email, login directly.
_login(request, email, password)
return HttpResponseRedirect(reverse('views.home'))
else:
"""
Generates a one-use only link for activation and sends to the user
"""
from django.core.mail import send_mail
email_template_name = 'register/activation_email.html'
current_site = get_current_site(request)
site_name = current_site.name
domain = current_site.domain
use_https = False
t = loader.get_template(email_template_name)
c = {
'email': user.email,
'domain': domain,
'site_name': site_name,
'uid': int_to_base36(user.id),
'user': user,
'token': default_token_generator.make_token(user),
'protocol': use_https and 'https' or 'http',
}
try:
send_mail(_(u'%s：激活账户') % site_name,
t.render(Context(c)), None, [user.email])
return HttpResponseRedirect(reverse('accounts.views.register_complete'))
except:
user.delete()
return TemplateView.as_view(template_name='register/register_fail.html')
template_var['form'] = form
return render_to_response(template_name, template_var, context_instance=RequestContext(request))
def create_user_from_weibo(request, template_name='register/create_user_from_weibo.html'):
oauth_access_token = request.session.get('oauth_access_token', None)
if request.user.is_authenticated() or oauth_access_token is None:
return HttpResponseRedirect(reverse('home.views.index'))
client = APIClient(app_key=APP_KEY, app_secret=APP_SECRET, redirect_uri=_get_weibo_callback_url(request))
client.set_access_token(oauth_access_token['access_token'], oauth_access_token['expires_in'])
weibo_user = client.get.users__show(uid=oauth_access_token['uid'])
weibo_username = weibo_user.screen_name
template_var = {}
form = RegistrationForm(initial={'username': weibo_username })
if request.method == 'POST':
form = RegistrationForm(request.POST.copy())
if request.method == 'POST':
if form.is_valid():
username = form.cleaned_data['username']
email = form.cleaned_data['email']
password = form.cleaned_data['password']
user = User.objects.create_user(username,email,password)
user.is_active = True
user.save()
profile = UserProfile()
profile.user = user
profile.song_ord_filed = 'post_datetime'
profile.save()
#weibo信息记录
w_user = WeiboUser()
w_user.user = user
w_user.weibo_user_id = oauth_access_token['uid']
w_user.weibo_username = weibo_username
w_user.oauth_access_token = oauth_access_token['access_token']
w_user.save()
#发微博提示
if request.POST.get('update_msg'):
msg = request.POST.get('bind_msg')[0:140]
client.post.statuses__update(status=msg)
user = authenticate(username=username, password=password)
auth_login(request,user)
return HttpResponseRedirect(reverse('songs.views.my_home'))
template_var['form'] = form
template_var['weibo_username'] = weibo_username
return render_to_response(template_name, template_var, context_instance=RequestContext(request))
def register_user(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
obj = form.save()
return HttpResponse('<meta http-equiv="refresh" content="1;url=/"/>Registration was successfull')
args = {}
args.update(csrf(request))
args['form'] = RegistrationForm()
return render_to_response('register.html', args)
def registration(request):
if request.user.is_authenticated():
return HttpResponseRedirect(reverse("accounts-home"))
if request.method == "POST":
form = RegistrationForm(request, request.POST)
if form.is_valid():
user = form.save()
send_activation(user)
return render(request, "accounts/registration_done.html")
else:
form = RegistrationForm(request)
return render(request, "accounts/registration.html", {"form": form})
def register(request):
registration_form = RegistrationForm(request.POST or None, request=request)
if registration_form.is_valid():
user = registration_form.save()
_backend_hackend(request, user)
return HttpResponseRedirect(request.REQUEST.get('next', '/'))
context = {
'registration_form': registration_form,
'months': range(1, 13),
'years': range(2011, 2036),
}
return TemplateResponse(request, 'accounts/register.html', context)
def registration(request):
if request.user.is_authenticated():
return HttpResponseRedirect(reverse('accounts-home'))
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
user = form.save()
send_activation(user)
return render(request, 'accounts/registration_done.html')
else:
form = RegistrationForm()
return render(request, 'accounts/registration.html', {'form': form})
def registration(request):
if request.user.is_authenticated():
return HttpResponseRedirect(reverse("accounts-home"))
if request.method == "POST":
form = RegistrationForm(request, request.POST)
if form.is_valid():
user = form.save()
send_activation2(user)
return render_to_response('accounts/registration_done.html', locals(), context_instance=RequestContext(request))
else:
form = RegistrationForm(request)
return render_to_response('accounts/registration.html', locals(), context_instance=RequestContext(request))
def registration(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
new_user = form.save()
password = new_user.password
new_user.set_password(password)
create_cloud_container ( new_user.username )
new_user.save()
user = authenticate(username=new_user.username, password=password)
login(request, user)
return HttpResponseRedirect('/%s' % user.username)
else:
form = RegistrationForm()
return render(request, 'registration.html', {'form': form}, context_instance=RequestContext(request))
def post(self, request):
form = RegistrationForm(request.POST)
print 'In Register View --- Post'
if form.is_valid():
user = User.objects.create_user(
username = form.cleaned_data['username'],
password = form.cleaned_data['password1'],
email = form.cleaned_data['email'],
#role = form.cleaned_data['role'],
)
user.save()
return HttpResponseRedirect('/register/success/')
variables = RequestContext(request, {'form' : form })
return render_to_response('registration/register.html', variables,)
def create_user(request):
form = RegistrationForm(request.POST or None)
if request.method == "POST" and form.is_valid():
form.save()
user = authenticate(username=form.cleaned_data["username"],
password=form.cleaned_data["password1"])
login(request, user)
return redirect("accounts:profile")
return render(request, "accounts/create.html", {
"form": form,
})
def register(request):
if request.user.is_authenticated(): # Check if the user is logged in
messages.add_message(request, messages.INFO, "You're currently logged in to Comet. If you want to register another account please <a href='/logout'>logout</a> first.")
return redirect("frontpage") # User is logged in, return them to index
if request.POST: # Some data was posted
# Create a form instance and populate it with the Post data
form = RegistrationForm(request.POST)
# Check whether the form is valid.
if form.is_valid():
# Form data is valid, send a verification email.
data = form.cleaned_data
user_url = generate()
while User.objects.filter(user_url=user_url).exists():
user_url = generate()
# You need to call user.objects.create_user rather than accessing
# the user manager directly.
User.objects.create_user(
email=data["email"],
username=data["username"],
password=data["password"],
user_url=user_url,
)
# Authenticate
user = authenticate(
username=data["email"],
password=data["password"],
)
login_user(request, user) # Log the user in.
if "next" in request.GET:
return redirect(request.GET["next"])
return redirect("messages")
# Form data was invalid, render the page with error messages
next_dir = ""
if "next" in request.GET:
next_dir=request.GET["next"]
return renderRegister(request, next_dir=next_dir, form=form)
else: # No data was posted, render a regular page
next_dir = ""
if "next" in request.GET:
next_dir=request.GET["next"]
return renderRegister(request, next_dir=next_dir)
def register(request):
"""
User registration view.
"""
navbarlinks = list_navbarlinks(request, ["Registration", "Help page"])
navbarlinks.append({"url": "/help#helpsection_registrationpage", "title": "Help page", "icon": "question-sign"})
shortcutlinks = list_shortcutlinks(request, ["Registration"])
auth_email = request.session["auth_email"]
auth_firstname = request.session["auth_firstname"]
auth_surname = request.session["auth_surname"]
auth_data = {"auth_email": auth_email, "auth_firstname": auth_firstname, "auth_lastname": auth_surname}
if request.method == 'POST':
data = request.POST.copy()
data.update(auth_data)
form = RegistrationForm(data=data)
if form.is_valid():
try:
user = form.save()
request.session["registration_state"] = "done"
user = authenticate(email=auth_email, password="******")
if user.is_active:
django_login(request, user)
request.session["user"] = user.annotator_id.annotator_id
except IntegrityError:
# catch "UNIQUE constraint failed" error
# May catch other errors in which case the error message displayed in the UI would not be accurate
return render_to_response(
'accounts/register.html',
{'navbarlinks': navbarlinks, 'shortcutlinks': shortcutlinks, 'form': form, 'alreadytaken': True},
context_instance=RequestContext(request)
)
return redirect('/interface_main')
else:
print form.errors
else:
form = RegistrationForm(data=auth_data)
return render_to_response('accounts/register.html', {
'navbarlinks': navbarlinks,
'shortcutlinks': shortcutlinks,
'auth_email': auth_email,
'auth_firstname': auth_firstname,
'auth_lastname': auth_surname,
'form': form,}, context_instance=RequestContext(request))
def AccountRegistration(request):
if request.user.is_authenticated():
return HttpResponseRedirect('/')
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
user = User.objects.create_user(username=form.cleaned_data['username'], password=form.cleaned_data['password'])
user.save()
return HttpResponseRedirect('/')
else:
return render_to_response('register.html', {'form': form}, context_instance = RequestContext(request))
else:
# user not submitted form show blank
form = RegistrationForm()
context = {'form': form}
return render_to_response('register.html', context, context_instance = RequestContext(request))
def payment(request):
form = RegistrationForm(request.POST or None)
context = {
'form': form,
'PAYMILL_PUBLIC_KEY': settings.PAYMILL_PUBLIC_KEY,
}
if form.is_valid():
token = request.POST['paymillToken']
try:
# Let's request a payment with our provider
client = card = subscription = None
py = pymill.Pymill(settings.PAYMILL_PRIVATE_KEY)
client = py.new_client(form.cleaned_data['email'])
card = py.new_card(token, client.id)
offer_id = settings.PAYMILL_OFFER_ID
subscription = py.new_subscription(client.id, offer_id, card.id)
except Exception:
logger.error('Payment error token:%(token)s client:%(client)s '
'card:%(card)s' % {
'token': token,
'client': client.id if client else 'NC',
'card': card.id if card else 'NC'})
message = _('There was a problem processing your credit card. '
'Your account was not created. Please, try again in '
'a few minutes or with different payment informations.')
messages.error(request, message)
return context
# So payment was created, and form data is valid
# Let's create this user account
data = form.cleaned_data
user = User.objects.create_user(data['email'], data['phone'],
is_active=False,
paymill_client_id=client.id,
paymill_card_id=card.id,
paymill_subscription_id=subscription.id)
logger.warning('New user created: %s' % user.email)
user.reset_activation_key()
user.send_activation_key()
message = _('Congratulations! Your account was created. You will receive '
'your activation email in a few seconds.')
messages.success(request, message)
return redirect('login')
return context
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
new_user = form.save()
# messages.info(request, "Thanks for registering. You are now logged in.")
new_user = authenticate(username= request.POST['email'],
password= request.POST['password1'])
login(request, new_user)
return HttpResponseRedirect('/dashboard/')
else:
form = RegistrationForm()
token = {}
token.update(csrf(request))
print token
token['form'] = form
return render_to_response('accounts/register.html', token)
def register(request):
if not request.user.is_authenticated():
title = 'register'
form = RegistrationForm(request.POST or None)
if request.POST and form.is_valid():
user = form.save()
if user:
return redirect('accounts:login')
context = {
'form': form,
'title':title,
}
return render(request, 'accounts/base.html', context)
else:
return redirect('accounts:view')
def register(request):
"""
User registration view.
"""
success = False
show_activation_info = False
if request.method == 'POST':
form = RegistrationForm(data=request.POST)
if form.is_valid():
user = form.save()
success = True
show_activation_info = not user.is_active
else:
form = RegistrationForm()
return render_to_response('register.html', {
'form': form, 'success': success, 'show_activation_info': show_activation_info
}, context_instance=RequestContext(request))
def register(request):
if request.method == 'POST':
user_form = RegistrationForm(request.POST, request.FILES)
profile_form = HomeForm(request.POST, request.FILES or None)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.refresh_from_db() # This will load the Profile created by the Signal
profile_form = HomeForm(request.POST, instance=user.userprofile) # Reload the profile form with the profile instance
profile_form.full_clean() # Manually clean the form this time. It is implicitly called by "is_valid()" method
profile_form.save() # Gracefully save the form
current_site = get_current_site(request)
subject = 'Activate Your MySite Account'
message = render_to_string('accounts/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),
})
user.email_user(subject, message)
return redirect(reverse_lazy('account_activation_sent'))
else:
user_form = RegistrationForm()
profile_form = HomeForm()
return render(request, 'accounts/reg_form.html', {
'user_form': user_form,
'profile_form': profile_form
})
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
user = form.save()
user.refresh_from_db(
) # load the profile instance created by the signal
user.userprofile.city = form.cleaned_data.get('city')
user.userprofile.country = form.cleaned_data.get('country')
user.userprofile.address1 = form.cleaned_data.get('address1')
user.userprofile.address2 = form.cleaned_data.get('address2')
user.userprofile.state = form.cleaned_data.get('state')
user.userprofile.postcode = form.cleaned_data.get('postcode')
user.userprofile.company = form.cleaned_data.get('company')
user.userprofile.role = form.cleaned_data.get('role')
geolocator = Nominatim()
fulladdress = user.userprofile.city + ' ' + user.userprofile.country + ' ' + user.userprofile.postcode + ' ' + user.userprofile.address1
location = geolocator.geocode(fulladdress)
user.userprofile.lat = location.latitude
user.userprofile.lon = location.longitude
print(user.userprofile.city + ' ' + user.userprofile.country +
' ' + user.userprofile.postcode + ' ' +
user.userprofile.address1)
print(location.latitude, location.longitude)
user.save()
raw_password = form.cleaned_data.get('password1')
user = authenticate(username=user.username, password=raw_password)
login(request, user)
return redirect('/account/my-product')
else:
form = RegistrationForm()
return render(request, 'accounts/reg_form.html', {'form': form})
def register(request):
if request.method == 'POST':
form = RegistrationForm(data=request.POST)
profile_form = DeliveryPersonProfileForm(data=request.POST, files=request.FILES)
if form.is_valid() and profile_form.is_valid():
new_user = form.save(commit=False)
new_user.is_delivery_person = True
new_user.save()
user_profile = profile_form.save(commit=False)
user_profile.user = new_user
user_profile.save()
username = form.cleaned_data.get('username')
messages.success(request, f'Account was created for {username}!')
return redirect('admin:delivery_person_registerdeliveryuser_changelist')
else:
form = RegistrationForm()
profile_form = DeliveryPersonProfileForm()
context = {
'form': form,
'profile_form': profile_form,
'title': 'Register Delivery Person',
}
return render(request, 'delivery_person/register.html', context)
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
response_data = {}
if form.is_valid():
user = form.save(commit=False)
user.save()
response_data['status'] = True
response_data[
'msg'] = "El Usuario " + user.email + " se creo correctamente."
return HttpResponse(json.dumps(response_data),
content_type="application/json")
else:
response_data['status'] = False
response_data['errors'] = form.errors
return HttpResponse(json.dumps(response_data),
content_type="application/json")
else:
form = RegistrationForm()
args = {'form': form}
return render(request, 'registration/registerUser.html', args)
def register(request):
error = ""
done = False
if request.user.is_authenticated:
return HttpResponseRedirect('/')
if request.method == 'POST':
form = RegistrationForm(request.POST)
if not form.is_valid():
error += "Invalid information/ Email already in use."
else:
user = form.save(commit=False)
user.is_active = True
user.set_password(form.cleaned_data["password1"])
user.save()
Profile.objects.create(user=user)
done = True
else:
form = RegistrationForm()
return render(request, 'accounts/register.html', {
'form': form,
'error': error,
'done': done,
})
def register(request):
"""
User registration view.
"""
navbarlinks = list_navbarlinks(request, ["Registration", "Help page"])
navbarlinks.append({
"url": "/help#helpsection_registrationpage",
"title": "Help page",
"icon": "question-sign"
})
shortcutlinks = list_shortcutlinks(request, ["Registration"])
if request.method == 'POST':
form = RegistrationForm(data=request.POST)
if form.is_valid():
user = form.save()
return redirect('/login')
else:
print form.errors
else:
form = RegistrationForm()
return render_to_response('accounts/register.html', {
'navbarlinks': navbarlinks,
'shortcutlinks': shortcutlinks,
'form': form,
},
context_instance=RequestContext(request))
def register(request):
if request.method == "POST":
form = RegistrationForm(request.POST)
if form.is_valid():
new_user = form.save(commit=False)
new_user.set_password(form.cleaned_data["password"])
new_user.save()
if settings.AVATAR_SITE:
Profile.objects.create(user = new_user, avatar = ImageFieldFile(instance=None, field=FileField(), name='user_avatars/default.png'))
else:
Profile.objects.create(user = new_user, field=FileField(), name='user_avatars/default.png')
# from django.contrib.auth.models import User
# from django.db.models.fields.files import ImageFieldFile, FileField
# from accounts.forms import Profile
# u = User.objects.get(username = "******")
# p = Profile.objects.get(user = u)
# p.avatar = ImageFieldFile(instance=None, field=FileField(), name='user_avatars/default.png')
return render(request, "accounts/registration_complete.html",
{"new_user": new_user})
else:
form = RegistrationForm()
return render(request, "accounts/register.html", {"user_form": form})
def register(request):
if request.method == 'POST':
username = request.POST.get('username', '')
password = request.POST.get('password', '')
accepted_eula = request.POST.get('accepted_eula', '')
favorite_animal = request.POST.get('favorite_animal', '')
is_exit_user = User.objects.filter(username=username).exists()
if is_exit_user:
return HttpResponse('user already exists!')
##用户自动登陆如果登陆成功说明已经注册，如果不能成功，在注册
registerform = RegistrationForm({
'username': username,
'password': password
})
userProfileform = UserProfileForm({
'accepted_eula': True,
'favorite_animal': favorite_animal
}) ##'agency_email': agency_email, 'agency_address': agency_address
if not registerform.is_valid():
return HttpResponse(registerform.errors.values())
if not userProfileform.is_valid():
return HttpResponse(userProfileform.errors.values())
user = User.objects.create_user(username=username, password=password)
profile = UserProfile()
profile.user = user
profile.accepted_eula = accepted_eula
profile.favorite_animal = favorite_animal
profile.save()
response = {
'status': 0,
'message': 'ok',
'result': {
'user_id': user.id
}
}
return HttpResponse(response)
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save() # 유저 생성해서 DB에 넣음
return redirect(reverse('home:home')) #redirect('/account')
else: #GET일 경우
form = RegistrationForm()
args = {'form': form}
return render(request, 'accounts/reg_form.html', args)
def register(request):
if request.method == 'POST': #POST method means user is sendding data to webbserver
form = RegistrationForm(request.POST)
if form.is_valid():
form.save() #creates the user in the database, saves information
return redirect('accounts:home')
else:
form = RegistrationForm()
args = {'form': form}
return render(request, 'accounts/reg_form.html', args)
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return redirect('/account')
else: # First time is GET, i.e Asking for the blank form
form = RegistrationForm()
args = {'form': form}
return render(request, 'accounts/reg_form.html', args)
def signup_users(request):
if request.method == 'POST':
username = request.POST['username']
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
request.session['username'] = username
return redirect('accounts:profil_accounts')
else:
form = RegistrationForm()
return render(request, 'accounts/signup.html', {'form': form})
def register(request):
if request.method =='POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return redirect('/accounts')
else:
form = RegistrationForm()
args = {'form': form}
return render(request, 'accounts/reg_form.html', args)
def register(request):
if request.method.lower() == 'post':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return redirect('login')
else:
form = RegistrationForm()
context = {'form': form}
return render(request, 'accounts/register_user.html', context)
def register(request):
msg = []
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
print "valid"
form.save()
return redirect('/account/login')
else:
form = RegistrationForm()
# username taken
if User.objects.filter(username=request.POST['username']).exists():
msg.append("username Exist")
# used email address
if User.objects.filter(email=request.POST['email']).exists():
msg.append("Email Address Exist")
# different password
if request.POST['password1'] != request.POST['password2']:
msg.append(
"Your password and confirmation password do not match.")
# password requirement
if len(request.POST['password1']) < 8 or len(
request.POST['password2']) < 8:
msg.append("Password must be more than 8 characters")
elif request.POST['password1'].isdigit(
) or request.POST['password2'].isdigit():
msg.append("Password must not be only integer")
args = {
'form': form,
'msg': msg,
'msgtrue': "true",
'alerttype': 'danger',
}
return render(request, 'accounts/reg_form.html', args)
else:
form = RegistrationForm()
args = {
'form': form,
'useractive': 'false',
}
return render(request, 'accounts/reg_form.html', args)
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return redirect(reverse('timemanager:manager'))
else:
form = RegistrationForm()
args = {'form': form}
return render(request, 'accounts/register.html', args)
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
messages.success(request, f'Cuenta Registrada!')
return redirect(reverse('accounts:register'))
else:
form = RegistrationForm()
args = {'form': form}
return render(request, 'accounts/reg_form.html', args)
def register(request):
if request.method == 'POST':
reg_form = RegistrationForm(request.POST)
if reg_form.is_valid():
reg_form.save()
return HttpResponseRedirect('/')
else:
reg_form = RegistrationForm()
args = {'reg_form': reg_form}
return render(request, 'register.html', args)
def register(request):
form = RegistrationForm()
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
success = messages.success(
request,
'Thank you for creating an account here ! please login !')
return redirect('login/')
return render(request, 'accounts/register.html', {'form': form})
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
# Checks if the form is valid
if form.is_valid():
form.save()
return redirect('../../account/login')
else:
form = RegistrationForm()
# Passes the form as an argument to the html template
args = {'form': form}
return render(request, 'accounts/reg_form.html', args)
def register(request):
if request.method == "POST":
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('acoount/login')
else:
return HttpResponseRedirect('account/register')
else:
form = RegistrationForm()
args = {'form': form}
return render(request, 'account/register.html', args)
def register(request):
template = 'accounts/register.html'
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return redirect('/')
return render(request, template, {'form': form})
form = RegistrationForm()
if request.user.is_authenticated:
return redirect('/')
return render(request, template, {'form': form})
def signup_view(request):
if(request.method=='POST'):
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return redirect('/')
else:
return HttpResponse("Please Enter good password")
else:
form = RegistrationForm()
args = {'form':form}
return render(request,'accounts/signup.html',args)
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
args = {"user": request.user}
return render(request, 'accounts/profile.html', args)
else:
form = RegistrationForm()
args = {'form': form}
return render(request, 'accounts/reg_form.html', args)
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return redirect(reverse('home:home'))
context = {'form': form}
return render(request, 'accounts/register.html', context)
else:
form = RegistrationForm()
context = {'form': form}
return render(request, 'accounts/register.html', context)
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
if form.cleaned_data['password1'] == form.cleaned_data[
'password2']:
password = form.cleaned_data['password1']
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'],
password=password,
)
user.save()
return redirect('logout')
else:
# return redirect('')
raise Exception(form.errors)
else: # its a get
form = RegistrationForm()
args = {'form': form}
return render(request, 'register.html', args)
def RegistrationView(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
print("The form reached")
print(form.is_valid())
if form.is_valid():
print("the form is validated")
form.save() # this pretty much creates the user
return redirect('/account') # this is /account
# giving them the opportunity to get the form
# the else condition is working
else:
form = RegistrationForm()
args = {'form': form}
# this refers to the template, so accounts/reg_form.html
return render(request, 'accounts/signup.html', args)
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
username = form.cleaned_data.get('username')
raw_password = form.cleaned_data.get('password1')
user = authenticate(username=username, password=raw_password)
login(request, user)
return redirect('accounts:login')
else:
form = RegistrationForm()
return render(request, 'accounts/templates/registration/register.html', {'form': form})
def register_view(request):
if request.method == "POST":
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
username = form.cleaned_data.get('username')
raw_password = form.cleaned_data.get('password1')
user = authenticate(username=username, password=raw_password)
login(request, user)
return redirect('home')
else:
form = RegistrationForm()
return render(request, "register.html", {'form': form})
def register(request):
template_name = 'accounts/register.html'
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
messages.success(request, 'Account created successfully')
return HttpResponseRedirect(reverse('accounts:login_view'))
else:
form = RegistrationForm()
return render(request, template_name, {
'form': form,
})
