def facebook_login_done(request):
user = authenticate(request=request)
if not user:
request.COOKIES.pop(FACEBOOK_API_KEY + '_session_key', None)
request.COOKIES.pop(FACEBOOK_API_KEY + '_user', None)
# TODO: maybe the project has its own login page?
logging.debug("SOCIALAUTH: Couldn't authenticate user with Django,"
"redirecting to Login page")
return HttpResponseRedirect(reverse('socialauth_login_page'))
login(request, user)
logging.debug("SOCIALAUTH: Successfully logged in with Facebook!")
next = request.GET.get('next', False)
if not next:
if request.COOKIES.get('redirect', False):
response = HttpResponseRedirect(request.COOKIES.get('redirect'))
response.delete_cookie('redirect')
return response
else:
next = request.session.get('redirect', False)
del_dict_key(request.session, 'redirect')
if next:
return HttpResponseRedirect(next)
else:
return HttpResponseRedirect(LOGIN_REDIRECT_URL)
def logout(request):
if request.user.is_authenticated():
auth.logout(request)
response = HttpResponseRedirect('/')
response.delete_cookie('findPr')
response.delete_cookie('check')
return response
def form_valid(self, form):
for device in devices_for_user(self.request.user):
device.delete()
resp = HttpResponseRedirect(reverse('edit_profile'))
resp.delete_cookie('S2FA', domain=settings.SESSION_COOKIE_DOMAIN)
return resp
def login(request):
email = request.POST.get("email", "")
passwd = request.POST.get("passwd", "")
passwd_remember = request.POST.get("passwd_remember", "")
next = request.POST.get("next", "/")
# user = User.objects.get(username=email)
# user.backend = 'django.contrib.auth.backends.ModelBackend'
# auth.login(request, user)
user = auth.authenticate(username=email, password=passwd)
if user is not None:
if user.is_active:
auth.login(request, user)
# save cookie
response = HttpResponseRedirect(next)
week = 60 * 60 * 24 * 7
response.set_cookie("email", email, max_age=week)
if passwd_remember:
response.set_cookie("passwd", passwd, max_age=week)
else:
response.delete_cookie("passwd")
return response
else:
return loginForm(request, errorMsg=u"사용이 정지된 계정입니다.")
else:
return loginForm(request, errorMsg=u"이메일/비밀번호를 확인하세요.")
def logout(request):
response = HttpResponseRedirect('../../op/login/')
response.delete_cookie('csrf_token')
response.delete_cookie('username')
auth.logout(request)
request.session.flush()
return response
def clear_cookie(request):
if request.method == 'GET':
return TemplateResponse(request, 'delete.html')
response = HttpResponseRedirect(REDIRECT_TO)
response.delete_cookie('cell', path=COOKIE_PATH)
response.delete_cookie('password', path=COOKIE_PATH)
return response
def user_logout(request):
if request.method == 'GET':
# 注销，删除当前登录的用户的cookies中的ticket信息
response = HttpResponseRedirect('/user/user_login/')
response.delete_cookie('ticket')
return response
def logout(request):
print('logout')
# 调转到主页面
response = HttpResponseRedirect(reverse("main:index"))
# 删除cookie
response.delete_cookie('username')
return response
def logout_user(request):
message = "See you later, " + request.user.first_name + "!"
messages.add_message(request, messages.SUCCESS, message)
logout(request)
response = HttpResponseRedirect("/")
response.delete_cookie("asked_for_checkin")
return response
def logout(request):
if request.user.is_authenticated():
auth.logout(request)
response = HttpResponseRedirect("/welcome/")
response.delete_cookie("findPr")
response.delete_cookie("check")
return response
def clear(request):
"""
Clears the subscription cookie.
"""
response = HttpResponseRedirect(reverse('home'))
response.delete_cookie(subscription_cookie)
return response
def link_anonymous_ratings_with_user(request, redirect_to):
user = request.user
response = HttpResponseRedirect(redirect_to)
if not user.is_authenticated():
return response
for cookie_key, cookie_value in filter(lambda item: item[0].startswith('vote-'), request.COOKIES.items()):
try:
content_type_id, object_id, key = cookie_key[5:].split('.')
response.delete_cookie(cookie_key)
sid = transaction.savepoint()
Vote.objects.filter(
content_type=content_type_id,
object_id = object_id,
key__startswith = key,
cookie = cookie_value,
user__isnull = True,
).update(user=user)
transaction.savepoint_commit(sid)
except ValueError:
pass
except IntegrityError:
transaction.savepoint_rollback(sid)
return response
def login(request):
email = request.POST.get('email', "")
passwd = request.POST.get('passwd', "")
passwd_remember = request.POST.get("passwd_remember", "")
next = request.POST.get("next", "/")
user = auth.authenticate(username=email, password=passwd)
if user is not None:
if user.is_active:
auth.login(request, user)
# save cookie
response = HttpResponseRedirect(next)
week = 60 * 60 * 24 * 7
response.set_cookie('email', email, max_age=week)
if passwd_remember:
response.set_cookie('passwd', passwd, max_age=week)
else:
response.delete_cookie('passwd')
return response
else:
return loginForm(request, errorMsg=u"사용이 정지된 계정입니다.")
else:
return loginForm(request, errorMsg=u"이메일/비밀번호를 확인하세요.")
def index(request):
logout(request)
response = HttpResponseRedirect("/login/")
# Redirect to a success page.
response.delete_cookie('user_mail',domain=".board.hoster.ru")
# raise Exception(SESSION_COOKIE_AGE)
return response
def return_to_mobile_version(request):
url = request.META.get("HTTP_REFERER")
if not url:
url = reverse("index")
response = HttpResponseRedirect(url)
response.delete_cookie("force_desktop")
return response
def app_validate_token(request, token, app_auth_key, next_url):
"""
Got a temporary token from SSO, now validate it
"""
# TODO(kevinx): error check
credentials = _get_sso_credentials_from_token(token)
if not credentials:
response = HttpResponseRedirect(next_url)
response.delete_cookie(app_auth_key)
return response
response = HttpResponseRedirect(next_url)
app_auth_chars = get_randomized_chars(64)
set_cookie(response, app_auth_key, app_auth_chars)
try:
app_auth_obj = models.AppAuthInfo(
app_auth_key=app_auth_chars,
cn=credentials['cn'],
mail=credentials['mail'],
displayName=credentials['displayName'],
objectSid=credentials['objectSid'])
except DatabaseError as e:
# pass, just store the error (could be "length too large", etc)
transaction.rollback()
raise e
try:
app_auth_obj.save()
except IntegrityError as e:
transaction.rollback()
raise e
return response
def login(request):
"""Login, if user is authenticated and active."""
if request.user.is_active:
return HttpResponseRedirect('/accounts/details/')
if request.POST:
username = request.POST['username']
password = request.POST['password']
user = auth.authenticate(username = username, password = password)
try:
if user.is_active:
auth.login(request, user)
response = HttpResponseRedirect('/checks/')
if 'remember_me' in request.POST:
response.set_cookie('username', username)
else:
response.delete_cookie('username')
return response
else:
messages.warning(request, _('This account is not active. Contact administrator.'))
except:
messages.warning(request, _('Account with these entries is not found. Try again or contact administrator.'))
if 'username' in request.COOKIES:
context = {'username': request.COOKIES['username']}
else:
context = {}
return render_to_response('login.html', RequestContext(request, context))
def frontendediting_request_processor(page, request):
"""
Sets the frontend editing state in the cookie depending on the
``frontend_editing`` GET parameter and the user's permissions.
"""
if 'frontend_editing' not in request.GET:
return
response = HttpResponseRedirect(request.path)
if request.user.has_module_perms('page'):
try:
enable_fe = int(request.GET['frontend_editing']) > 0
except ValueError:
enable_fe = False
if enable_fe:
response.set_cookie(str('frontend_editing'), enable_fe)
else:
response.delete_cookie(str('frontend_editing'))
else:
response.delete_cookie(str('frontend_editing'))
# Redirect to cleanup URLs
return response
def return_to_mobile_version(request):
url = request.META.get('HTTP_REFERER')
if not url:
url = reverse('dnd:mobile:index:index_mobile')
response = HttpResponseRedirect(url)
response.delete_cookie('force_desktop')
return response
def logout_(request):
logout(request)
response = HttpResponseRedirect('/frog')
response.delete_cookie('sessionid')
return JsonResponse({'value': 1})
def changepassword(request,username):
error = []
if request.method == 'POST':
form = ChangepwdForm(request.POST)
if form.is_valid():
data = form.cleaned_data
user = authenticate(username=username,password=data['old_pwd'])
if user is not None:
if data['new_pwd']==data['new_pwd2']:
newuser = AuthUser.objects.get(username=username)
newuser.password = make_password(data['new_pwd'], None, 'pbkdf2_sha256')
newuser.save()
# return HttpResponseRedirect('/account/login/')
response = HttpResponseRedirect('/account/login/')
#清理cookie里保存username
response.delete_cookie('username')
return response
else:
error.append('请确认二次密码与新密码是否一致！')
else:
error.append('请输入正确的旧密码！')
else:
error.append('Please input the required domain')
else:
form = ChangepwdForm()
return render_to_response('changepassword.html',{'form':form,'error':error})
def logout(request):
response = HttpResponseRedirect('/')
try:
response.delete_cookie(ymgconst.YMG_COOKIE)
except KeyError:
pass
return response
def fb_logout(request, next=None):
"""
Logout for the server-sided authentication flow. We can't rely on any js
here.
Upon logout we logout from the django auth system, we also delete the fbsr_
cookie.
TODO: this view does not work when you are logged in through the js SDK, due
to the fact that the browser does not remove the fbsr_ cookie properly and
our login middleware logs the user in again...
"""
if next is None:
try:
next = settings.LOGOUT_REDIRECT_URL
except AttributeError:
next = reverse('djfb_debug')
logout(request)
response = HttpResponseRedirect(next)
# Facebook sets the fbsr_ cookie for the "base_domain" in the fbm_ cookie
cookie_domain = request.COOKIES.get('fbm_%s' % conf.APP_ID, '=').split('=')[1]
response.delete_cookie(conf.COOKIE_NAME, domain=cookie_domain)
return response
def order(request):
cookie_order = unquote(request.COOKIES.get("order", "{}"))
order_items = json.loads(cookie_order)
order_products = Product.objects.filter(id__in=order_items.keys())
if request.method == "POST":
form = OrderForm(request.POST)
response = HttpResponseRedirect("/order")
if form.is_valid():
try:
order=form.save(commit=False)
order.save()
ocs = []
total = 0;
for product in order_products:
oc = OrderCount(product=product, order=order, count=int(order_items[u"%d" % product.pk]['order_num'])*product.load)
oc.save()
oc.summ = order_items[u"%d" % product.pk]['order_summ']
total += oc.summ
ocs.append(oc)
message = render_to_string('order_email.txt', {"products": ocs, "order": order, "total": total})
send_to = [manager[1] for manager in settings.MANAGERS]
email = EmailMessage(u'Заказ на сайте', message, 'temp <*****@*****.**>', to=send_to)
email.send()
messages.success(request, u'Ваша заявка отправлена специалистам компании.')
response.delete_cookie("order")
except :
messages.error(request, u'При отправке заявки произошла ошибка. Пожалуйста, повторите попытку позднее.')
return response
else:
form = OrderForm()
return {'form':form, "products": order_products, "p": Page.objects.get(url="order")}
def attraction(request, attraction):
token = api_token(request)
content = {'access_token': token}
r = requests.get("http://crash-api.herokuapp.com/1.0/attractions/"+attraction+".json", params=content)
if r.status_code != requests.codes.ok:
token = api_token(request, True)
res = HttpResponseRedirect(request.build_absolute_uri())
res.delete_cookie('api_token')
return res
if not r.json:
raise Http404
content = {'access_token': token, 'attraction_id': attraction, 'type': 'photo'}
ck = requests.get("http://crash-api.herokuapp.com/1.0/checkins.json", params=content)
if ck.status_code != requests.codes.ok:
ck.raise_for_status()
ck2 = []
for i in ck.json:
if (i['type'] == 'photo'):
ck2.append(i)
content = {'access_token': token, 'region_id': r.json['region']['id'], 'count': '100', 'latitude': r.json['latitude'], 'longitude': r.json['longitude']}
atr = requests.get("http://crash-api.herokuapp.com/1.0/attractions.json", params=content)
if atr.status_code != requests.codes.ok:
atr.raise_for_status()
if mobileBrowser(request):
return render_to_response('attraction.html', {'attraction': r.json, 'checkins': ck2, 'attr': atr.json[1::], 'token': token, 'req': request})
else:
return render_to_response('attraction.html', {'attraction': r.json, 'checkins': ck2, 'attr': atr.json[1::], 'token': token, 'req': request})
def signin(request):
form = LoginForm()
if is_login(request):
return HttpResponseRedirect(constant.home_url)
if request.method == constant.POST:
form = LoginForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
username = cd.get(constant.employee_number)
password = cd.get(constant.password)
time_exp = 0 # clear session when close browser
request.session[constant.login] = True # you are login now and whenever session expire
request.session[constant.usernameParam] = username # save login to show
hrr = HttpResponseRedirect(constant.search_url)
if cd.get(constant.remember): # if remember me
time_exp = 86400 * 7 # a week
hrr.set_cookie(constant.usernameParam, username, max_age=time_exp) # expire cookie
hrr.set_cookie(constant.password, password, max_age=time_exp)
else:
time_exp = 3600
if request.COOKIES.has_key(constant.usernameParam):
hrr.delete_cookie(constant.usernameParam)
hrr.delete_cookie(constant.password)
request.session.set_expiry(time_exp)
return hrr
return render(request, constant.signin, {constant.form: form})
def checkin(request, checkin):
token = api_token(request)
content = {'access_token': token, 'type': 'photo'}
r = requests.get("http://crash-api.herokuapp.com/1.0/checkins/"+checkin+".json", params=content)
if r.status_code != requests.codes.ok:
token = api_token(request, True)
res = HttpResponseRedirect(request.build_absolute_uri())
res.delete_cookie('api_token')
return res
if not r.json:
raise Http404
content = {'access_token': token, 'email': r.json['user']['email'], 'summary': '0'}
ck = requests.get("http://crash-api.herokuapp.com/1.0/users.json", params=content)
if ck.status_code != requests.codes.ok:
ck.raise_for_status()
content = {'access_token': token}
atr = requests.get("http://crash-api.herokuapp.com/1.0/attractions/"+r.json['attraction']['id']+".json", params=content)
if atr.status_code != requests.codes.ok:
atr.raise_for_status()
currentUrl = request.get_full_path()
user_name = ck.json[0]['username']
if mobileBrowser(request):
return render_to_response('checkin.html', {'checkin': r.json, 'attraction': atr.json, 'user_name': user_name, 'user': ck.json[0], 'thisurl': currentUrl, 'token': token, 'req': request})
else:
return render_to_response('checkin.html', {'checkin': r.json, 'attraction': atr.json, 'user_name': user_name, 'user': ck.json[0], 'thisurl': currentUrl, 'token': token, 'req': request})
def fb_logout(request):
response = HttpResponseRedirect("/")
# Force expiration of fbs_ cookies so that they are not being used.
fbs_cookie_name = 'fbs_' + settings.FACEBOOK_API_KEY
fbs_cookie = request.COOKIES.get(fbs_cookie_name)
# If we are using the JavaScript OAuth library cookie, then we'll be unable to
# logout because Facebook's Connect library is keyed to using the apiKey set
# during FB.init. Thus, you are unable to use it to delete the fbs_ cookie
# without special JavaScript code that uses their routines, which gets
# annoying if we have so many places in our code base to add it.
#
# A better way is just set it on Django's end, which will send an instruciton
# to a set cookie on the first day of GMT (1970), which the browser will
# realize is a delete cookie command.
# If you don't get the domain= parameter right, you won't delete it.
if fbs_cookie:
logging.debug("User was using fbs_ cookie %s...forcing to delete." % fbs_cookie)
cookie_dict = decode_cookie_string(fbs_cookie)
base_domain = cookie_dict.get('base_domain')
logging.debug("cookie_dict: %s" % (base_domain))
# You can't delete cookies properly without the base_domain set.
if base_domain:
response.delete_cookie(fbs_cookie_name, domain="." + base_domain)
return response
def auth_logout(request):
request.session.pop(ENCRYPTED_LDAP_PASSWORD)
redirect_to = request.GET.get('next', '') or '/'
logout(request)
response = HttpResponseRedirect(redirect_to)
response.delete_cookie('sessionkey')
return response
def next_test(request):
# redirect the browser to the next test according to the executed test suite
dispb = request.META["HTTP_USER_AGENT"]
# grab the user agent of the registered browser session
sessb = Browser.objects.filter(id=request.session["browser"])[0].ua
if sessb != dispb:
return HttpResponse("<a href='/browser/add'>please register your browser first</a>")
todo = request.session["tests"]
if len(todo) > 0:
next = todo.pop()
request.session["tests"] = todo
url = "/test/%(vid)s/%(cid)s/%(eid)s/" % {"vid": next[0], "cid": next[1], "eid": next[2]}
resp = HttpResponseRedirect(url)
else:
resp = HttpResponse("suite executed")
for c in request.COOKIES:
cmatch = re.match("(?P<vid>\d+)-(?P<cid>\d+)-(?P<eid>\d+)", c)
if cmatch:
vnum = int(cmatch.group("vid"))
cnum = int(cmatch.group("cid"))
encnum = int(cmatch.group("eid"))
b = Browser.objects.get(id=request.session["browser"])
v = Vector.objects.get(id=vnum)
wc = WebContext.objects.get(id=cnum)
enc = Encoding.objects.get(id=encnum)
# todo: refactoring test object update
t = Test.objects.filter(browser=b, vector=v, context=wc, encoding=enc)
if t:
t = t[0]
t.result = "PASS"
else:
t = Test(browser=b, vector=v, context=wc, encoding=enc, result="PASS")
t.save()
resp.delete_cookie(c)
return resp
def logout(request):
auth.logout(request)
messages.success(request, 'you are logged out')
#cookies
res = HttpResponseRedirect("/")
res.delete_cookie("user_id")
res.delete_cookie("date_login")
return res
def resetcookies(request):
if request.COOKIES.get('usersoup'):
response = HttpResponseRedirect('/cooking/')
response.delete_cookie('usersoup')
return response
else:
return HttpResponseRedirect('/cooking/')
def logout(request):
"""Log the user out."""
auth.logout(request)
statsd.incr('user.logout')
res = HttpResponseRedirect(get_next_url(request) or reverse('home'))
res.delete_cookie(settings.SESSION_EXISTS_COOKIE)
return res
def logout(request):
"""
注销
"""
if request.method == 'GET':
response = HttpResponseRedirect(reverse('user:login'))
response.delete_cookie('ticket')
return response
def logout(request):
try:
response = HttpResponseRedirect('/')
response.delete_cookie('user_id')
return response
except KeyError:
pass
return HttpResponseRedirect('/')
def assign_cart_and_redirect_view(request):
find_and_assign_anonymous_cart(request)
redirect_to = get_request_param(request, "next")
if redirect_to is None:
redirect_to = '/'
response = HttpResponseRedirect(redirect_to)
response.delete_cookie(Cart.COOKIE_NAME)
return response
def logout(request):
if request.method == 'GET':
users["username"] = "******"
users["style"] = "none"
users["lg"] = "lg"
response = HttpResponseRedirect('/')
response.delete_cookie('ticket')
return response
def logout(request):
if request.oauth.has_credentials():
response = HttpResponseRedirect(reverse('home'))
response.delete_cookie('sessionid')
return response
def logout(request):
"""登出"""
response = HttpResponseRedirect("/login")
if 'uid' in request.COOKIES:
response.delete_cookie('uid')
if 'iss' in request.COOKIES:
response.delete_cookie('iss')
return response
def logout(request):
resp = HttpResponseRedirect(reverse('app:home'))
# 将token从前端拿走
resp.delete_cookie('utoken')
request.session.flush()
return resp
def logout(request):
if request.method == 'GET':
# 删除cookie
response = HttpResponseRedirect('/index/index/')
response.delete_cookie('ticket')
ticket = request.COOKIES.get('ticket')
Userticket.objects.filter(ticket=ticket).delete()
return response
def logout(request):
auth = request.COOKIES.get('authenticator')
req = urllib.request.Request('http://exp-api:8000/logout/' + str(auth))
resp_json = urllib.request.urlopen(req).read().decode('utf-8')
resp = json.loads(resp_json)
response = HttpResponseRedirect(reverse('login'))
response.delete_cookie("authenticator")
return response
def logout(request):
if request.method == 'GET':
auth_logout(request)
response = HttpResponseRedirect('/')
response.delete_cookie('isAuthenticated')
return response
else:
return http_error_response(405, 'Expecting GET')
def logout(request):
##删除cookie和 session
##重定向到登录页
response = HttpResponseRedirect('/login')
response.delete_cookie('email')
del request.session['email']
return response
def Logout(request):
if request.method == 'GET':
response = HttpResponseRedirect('/axf/home/')
response.delete_cookie('ticket')
ticket = request.COOKIES.get('ticket')
userticket = UserTicketModel.objects.filter(ticket=ticket)
userticket.delete()
return response
def cookie_clear(request):
res = HttpResponseRedirect('/lab-9/cookie/login')
res.delete_cookie('lang')
res.delete_cookie('user_login')
msg = "Anda berhasil logout. Cookies direset"
messages.info(request, msg)
return res
def logout(request):
user = getattr(request, 'user', None)
if user:
cache.delete(utils.REDIS_USER_TOKEN % request.session["X-Auth-Token"])
request.session.flush()
response = HttpResponseRedirect(reverse("login"))
response.delete_cookie("X-Auth-Token")
return response
def logout(request):
"""Log the user out."""
auth.logout(request)
next_url = _clean_next_url(request) or reverse('home')
resp = HttpResponseRedirect(next_url)
resp.delete_cookie('authtoken')
return resp
def get(self, *args, **kwargs):
"""Retrieve an access token from pocket, save to user, redirect."""
self._set_access_token_to_user()
response = HttpResponseRedirect(self.success_url)
response.delete_cookie(self.STATE_COOKIE_KEY)
response.delete_cookie(self.CODE_COOKIE_KEY)
return response
def logout(request):
## 删除cookie 和session
## 重定向到登录页
response = HttpResponseRedirect("/login/")
response.delete_cookie("username")
del request.session["username"]
return response
def logout(request):
username = request.COOKIES.get('username', '')
if username:
response = HttpResponseRedirect('/login/')
response.delete_cookie('username', username, 3600)
return response
else:
return HttpResponse('Veuillez vous connecter d\'abord')
def refresh(request):
"""Simulate cookie refresh - redirect logged in user with a new cookie"""
redirect_url = request.GET.get(REDIRECT_FIELD_NAME, '')
response = HttpResponseRedirect(redirect_url)
response.delete_cookie(SSO_COOKIE_NAME)
# Redirect with cookie doesn't work with 300 series
response.status_code = 200
return set_ticket_cookie(request.user, response)
def logout(request):
if request.method == 'GET':
user = request.user
UserSession.objects.filter(user=user).delete()
res = HttpResponseRedirect(reverse('web:index'))
res.delete_cookie('session')
return res
def logout(request):
if request.method == 'GET':
res = HttpResponseRedirect(reverse('user:login'))
# 删除浏览器cookie
res.delete_cookie('token')
token = request.COOKIES.get('token')
UserToken.objects.filter(token=token).delete()
return res
def logout(request):
response = HttpResponseRedirect("/index/")
response.delete_cookie("username")
## 删除session 目的是 用户再次使用相同的sessionid 进行访问，拿到的session的值是不一样的
# del request.session["username"] ### 删除指定session 删除的是保存在服务器上面session的值
request.session.flush() ## 删除所有的session
return response
def logout(request):
response = HttpResponseRedirect("/")
if request.COOKIES.get('customerId'):
response.delete_cookie('customerId')
if request.session.get('client'):
del request.session['client']
return response
def delete_playlist(request, id):
current_playlist = Playlist.objects.filter(id=id).first()
if current_playlist and current_playlist.owner == request.user:
current_playlist.delete()
response = HttpResponseRedirect(reverse('playlist.index'))
if request.COOKIES.get('current_playlist') == id:
response.delete_cookie("current_playlist")
return response
def logout(request):
# auth_logout(request)
try:
res = HttpResponseRedirect(request.META.get('HTTP_REFERER', '/'))
res.delete_cookie('name')
return res
except:
return HttpResponseRedirect("/")
def login_views(request):
if request.method == 'GET':
#獲取來訪地址，如果沒有則設置為/
url = request.META.get('HTTP_REFERER','/')
#get請求 - 判斷session，判斷cookie，登入頁
#先判斷session中是否有登入信息
if 'uid' in request.session and 'uphone' in request.session:
#從那來回那去
resp = HttpResponseRedirect(url)
return resp
else:
#沒有登入信息保存在session，繼續判斷cookies中是否有登入信息
if 'uid' in request.COOKIES and 'uphone' in request.COOKIES:
#cookies中有登入信息 - 曾經記住過密碼
#將cookies中的信息取出保存進session，在返回到首頁
uid = request.COOKIES['uid']
uphone = request.COOKIES['uphone']
request.session['uid'] = uid
request.session['uphone'] = uphone
#從那來回那去
resp = HttpResponseRedirect(url)
return resp
else:
# 創建LoginForm的對象併發送給login.html
form = LoginForm()
# 將來訪地址保存進cookies中
resp = render(request,'login.html',locals())
resp.set_cookie('url',url)
return resp
else:
#post請求 - 實現登入操作
#先獲取手機號和密碼
uphone = request.POST['uphone']
upwd = request.POST['upwd']
#判斷手機號和密碼是否存在(登入是否成功)
users = User.objects.filter(uphone=uphone,upwd=upwd)
if users:
#登入成功：先存進session
request.session['uid'] = users[0].id
request.session['uphone'] = uphone
#聲明響應對象:從那來回那去
url = request.COOKIES.get('url','/')
resp = redirect(url)
#將url從cookies中刪除出去
if 'url' in request.COOKIES:
resp.delete_cookie('url')
#判斷是否要存進cookies
if 'isSaved' in request.POST:
expire = 60*60*24*90
resp.set_cookie('uid',users[0].id,expire)
resp.set_cookie('uphone',uphone, expire)
return resp
else:
#登入失敗
errMsg = '您輸入的電話或密碼不正確'
form = LoginForm()
return render(request,'login.html',locals())
def login_views(request):
# 判断 get 请求还是 post 请求
if request.method == 'GET':
# 获取来访地址，如果没有则设置为/
url = request.META.get('HTTP_REFERER','/')
#get请求 － 判断session,判断cookie,登录页
#先判断session中是否有登录信息
if 'uid' in request.session and 'uphone' in request.session:
#有登录信息保存在 session
# 从哪来，回哪去
resp = HttpResponseRedirect(url)
return resp
else:
#没有登录信息保存在 session，继续判断cookies中是否有登录信息
if 'uid' in request.COOKIES and 'uphone' in request.COOKIES:
#cookies中有登录信息 － 曾经记住过密码
#将cookies中的信息取出来保存进session，再返回到首页
uid = request.COOKIES['uid']
uphone = request.COOKIES['uphone']
request.session['uid']=uid
request.session['uphone']=uphone
# 从哪来，回哪去
resp = redirect(url)
return resp
else:
#cookies中没有登录信息 － 去往登录页
form = LoginForm()
#将来访地址保存进cookies中
resp = render(request,'login.html',locals())
resp.set_cookie('url',url)
return resp
else:
#post请求 - 实现登录操作
#获取手机号和密码
uphone = request.POST['uphone']
upwd = request.POST['upwd']
#判断手机号和密码是否存在(登录是否成功)
users=User.objects.filter(uphone=uphone,upwd=upwd)
if users:
#登录成功：先存进session
request.session['uid']=users[0].id
request.session['uphone']=uphone
#声明响应对象：从哪来回哪去
url = request.COOKIES.get('url','/')
resp = redirect(url)
#将url从cookies中删除出去
if 'url' in request.COOKIES:
resp.delete_cookie('url')
#判断是否要存进cookies
if 'isSaved' in request.POST:
expire = 60*60*24*90
resp.set_cookie('uid',users[0].id,expire)
resp.set_cookie('uphone',uphone,expire)
return resp
else:
#登录失败
form = LoginForm()
return render(request,'login.html',locals())
