def account_profile(request):
if request.POST.get('action') == 'makeprovider' and not request.user.has_service_provider():
request.user.service_provider = ServiceProvider.objects.create(name='Unnamed Service Provider')
request.user.service_provider.reservation_confirmation_needed = False
request.user.service_provider.save()
request.user.save()
return HttpResponseRedirect('')
if request.POST.get('action') == 'removeprovider' and request.user.has_service_provider():
service_provider = request.user.service_provider
request.user.service_provider = None
request.user.save()
service_provider.delete()
return HttpResponseRedirect('')
initial = {
'first_name': request.user.first_name,
'last_name': request.user.last_name,
'phone': request.user.phone,
'language': request.user.language,
'notification_type': request.user.notification_type,
}
if request.user.service_provider:
lat = request.user.service_provider.lat
lng = request.user.service_provider.lng
if request.user.service_provider.userpage_link:
user_page_link = '%s/u/%s' % (settings.BASE_URL, request.user.service_provider.userpage_link)
if request.method == "POST":
form = SignupForm(request.POST, initial=initial)
service_provider_form = ServiceProviderForm(request.POST, request.FILES, instance=request.user.service_provider)
if not request.user.service_provider:
if form.is_valid():
form.save(request.user)
request.session['django_language'] = request.user.language
return HttpResponseRedirect('')
elif request.user.service_provider:
if form.is_valid() and service_provider_form.is_valid():
form.save(request.user)
data = service_provider_form.cleaned_data
service_provider_form.save()
request.session['django_language'] = request.user.language
return HttpResponseRedirect('')
else:
form = SignupForm(initial=initial)
service_provider_form = ServiceProviderForm(instance=request.user.service_provider)
return render_to_response('account/profile.html', locals(), context_instance=RequestContext(request))
def signup_view(request):
if request.method == "POST":
form = SignupForm(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
name = form.cleaned_data['name']
email = form.cleaned_data['email']
password = form.cleaned_data['password']
#saving data to DB
user = UserModel(name=name,
password=make_password(password),
email=email,
username=username)
user.save()
#sg = sendgrid.SendGridAPIClient(apikey='sendgrid_key')
#from_email = Email("*****@*****.**")
#to_email = Email(email)
# subject = "Susseccfully Signed Up"
#content = Content("text/plain", "Welcome to Social Kids")
#mail = Mail(from_email, subject, to_email, content)
#response = sg.client.mail.send.post(request_body=mail.get())
#print(response.status_code)
return render(request, 'success.html')
else:
error = 'Error.Sign Up again!'
return render(request, 'index.html', {'text': error})
else:
form = SignupForm()
return render(request, 'index.html', {'signup_form': form})
def signup(request):
'''注册动作'''
errors = []
signupform = SignupForm(auto_id=True)
if request.method == 'POST':
signupform = SignupForm(request.POST)
if signupform.is_valid():
# 获取form信息
account = signupform.cleaned_data['account']
password = signupform.cleaned_data['password']
nickname = signupform.cleaned_data['nickname']
address = signupform.cleaned_data['address']
phone = signupform.cleaned_data['phone']
ex_phone = signupform.cleaned_data['ex_phone']
# TODO:创建数据库对象,写入数据库
user = {
'account':account,
'nickname':nickname,
'password':password,
}
print user
return HttpResponseRedirect('/')
return render_to_response(
'customer/signup.html',
{
'form' : signupform,
},
context_instance=RequestContext(request)
)
def signup(request):
'''注册动作'''
errors = []
signupform = SignupForm(auto_id=True)
if request.method == 'POST':
signupform = SignupForm(request.POST)
if signupform.is_valid():
# 获取form信息
account = signupform.cleaned_data['account']
password = signupform.cleaned_data['password']
nickname = signupform.cleaned_data['nickname']
address = signupform.cleaned_data['address']
phone = signupform.cleaned_data['phone']
ex_phone = signupform.cleaned_data['ex_phone']
# FIXME: 假如数据库中已经有相同的account，应报错让用户重新输入
# 创建数据库对象,写入数据库
newuser = CustomerModel(account=account,
password=password,
name=nickname,
address=address,
phone=phone,
alternatephone=ex_phone)
newuser.save()
return HttpResponseRedirect('/')
return render_to_response('customer/signup.html', {
'session': request.session,
'form': signupform,
},
context_instance=RequestContext(request))
def signup_view(request):
request.JSON = JsonRequest(request)
data = {
'username' : request.JSON.get('username', False),
'email' : request.JSON.get('email', False),
'password' : request.JSON.get('password', False),
'first_name' : request.JSON.get('first_name', False),
'last_name' : request.JSON.get('last_name', False),
}
response = Response()
form = SignupForm(data)
if form.is_valid():
#creating user
user = User.objects.create_user(data['username'], data['email'], data['password']);
user.first_name = data['first_name']
user.last_name = data['last_name']
user.save()
#creating profile
userProfile = UserProfile(user_id=user.id)
userProfile.save()
response.add_message('success', 'Usuario registrado correctamente')
else:
response.add_message('error', 'Error al registrar el usuario')
response.read_form(form.errors);
return HttpResponse(response.result('json'), mimetype='application/json')
def register(request):
"""
A view for registering a new user
"""
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
# create the user account itself
# (it will be inactive)
user = form.create_user()
# send email with verification code
utils.send_email_verification_email(request, user)
# re-direct to information message
msg = """
Thanks for registering! A verification email with further
instructions has been sent.
"""
messages.success(request, msg)
return redirect('url_login')
else:
form = SignupForm()
return render_to_response('registration/register.html',
{ 'form' : form },
context_instance=RequestContext(request))
def signup(request, template="accounts/account_signup.html"):
"""
Signup form.
"""
if request.method == "POST":
form = SignupForm(request.POST)
if form.is_valid():
try:
new_user = form.save()
info(request, _("Successfully signed up"))
# from django.contrib.auth import authenticate
auth_login(request, new_user)
return redirect("enterprise.projects")
except forms.ValidationError as e:
error(request, e.message)
# 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)
else:
form = SignupForm()
context = {"form": form, "title": _("Sign up")}
return render(request, template, context)
def signup(request):
if request.method == 'POST':
form = SignupForm(request.POST)
jdict = {'status': 'error', 'message': 'Invalid E-Mail Address'}
if form.is_valid():
jdict = {'status': 'ok'}
tracking = form.cleaned_data['tracking']
if tracking is None:
tracking = 'unknown'
optin = Optin.objects.create(email=form.cleaned_data['email'],
signup_location=tracking,
skey=Optin.generate_optin_key())
for l in List.objects.all():
value = request.POST.get('list%d' % l.id, '')
if value == 'ON':
optin.bulk_lists.add(l)
optin.save()
optin.send_email(request.get_host())
return http.HttpResponse(json.dumps(jdict),
mimetype='application/javascript')
raise http.Http404
def signup_user(request):
# if uer is logged in , rediret to dashboard
if request.method == 'POST':
processed_data = SignupForm(request.POST)
if processed_data.is_valid():
first_name = processed_data.cleaned_data['first_name']
last_name = processed_data.cleaned_data['last_name']
email = processed_data.cleaned_data['email']
password = processed_data.cleaned_data['password']
with transaction.atomic():
User.objects.create_user(first_name=first_name,
last_name=last_name,
username=email,
email=email,
password=password)
user = authenticate(username=email, password=password)
login(request, user)
return redirect(reverse('dashboard'))
else:
return render(request,
"user_login/login_or_signup.html", {
'header': 'Sign Up',
'type': 'signup',
'form': processed_data
},
status=400)
else:
empty_Form = SignupForm()
return render(request, "user_login/login_or_signup.html", {
'header': 'Sign Up',
'type': 'signup',
'form': empty_Form
})
def signupform(request):
#if form is submitted
if request.method == 'POST':
form = SignupForm(request.POST)
#checking the form is valid or not
if form.is_valid():
#if valid rendering new view with values
#the form values contains in cleaned_data dictionary
page_name = form.cleaned_data['page'].split('/')[-1]
start_date = form.cleaned_data['start_date']
fb_scrap.start_date = start_date
end_date = form.cleaned_data['end_date']
fb_scrap.end_date = end_date
fb_scrap.page_id = page_name.split('/')[-1]
diff_days = ((end_date + datetime.timedelta(1)) -
(start_date - datetime.timedelta(1))).days
fb_scrap.diff_days = diff_days
response = HttpResponse(content_type='text/csv')
response[
'Content-Disposition'] = 'attachment; filename=%s' % page_name + '_FB_activity.csv'
fb_scrap.do_scraping(response)
return response
else:
#creating a new form
form = SignupForm()
#returning form
return render(request, 'signupform.html', {'form': form})
def signup(request):
form = SignupForm(request.POST)
valid_form = form.is_valid()
token_key = None
user_details = {}
if valid_form:
user = form.save()
token_key = Token.objects.get(user=user).key
logger.info("Signup Success: u:{0} e:{0}".format(
user.username, user.email))
key = _generateEmailConfirmationKey(user.email)
timeout = _emailConfirmationKeyTimeout()
cache.set(key, user.pk, timeout)
# TODO(connor): remove hard-coded url: https://github.com/SanaMobile/sana.protocol_builder/issues/325
env = templater.get_environment("authentication", "templates")
template = env.get_template("confirmation_email.html")
body = template.render(
url="https://sanaprotocolbuilder.me/confirm_email/{0}".format(key))
send_email.delay(user.email,
"Account Confirmation for Sana Protocol Builder",
body)
user_details = _getUserDetails(user)
else:
logger.info("Signup Failed: {0}".format(_flattenFormErrors(form)))
return JsonResponse({
'success': valid_form,
'errors': form.errors,
'token': token_key,
'user': user_details,
})
def signup(request):
if request.user.is_authenticated():
return HttpResponseRedirect('/search')
if request.method == 'POST':
form = SignupForm(request.POST or None)
# form = RegisterUserForm(request.POST)
if request.POST.get('is_trainer', ''):
is_trainer = True
else:
is_trainer = False
if form.is_valid():
user = User.objects.create_user(email=request.POST.get('email', ''), username=request.POST.get('username', ''), password=request.POST.get('password', ''), first_name=request.POST.get('first_name', ''), last_name=request.POST.get('last_name', ''), is_trainer=is_trainer)
if user.is_active:
user_auth = authenticate(username=request.POST.get('username', ''), password=request.POST.get('password', ''))
if user_auth is not None:
login(request, user_auth)
if is_trainer:
return HttpResponseRedirect('/signup/step-2')
else:
return HttpResponseRedirect('/search/')
else:
return HttpResponseRedirect('/')
#return HttpResponseRedirect('/continue/')
else:
return HttpResponseRedirect('/')
# form = userCreationForm()
ctx = {}
form = SignupForm()
ctx['form'] = form
return render_to_response('web/signup3.html', ctx, context_instance=RequestContext(request))
def signup_view(request): #view for signup.html and all other invalid urls
if request.method == "POST":
form = SignupForm(request.POST)
if form.is_valid():
name = form.cleaned_data.get('name')
username = form.cleaned_data.get('username')
email = form.cleaned_data.get('email')
password = form.cleaned_data.get('password')
parentmail = form.cleaned_data.get('parentmail')
user = User(
name=name,
username=username,
email=email,
password=make_password(password),
parentmail=parentmail
) #make_password converts a string into hashcode with is one way encryption
user.save()
recipient_mail = email
content_text = "Hey " + username + "!! Welcome to the Kids Zone, a social networking site for kids.You have successfully signed up!!"
sending_mail(recipient_mail, content_text)
token = SessionToken(user=user)
token.create_token()
token.save()
response = redirect('/feed/')
response.set_cookie(key='session_token', value=token.session_token)
return response
else:
form = SignupForm()
return render(request, 'signup.html', {'form': form})
def get_ajax_login_form(request):
response = "FAIL"
extra_context = {
'domain': request.META['HTTP_HOST'],
'url_redes_sociales': url_redes_sociales,
'form_register': form_register,
'html_captcha': html_captcha
}
if request.method == 'GET':
form = SignupForm()
extra_context['form'] = form
return render_to_response('portal/ajax/login.html',
extra_context,
context_instance=RequestContext(request))
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
form.save(request)
response = "OK"
extra_context['form'] = form
html = render_to_string('portal/ajax/login.html',
extra_context,
context_instance=RequestContext(request))
json_response = json.dumps({'response': response, 'html': html})
return HttpResponse(json_response)
def signup(request):
"""
Allow a new user to register an account.
"""
form = SignupForm(request.POST or None)
if form.is_valid():
first_name = form.cleaned_data['username'].partition(' ')[0]
form.cleaned_data['username'] = form.cleaned_data['username'].replace(
' ', '_')
username = form.cleaned_data['username']
email = form.cleaned_data['email']
password = form.cleaned_data['password1']
context_vars = {
'username': username,
'email': email,
'password': password,
'first_name': first_name
}
user = User.objects.create_user(username=username,
email=email,
password=password)
subject = render_to_string('accounts/email/register_subject.txt',
context_vars).rstrip('\n')
message = render_to_string('accounts/email/register_message.txt',
context_vars)
send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [email])
backend = get_backends()[0]
user.backend = "%s.%s" % (backend.__module__,
backend.__class__.__name__)
login(request, user)
return redirect(reverse('buddies_create'))
return render_to_response('accounts/signup.html', {'form': form},
context_instance=RequestContext(request))
def signup(request):
form = SignupForm(request.POST)
valid_form = form.is_valid()
token_key = None
user_details = {}
if valid_form:
user = form.save()
token_key = Token.objects.get(user=user).key
logger.info("Signup Success: u:{0} e:{0}".format(user.username, user.email))
key = _generateEmailConfirmationKey(user.email)
timeout = _emailConfirmationKeyTimeout()
cache.set(key, user.pk, timeout)
# TODO(connor): remove hard-coded url: https://github.com/SanaMobile/sana.protocol_builder/issues/325
env = templater.get_environment("authentication", "templates")
template = env.get_template("confirmation_email.html")
body = template.render(url="https://sanaprotocolbuilder.me/confirm_email/{0}".format(key))
send_email.delay(user.email, "Account Confirmation for Sana Protocol Builder", body)
user_details = _getUserDetails(user)
else:
logger.info("Signup Failed: {0}".format(_flattenFormErrors(form)))
return JsonResponse({
'success': valid_form,
'errors': form.errors,
'token': token_key,
'user': user_details,
})
def signup(request):
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
new_user = User.objects.create_user(
username=cd['username'],
email=cd['email1'],
password=cd['password1'],
is_active=False,
)
token = default_token_generator.make_token(new_user)
uid = urlsafe_base64_encode(force_bytes(new_user.id))
signup_email(request, new_user, uid, token)
message = "We have sent you an email to validate your address, follow the link therein"
url = None
return success(request, url, message)
else:
form = SignupForm()
return render(request, 'signup_form.html', {
'form': form,
'form_title': 'Sign up',
'action': reverse('signup'),
})
def signup(request):
if request.method == 'GET':
return render(request, 'registration/signup.html',
{'form': SignupForm})
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
password = make_password(form.data['password'])
profile_pic = request.FILES.get('profile_pic',
None) or './default.jpg'
user = PicShurUser(username=form.data['username'],
password=password,
email=form.data['email'],
first_name=form.data['first_name'],
last_name=form.data['last_name'],
profile_pic=profile_pic)
try:
user.save()
except IntegrityError as ie:
return render(request, 'registration/signup.html',
{'form': form})
return HttpResponseRedirect(reverse('login'))
else:
return render(request, 'registration/signup.html', {'form': form})
def testValidForm(self):
form = SignupForm(self.f_postal_address_form, self.f_postal_address_form, data=self.f_valid_form_data)
self.assertEqual(form.is_valid(), True)
"Here, it must not raise..."
form.save()
user = User.objects.get(username=self.f_valid_form_data['username'])
user.delete()
def signup(request):
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
user = User.objects.create_user(
email=form.cleaned_data['email'],
password=form.cleaned_data['password'],
)
email = form.cleaned_data['email']
salt = hashlib.sha1(str(random.random())).hexdigest()[:5]
activation_key = hashlib.sha1(salt+email).hexdigest()
key_expires = datetime.datetime.today() + datetime.timedelta(2)
#get email
user = User.objects.get(email=email)
# Create and save user profile
new_profile = UserConfirmation(user=user, activation_key=activation_key, key_expires=key_expires)
new_profile.save()
# Send email with activation key
email_subject = 'Account confirmation'
email_body = "Hey %s, thanks for signing up. To activate your account, click this link within 48hours http://127.0.0.1:8000/confirm/%s" % (email, activation_key)
from_email = settings.EMAIL_HOST_USER
send_mail(email_subject, email_body,from_email,[email], fail_silently=True)
return HttpResponseRedirect('/registered/')
else:
form= SignupForm()
return render(request,'accounts/signup.html',{'form':form},context_instance=RequestContext(request))
def signup(request):
print "request method: " + str(request.method)
messages =[]
if request.method == 'POST':
signupForm = SignupForm(request.POST)
if signupForm.is_valid():
username = signupForm.cleaned_data['email']
# validate that a user does not already exist with that email
firstName = signupForm.cleaned_data['firstname']
lastName = signupForm.cleaned_data['lastname']
password = signupForm.cleaned_data['password']
email = signupForm.cleaned_data['email']
user = User.objects.create_user(username, email, password, first_name = firstName, last_name = lastName)
user.save()
messages.append('User added')
user = authenticate(username=username, password=password)
login(request, user)
# reverse()
#need to add something here to return the image
return render(request, 'home.html',{'messages': messages})
else:
messages.append('Something was screwed up with the form, try again')
return render(request, 'signup.html', {'messages': messages, 'signupForm': signupForm, 'loginForm': LoginForm})
else:
signupForm = SignupForm()
loginForm = LoginForm()
return render(request, 'signup.html',{'signupForm': signupForm,'loginForm': loginForm})
def home(request, code=None):
form = SignupForm(request.POST or None)
if request.method == 'POST':
if form.is_valid():
signup = form.save()
request.session['code'] = base36.base36encode(signup.pk)
if code:
try:
signup_inviter = Signup.objects.get(pk=base36.base36decode(code.upper()))
signup_inviter.invitees = F('invitees') + 1
signup_inviter.save()
except Exception, e:
pass
return redirect(reverse('launch_app_success'))
else:
# If user has signed up already, show the invite code
try:
signup = Signup.objects.get(email=form.data.get('email', ''))
return render_to_response('launch/already_registered.html', {
'code': base36.base36encode(signup.pk).lower()
}, context_instance=RequestContext(request))
except:
pass
def signup(request):
form = SignupForm()
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
username = request.POST.get('username')
password = request.POST.get('password')
email = request.POST.get('email')
user = User.objects.create_user(username, email, password)
user.save()
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
response = HttpResponseRedirect(default_url)
return response
#session = do_login(username, password)
#if session:
# sessid = session.key
# response = HttpResponseRedirect(default_url)
# response.set_cookie('sessid', sessid,
# domain=default_url, httponly=True,
# expires = session.expires,
# )
# return response
return render(request, 'signup_form.html',{
'form':form,
})
def signup(request):
if request.user.is_authenticated():
return HttpServerError(
request,
"You must log out before you can sign up for a new account")
if request.method == 'POST':
# Attempt to create user then, eh?
form = SignupForm(get_client_ip(request), data=request.POST)
if form.is_valid():
# Attempt to create the user here
# XXX: Do we need to validate something else?
log.info("Creating user for {0} from {1}".format(
form.cleaned_data['username'], get_client_ip(request)))
user = User.objects.create_user(
form.cleaned_data['username'].lower(),
form.cleaned_data['email'].lower(),
last_login=datetime.now())
user.first_name = form.cleaned_data['first_name']
user.last_name = form.cleaned_data['last_name']
# generate a random value for password. It won't be possible to log in with it, but
# it creates more entropy for the token generator (I think).
user.password = generate_random_token()
user.save()
# Now generate a token
token = default_token_generator.make_token(user)
log.info("Generated token {0} for user {1} from {2}".format(
token, form.cleaned_data['username'], get_client_ip(request)))
# Generate an outgoing email
send_template_mail(
settings.ACCOUNTS_NOREPLY_FROM, form.cleaned_data['email'],
'Your new postgresql.org community account',
'account/new_account_email.txt', {
'uid': urlsafe_base64_encode(force_bytes(user.id)),
'token': token,
'user': user
})
return HttpResponseRedirect('/account/signup/complete/')
else:
form = SignupForm(get_client_ip(request))
return render_pgweb(
request, 'account', 'base/form.html', {
'form': form,
'formitemtype': 'Account',
'form_intro': """
To sign up for a free community account, enter your preferred userid and email address.
Note that a community account is only needed if you want to submit information - all
content is available for reading without an account.
""",
'savebutton': 'Sign up',
'operation': 'New',
'recaptcha': True,
})
def signup(request):
form = SignupForm()
if request.POST:
form = SignupForm(request.POST)
if form.is_valid() and form.save():
return render(request, "registration/registration_complete.html")
return render(request, "registration/registration_form.html", {"form": form},
context_instance=RequestContext(request))
def signup(request):
form = SignupForm()
if request.POST:
form = SignupForm(request.POST)
if form.is_valid() and form.save():
return render(request, "registration/registration_complete.html")
return render(request,
"registration/registration_form.html", {"form": form},
context_instance=RequestContext(request))
def signup(request, template_name='emailauth/signup.html', user_class=UserWithEmail):
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
user_class.objects.create_user(**form.cleaned_data)
return redirect('will_notify')
else:
form = SignupForm()
return render_to_response(template_name, {'form': form}, context_instance=RequestContext(request))
def signup(request):
if request.method == "GET":
form = SignupForm()
else:
form = SignupForm(request.POST)
if form.is_valid():
user_entry = form.save()
return render(request, "profile.html")
def signup_form(request):
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/login/')
args = {}
args.update(csrf(request))
args['form'] = SignupForm()
return render_to_response('oncotator/sign_up_form.html', args)
def signup(request):
response_dict = dict()
form = SignupForm(request)
if request.POST:
if form.is_valid():
DBSession.add(form.create_user())
form.dispatch_verify_email()
return HTTPFound(request.route_url('signup_complete'))
response_dict['form'] = form
return response_dict
def psignup(request):
context = dict()
form = SignupForm(request.POST)
context['form'] = form
next = form.data.get('next')
if form.is_valid():
return redirect(next or reverse('games'))
return render_to_response('signup.html', context)
def signup(request):
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
user = form.save()
login(request, user)
return HttpResponseRedirect('/login/')
else:
form = SignupForm()
return render(request, 'signup_page.html', {'form': form})
def signup(request):
if request.method == "POST":
form = SignupForm(request.POST)
if form.is_valid():
user = form.save()
login(request, user)
return HttpResponseRedirect('/')
else:
form = SignupForm()
return render(request, 'signup_form.html', {'form': form})
def signup(request):
if request.POST:
form = SignupForm(request.POST)
if form.is_valid():
profile = form.save()
profile.send_activation_email()
return redirect('signup_success')
else:
form = SignupForm()
return render(request, 'profile/signup.html', {'form': form})
def signup(request):
if request.method == 'POST':
form = SignupForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return render(request, 'answers/signup_complete.html')
else:
form = SignupForm()
return render(request, 'answers/signup.html', {'form': form})
def signup(request):
if request.method == "POST":
form = SignupForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('signup_success')
args = {}
args.update(csrf(request))
args['form'] = SignupForm()
return render_to_response('signup.html', args)
def home(request):
success = None
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
form.save()
success = "Thanks for signing up!"
form = SignupForm()
else:
form = SignupForm()
return render(request, 'home.html', {'form': form, 'success': success})
def signup(request):
if request.method=="POST":
form = SignupForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('signup_success')
args={}
args.update(csrf(request))
args['form'] = SignupForm()
return render_to_response('signup.html', args)
def submitSignup(request):
"""Sign up the user."""
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
user = form.save()
return HttpResponseRedirect('/login/')
else:
return render(request, 'signup.html', {'form': form})
else:
return render(request, 'invalidAttempt.html',
{'message': 'Form resubmission!'})
def signup(request):
if (request.method == "GET"):
newUserForm = SignupForm()
else:
newUserForm = SignupForm(request.POST)
if newUserForm.is_valid():
user = newUserForm.save()
return logining(request)
#return HttpResponseRedirect('/')
return render(request,'signup.html',{
"form": newUserForm,
})
def user_signup(request):
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
user = form.save()
if user is not None:
login(request, user)
return HttpResponseRedirect('/')
form = SignupForm()
return render(request, 'signup.html', {'form': form,
'user': request.user,
'session': request.session})
def updateprofile(request):
try:
if request.method=='POST' :
instance = Seek_User.objects.get(username=request.session.get('username'))
#print instance
#form1 = SignupForm(instance=instance)
form1 = SignupForm(request.POST,instance=instance)
print form1
#print form1
if form1.is_valid():
form1.save()
return redirect('profile')
#return HttpResponeRedirect('profile')
else:
return render_to_response('wrongpage.html', {},{})
else:
#only have to update
instance1 = Seek_User.objects.get(username=request.session.get('username'))
print instance1
print instance1.firstname
s = instance1
#form1={'form1':SignupForm({'username':request.user,'points':0,'email':s.email,'firstname':s.firstname,'lastname':s.lastname})}
signup_form ={ 'signup_form':SignupForm(instance=instance1) }
#print form1
return render_to_response('Signup.html',signup_form,context_instance=RequestContext(request))
if request.method=='POST' or form1.is_valid():
#print form1
return redirect('profile')
#render_to_response('updateprofile.html',form1,context_instance=RequestContext(request))
#print 'hello'
#print form1
#data = form1.cleaned_data
#print form1.username
return render_to_response('wrongpage.html',{},{})
#return render_to_response('updateprofile.html',form1,context_instance=RequestContext(request))
except KeyError:
return render_to_response('wrongpage.html',{},{})
def signup(request):
c = {}
c.update(csrf(request))
if request.method == 'POST':
form = SignupForm(request.POST)
if(form.is_valid()):
form.save()
return HttpResponse("User Created !!")
return ren
else:
form = SignupForm()
print form
return render(request,'signup.html',{'form': form}, c)
def signup(request):
if request.method == "POST":
form = SignupForm(request.POST)
if form.is_valid():
username, password = form.save()
user = authenticate(username=username, password=password)
login(request, user)
return HttpResponseRedirect("/")
else:
form = SignupForm()
return render_to_response("signup.html", {
"form": form,
})
def userprofile(request):
if request.method == "GET":
form = SignupForm
else:
form = SignupForm(request.POST, request.FILES)
pic = handle_uploaded_file(request.FILES["upload"])
print pic
if form.is_valid():
form.save()
return render(request, "profile.html", {"success": True})
def signup(request):
if request.method == "POST":
form = SignupForm(request.POST)
if form.is_valid():
user = form.save()
response = redirect(reverse('home'))
response.set_cookie('sessionid', user.id)
return response
else:
form = SignupForm()
return render(request, 'signup.html', {
'form': form
})
def signup(request, *args, **kwargs):
if request.method == "GET":
form = SignupForm()
elif request.method == "POST":
form = SignupForm(request.POST)
if form.is_valid():
u = form.save()
user = authenticate(username=request.POST.get('username'), password=request.POST.get('password'))
assert user is not None
django_login(request, user)
resp = HttpResponseRedirect(reverse('home'))
return resp
return render(request, "form.html", {'url':request.path, 'form':form})
def signup(request):
if request.method=="POST":
form= SignupForm(request.POST)
if form.is_valid():
new_user = User.objects.create_user(**form.cleaned_data)
User.backend='django.contrib.auth.backends.ModelBackend'
authenticate()
login(request,new_user)
#redirect, or however you want to get to the main view
return HttpResponseRedirect('/')
else:
form = SignupForm()
return render(request,'users/adduser.html',{'form':form})
def signup(request):
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
user = form.save()
login(request, user)
url = '/'
return HttpResponseRedirect(url)
else:
form = SignupForm()
return render(request, 'signup.html', {
'form': form,
})
def signup(request):
if request.method == "POST":
form = SignupForm(request.POST)
if form.is_valid():
user = form.save()
if user is not None:
auth_login(request, user)
return HttpResponseRedirect("/")
else:
form = SignupForm()
return render(request, 'qa/signup.html', {
'form': form
})
def signup(request):
if request.method == "POST":
form = SignupForm(request.POST)
if form.is_valid():
username, password = form.save()
user = authenticate(username=username, password=password)
login(request, user)
return HttpResponseRedirect("/")
else:
form = SignupForm()
return render_to_response("signup.html", {
"form": form,
})
def account_profile(request):
if request.POST.get(
'action'
) == 'makeprovider' and not request.user.has_service_provider():
request.user.service_provider = ServiceProvider.objects.create(
name='Unnamed Service Provider')
request.user.service_provider.save()
request.user.save()
return HttpResponseRedirect('')
if request.POST.get(
'action'
) == 'removeprovider' and request.user.has_service_provider():
service_provider = request.user.service_provider
request.user.service_provider = None
request.user.save()
service_provider.delete()
return HttpResponseRedirect('')
initial = {
'first_name': request.user.first_name,
'last_name': request.user.last_name,
'phone': request.user.phone,
'language': request.user.language,
'service_notifications': request.user.service_notifications,
'service_reminder': request.user.send_reminders
}
if request.user.service_provider:
lat = request.user.service_provider.lat
lng = request.user.service_provider.lng
if request.method == "POST":
form = SignupForm(request.POST, initial=initial)
service_provider_form = ServiceProviderForm(
request.POST,
request.FILES,
instance=request.user.service_provider)
if form.is_valid() and service_provider_form.is_valid():
form.save(request.user)
service_provider_form.save()
request.session['django_language'] = request.user.language
return HttpResponseRedirect('')
else:
form = SignupForm(initial=initial)
service_provider_form = ServiceProviderForm(
instance=request.user.service_provider)
return render_to_response('account/profile.html',
locals(),
context_instance=RequestContext(request))
def signup(request):
if request.method=='POST':
form=SignupForm(request.POST)
if form.is_valid():
form.save(commit=True)
return HttpResponseRedirect('/blog/login/')
else:
form.errors
else:
form=SignupForm()
return render(request,'blog/signup.html',{'form':form})
def signup(request):
if request.method == "POST":
form = SignupForm(request.POST)
if form.is_valid():
user = form.save(commit=False)
user.save()
messages.success(request, "User saved")
return redirect("shop:signin")
else:
messages.error(request, "Error in form")
else:
form = SignupForm()
context = {"form": form}
return render(request, "shop/signup.html", context)
def signup(request):
if request.POST:
form = SignupForm(request.POST)
if form.is_valid():
profile = form.save()
user.profile.is_verified = True
user.profile.save()
activate_the_profile()
profile = form.save()
return redirect('signup_success')
else:
form = SignupForm()
return render(request, 'profile/signup.html', {'form': form})
def signup(request):
if request.method =='POST':
form = SignupForm(request.POST)
form._user = request.user
if form.is_valid():
user = form.save()
user.backend = 'django.contrib.auth.backends.ModelBackend'
login(request, user)
return HttpResponseRedirect(reverse('home'))
else:
form = SignupForm()
return render(request, 'signup.html', {
'form': form
})
