def login_page(request):
if request.user.is_authenticated():
response = HttpResponseRedirect('/diary/')
return response
if request.method == 'POST':
uf = UserForm(request.POST)
if uf.is_valid():
username = uf.cleaned_data['username']
password = uf.cleaned_data['password']
user = authenticate(username=username,password=password)
login(request, user)
if request.META.has_key('HTTP_CF_CONNECTING_IP'):
logInIP = request.META['HTTP_CF_CONNECTING_IP']
else:
logInIP = request.META['REMOTE_ADDR']
logInTime = datetime.datetime.now()
logOutTime = datetime.datetime.now()
UserAgent = str(parse(request.META.get('HTTP_USER_AGENT')))
try:
UItem= UserLogInfo.objects.create(user = user,
logInIP = logInIP,
logInTime = logInTime,
logOutTime = logOutTime,
UserAgent = UserAgent)
except:
pass
response = HttpResponseRedirect('/diary/')
LogID = UItem.pk
response.set_cookie('LogID',LogID,3600)
return response
else:
uf = UserForm()
else:
uf = UserForm()
return render_to_response('login_page.html',locals(),context_instance=RequestContext(request))
def ingresar(request):
mensaje=""
if not request.user.is_anonymous():
return HttpResponseRedirect('/home')
if request.method == 'POST':
formulario = AuthenticationForm(request.POST)
if formulario.is_valid:
usuario = request.POST['username']
clave = request.POST['password']
acceso = authenticate(username=usuario,password=clave)
if acceso is not None:
if acceso.is_active:
agregar_visita(usuario)
login(request, acceso)
response = HttpResponseRedirect('/home')
response.set_cookie("usuario",usuario)
response.set_cookie("use",acceso)
return response
else:
mensaje=mensajes_no_activo
else:
mensaje=mensajes_error_login
else:
mensaje=mensajes_error_login
else:
formulario = AuthenticationForm()
return render_to_response('ingresar.html',{'formulario':formulario,'mensaje':mensaje},context_instance=RequestContext(request))
def signin_view(request):
if request.method == "GET":
mobile = request.COOKIES.get("mobile", "")
return render(request, "account/signin.html", {
"mobile": mobile,
})
elif request.method == "POST":
mobile = request.POST['mobile']
password = request.POST['password']
if mobile is None or password is None:
error = "Mobile or Password is empty."
else:
next = request.POST.get('next', "/")
if not next:
next = "/"
response = HttpResponseRedirect(next)
response.set_cookie(key="mobile", value=mobile, max_age=None, expires=None, path='/', domain=None, secure=None, httponly=False)
user = authenticate(username=mobile, password=password)
if user:
if user.is_active:
login(request, user)
print "User is valid, active and authenticated"
return response
else:
error = "Please active your account before trying to login again."
else:
error = "The username and password were incorrect."
return HttpResponse(status=400, content=error)
def login(request):
auth = request.COOKIES.get('auth')
if auth: #already logged in, redirect to home page
return HttpResponseRedirect(reverse("displayCells"))
if request.method == 'GET':
l_form = LoginForm()
next = request.GET.get('login') or reverse('displayCells')
return render(request, 'login.html', {'form': l_form})
f = LoginForm(request.POST)
if not f.is_valid():
# bogus form post, send them back to login page and show them an error
messages.error(request, 'You must fill out all fields')
return HttpResponseRedirect('/login/')
email = f.cleaned_data['email']
password = f.cleaned_data['password']
next = reverse('displayCells') #reverse takes name of the view and returns the URL of the view
#send typed email and password to exp level
resp = requests.post('http://expul:8000/api/v1/login_exp_api/', data={"email": email, "password": password}).json()
if not resp or not resp[0]['pk']: #no student with that username/password, send back to login page with error
messages.error(request, 'Invalid username and/or password.')
return HttpResponseRedirect(reverse('login'))
# logged them in. set their login cookie and redirect to back to wherever they came from
authenticator = resp[0]['pk']
response = HttpResponseRedirect(next)
response.set_cookie("auth", authenticator)
return response
def login_handle(request):
#接收请求信息
post = request.POST
uname = post.get('username')
upwd = post.get('pwd')
remember = post.get('remember',0)
#根据用户名查询对象
user = UserInfo.objects.filter(uname=uname)
#如果能查到正确的用户名，则判断密码是否正确，都正确则转向用户中心
if len(user)==1:
s1 = sha1()
s1.update(upwd.encode('utf-8'))
upwd = s1.hexdigest()
if upwd==user[0].upwd:
red = HttpResponseRedirect('/goods/index/')
count = CartInfo.objects.filter(user_id=user[0].id).count()
#记住用户名
if remember != 0:
red.set_cookie('uname',uname)
else:
red.set_cookie('uname','',max_age=-1)
request.session['user_id'] = user[0].id
request.session['user_name'] = uname
request.session['count'] = count
return red
else:
context = {'title':'用户登录','error_name':0,'error_pwd':1,'uname':uname}
return render(request,'df_user/login.html',context)
else:
context = {'title': '用户登录', 'error_name': 1, 'error_pwd': 0, 'uname': uname}
return render(request, 'df_user/login.html', context)
def login_fun(request):
if request.method == 'GET':
# 每次在登录的时候，都要去cookie中获取username的值。
name = request.COOKIES.get('username', '')
return render(request, 'login.html', {'name': name})
elif request.method == 'POST':
uname = request.POST.get('username')
upassword = request.POST.get('password')
user = UserModel.objects.filter(uname=uname, upassword=upassword)
if user:
# 用户名密码都正确。
# 需要判断用户是否勾选了 "记住用户名"，如果勾选了，可以将这个用户名保存到浏览器的cookie中，并且可以设置过期时间。cookie一旦被浏览器缓存，除非cookie过期了，cookie不会受到项目的是否运行的影响。
is_jizhu = request.POST.get('box')
response = HttpResponseRedirect('/index/')
if is_jizhu:
# 用户选择了记住，后台如何向前端传递cookie? 响应头中的Set-Cookie
response.set_cookie('username', uname)
else:
# 如果用户没有勾选记住。将username这个cookie置为空。
response.set_cookie('username', max_age=1900000)
# 在向浏览器返回cookie的同时，也需要向后台表django_session中添加用户的登录状态session_data.
request.session['username'] = uname
return response
else:
return render(request, 'login.html', {'error': '用户名或密码错误'})
def login(request):
referer = request.GET.get("referer")
if not referer:
referer = request.META.get("HTTP_REFERER")
if request.method == "POST":
email = request.POST.get("email")
password = request.POST.get("pwd")
# 判断用户是否存在
# 如果存在
user = valid_user(email)
if user:
# 判断密码是否正确
db_password = user.password
request_password = set_password(password)
if db_password == request_password:
if request.POST.get("referer"):
referer = request.POST.get("referer")
if referer in ('http://127.0.0.1:8000/Buyer/login/', "None",
"http://127.0.0.1:8000/Buyer/resgister/"):
referer = "/Buyer/"
response = HttpResponseRedirect(referer)
response.set_cookie("email", user.email)
response.set_cookie("user_id", user.id)
request.session["email"] = user.email
return response
else:
error = "密码错误"
else:
error = "用户不存在"
return render(request, "buyer/login.html", locals())
def login(request):
error_message = ''
if request.method == 'POST':
username = request.POST.get('username')
password = request.POST.get('password')
if username:
user = LoginUser.objects.filter(username=username).first()
if user:
password = password_md(password)
db_password = user.password
if db_password == password:
response = HttpResponseRedirect('/Buyer/index/')
response.set_cookie('username', user.username)
response.set_cookie('user_id', user.id)
request.session['username'] = user.username
return response
else:
error_message = '密码有误'
else:
error_message = '用户不存在'
else:
error_message = '请输入用户名'
else:
error_message = '请求方式有误'
return render(request, 'buyer/login.html', locals())
def login_handle(request):
# 接收请求信息
post = request.POST
uname = post.get('username')
upwd = post.get('pwd')
jizhu = post.get('jizhu',0)
# 根据用户名查询对象
users = UserInfo.objects.filter(uname=uname)
print uname
# 判断：如果未查到，则用户名错，如果查到，则判断密码是否正确，正确则转到用户中心
if len(users) == 1:
s1 = sha1()
s1.update(upwd)
if s1.hexdigest() == users[0].upwd:
url = request.COOKIES.get('url','/')
red = HttpResponseRedirect('/user/info/')
# 记住用户名
if jizhu != 0:
red.set_cookie('uname',uname)
else:
red.set_cookie('uname','',max_age=-1)
request.session['user_id'] = users[0].id
request.session['user_name'] = uname
return red
else:
context = {'title':'用户登录','error_name':0,'error_pwd':1,'uname':uname,'upwd':upwd}
return render(request, 'df_user/login.html/', context)
else:
context = {'title': '用户登录', 'error_name': 1, 'error_pwd': 0, 'uname': uname, 'upwd':upwd}
return render(request, 'df_user/login.html/', context)
def shop_login(request):
error_message = ''
if request.method == 'POST':
email = request.POST.get('email')
password = request.POST.get('password')
if email:
#首先检测email有没有
user = UserRegister.objects.filter(email=email).first()
user_info = Userinfo.objects.filter(email=email).first()
if user and user_info: #如果正确
db_password = user.password #存入数据库的密码
password = setPassword(password) #从前端传过来的密码
if db_password == password: #判断与数据库中加密后的密码是否一致
response = HttpResponseRedirect('/')
response.set_cookie('user_id', user_info.id)
response.set_cookie('user_name', user_info.username)
request.session['user_id'] = user_info.id
return response
else:
error_message = '密码错误'
else:
response = HttpResponseRedirect('/shop/shop_register/')
return response
else:
error_message = '邮箱不可以为空'
return render(request, 'shop/shop_login.html', locals())
def loginProcess(request):
username = request.POST.get('username', '')
password = request.POST.get('password', '')
if username == '' or password == '':
return redirect(reverse('user:login', args=[]))
else:
m = hashlib.md5()
m.update(password)
password = m.hexdigest()
try:
user = User.objects.get(Q(username=username) | Q(academiccode=username) | Q(email=username),
password=password)
user.lastlogintime = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())
user.save()
request.session['userid'] = user.id
origin = request.session.get('origin', '')
if not user.username:
return redirect(reverse('user:register', args=[]))
# 旧系统没有录入手机号码，没有手机号码的补录一下
if not user.phone:
return redirect(reverse('user:changepassword', args=[]) + u"?error=请配合系统升级补录手机号码")
if origin != '':
del request.session['origin']
response = HttpResponseRedirect(origin)
else:
response = redirect(reverse('home', args=[]))
if request.POST.get('remember', default=False) == "remember-me":
remembercode = make_password("%d%s" % (user.id, settings.SECRET_KEY), None, 'pbkdf2_sha256')
response.set_cookie('remembercode', remembercode, None, datetime.now() + timedelta(days=365))
response.set_cookie('userid', user.id, None, datetime.now() + timedelta(days=365))
return response
except ObjectDoesNotExist:
logger.info("wrong password when login %s" % username)
return redirect(reverse('user:login', args=[]) + u"?error=用户名或密码错误")
def Register(request):
if request.method=='POST':
print request.POST
rf=RegisterForm(request.POST,request.FILES)
print rf,"rf.is_valid()===",rf.is_valid(),rf.cleaned_data['image']
if rf.is_valid():
rg_user=User()
rg_bbs_user=models.BbsUser()
print '=============================================================='
rg_user.username=rf.cleaned_data['username']
rg_user.password=rf.cleaned_data['password']
rg_user.email=rf.cleaned_data['email']
rg_user.first_name=rf.cleaned_data['firstname']
rg_user.last_name=rf.cleaned_data['lastname']
rg_user.date_joined=datetime.datetime.now()
print "rg_user:"******"保存失败，请重试！"})
return render(request,'newbbs/register.html')
def login_handle(request):
post=request.POST
uname=post.get('username')
upwd=post.get('pwd')
jizhu=post.get('jizhu',0)
print(uname,upwd,jizhu)
users=models.UserInfo.objects.filter(uname=uname)
if len(users)==1:
s1=sha1()
s1.update(upwd.encode('utf-8'))
upwd2=s1.hexdigest()
if upwd2==users[0].upwd:
u_url=request.COOKIES.get('url','/')
print(u_url)
red=HttpResponseRedirect(u_url)
if jizhu==1:
red.set_cookie('uname',uname)
else:
red.set_cookie('uname','',max_age=-1)
request.session['user_id']=users[0].id
request.session['user_name']=uname
request.session.set_expiry(0)
return red
else:
context={'title':'用户登录','error_name':0,'error_pwd':1,'uname':uname,'upwd':''}
print(222,context)
return render(request,'df_user/login.html',context)
else:
context={'title':'用户登录','error_name':1,'error_pwd':0,'uname':uname,'upwd':''}
print(333,context)
return render(request,'df_user/login.html',context)
def createAccount(request):
if request.method == 'GET':
return HttpResponse(
render(request, 'createAccount.html', {'valid': True}))
elif request.method == 'POST':
try:
username = request.POST['username']
password = request.POST['password']
if User.objects.filter(username=username).exists() or not re.match(
'[a-zA-Z0-9]+', username) or not len(password) > 4:
return HttpResponse(
render(request, 'createAccount.html', {'valid': False}))
else:
session = uuid.uuid4().hex
newUser = User(username=username,
password=password,
sessionId=session)
newUser.save()
response = HttpResponseRedirect("/battleship/")
response.set_cookie(key="session_id",
value=session,
max_age=86400,
httponly=True)
return response
except KeyError:
return HttpResponse('bad post')
def register_store(request):
type_list = StoreType.objects.all()
if request.method == "POST":
post_data = request.POST
store_name = post_data.get("store_name")
store_description = post_data.get("store_description")
print(store_description)
store_phone = post_data.get("store_phone")
store_money = post_data.get("store_money")
store_address = post_data.get("store_address")
user_id = int(request.COOKIES.get("user_id"))
type_lists = post_data.getlist("type")
print(type_lists)
store_logo = request.FILES.get("store_logo")
store = Store()
store.store_name = store_name
store.store_description = store_description
store.store_phone = store_phone
store.store_money = store_money
store.store_address = store_address
store.user_id = user_id
store.store_logo = store_logo
store.save()
for i in type_lists:
store_type = StoreType.objects.get(id=i)
store.type.add(store_type)
store.save()
response = HttpResponseRedirect("/Store/index/")
response.set_cookie("has_store", store.id)
return response
return render(request, "store/register_store.html", locals())
def login(request):
referer = request.GET.get('referer')
if not referer:
referer = request.META.get('HTTP_REFERER')
if request.method == 'POST':
email = request.POST.get('email')
password = request.POST.get('password')
user = valid_user(email)
if user:
post_password = set_password(password)
db_password = user.password
if post_password == db_password:
referer = request.POST.get('referer')
if referer in ('http://127.0.0.1:8000/Buyer/login/', "None",
'http://127.0.0.1:8000/Buyer/register/'):
referer = '/Buyer/'
response = HttpResponseRedirect(referer)
response.set_cookie('email', user.email)
response.set_cookie('user_id', user.id)
request.session['email'] = user.email
return response
else:
error = '密码错误!'
else:
error = '用户名不存在!'
return render(request, 'buyer/login.html', locals())
def login_fun(request, *args, **kwargs):
if request.session.get('user_id'):
return func(request, *args, **kwargs)
else:
red = HttpResponseRedirect('/user/login/')
red.set_cookie('url', request.get_full_path)
return red
def user_login(request):
if request.method == "GET":
uname = request.COOKIES.get('uname', '')
return render(request, 'users/login.html', {
'uname': uname,
})
else:
login_form = LoginForm(request.POST)
if login_form.is_valid():
username = login_form.cleaned_data['username']
password = login_form.cleaned_data['password']
user = authenticate(username=username, password=password)
if user:
login(request, user)
# request.session.set_expiry(0)
request.session['userid'] = user.id
xuanze = request.POST.get("xuanze", '')
url = request.COOKIES.get('url', '/')
ret = HttpResponseRedirect(url)
if xuanze == 'on':
ret.set_cookie('uname', username)
return ret
else:
ret.delete_cookie('uname')
return ret
else:
return render(request, 'users/login.html',
{'msg': '用户名或者密码错误'})
else:
return render(request, 'users/login.html', {
'forms': login_form,
})
def login_handler(request):
# 获取用户的用户名和密码
post = request.POST
uname = post.get('username')
upwd = post.get('pwd')
jizhu = post.get('jizhu', 0)
print(jizhu)
# 实例化
# 获取加密后的密码
sha1_obj = sha1()
sha1_obj.update(upwd.encode())
sha1_upwd = sha1_obj.hexdigest()
user = models.UserInfo.objects.filter(uname=uname, upwd=sha1_upwd)
if user:
response = HttpResponseRedirect('/good/')
if jizhu != 0:
# 记住用户名勾上的话,如果登录成功,把用户名记录在cookie中
response.set_cookie('uname', uname)
else:
response.set_cookie('uname', '', max_age=-1) # max_age 超时时间
# 进入这一步表示已经登录成功了,把用户信息写入session
request.session['user_id'] = user[0].id
request.session['user_name'] = user[0].uname
return response
else:
return HttpResponseRedirect('/user/login')
def login_view(request):
response_data = {}
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
password = form.cleaned_data['password']
user = UserModel.objects.filter(username=username).first()
if user:
if user.is_active == True:
print user.is_active
if check_password(password, user.password):
token = SessionToken(user=user)
token.create_token()
token.save()
response = HttpResponseRedirect('/feed/')
response.set_cookie(key='session_token',
value=token.session_token)
print "success"
return response
else:
response_data[
'message'] = 'Incorrect Password! Please try again!'
else:
print 'user has not been activated'
return HttpResponse('You Must activate first.')
elif request.method == "GET":
form = LoginForm()
response_data['form'] = form
return render(request, 'login.html', response_data)
def login_fun(request, *args, **kwargs):
if request.session.has_key('user_id'):
return func(request, *args, **kwargs)
else:
red = HttpResponseRedirect('login')
red.set_cookie('url', request.get_full_path()) #提取url到cookie
return red
def login_handle(request):
# 接收请求信息
get = request.POST
uname = get.get('username')
upwd = get.get('pwd')
jizhu = get.get('jizhu', 0)
# 根据用户名查询对象
users = UesrInfo.objects.filter(uname=uname)
# print uname
# 判断如果未查到则用户名错，查到再判断密码是否正确，
if len(users) == 1:
s1 = sha1()
s1.update(upwd)
if s1.hexdigest() == users[0].upwd:
red = HttpResponseRedirect('/')
count = CartInfo.objects.filter(user_id=users[0].id).count()
if jizhu != 0:
red.set_cookie('uname', uname)
else:
red.set_cookie('uname', '', max_age=-1)
request.session['user_id'] = users[0].id
request.session['user_name'] = uname
return red
else:
context = {'title': '用户登录', 'error_name': 0, 'error_pwd': 1, 'uname': uname}
return render(request, 'rb_user/login.html', context)
else:
context = {'title': '用户登录', 'error_name': 1, 'error_pwd': 0, 'uname': uname }
return render(request, 'rb_user/login.html', context)
def login(request):
error_message = ''
if request.method == 'POST':
email = request.POST.get('email')
password = request.POST.get('password')
code = request.POST.get("valid_code")
if email:
user = Login.objects.filter(email=email).first()
if user:
db_password = user.password
password = setPassword(password)
if db_password == password:
#检测验证码和获取验证码
codes = ValidCode.objects.filter(
code_user=email).order_by("-code_time").first()
#校验验证码是否存在，是否过期，是否被使用
now = time.mktime(datetime.datetime.now().timetuple())
db_time = time.mktime(codes.code_time.timetuple())
t = (now - db_time) / 60
if codes and codes.code_state == 0 and t <= 5 and codes.code_content.upper(
) == code.upper():
response = HttpResponseRedirect('/Seller/index/')
response.set_cookie('username', user.username)
response.set_cookie('user_id', user.id)
request.session['username'] = user.username
return response
else:
error_message = "验证码错误"
else:
error_message = '密码错误'
else:
error_message = '用户不存在'
else:
error_message = '邮箱不能为空'
return render(request, 'seller/login.html', locals())
def login(request):
if request.method == 'GET':
return HttpResponse(render(request, 'login.html', {'valid': True}))
elif request.method == 'POST':
try:
username = request.POST['username']
password = request.POST['password']
try:
if User.objects.get(username=username) and User.objects.get(
username=username).password == password:
print("Logged In User: "******"/battleship/")
response.set_cookie(key="session_id",
value=session,
max_age=86400,
httponly=True)
return response
else:
return HttpResponse(
render(request, 'login.html', {'valid': False}))
except ObjectDoesNotExist:
return HttpResponse(
render(request, 'login.html', {'valid': False}))
except KeyError:
return HttpResponse('bad post')
def register_store(request):
type_list = StoreType.objects.all()
if request.method == "POST":
post_data = request.POST #接收post数据
store_name = post_data.get("store_name")
store_descripton = post_data.get("store_descripton")
store_phone = post_data.get("store_phone")
store_money = post_data.get("store_money")
store_address = post_data.get("store_address")
user_id = int(request.COOKIES.get("user_id")) #通过cookie来得到user_id
type_lists = post_data.getlist("type") #通过request.post得到类型，但是是一个列表
store_logo = request.FILES.get("store_logo") #通过request.FILES得到
#保存非多对多数据
store = Store()
store.store_name = store_name
store.store_descripton = store_descripton
store.store_phone = store_phone
store.store_money = store_money
store.store_address = store_address
store.user_id = user_id
store.store_logo = store_logo #django1.8之后图片可以直接保存
store.save() #保存，生成了数据库当中的一条数据
#在生成的数据当中添加多对多字段。
for i in type_lists: #循环type列表，得到类型id
store_type = StoreType.objects.get(id=i) #查询类型数据
store.type.add(store_type) #添加到类型字段，多对多的映射表
store.save() #保存数据
response = HttpResponseRedirect("/Store/index/")
response.set_cookie("has_store", store.id)
return response
return render(request, "store/register_store.html", locals())
def login(request):
error_message = "" #异常状态容器
if request.method == "POST": #如果请求是post
email = request.POST.get("email") #email等于post请求传过来的name=email值
password = request.POST.get(
"password") #password等于post请求传过来的name=password的值
if email: #如果email不为空
user = LoginUser.objects.filter(
email=email).first() #调取数据库中LoginUser表中email=email的数据列传给user
if user: #如果user存在（说明网页传来的数据和数据库对的上）
db_password = user.password #数据库中对应的密码值给变量db_password
password = setPassword(password) #把网页上加密的password赋值给新的password
if db_password == password: #如果都经过md5 加密的password值相等
response = HttpResponseRedirect(
"/Seller/index/") #访问主页index
response.set_cookie("email",
user.email) #把数据库中的username下载到本地
response.set_cookie("user_id", user.id) #把数据库中的id下载到本地缓存
request.session["email"] = user.email #把用户信息放到服务器端
return response #返回请求
else:
error_message = "密码错误"
else:
error_message = "用户名不存在"
else:
error_message = "邮箱不可为空"
return render(request, "seller/login.html", locals())
def post(self, request):
"""
Process form data on POST requests
"""
auth_form = AuthenticationForm(data=request.POST)
if auth_form.is_valid():
login(request, auth_form.get_user())
# obtain JW token
jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER
payload = jwt_payload_handler(auth_form.get_user())
user_token = jwt_encode_handler(payload)
response = HttpResponseRedirect(reverse('home'))
response.set_cookie('user_token', user_token)
response.set_cookie('user_id', request.user.id)
request.session.set_expiry(600)
return response
else:
for key in auth_form.errors:
for error in auth_form.errors[key]:
messages.add_message(request, messages.INFO, error)
args = {}
args.update(csrf(request))
args.update({'form': RegisterForm})
return render(
request, 'authenticate.html', {'form': RegisterForm}
)
def Login(request):
if request.method=='POST' and request.POST.has_key('username') and request.POST.has_key('password'):
username = request.POST['username']
password = request.POST['password']
#print username,password
#result_login=models.BbsUser.objects.filter(user__username=username,user__password=password)
#print 'result_login',result_login
user = authenticate(username=username, password=password)
print 'user:'******'username'] = username
response=HttpResponseRedirect('/')
response.set_cookie('username',username,3600)
#request.session
# Redirect to a success page.
return response
else:
return render(request,'newbbs/login.html',{'error':"此用户未激活"})
else:
return render(request,'newbbs/login.html',{'error':"用户名或密码有误，请重试！"})
return render(request,'newbbs/login.html')
def login_handle(request):
get = request.POST
uname = get.get('username')
upwd = get.get('pwd')
jizhu = get.get('jizhu', 0)
users = UserInfo.objects.filter(uname=uname)
print(uname)
if len(users) == 1:
red = HttpResponseRedirect('/user/info')
if jizhu != 0:
red.set_cookie('uname', uname)
else:
red.set_cookie('uname', '', max_age=-1)
request.session['user_id'] = users[0].id
request.session['user_name'] = uname
return red
else:
context = {
'title': '用户登录',
'error_name': 1,
'error_pwd': 1,
'uname': uname,
'upwd': upwd
}
return render(request, 'df_user/login.html', context)
def getlogin(request):
email = "test"
form = loginCustomerForm(request.POST or None)
if form.is_valid():
passwordd = form.cleaned_data['password']
emaill = form.cleaned_data['email']
passworddd = make_password(password=passwordd,
salt=None,
hasher='unsalted_md5')
# user = get_object_or_404(customer, email=emaill,password=passworddd)
user = customer.objects.filter(email=emaill,
password=passworddd,
active=True)
if (user):
#request.session['user']=emaill
response = HttpResponseRedirect('/')
response.set_cookie('user', emaill)
#response.set_cookie('cookie_name2', 'cookie_name2_value')
return response
#response.set_cookie('user',emaill)
#return response
else:
return redirect('regislogin')
return render(request, "appone/login.html", {"form": form})
def log_in(request):
global s
if request.method == 'GET':
form = forms.LoginForm()
return render(request, 'port/login.html', {'form': form})
elif request.method == 'POST':
form = forms.LoginForm(request.POST)
if form.is_valid():
username = form.cleaned_data['uname']
password = form.cleaned_data['pwd']
url = 'http://59.110.6.179:9007/fcwz/userlogin/login'
data = {'login': username, 'password': password}
r = s.post(url, data=data)
dict1 = json.loads(r.text)
if 'error' in dict1.keys():
return render(request, 'port/login.html', {
'form': form,
'error': dict1['error']
})
else:
r = request.POST.get('next', '')
if r:
response = HttpResponseRedirect(r)
else:
response = HttpResponseRedirect('/address')
cookie = dict1['session_id']
print('返回给我得' + cookie)
response.set_cookie('cookie', cookie, max_age=100)
response.set_cookie('user', username, max_age=100)
return response
else:
return render(request, 'port/login.html', {'form': form})
def login(request):
error_message = ""
if request.method == "POST":
email = request.POST.get("email")
password = request.POST.get("password")
code = request.POST.get("valid_code")
if email:
user = Login_User.objects.filter(email=email).first()
if user:
db_password = user.password
password = setPassword(password)
if db_password == password:
#检测验证码 获取验证码
codes = Vaild_Code.objects.filter(
code_user=email).order_by("-code_time").first()
#校验验证码是否存在，是否过期，是否被使用
now = time.mktime(datetime.datetime.now().timetuple())
db_time = time.mktime(codes.code_time.timetuple())
t = (now - db_time) / 60
if codes and codes.code_state == 0 and t <= 5 and codes.code_content.upper(
) == code.upper():
response = HttpResponseRedirect("/Seller/index/")
response.set_cookie("username", user.username)
response.set_cookie("id", user.id)
request.session["username"] = user.username
return response
else:
error_message = "验证码错误"
else:
error_message = "密码错误"
else:
error_message = "用户不存在"
else:
error_message = "邮箱不可为空"
return render(request, "seller/login.html", locals())
def log_in(request):
response_data = {}
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
username = form.cleaned_data.get('username')
password = form.cleaned_data.get('password')
#print username + password
user = UserModel.objects.filter(username=username).first()
if user:
if check_password(password, user.password):
#print 'valid user'
token = SessionToken(user=user)
token.create_token()
token.save()
response = HttpResponseRedirect('/feed/')
response.set_cookie(key='session_token',
value=token.session_token)
return response
else:
#print 'invalid user'
response_data['message'] = 'Incorrect Password!'
elif request.method == "GET":
form = LoginForm()
response_data['form'] = form
return render(request, 'login.html', {'form': form})
def login_handle(request):
post = request.POST
name = post.get('username')
pwd = post.get('pwd')
rem = post.get('remember', 0)
# 根据用户名查询对象
users = models.UserInfo.users.filter(name=name)
if len(users) == 1:
s1 = sha1()
s1.update(pwd)
if s1.hexdigest() == users[0].pwd:
url = request.COOKIES.get('url', '/')
# print(url)
red = HttpResponseRedirect(url)
if rem != 0:
red.set_cookie('username', name)
else:
red.delete_cookie('username')
request.session['user_id'] = users[0].id
request.session['user_name'] = name
return red
else:
context = {'username': name, 'error_name': 0, 'error_pwd': 1, 'title': '登录'}
return render(request, 'df_user/login.html', context)
else:
context = {'error_name': 1, 'error_pwd': 0, 'title': '登录'}
return render(request, 'df_user/login.html', context)
def login(request):
if request.method == "POST" and request.POST:
#获取校验cookie
login_cookie = request.get_signed_cookie(key="login_cookie",
salt="nihao")
if login_cookie:
data = request.POST
username = data.get("username")
password = data.get("password")
try:
user = CMDBUser.objects.get(username=username)
except:
return HttpResponse("用户不存在")
else:
db_password = user.password
if password == db_password:
response = HttpResponseRedirect("testing/index/", locals())
response.set_cookie(key="username", value=user.username)
return response
else:
return HttpResponse("密码错误")
else:
return HttpResponse("404")
else:
#登陆页面，login.html get请求
#生成response实例
response = render(request, "testing/login/")
#设置cookie
response.set_signed_cookie("login_cookie",
"while",
salt="nihao",
max_age=3600)
#返回设置了cookie的响应
return response
def login_handle(request):
get = request.POST
uname = get.get('username')
upwd = get.get('pwd')
rm = get.get('rm',0)
#according username searching
users = UserInfo.objects.filter(uname=uname)
if len(users) == 1:
s1 = sha1()
s1.update(upwd)
if s1.hexdigest() == users[0].upwd:
url = request.COOKIES.get('url','/')
red = HttpResponseRedirect(url)
#remember it
if rm != 0:
red.set_cookie('uname',uname)
else:
red.set_cookie('uname','',max_age=-1)
request.session['user_id'] = users[0].id
request.session['user_name'] = uname
return red
else:
context = {'title':'用户登录','error_name':0,'error_pwd':1,'uname':uname,'upwd':upwd}
return render(request,'fd_user/login.html',context)
else:
context = {'title': '用户登录', 'error_name': 1, 'error_pwd': 0, 'uname': uname, 'upwd': upwd}
return render(request, 'fd_user/login.html', context)
def signin(request):
# if request.COOKIES.get('username') is not None:
# username = request.COOKIES.get('username')
# password = request.COOKIES.get('password')
# user = authenticate(request, username=username, password=password)
# if user is not None:
# login(request, user)
# return HttpResponseRedirect(reverse('main'))
#
# else:
# return render(request, 'accounts/login_fail.html')
if request.method == "POST":
form = LoginForm(request.POST)
username = request.POST['username']
password = request.POST['password']
user = authenticate(username=username, password=password)
if user is not None:
login(request, user)
response = HttpResponseRedirect(reverse('main'))
response.set_cookie('username', username)
response.set_cookie('password', password)
return HttpResponseRedirect(reverse('client:client_list'))
else:
return render(request, 'accounts/login_fail.html')
else:
form = LoginForm()
return render(request, 'accounts/login.html', {'form': form})
def add_product_to_cart(request):
context={}
response = HttpResponseRedirect('/cart/')
product_id = request.POST['product_id']
if (request.COOKIES.get(COOKIES_ID)):
cart = Cart.objects.get(
id=request.COOKIES.get(COOKIES_ID)
)
else:
cart = Cart.objects.create(
total_amount=0
)
cart_id = cart.id
cart.total_amount += Product.objects.get(id=product_id).price
cart.save()
cart_element = CartElement.objects.create(
product=Product.objects.get(
id=product_id
),
cart=Cart.objects.get(
id=cart_id
),
size=Size.objects.filter(
size = request.POST['size']
).first()
)
size = Size.objects.filter(
size = request.POST['size'],
available=True
).first()
size.available = False
size.save()
cart_element_id = cart_element.id
response.set_cookie(
key=COOKIES_ID,
value=str(cart_id),
max_age=10000000
) # неделя
available_sizes = Size.objects.filter(
available=True,
product=Product.objects.get(id=product_id)
).count()
if (available_sizes == 0):
product = Product.objects.get(
id=product_id
)
product.available = False
product.save()
return response
def Inst(request):
if request.method == 'GET':
contestName=request.GET.get('name')
response= HttpResponseRedirect("hi")
response = render_to_response('Instructions.html',{'contest':Contests.objects.get(contestName=contestName)},context_instance=RequestContext(request))
response.set_cookie('contestName')
return response
else:
print 'form invalid so entered here'
return render_to_response('TakeExam.html',{'contest_var':Contests.objects.all()},context_instance=RequestContext(request))
def set_language(request):
'''
Set language cookie, redirect to requested page
'''
lang = request.GET.get('lang', None)
response = HttpResponseRedirect(request.META["HTTP_REFERER"])
if lang == "ru":
response.set_cookie(key="lang", value="ru", max_age=365*24*60*60, expires=None, path='/')
else:
response.set_cookie(key="lang", value="en", max_age=365*24*60*60, expires=None, path='/')
return response
def login_handle(request):
# 接收请求信息
post = request.POST
uname = post.get('username')
upwd = post.get('pwd')
#这里接收的参数'jizhu'为从login.html中接收的，默认为勾选了则为1，那么就不会用后面的默认值0
jizhu = post.get('jizhu', 0)
# 根据用户名查询对象，这里用filter，如果查不到会返回[]
users = UserInfo.objects.filter(uname=uname)
# print uname
# 判断如果未查到则用户名错，查到再判断密码是否正确，正确则转到用户中心
if len(users) == 1:
s1 = sha1()
s1.update(upwd.encode("utf-8"))
#登录带cookie值 必须 red = HttpResponseRedirect red.set_cookie renturn red
if s1.hexdigest() == users[0].upwd:
red = HttpResponseRedirect('/user/info') #转到用户中心
count = CartInfo.objects.filter(user_id=users[0].id).count()
#另外一种写法
#url = request.COOKIES.get('url', '/') 这里的'/'是默认值，表示url中没设定时，转到'/'
#red=HttpResponseRedirect(url)
# 记住用户名，就是如果选上记住用户名勾选框，就把用户名记在cookie中
#set_cookie()是HttpResponse中的方法，而HttpResponseRedirect继承了HttpResponse.
if jizhu != 0:
red.set_cookie('uname', uname)
#如果不勾选记住用户名，就把uname值清空，max_age=-1表示立即过期，
else:
red.set_cookie('uname', '', max_age=-1)
#状态保持中的session存储方式的使用，对于使用频率比较高的数据可以使用
#存储方式包括cookie、session，会话一般指session对象
#使用cookie，所有数据存储在客户端，注意不要存储敏感信息
#推荐使用sesison方式，所有数据存储在服务器端，在客户端cookie中存储session_id
#状态保持的目的是在一段时间内跟踪请求者的状态，可以实现跨页面访问当前请求者的数据
request.session['user_id'] = users[0].id
request.session['user_name'] = uname
request.session['count'] = count
return red #记住最后必须return
#这里表示密码不对的处理
else:
context = {'title': '用户登录', 'error_name': 0, 'error_pwd': 1, 'uname': uname}
return render(request, 'df_user/login.html', context)
#这里表示没查到用户名，表明用户名错误，这里error_name设为1
else:
context = {'title': '用户登录', 'error_name': 1, 'error_pwd': 0, 'uname': uname }
#error_name=1传到login.html中，在里面会对应的代码显示用户名错误
return render(request, 'df_user/login.html', context)
def set_language(request, lang_code='en'):
"""sets the application's language and redirects back to the calling template"""
original_url = request.META.get('HTTP_REFERER', None)
response = HttpResponseRedirect(original_url)
if hasattr(request, 'session'):
if lang_code and check_for_language(lang_code):
request.session['django_language'] = lang_code
else:
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code)
return response
def login_check_user(request):
'''验证用户
'''
username = request.POST['username']
password = request.POST['password']
try:
theuser = AdminUser.objects.get(name=username)
except Exception:
theuser = None
if not theuser:
return render_to_response('login.html',{'errormsg':USER_ERROR})
if not theuser.check_password(password):
return render_to_response('login.html',{'errormsg':PASSWORD_ERROR})
response = HttpResponseRedirect("/main")
response.set_cookie('login_user', username,max_age=600)
return response
def switch_lang(request):
next = request.REQUEST.get('next', None)
if not next:
next = request.META.get('HTTP_REFERER', None)
if not next:
next = '/'
response = HttpResponseRedirect(next)
if request.method == 'GET':
lang_code = request.GET.get('lang_code', None)
if lang_code and check_for_language(lang_code):
if hasattr(request, 'session'):
request.session['django_language'] = lang_code
else:
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code)
return response
def login(request):
if request.method == 'POST':
print(request.POST)
form_value = UserForm(request.POST)
if form_value.is_valid():
#获取表单用户密码
username = form_value.cleaned_data['username']
password = form_value.cleaned_data['password']
#获取的表单数据与数据库进行比较
user = User.objects.filter(username__exact = username,password__exact = password)
if user:
#比较成功，跳转index
response = HttpResponseRedirect('/cmdb/home/')
#将username写入浏览器cookie,失效时间为3600
response.set_cookie('username',username,3600)
# logger.logger.info("%s loggin !"%username)
return response
else:
#比较失败，还在login
return HttpResponseRedirect('/cmdb/login/')
else:
form_value = UserForm()
return render_to_response('login.html')
def show_followed(request):
resp = HttpResponseRedirect('/')
resp.set_cookie('show_followed', '1', max_age=30 * 24 * 60 * 60)
return resp
