def signin(request):
error = []
if request.user.is_authenticated():
return HttpResponseRedirect('/profile/')
if request.method =="POST":
form = LoginForm(request.POST) #pass the form the request.post values
if form.is_valid():
username = form.cleaned_data['username']
password = form.cleaned_data['password']
userprofile = authenticate(username=username, password=password) #if passwords are valid
if userprofile is not None: #if all went well
if userprofile.is_active:
login(request, userprofile) #login the request as this particular user
return HttpResponseRedirect('/a/profile/')
else:
errors.append('User %s is disabled' % userprofile.username)
else:
error.append('Username and password combination did not match.')
return render_to_response('accounts/login.html', {'form':form, 'error':error}, context_instance=RequestContext(request)) #wrong credentials, go back and look at errors
else:
return render_to_response('accounts/login.html', {'form':form}, context_instance=RequestContext(request))
else:
""" nothing has been done, show the form"""
form = LoginForm()
context = {'form': form, 'errors':error,}
return render_to_response('accounts/login.html', context, context_instance=RequestContext(request))
def login(request):
template = 'accounts/login.html'
if request.user.is_authenticated():
return HttpResponseRedirect(reverse('accounts:index'))
else:
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
username = request.POST['login']
password = request.POST['password']
user = auth.authenticate(username=username, password=password)
if user is not None:
auth.login(request, user)
return HttpResponseRedirect(reverse('saisie:index'))
else:
return render(request, template, {
'form': form,
'error': 'La connexion a échouée.',
})
else:
return render(request, template, {
'form': form,
'error': 'Veuillez remplir tous les champs correctement.',
})
else:
form = LoginForm()
return render(request, template, {
'form': form,
})
class LoginView(TemplateView):
template_name = "signin.html"
def __init__(self):
super(LoginView, self).__init__()
self.form = LoginForm()
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 = LoginForm(request.POST)
if self.form.is_valid():
self.form.save()
user = auth.authenticate(
email=self.form.user.email,
password=self.form.str_password
)
auth.login(request, user)
del request.POST['email']
del request.POST['password']
return redirect('index_page')
else:
return self.render_to_response(self.get_context(request))
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 mylogin(request):
form = LoginForm(request.POST or None)
if form.is_valid():
username = form.cleaned_data['username']
password = form.cleaned_data['password']
try :
the_user = MyUser.objects.get(username=username)
user = authenticate(username=the_user.username,password=password)
except :
user = None
if user is not None:
# user = authenticate(username=the_user.username,password=password)
if user.is_active:
login(request,user)
messages.success(request, 'Vous êtes maintenant connecté')
else:
messages.success(request, "Votre compte est en attente d'activation")
pass
else:
return redirect('/register/')
context = {'form':form}
return render(request,"registration/login.html",context)
def loginview(request):
if request.method == 'POST':
form=LoginForm(request.POST)
session_cart=getCart(request)
try:
next= request.POST['next']
except:
next='/'
if form.is_valid():
username=form.cleaned_data['username']
password=form.cleaned_data['password']
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
user_cart=getCart(request)
cartMerge(user_cart, session_cart)
request.session['cart']={}
return HttpResponseRedirect(next)
else:
if '_auth_user_id' in request.session:
return HttpResponseRedirect('/')
else:
form=LoginForm()
try:
next= request.GET['next']
except:
next='/'
return render_to_response('login_form.html',
{'form': form,
'next': next},
context_instance=RequestContext(request))
def test_empty_password(self):
form = LoginForm({'username': '******', 'password': ''})
self.assertFalse(form.is_valid())
self.assertEqual(
form.errors,
{'password': [u'This field is required.']}
)
def login(request):
if request.user.is_authenticated():
return redirect(reverse('home'))
_request = None
if request.method == 'POST':
_request = request.POST.copy()
else:
_request = request.GET.copy()
next_uri = _request.get('next', get_config('LOGIN_REDIRECT_URL',
reverse('home')))
# rescuing poor users from infinite redirection loop
if next_uri == get_config('LOGIN_URL', reverse('login')):
next_uri = get_config('LOGIN_REDIRECT_URL', reverse('home'))
login_form = LoginForm()
if request.method == 'POST':
login_form = LoginForm(request.POST)
if login_form.is_valid() and login_form.user:
auth_login(request, login_form.user)
messages.success(request, "Hello, {0}.".format(login_form.user))
badges.possibly_award_badge("logged_in",
user=login_form.user)
return redirect(next_uri)
return {
'login_form': login_form,
'next': next_uri,
}
def test_wrong_username(self): data = self.data data['username'] = '******' form = LoginForm(data) self.assertFalse(form.is_valid()) self.assertEqual(form.errors['__all__'], ["Invalid username and/or password"])
def login_request(request):
if request.user.is_authenticated():
return reverse(index)
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
password = form.cleaned_data['password']
user = authenticate(username=username, password=password)
if user is not None:
login(request, user)
return redirect(reverse('create'))
else:
# Invalid User or Pass
messages.add_message(request, ERROR, 'You have provided invalid login information.')
return render(request, 'login.html', {
'form':form
})
else:
# Blank
messages.add_message(request, ERROR, 'Please enter correct login information.')
return render(request, 'login.html', {
'form':form
})
else:
# No POST, Show Form
messages.add_message(request, INFO, 'Please login below.')
return render(request, 'login.html', {
'form':LoginForm(),
})
def view_account(request):
if request.method != 'POST':
return HttpResponse(json.dumps({'success': False, 'message': 'POST requests only'}), mimetype='application/json')
form = LoginForm(request.POST)
if not form.is_valid():
return HttpResponse(json.dumps({'success': False, 'message': form.errors}), mimetype='application/json')
email = form.cleaned_data.get('email', None)
password = form.cleaned_data.get('password', None)
create = form.cleaned_data.get('create', False)
if email is None or password is None:
return HttpResponse(json.dumps({'success': False, 'message': 'Missing required parameters email or password'}), mimetype='application/json')
user = accounts.user_for_email(email)
success_message = 'Login Successful'
if user is None and create is True:
success_message = 'Account Creation Successful'
user = PushUser.objects.create_user(username=email, email=email, password=password)
user = authenticate(username=email, password=password)
if user is not None:
if user.is_active:
login(request, user)
return HttpResponse(json.dumps({'success': True, 'message': success_message}), mimetype='application/json')
return HttpResponse(json.dumps({'success': False, 'message': 'Invalid Login'}), mimetype='application/json')
def login(request):
"""Login. Looks up by username or email address."""
if request.user.is_authenticated():
return HttpResponseRedirect(reverse('index'))
next_url = None
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
user = auth.authenticate(username=request.POST['username'],
password=request.POST['password'])
if not user:
try:
email_user = User.objects.get(
email__exact=request.POST['username'])
user = auth.authenticate(username=email_user.username,
password=request.POST['password'])
except User.DoesNotExist:
user = None
if user:
if user.is_active:
auth.login(request, user)
if 'next' in request.POST:
return HttpResponseRedirect(request.POST['next'])
else:
return HttpResponseRedirect(reverse('index'))
else:
form.errors['username'] = '******'
else:
form.errors['username'] = (
'username or email address not found and/or password wrong')
else:
form = LoginForm()
next_url = urllib.unquote_plus(request.GET.get('next', '')).decode('utf8')
return render(request, 'accounts/login.html', {'login_form': form,
'next': next_url})
def test_too_long_username(self):
form = LoginForm(self.too_long_username)
self.assertFalse(form.is_valid())
self.assertEqual(
form.errors,
{'username': [u'Ensure this value has at most 64' +
' characters (it has 65).']}
)
def login(request, template_name='signin.html'):
if request.GET.get('next', None):
request.session['POST_AUTH_URL'] = request.GET.get('next')
if 'POST' == request.method:
form = LoginForm(data=request.POST)
if form.is_valid():
auth.login(request, form.get_user())
if request.session.test_cookie_worked():
request.session.delete_test_cookie()
if form.cleaned_data['keep_signed_in']:
# Sessions expire in about ten years.
request.session.set_expiry(datetime.timedelta(3650))
else:
# Session expires when user closes browser.
request.session.set_expiry(0)
if request.GET.get('ajax'):
pass
'''
from utils import json
return HttpResponse(
json.get_json(
request,
200,
ugettext(u'Login successful.'),
dict()
),
content_type=json.get_response_mimetype(request)
)
'''
else:
return accounts.post_auth_redirect(request)
else:
if request.GET.get('ajax'):
pass
'''
from utils import json
return HttpResponse(
json.get_json(
request,
403,
ugettext(u'Authentication Failed. Access forbidden.'),
dict()
),
content_type=json.get_response_mimetype(request)
)
'''
else:
form = LoginForm()
context = dict(
form=form
)
return render_to_response(
template_name,
context,
context_instance=RequestContext(request)
)
def login():
next = request.values.get('next', '/')
form = LoginForm()
form.next.data = next
if form.validate_on_submit():
session['user_id'] = unicode(form.user.pk)
flash(u'Login successfully', 'success')
return redirect(next)
return render_template('accounts/login.html', form=form)
def login(request):
login_form = LoginForm(request.POST or None)
if login_form.is_valid():
_backend_hackend(request, login_form.user)
return HttpResponseRedirect(request.REQUEST.get('next', '/'))
context = {
'login_form': login_form,
}
return TemplateResponse(request, 'accounts/login.html', context)
def test_login_form_validation_for_blank_items(self):
email_blank_form = LoginForm(
data={'email': '', 'password': self.valid_password}
)
self.assertFalse(email_blank_form.is_valid())
password_blank_form = LoginForm(
data={'email': self.valid_email, 'password': ''}
)
self.assertFalse(password_blank_form.is_valid())
def post(self, request):
form = LoginForm(request.POST)
if form.is_valid():
user = form.get_user()
if not user:
return redirect('login')
login(request, user)
return redirect('dashboard:home')
else:
context = {'form': form}
return render(request, 'dashboard/utility/login.html', context)
def login(request):
'''登陆视图'''
template_var={}
form = LoginForm()
if request.method == 'POST':
form=LoginForm(request.POST.copy())
if form.is_valid():
_login(request,form.cleaned_data["username"],form.cleaned_data["password"])
return HttpResponseRedirect("/")
template_var["form"]=form
return render_to_response("accounts/login.html",template_var,context_instance=RequestContext(request))
def login(request):
# Checking for the sesion, if exists then redirect to the profile page
try:
if request.session['username']:
username = request.session['username']
return HttpResponseRedirect('/accounts/profile/%s' % username)
except KeyError:
pass
msg_on_email_not_match = ""
msg_on_password_not_match = ""
email_id_from_login_form = ""
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
email_id_from_login_form = form.cleaned_data['email_id']
password_from_login_form = form.cleaned_data['password']
email_id_to_be_match = ""
password_to_be_match = ""
username = ""
password_match = False
users = User.objects.filter(email = email_id_from_login_form)
for user in users:
email_id_to_be_match = user.email
password_to_be_match = user.password
password_match = check_password(password_from_login_form, password_to_be_match)
username = user.username
if email_id_from_login_form == email_id_to_be_match:
if password_match == True:
# url = reverse('profile', kwargs = {'username': username})
request.session['username'] = username
# write code here to update the last_login time
users = User.objects.filter(email = email_id_to_be_match).update(last_login = datetime.datetime.now())
return HttpResponseRedirect('/accounts/profile/%s' % username)
else:
msg_on_password_not_match = "Entered password is incorrect"
return render_to_response('registration/login.html', {'msg_on_password_not_match':msg_on_password_not_match,
'msg_on_email_not_match':msg_on_email_not_match,
'email_id_from_login_form':email_id_from_login_form,
}, context_instance = RequestContext(request))
else:
msg_on_email_not_match = "Email Id is not registered with us"
return render_to_response('registration/login.html', {'msg_on_password_not_match':msg_on_password_not_match,
'msg_on_email_not_match':msg_on_email_not_match,
'email_id_from_login_form':email_id_from_login_form,
}, context_instance = RequestContext(request))
return render_to_response('registration/login.html', {}, context_instance = RequestContext(request))
def login(request):
'''Login form'''
form = LoginForm()
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
if form.authenticate(request) == True:
if request.GET.get('next'):
return redirect(request.GET['next'])
return redirect('project_category')
else:
form.errors['authenticate'] = "Whoops, wrong email and password!"
return direct_to_template(request, 'login_form.html', locals())
def post(self, request, *args, **kwargs):
destination = request.POST.get('next', reverse('home'))
form = LoginForm(request.POST)
if form.is_valid():
user = form.user
auth.login(request, user)
return HttpResponseRedirect(destination)
else:
response = self.render_to_response(self.get_context_data(**{
'login_form': form
}), status=401)
response['auth-response'] = 'authError'
return response
def login(request):
# get next parameter
next = request.REQUEST.get('next', settings.LOGIN_REDIRECT_URL)
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
user = form.save()
auth_login(request, user)
return redirect(next)
else:
form = LoginForm()
return render(request, 'accounts/login.html', {'form': form, 'next': next})
def test_form_renders_login_fields(self):
"LoginForms must render email and password fields"
form = LoginForm()
form_html = form.as_p()
self.assertIn('id="id_email"', form_html)
self.assertIn('name="email"', form_html)
self.assertIn('type="email"', form_html)
self.assertIn('placeholder="Email"', form_html)
self.assertIn('id="id_password"', form_html)
self.assertIn('name="password"', form_html)
self.assertIn('type="password"', form_html)
self.assertIn('placeholder="Senha"', form_html)
def login_page(request):
if request.method == 'POST':
redirect_to = request.REQUEST.get(REDIRECT_FIELD_NAME, '/')
login_form = LoginForm(request.POST)
if login_form.is_valid():
login(request, login_form.get_user())
print redirect_to
return HttpResponseRedirect(redirect_to)
login_form = LoginForm()
return render_to_response("login_page.html", context_instance=RequestContext(
request, {
"action": "login",
"form": login_form,
"errors": login_form.errors.values()
}))
def login(request):
if request.method == 'GET':
form = LoginForm()
return render_to_response('login.html', RequestContext(request, {'form': form}))
else:
print "in post"
form = LoginForm(request.POST)
if form.is_valid():
result = validate_login(request, form.cleaned_data["username"], form.cleaned_data["password"])
if result:
return HttpResponseRedirect("/simpleblog/bloglist")
else:
return render_to_response('login.html', RequestContext(request, {'form': form ,'password_is_wrong':True}))
else:
return render_to_response('login.html', RequestContext(request, {'form': form}))
def login_user(request):
"""
Function is used for login the registered user in the Peekhi.
"""
if request.user.is_authenticated():
return redirect(reverse('profiles_list'))
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
user_obj = User.objects.get(email=form.cleaned_data['email'])
user = authenticate(username=user_obj.username, password=form.cleaned_data['password'])
if user:
if user.is_active:
login(request, user)
return redirect(request.GET.get('next') or reverse('profiles_list'))
messages.add_message(request, messages.ERROR, "Please check your email and verify the email address to log on to 64 bit Consultants.")
return redirect(reverse('login_user'))
error_message = "Email Id and password did't match."
return render_to_response("accounts/login_user.html",{
"form": form,
"error_message": error_message,
"current": "login",
"next": request.POST.get('next', '')
}, context_instance=RequestContext(request))
return render_to_response("accounts/login_user.html",{
"form": form,
"current": "login",
"next": request.POST.get('next', '')
}, context_instance=RequestContext(request))
else:
form = LoginForm()
return render_to_response("accounts/login_user.html", {
"form": form,
"current": "login",
"next": request.GET.get('next', '')
}, context_instance=RequestContext(request))
def checkout_home(request):
cart_obj, cart_created = Cart.objects.new_or_get(request)
order_obj = None
if cart_created or cart_obj.products.count() == 0:
return redirect("cart:home")
login_form = LoginForm()
guest_form = GuestForm()
address_form = AddressForm()
billing_address_id = request.session.get("billing_address_id", None)
shipping_address_id = request.session.get("shipping_address_id", None)
billing_profile, billing_profile_created = BillingProfile.objects.new_or_get(
request)
address_qs = None
has_card = False
if billing_profile is not None:
if request.user.is_authenticated():
address_qs = Address.objects.filter(
billing_profile=billing_profile)
order_obj, order_obj_created = Order.objects.new_or_get(
billing_profile, cart_obj)
if shipping_address_id:
order_obj.shipping_address = Address.objects.get(
id=shipping_address_id)
del request.session["shipping_address_id"]
if billing_address_id:
order_obj.billing_address = Address.objects.get(
id=billing_address_id)
del request.session["billing_address_id"]
if billing_address_id or shipping_address_id:
order_obj.save()
has_card = billing_profile.has_card
if request.method == "POST":
"check that order is done"
is_prepared = order_obj.check_done()
if is_prepared:
did_charge, crg_msg = billing_profile.charge(order_obj)
if did_charge:
order_obj.mark_paid()
request.session['cart_items'] = 0
del request.session['cart_id']
if not billing_profile.user:
billing_profile.set_cards_inactive()
return redirect("cart:success")
else:
print(crg_msg)
return redirect("cart:checkout")
context = {
"object": order_obj,
"billing_profile": billing_profile,
"login_form": login_form,
"guest_form": guest_form,
"address_form": address_form,
"address_qs": address_qs,
"has_card": has_card,
"publish_key": STRIPE_PUB_KEY,
}
return render(request, "carts/checkout.html", context)
def cart_checkout(request):
order_obj = None
old_addresses = None
credit_card = None
loginForm = LoginForm()
guestForm = GuestForm()
addressForm = AddressForm()
# print('AddressForm', addressForm)
cart_obj, cart_created = Cart.objects.new_or_get(request)
billing_profile, bill_created = BillingProfile.objects.new_or_get(request)
cards = Card.objects.filter(billing_profile=billing_profile, default=True)
if cards.exists():
credit_card = cards.last()
# print('BillingProfile ',billing_profile)
if billing_profile is not None:
order_obj, order_created = Order.objects.new_or_get(
billing_profile=billing_profile, cart_obj=cart_obj)
if order_obj is not None:
old_addresses = Address.objects.filter(billing_profile=billing_profile)
context = {
'order_obj': order_obj,
'loginForm': loginForm,
'guestForm': guestForm,
'addressForm': addressForm,
'billing_profile': billing_profile,
'old_addresses': old_addresses,
'credit_card': credit_card,
}
return render(request, 'carts/cart_checkout.html', context)
def log_in(request):
args = {}
args.update(csrf(request))
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
username = form.cleaned_data.get('username')
password = form.cleaned_data.get('password')
user = authenticate(username=username,
password=password)
login(request, user)
return redirect('/')
elif request.method == "GET":
form = LoginForm()
args.update({'form': form})
return render(request, 'accounts/login.html', args)
def checkout_home(request):
cart_obj, cart_created = Cart.objects.new_or_get_cart(request)
order_obj = None
if cart_created or cart_obj.products.count() == 0:
return redirect('cart:home')
login_form = LoginForm()
guest_form = GuestForm()
billing_address_form = AddressForm()
address_form = AddressForm()
billing_profile, billing_profile_created = BillingProfile.objects.new_or_get_billing(request)
if billing_profile is not None:
order_obj, order_obj_created = Order.objects.new_or_get_order(billing_profile, cart_obj)
context = {
'object': order_obj,
'billing_profile': billing_profile,
'login_form': login_form,
'guest_form': guest_form,
'address_form': address_form,
'billing_address_form': billing_address_form
}
return render(request, 'carts/checkout.html', context)
def get_context_data(self, **kwargs):
context = super(LoginView, self).get_context_data(**kwargs)
if self.request.method == "POST":
form = LoginForm(self.request.POST)
if form.is_valid:
context['email'] = self.request.POST['email']
return context
def login_page(request):
if request.user.is_authenticated:
return redirect('/')
else:
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
email = form.cleaned_data.get("email")
password = form.cleaned_data.get("password")
user = authenticate(request, email=email, password=password)
if user is not None:
login(request, user)
return redirect('/')
else:
form = LoginForm()
return render(request, "accounts/login_page.html", {'form': form})
def index(request):
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
user = authenticate(username=request.POST['username'],
password=request.POST['password'])
if user is not None:
if user.is_active:
login(request, user)
return render(request, 'lists/homepage.html')
else:
return render(request, 'accounts/login.html', {'form': form})
else:
return render(request, 'accounts/login.html', {'form': LoginForm()})
return redirect('lists:index')
def fast_login_view(request):
user = request.user
if user.is_authenticated:
return HttpResponseRedirect('/')
form = LoginForm(request.POST or None)
if form.is_valid():
username = form.cleaned_data.get('username')
raw_password = form.cleaned_data.get('password')
user = authenticate(username=username, password=raw_password)
if user:
login(request, user)
else:
messages.warning(request, 'The password or the email is wrong.')
else:
messages.warning(request, 'Something is wrong, try again.')
return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
def add_product_view(request):
form = AddProductForm(request.POST or None)
login_form = LoginForm(request)
if request.user.is_authenticated:
context = {
"form": form,
"loginForm": login_form,
}
try:
stores = Store.objects.get(user=request.user or None)
print (stores)
except:
pass
if form.is_valid(): # All validation rules pass
# Process the data in form.cleaned_data
# ...
title = request.POST.get('title')
description = request.POST.get('description')
price = request.POST.get('price')
image = request.POST.get('image')
featured = request.POST.get('featured')
product_add = Product(title=title,description=description, price=price,image=image)
product_add.save()
stores.products.add(product_add)
stores.save()
return redirect("/products/")
else:
context = {
"loginForm": login_form,
}
return render(request, "products/add_product.html", context)
def checkout_home(request):
cart_obj, cart_created = Cart.objects.new_or_get(request)
order_obj = None
if cart_created or cart_obj.products.count() == 0:
return redirect("cart:home")
login_form = LoginForm()
guest_form = GuestForm()
address_form = AddressForm()
billing_address_form = AddressForm()
billing_profile, billing_profile_created = BillingProfile.objects.new_or_get(
request)
#get the order associated with the Cart
if billing_profile is not None:
order_obj, order_obj_created = Order.objects.new_or_get(
billing_profile, cart_obj)
context = {
"object": order_obj,
"billing_profile": billing_profile,
"login_form": login_form,
"guest_form": guest_form,
"address_form": address_form,
"billing_address_form": billing_address_form
}
return render(request, "carts/checkout.html", context)
def post(self, request, *args, **kwargs):
form = LoginForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
print(cd)
user = authenticate(request,
username=cd['username'],
password=cd['passwords'])
if user is None:
return HttpResponse('Неправильный логин и/или пароль')
if not user.is_active:
return HttpResponse('Ваш аккаунт заблокирован')
login(request, user)
return HttpResponse('Добро пожаловать! Успешный вход')
return render(request, 'accounts/login.html', {'form': form})
def checkout_home(request):
cart_obj,cart_created=Cart.objects.new_or_get(request)
order_obj=None
has_card=False
if cart_created or cart_obj.cartitem_set.count()==0:
redirect('carts:cart_view')
login_form=LoginForm()
guest_form=GuestForm()
# billing model manager
billing_profile, billing_profile_created = BillingProfile.objects.new_or_get(request)
if billing_profile is not None:
# order model manager
order_obj, order_obj_created = Order.objects.new_or_get(billing_profile, cart_obj)
has_card=billing_profile.has_card
# finalize checkout
if request.method == "POST":
"check the order is done"
is_done = order_obj.check_done()
if is_done:
order_obj.mark_paid()
request.session['cart_items'] = 0
del request.session['cart_id']
return redirect('carts:success')
context={
'billing_profile':billing_profile,
'object': order_obj,
'login_form':login_form,
'guest_form':guest_form,
"has_card":has_card
}
return render(request,'checkout.html',context)
def checkout_home(request):
cart_obj, cart_created = Cart.objects.new_or_get(request)
order_obj = None
if cart_created or cart_obj.products.count() == 0:
return redirect("cart:home")
login_form = LoginForm()
guest_form = GuestForm()
address_form = AddressForm()
billing_address_id = request.session.get("billing_address_id", None)
shipping_address_id = request.session.get("shipping_address_id", None)
billing_profile, billing_profile_created = BillingProfile.objects.new_or_get(
request)
if billing_profile is not None:
order_obj, order_obj_created = Order.objects.new_or_get(
billing_profile, cart_obj)
if shipping_address_id:
order_obj.shipping_address = Address.objects.get(
id=shipping_address_id)
del request.session["shipping_address_id"]
if billing_address_id:
order_obj.billing_address = Address.objects.get(
id=billing_address_id)
del request.session["billing_address_id"]
if billing_address_id or shipping_address_id:
order_obj.save()
context = {
"object": order_obj,
"billing_profile": billing_profile,
"login_form": login_form,
"guest_form": guest_form,
"address_form": address_form,
}
return render(request, "carts/checkout.html", context)
def checkout_home(request):
cart_obj, cart_created = Cart.objects.new_or_get(request)
order_obj = None
if cart_created or cart_obj.products.count() == 0:
return redirect("cart:home")
user = request.user
billing_profile = None
login_form = LoginForm()
guest_form = GuestForm()
guest_email_id = request.session.get('guest_email_id')
if user.is_authenticated:
billing_profile, billing_profile_created = BillingProfile.objects.get_or_create(
user=user, email=user.email)
elif guest_email_id is not None:
guest_email_obj = GuestEmail.objects.get(id=guest_email_id)
billing_profile, billing_guest_profile_created = BillingProfile.objects.get_or_create(
email=guest_email_obj.email)
else:
pass
if billing_profile is not None:
order_obj, order_obj_created = Order.objects.new_or_get(
billing_profile, cart_obj)
context = {
"object": order_obj,
"billing_profile": billing_profile,
"login_form": login_form,
"guest_form": guest_form
}
return render(request, "carts/checkout.html", context=context)
def test_class_meta_variable__is_registered_correctly(self):
lf = LoginForm(AppUser)
self.assertIsInstance(lf.fields['username'], forms.CharField)
self.assertEqual(lf.fields['username'].label, 'ユーザー名')
self.assertEqual(lf.fields['username'].max_length, 100)
self.assertIsInstance(lf.fields['password'].widget,
forms.PasswordInput)
def checkout_home(request):
(cart_obj, cart_created) = Cart.objects.new_or_get(request)
order_obj = None
if cart_created or cart_obj.products.count() == 0:
return redirect('cart:home')
login_form = LoginForm()
guest_form = GuestForm()
address_form = AddressForm()
billing_address_id = request.session.get('billing_address_id', None)
shipping_address_id = request.session.get('shipping_address_id', None)
(billing_profile, billing_profile_created) = \
BillingProfile.objects.new_or_get(request)
address_qs = None
has_card = False
if billing_profile is not None:
if request.user.is_authenticated():
address_qs = \
Address.objects.filter(billing_profile=billing_profile)
(order_obj, order_obj_created) = \
Order.objects.new_or_get(billing_profile, cart_obj)
if shipping_address_id:
order_obj.shipping_address = \
Address.objects.get(id=shipping_address_id)
del request.session['shipping_address_id']
if billing_address_id:
order_obj.billing_address = \
Address.objects.get(id=billing_address_id)
del request.session['billing_address_id']
if billing_address_id or shipping_address_id:
order_obj.save()
has_card = billing_profile.has_card
if request.method == 'POST':
# check that order is done
is_prepared = order_obj.check_done()
if is_prepared:
(did_charge, crg_msg) = billing_profile.charge(order_obj)
if did_charge:
order_obj.mark_paid()
request.session['cart_items'] = 0
del request.session['cart_id']
return redirect('cart:success')
else:
print(crg_msg)
return redirect('cart:checkout')
context = {
'object': order_obj,
'billing_profile': billing_profile,
'login_form': login_form,
'guest_form': guest_form,
'address_form': address_form,
'address_qs': address_qs,
'has_card': has_card,
'publish_key': STRIPE_PUB_KEY,
}
return render(request, 'cart/checkout.html', context)
def checkout_home(request):
cart_obj, cart_created = Cart.objects.new_or_get(request)
order_obj = None
if cart_created or cart_obj.products.count() == 0:
return redirect("cart:home")
login_form = LoginForm()
guest_form = GuestForm()
address_form = AddressForm()
billing_address_id = request.session.get("billing_address_id", None)
shipping_address_id = request.session.get("shipping_address_id", None)
billing_profile, billing_profile_created = BillingProfile.objects.new_or_get(
request)
address_qs = None
if billing_profile is not None:
if request.user.is_authenticated():
address_qs = Address.objects.filter(
billing_profile=billing_profile)
shipping_address_qs = address_qs.filter(address_type='shipping')
billing_address_qs = address_qs.filter(address_type='billing_')
order_obj, order_obj_created = Order.objects.new_or_get(
billing_profile, cart_obj)
if shipping_address_id:
order_obj.shipping_address = Address.objects.get(
id=shipping_address_id)
del request.session["shipping_address_id"]
if billing_address_id:
order_obj.billing_address = Address.objects.get(
id=billing_address_id)
del request.session["billing_address_id"]
if billing_address_id or shipping_address_id:
order_obj.save()
if request.method == "POST":
"check that order is done"
is_done = order_obj.check_done()
print("is_done", is_done)
print(request.session['cart_id'])
if is_done:
order_obj.mark_paid()
request.session['cart_items'] = 0
del request.session['cart_id']
return redirect("cart:success")
print("sessionID", request.session['card_id'])
context = {
"object": order_obj,
"billing_profile": billing_profile,
"login_form": login_form,
"guest_form": guest_form,
"address_form": address_form,
"address_qs": address_qs
}
print("rendring to checkout")
return render(request, "carts/checkout.html", context)
def checkout_home(request):
cart_obj, cart_created = Cart.objects.new_or_get(request)
order_obj = None
if cart_created or cart_obj.items.count() == 0:
return redirect('cart:home')
login_form = LoginForm()
guest_form = GuestForm()
address_form = AddressForm()
billing_address_id = request.session.get('billing_address_id', None)
shipping_address_id = request.session.get('shipping_address_id', None)
billing_profile, billing_profile_created = BillingProfile.objects.new_or_get(
request)
has_card = False
if billing_profile is not None:
order_obj, order_obj_created = Order.objects.new_or_get(
billing_profile, cart_obj)
if shipping_address_id:
order_obj.shipping_address = Address.objects.get(
id=shipping_address_id)
del request.session['shipping_address_id']
if billing_address_id:
order_obj.billing_address = Address.objects.get(
id=billing_address_id)
del request.session['billing_address_id']
if billing_address_id or shipping_address_id:
order_obj.save()
has_card = billing_profile.has_card
#Check that order is done
if request.method == 'POST':
if order_obj.check_done():
did_charge, crg_msg = billing_profile.charge(order_obj)
if did_charge:
order_obj.mark_paid()
del request.session['cart_id']
request.session['cart_total'] = 0
if billing_profile.user is None:
billing_profile.set_cards_inactive(
) #do the all cards inactive
return redirect('cart:success')
else:
return redirect('cart:checkout')
context = {
'billing_profile': billing_profile,
'object': order_obj,
'login_form': login_form,
'guest_form': guest_form,
'address_form': address_form,
'has_card': has_card,
'publish_key': STRIPE_PUB_KEY,
}
return render(request, 'carts/checkout.html', context)
def login(request, redirect_field_name = REDIRECT_FIELD_NAME):
redirect_to = request.REQUEST.get(redirect_field_name, '/account/')
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
try:
uid = form.cleaned_data['uid']
passwd = form.cleaned_data['passwd']
bind_dict = {
'NAME': 'ldap://ldap.rez-gif.supelec.fr/',
'USER': '******' % uid,
'PASSWORD': passwd,
'CACERT': None,
'STARTTLS': False
}
# Connects with a default databaseobject (see helpers)
db = LdapDatabase(bind_dict)
except InvalidCredentials:
request.flash['error'] = "Vos identifiants sont incorrects."
except ServerDown:
request.flash['error'] = "Le serveur LDAP est injoignable."
except ConnectionError:
request.flash['error'] = "Une erreur indéterminée s'est produite lors de la connexion."
else:
request.session['ldap_connected'] = True
request.session['ldap_uid'] = uid
request.session['ldap_passwd'] = passwd
request.flash['success'] = "Authentification réussie."
return HttpResponseRedirect(redirect_to)
else:
form = LoginForm(label_suffix='')
vars = { 'form': form, redirect_field_name: redirect_to }
vars.update(csrf(request))
return render_to_response('login.html', vars, context_instance=RequestContext(request))
def post(self, request):
form = LoginForm(data=request.POST)
if form.is_valid():
user = form.get_user()
remember_me = form.data.get('remember_me', 'off')
if remember_me == 'on':
request.session.set_expiry(0)
login(request, user)
data = {'message': 'Success'}
response = JsonResponse(data)
response.status_code = 200
return response
else:
data = form.errors
response = JsonResponse(data, safe=False)
response.status_code = 400
return response
def post(self, request, *args, **kwargs):
form = LoginForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
user = authenticate(
request, username=cd["username"], password=cd["password"]
)
if user is None:
return HttpResponse("Invalid login")
if not user.is_active:
return HttpResponse("Disabled account")
login(request, user)
return HttpResponse("Welcome! Authenticated successfully")
return render(request, "accounts/login.html", {"form": form})
def post(self, request, *args, **kwargs):
form = LoginForm(request.POST)
if form.is_valid():
cleanedData = form.cleaned_data
user = authenticate(request,
username=cleanedData['username'],
password=cleanedData['password'])
if user is None:
return HttpResponse('Wrong login and/or password')
if not user.is_active:
return HttpResponse('Your account is forbidden')
login(request, user)
return HttpResponse('Welcome! Authenticated successful')
return render(request, 'accounts/login.html', {'form': form})
def get(self, request):
login_required = request.GET.get('next', False)
context = {
'login_required': login_required,
'record_form': forms.RecordForm(),
'login_form': LoginForm(),
}
return render(request, self.name, context)
def login():
form = LoginForm()
next_url = request.values.get('next', url_for('qa.index'))
if form.validate_on_submit():
user = form.do_login()
if user:
# 4 跳转到首页
flash('{}欢迎回来'.format(user.nickname), 'success')
return redirect(next_url)
else:
flash('登陆失败', 'danger')
# else:
# print(form.errors)
# print(form.username.data)
# print(form.password.data)
return render_template('login.html', form=form, next_url=next_url)
def land(request):
return render(request,
'magazine/landing.html',
context={
'form': LoginForm(),
'reg_form': RegisterForm()
})
def post(self, request):
u = LoginForm(request.POST)
response = None
if (u.is_valid()):
user = u.cleaned_data
authenticated = authenticate(username=user["username"],
password=user["password"])
if (authenticated != None):
login(request, authenticated)
response = redirect("userpage")
else:
response = render(request, "accounts\login.html",
{"error": "Incorrect credentials"})
else:
response = render(request, "accounts\login.html",
{"error": "Please fill in all the fields"})
return response
def login(request):
if request.user.is_authenticated:
return redirect('chat:pilot')
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
email = form.cleaned_data['email'].lower().strip()
password = form.cleaned_data['password']
user = authenticate(email=email, password=password)
if user is not None:
auth_login(request, user)
return redirect('chat:pilot')
else:
form = LoginForm()
context = {'form': form}
return render(request, 'accounts/login.html', context)
def process_admin_signin(request):
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
user = authenticate(username=form.cleaned_data['username'],
password=form.cleaned_data['password1'])
if user is not None:
if user.is_superuser == True:
login(request, user)
return redirect('system_admin:admin_dash')
else:
messages.error(request, "Wrong Login Credentials")
else:
messages.error(request, 'Wrong username or Password')
else:
form = LoginForm()
return render(request, 'sys_admin/login.html', {'form': form})
def sign_in(request):
if request.user.is_authenticated():
return HttpResponseRedirect(reverse("home"))
else:
form = LoginForm()
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
data = form.cleaned_data
user = authenticate(username=data.get("username"),
password=data.get("password"))
if user:
login(request, user)
return HttpResponseRedirect(reverse("home"))
else:
print("sorry")
return render(request, "login.html", {"form": form})
def get(self, request):
if request.user.is_authenticated:
return redirect('/portal')
template_name = 'login1.html'
loginForm = LoginForm()
registerForm = RegisterForm()
context = {'form': loginForm, 'registerForm': registerForm}
return render(request, template_name, context)
def login_view(request):
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
user = authenticate(username=form.cleaned_data['username'],
password=form.cleaned_data['password'])
if user:
login(request, user)
return redirect('/accounts/profile')
else:
print('Auth Credential is not found.')
elif request.method == 'GET':
if request.user.is_authenticated:
return redirect('/accounts/profile')
form = LoginForm()
return render(request, 'accounts/login.html', {'form': form})
def sign_in(request):
if request.user.is_authenticated():
return HttpResponseRedirect(reverse('all_articles'))
else:
form = LoginForm()
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
data = form.cleaned_data
user = authenticate(email=data.get("email"),
password=data.get("password"))
if user:
login(request, user)
return HttpResponseRedirect(reverse("all_articles"))
else:
print("sorry")
return render(request, 'sign-in.html', {'form': form})
def signlogup(request):
data = get_global_data(request)
data['message'] = False
if request.user.is_authenticated():
return HttpResponseRedirect('/profile/')
elif request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid() and 'password' in request.POST:
username = request.POST['username']
password = request.POST['password']
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
request.session.set_expiry(60*60*24*365)
login(request, user)
return HttpResponseRedirect('/profile/')
else:
data['message'] = 'Эккаунт заблокирован'
else:
data['message'] = 'Неправильная пара логин/пароль'
elif 'username' in request.POST:
username = request.POST['username']
try:
user = User.objects.create_user(username, username, username)
user.is_active = False
user.is_staff = False
activate_code = md5.new(username).hexdigest()
send_html_mail('Activation letter', username, {'name': username, 'code': activate_code}, 'emails/activate_letter.html', sender='*****@*****.**')
user.save()
profile = Profile(user = user, phone = '+7 ')
profile.save()
return { 'message': 'Спасибо за регистрацию. Вам выслано письмо с инструкциями по активации эккаунта.' }
except:
if User.objects.get(username=username) is not None:
data['message'] = 'Пользователь с таким e-mail уже зарегистрирован'
else:
data['message'] = 'Неизвестная ошибка при добавлении пользователя. Обратитесь в поддержку'
else:
form = LoginForm()
data['login_form'] = form
return data
