def post(self, request):
# 前端提交信息，与微博user绑定
json_obj = json.loads(request.body)
data = self.check_args(json_obj, 5)
uid = data.get('uid', None) #微博uid
username = data.get('username', None)
password = data.get('password', None)
print(type(password))
phone = data.get('phone', None)
email = data.get('email', None)
# 哈希加密
m = hash_pwd(password)
# 创建用户以及微博用户表
try:
# 开启事务
with transaction.atomic():
user = UserProfile.objects.create(username=username,
password=m.hexdigest(),
email=email,
phone=phone)
weibo_user = WeiboUser.objects.get(uid=uid)
weibo_user.username = user
weibo_user.save()
except Exception as e:
return JsonResponse({
'code': 10129,
'error': 'create user failed!'
})
# 创建成功返回用户信息
token = make_token(username)
result = {'code': 200, 'username': username, 'token': token.decode()}
return JsonResponse(result)
def post(self, request):
json_str = request.body
json_obj = json.loads(json_str)
# {"uid":"1861495121","username":"******","password":"******","phone":"13488873110","email":"*****@*****.**"}
wuid = json_obj['uid']
username = json_obj['username']
password = json_obj['password']
phone = json_obj['phone']
email = json_obj['email']
m = hashlib.md5()
m.update(password.encode())
try:
with transaction.atomic():
# 生成一个 UserProfile
user = UserProfile.objects.create(username=username, password=m.hexdigest(), email=email, phone=phone)
# update 给wuid对应的 WeiboProfile 对象 绑定 外键
weibo_user = WeiboProfile.objects.get(wuid=wuid)
weibo_user.user_profile = user
weibo_user.save()
except Exception as e:
print('---bind weibouser error is %s' % (e))
return JsonResponse({'code': 10109, 'error': 'The database is error'})
token = make_token(username)
return JsonResponse({'code': 200, 'username': username, 'token': token.decode()})
def post(self, request):
# 微博用户绑定注册关联模块
json_obj = json.loads(request.body)
uid = json_obj['uid']
username = json_obj['username']
password = json_obj['password']
phone = json_obj['phone']
email = json_obj['email']
# 密码处理
m = hashlib.md5()
m.update(password.encode())
# 生成原始对象,绑定微博账号的外键(采用数据库的事物控制)
try:
# 触发数据库事物控制
with transaction.atomic():
user = UserProfile.objects.create(username=username,
password=m.hexdigest(),
email=email,
phone=phone)
weibo_user = WeiBoProfile.objects.get(wb_uid=uid)
weibo_user.user_profile = user
weibo_user.save()
except Exception as e:
return JsonResponse({'code': 10109, 'error': '服务器繁忙,请稍后重试!'})
token = make_token(username=username)
return JsonResponse({
'code': 200,
'username': username,
'token': token.decode()
})
def post(self, request):
"""
用户提交了关于个人信息以及uid，创建用户，并且创建绑定微博关系
"""
data = json.loads(request.body)
uid = data.get('uid', None)
username = data.get('username', None)
password = data.get('password', None)
phone = data.get('phone', None)
email = data.get('email', None)
# 创建用户表
m = hashlib.md5()
m.update(password.encode())
# 创建用户以及微博用户表
try:
with transaction.atomic():
user = UserProfile.objects.create(username=username, password=m.hexdigest(),
email=email, phone=phone)
weibo_user = WeiboProfile.objects.get(wuid=uid)
weibo_user.user_profile = user
weibo_user.save()
except Exception as e:
return JsonResponse({'code': 10128, 'error':'create user failed!'})
token = make_token(username)
return JsonResponse({'code': 200, 'username': username, 'token': token.decode()})
def post(self, request):
data = json.loads(request.body)
uid = data['uid']
username = data['username']
password = data['password']
phone = data['phone']
email = data['email']
m = hashlib.md5()
m.update(password.encode())
password_h = m.hexdigest()
try:
with transaction.atomic():
# 创建UserProfile数据
user = UserProfile.objects.create(username=username,
password=password_h,
email=email,
phone=phone)
# 绑定WeiboProfile的外键
weibo_user = WeiboProfile.objects.get(wuid=uid)
weibo_user.user_profile = user
weibo_user.save()
except Exception as e:
print('--create error is %s' % (e))
return JsonResponse({'code': 10112, 'error': 'Create user error'})
token = make_token(username)
return JsonResponse({
'code': 200,
'username': username,
'token': token.decode()
})
def Wxlogin(request):
if request.method == 'GET':
return JsonResponse({'code': 'Wxlogin'})
if request.method == 'POST':
data = request.body
data_obj = json.loads(data)
openid = data_obj.get('openid')
nickname = data_obj.get('nickname')
old_user = UserProfile.objects.filter(openid=openid)
if old_user:
user = old_user[0]
token = make_token(user.id)
return JsonResponse({'code': 200, 'message': '登录成功', 'token': token.decode(), 'id': old_user[0].id,'openid':user.openid})
else:
user = UserProfile.objects.create(openid=openid, nickname=nickname)
token = make_token(user.id)
return JsonResponse({'code': 200, 'message': '登录成功', 'token': token.decode(), 'id': user.id,'openid':user.openid})
def users(request):
if request.method == 'POST':
'注册用户'
data = request.body # 取出请求体里的所有数据，拿到json串
json_obj = json.loads(data) # 反序列化，变成python字典
print(data)
username = json_obj['uname']
email = json_obj['email']
password = json_obj['password']
phone = json_obj['phone']
if len(password) < 6:
result = {'code': 10100, 'error': 'password is error!'}
return JsonResponse(result) # JsonResponse可以把传进来的参数序列化成一个字典，并且吧响应头里的content—type变成便准的application/json，
"""
#用户名是否可用，已注册的话给个错误返回
#创建用户 密码用md5
#用jwt 签发token 有效期1天，token 里面存放e:xxx
#查看用户名是否注册过，filter返回queryset结构，
"""
old_user = UserProfile.objects.filter(username=username)
if old_user:
result = {'code': 10101, 'error': 'The username is already exist～'}
return JsonResponse(result)
# 创建用户 密码用md5
p_m = hashlib.md5()
p_m.update(password.encode()) # update传进去需要一个字节串，password是字符串，需要encode
password = p_m.hexdigest()
# 创建用户需要try下
try:
# 创建用户
user = UserProfile.objects.create(username=username, password=password, email=email, phone=phone)
except Exception as e:
print('create error is %s' % (e))
result = {'code': 10102, 'error': 'The username is Already exist～'}
return JsonResponse(result)
token = make_token(username)
"""
#生成四位随机数
#拿用户名 + 随机数 拼接成一个新的字符串
#b64(新字符串）
#存储随机数
#生成激活链接 “http://127.0.0.1:7000/dadashop/templates/active.html?code =%s'
#将链接发送至用户邮箱
"""
code = "%s" % (random.randint(1000, 9999))
code_str = code + "_" + username
code_bs = base64.urlsafe_b64encode(code_str.encode()) # 字节串
# 存储随机数
EMAIL_CACHE.set('email_active_%s' % (username), code, 3600 * 24 * 3)
# 激活链接
verify_url = "http://127.0.0.1:7000/dadashop/templates/active.html?code =%s" % (code_bs.decode())
# 将链接发送至用户邮箱
# send_active_email(email,verify_url)
send_active_email_celery.delay(email, verify_url) # 用新写的方法代替容易阻塞的方法去执行
# 此阶段通讯了QQ,响应
return JsonResponse({'code': 200, 'username': username, 'data': {'token': token.decode()}, 'carts_count': 0})
def users(request):
if request.method != 'POST':
return JsonResponse({'code': 10100, 'error': 'Please use POST !'})
json_str = request.body
data = json.loads(json_str)
username = data['uname']
email = data['email']
password = data['password']
phone = data['phone']
#TODO 参数判断
#检查用户名是否已经存在
old_users = UserProfile.objects.filter(username=username)
if old_users:
result = {'code': 10101, 'error': 'Your username is already existed!'}
return JsonResponse(result)
m = hashlib.md5()
m.update(password.encode())
#创建用户
try:
user = UserProfile.objects.create(username=username,
password=m.hexdigest(),
email=email,
phone=phone)
except Exception as e:
print('---create error is ---')
print(e)
return JsonResponse({
'code': 10102,
'error': 'Your username is already existed~~'
})
#生成令牌
token = make_token(username)
#容错性
try:
#激活邮件的功能
#1,给用户邮箱中 发邮件，邮件内容 - ‘欢迎来到达达商城，点击如下链接，可完成注册’
#2,邮件中的链接有效期为3天
#3,code的隐私性
# send_mail(html_message='')
verify_url = 'http://127.0.0.1:7000/dadashop/templates/active.html?code=xxx'
except Exception as e:
pass
return JsonResponse({
'code': 200,
'username': username,
'data': {
'token': token.decode()
},
'carts_count': 0
})
def post(self, request):
data = request.body
if not data:
result = {'code': '10101', 'error': '请提供完整的注册信息'}
return JsonResponse(result)
json_obj = json.loads(data)
username = json_obj.get('username')
password = json_obj.get('password')
email = json_obj.get('email')
phone = json_obj.get('phone')
gender = json_obj.get('gender')
birthday = json_obj.get('birthday')
print('--------------------', username, password, email, phone, gender,
birthday)
# 检查用户名是否可用
old_user = UserProfile.objects.filter(username=username)
if old_user:
result = {'code': '10102', 'error': '用户名已存在!'}
return JsonResponse(result)
# 生成密码哈希
m = hashlib.md5()
m.update(password.encode())
# 创建用户
try:
user = UserProfile.objects.create(username=username,
password=m.hexdigest(),
email=email,
phone=phone,
gender=gender,
birthday=birthday)
except Exception as e:
result = {'code': '10103', 'error': '用户名已存在!'}
return JsonResponse(result)
user = UserProfile.objects.filter(username=username)
user = user[0]
create_uid = user.id
r.hset('followed:amount', create_uid, 0)
r.hset('fans:amount', create_uid, 0)
# 生成、签发token
# {'code':200, 'username':'******', 'data':{'token':xxxx}}
token = make_token(username)
# 发激活邮件
random_int = random.randint(1000, 9999)
code_str = username + '_' + str(random_int)
code_str_bs = base64.urlsafe_b64encode(code_str.encode())
# 将随机码组合存储在redis中 可以扩展成只存储1-3天
r.set('email_active_%s' % (username), code_str)
active_url = 'http://127.0.0.1:7000/dadashop/templates/active.html?code=%s' % (
code_str_bs.decode())
send_active_email.delay(email, active_url)
return JsonResponse({
'code': 200,
'username': username,
'data': {
'token': token.decode()
}
})
def post(self, request):
"""
此时用户提交了关于个人信息以及uid
创建用户，并且创建绑定微博关系
:param requset:
:return:
"""
data = json.loads(request.body)
uid = data.get('uid', None)
username = data.get('username', None)
password = data.get('password', None)
phone = data.get('phone', None)
email = data.get('email', None)
if not username:
return JsonResponse({'code': 201, 'error': 'Invalid username!'})
if not password:
return JsonResponse({'code': 10108, 'error': 'Invalid password!'})
if not email:
return JsonResponse({'code': 10126, 'error': 'Invalid email'})
if not phone:
return JsonResponse({
'code': 10117,
'error': 'Invalid phone number!'
})
if not uid:
return JsonResponse({
'code': 10130,
'error': 'Invalid access token!'
})
# 创建用户表
m = hashlib.md5()
m.update(password.encode())
# 创建用户以及微博用户表
try:
with transaction.atomic():
user = UserProfile.objects.create(username=username,
password=m.hexdigest(),
email=email,
phone=phone)
weibo_user = WeiboUser.objects.get(uid=uid)
weibo_user.username = user
weibo_user.save()
except Exception as e:
return JsonResponse({
'code': 10128,
'error': 'create user failed!'
})
# 创建成功返回用户信息
token = make_token(username)
result = {
'code': 200,
'username': username,
'data': {
'token': token.decode()
}
}
return JsonResponse(result)
def get(self, request):
#接收前端转发过来的 授权码
code = request.GET.get('code')
if not code:
return JsonResponse({'code': 10109, 'error': 'no code'})
token_url = 'https://api.weibo.com/oauth2/access_token'
req_data = {
'client_id': settings.WEIBO_CLIENT_ID,
'client_secret': settings.WEIBO_CLIENT_SECRET,
'grant_type': 'authorization_code',
'redirect_uri': settings.WEIBO_REDIRECT_URI,
'code': code
}
#向微博服务器发post请求，交换access_token
response = requests.post(token_url, data=req_data)
if response.status_code == 200:
weibo_data = json.loads(response.text)
else:
print('weibo server error is %s' % (response.status_code))
return JsonResponse({'code': 10110, 'error': 'Oauth error'})
#如果返回数据中有 error字段，则证明交换失败
if weibo_data.get('error'):
#TODO 可按需打印出该异常信息
return JsonResponse({'code': 10111, 'error': 'Oauth error!'})
print(weibo_data)
#{'access_token': '2.00rudyBCjfiLSD603d5ecdc40GBwIO', 'remind_in': '157679999', 'expires_in': 157679999, 'uid': '1861495121', 'isRealName': 'false'}
weibo_uid = weibo_data['uid']
access_token = weibo_data['access_token']
#查询当前weibo用户是否是第一次 光临
try:
weibo_user = WeiboProfile.objects.get(wuid=weibo_uid)
except Exception as e:
#第一次来～ 插入数据
WeiboProfile.objects.create(access_token=access_token,
wuid=weibo_uid)
return JsonResponse({'code': 201, 'uid': weibo_uid})
else:
#之前来过，检查是否绑定过
user = weibo_user.user_profile
if user:
#之前成功绑定过 UserProfile的用户
username = user.username
token = make_token(username)
return JsonResponse({
'code': 200,
'username': username,
'token': token.decode()
})
else:
#未绑定 - 触发绑定注册
return JsonResponse({'code': 201, 'uid': weibo_uid})
def post(self, request):
"""
Cautions： verify_url :此处发送前端的地址。
"""
data = json.loads(request.body)
if len(data) != 4:
return JsonResponse({'code': 10123, 'error': 'Miss parameters!'})
checked_data = self.check_args(data)
if type(checked_data) == str:
return JsonResponse({
'code': 10123,
'error': 'Missing %s parameters' % checked_data
})
username = data.get('uname')
email = data.get('email')
password = data.get('password')
phone = data.get('phone')
# 优先查询当前用户名是否已存在
old_user = UserProfile.objects.filter(username=username)
if old_user:
result = {'code': 206, 'error': 'Your username is already existed'}
return JsonResponse(result)
m = hashlib.md5()
m.update(password.encode())
try:
UserProfile.objects.create(username=username,
password=m.hexdigest(),
email=email,
phone=phone)
except Exception as e:
return JsonResponse({'code': 208, 'error': 'Server is busy'})
# 发送用户激活链接
# 此链接是通过用户名和邮箱中间拼接了/
code = "%d" % random.randint(1000, 9999)
code_str = code + '/' + username
# 生成激活链接：
active_code = base64.urlsafe_b64encode(
code_str.encode(encoding='utf-8')).decode('utf-8')
redis_conn = get_redis_connection('verify_email')
# TODO : 用户激活链接永久有效，可以根据自己的喜好去设置。
redis_conn.set("email_active_%s" % email, active_code)
verify_url = settings.ACTIVE_HOST + '/html/templates/active.html?code=%s' % (
active_code)
token = make_token(username)
result = {
'code': 200,
'username': username,
'data': {
'token': token.decode()
}
}
send_verify.delay(email=email, verify_url=verify_url, sendtype=1)
return JsonResponse(result)
def users(request):
json_str = request.body
json_obj = json.loads(json_str)
print(json_obj)
# {'uname': 'guoxiaonao', 'password': '******', 'phone': '13488873110', 'email': '*****@*****.**', 'carts': None}
username = json_obj['uname']
password = json_obj['password']
phone = json_obj['phone']
email = json_obj['email']
# 检查参数
# 检查用户名是否可用
old_users = UserProfile.objects.filter(username=username)
print(old_users)
print("***1211213135")
if old_users[0]:
result = {'code': 10100, 'error': 'The username is already existed !'}
return JsonResponse(result)
# 创建用户 UserProfile创建数据
m = hashlib.md5()
m.update(password.encode())
password_m = m.hexdigest()
try:
user = UserProfile.objects.create(username=username, password=password_m, phone=phone, email=email)
except Exception as e:
print('---user create error is')
print(e)
result = {'code': 10101, 'error': 'The username is already existed !'}
return JsonResponse(result)
# 签发jwt token(一天)
token = make_token(username)
# 激活邮件发送
# 生成四位随机数，将随机数存入redis
# 生成邮件内容 “欢迎注册达达电商，点击《链接》激活”
try:
code = "%d" % random.randint(1000, 9999)
code_str = '%s_%s' % (code, username)
b64_code = base64.urlsafe_b64encode(code_str.encode()).decode()
cache.set("email_active_%s" % (username), code, 3600 * 24 * 3)
# 生成链接
verify_url = 'http://127.0.0.1:7000/dadashop/templates/active.html?code=%s' % (b64_code)
# 发送邮件
# send_active_email(email, verify_url)
asyn_send_active_email.delay(email, verify_url)
# .....
except Exception as e:
print('----send active email error is %s' % (e))
return JsonResponse({'code': 200, 'username': username, 'data': {'token': token.decode()}, 'carts_count': 0})
def post(self, request):
json_str = request.body
if not json_str:
result = {'code': 10132, 'error': 'No data found'}
return JsonResponse(result)
json_obj = json.loads(json_str)
username = json_obj.get('uname')
if not username:
result = {'code': 202, 'error': 'Please give me username'}
return JsonResponse(result)
email = json_obj.get('email')
if not email:
result = {'code': 203, 'error': 'Please give me email'}
return JsonResponse(result)
# 优先查询当前用户名是否已存在
old_user = UserProfile.objects.filter(username=username)
if old_user:
result = {'code': 206, 'error': 'Your username is already existed'}
return JsonResponse(result)
password = json_obj.get('password')
m = hashlib.md5()
m.update(password.encode())
phone = json_obj.get('phone')
if not phone:
result = {'code': 207, 'error': 'Please give me phone'}
return JsonResponse(result)
try:
UserProfile.objects.create(username=username, password=m.hexdigest(),
email=email, phone=phone)
except Exception as e:
result = {'code': 208, 'error': 'Server is busy'}
return JsonResponse(result)
# 发送用户激活链接
code_str = username + '.' + email
# 生成激活链接：
active_code = base64.b64encode(code_str.encode(encoding='utf-8')).decode('utf-8')
redis_conn = get_redis_connection('verify_email')
### todo : 用户激活链接永久有效
redis_conn.set("email_active_%s" % email, active_code)
verify_url = 'http://114.116.244.115:7000/dadashop/templates/active.html?code=%s&username=%s' % (active_code, username)
token = make_token(username)
result = {'code': 200, 'username': username, 'data': {'token': token.decode()}}
send_verify.delay(email=email, verify_url=verify_url, sendtype=1)
return JsonResponse(result)
def post(self, request):
# 绑定注册
# 前端将weiboid命名为uid POST 过来
# 返回值 跟 正常注册 一样
data = json.loads(request.body)
# 获取微博的用户id
uid = data.get('uid')
username = data.get('username')
email = data.get('email')
phone = data.get('phone')
password = data.get('password')
birthday = data.get('birthday')
gender = data.get('gender')
# todo 检查参数是否存在
m = hashlib.md5()
m.update(password.encode())
password_m = m.hexdigest()
try:
# 注册用户 事务
with transaction.atomic():
user = UserProfile.objects.create(username=username,
phone=phone,
email=email,
password=password_m,
birthday=birthday,
gender=gender)
weibo_user = WeiboUser.objects.get(wuid=uid)
# 绑定外键
weibo_user.uid = user # 用类属性赋值
weibo_user.uid_id = user.id # 用数据库字段赋值
weibo_user.save()
except Exception as e:
print('---weibo register error---')
print(e)
return JsonResponse({
'code': '10115',
'error': {
'message': 'The username is exitsed'
}
})
# 签发token
token = make_token(username)
result = {
'code': 200,
'username': username,
'data': {
'token': token.decode()
}
}
return JsonResponse(result)
def post(self, request):
"""
Cautions,verify_url :此处发送前端的地址。
"""
data = json.loads(request.body)
username = data.get('uname')
email = data.get('email')
password = data.get('password')
phone = data.get('phone')
carts_data = data.get('carts')
if len(password) < 6 or len(password) > 12:
result = {'code': 101990, 'error': 'Password length is wrong'}
return JsonResponse(result)
if len(username) < 6 or len(username) > 11:
result = {'code': 101991, 'error': 'Username length is wrong'}
return JsonResponse(result)
if carts_data:
carts_data = json.loads(carts_data)
# 优先查询当前用户名是否已存在
old_user = UserProfile.objects.filter(username=username)
if old_user:
result = {'code': 10199, 'error': 'Your username is already existed'}
return JsonResponse(result)
m = hashlib.md5()
m.update(password.encode())
try:
user = UserProfile.objects.create(username=username, password=m.hexdigest(),email=email, phone=phone)
except Exception as e:
return JsonResponse({'code': 10198, 'error': 'Server is busy'})
# 此链接是通过用户名和code中间拼接了/
try:
code = "%d" % random.randint(1000, 9999)
code_str = code + '/' + username
# 生成激活链接：
active_code = base64.urlsafe_b64encode(code_str.encode(encoding='utf-8')).decode('utf-8')
# TODO : 用户激活链接永久有效，可以根据自己的喜好去设置。
EMAIL_CACHE.set("email_active_%s" % username, code, 60*60*24*3)
verify_url = settings.CLIENT_HOST + '/dadashop/templates/active.html?code=%s' % (active_code)
token = make_token(username)
send_active_email.delay(email, verify_url)
#合并购物车
carts_obj = CartsView()
carts_len = carts_obj.merge_carts(user.id,carts_data)
#res = merge_cart(user,token,cart_data)
except Exception as e:
return JsonResponse({'code':10111,'error':'something bad!'})
return JsonResponse({'code': 200, 'username': username, 'data':{'token': token.decode()},'carts_count':carts_len})
def users(request):
if request.method == 'POST':
data = request.body
json_obj = json.loads(data)
username = json_obj['uname']
password = json_obj['password']
phone = json_obj['phone']
email = json_obj['email']
if len(password) < 6:
result = {'code': 10100, "error": 'password is wrong'}
return JsonResponse(result)
# 用户名是否可用;已注册的话给个错误返回
old_user = UserProfile.objects.filter(username=username)
if old_user:
result = {
'code': 10100,
"error": 'The username is already existed'
}
return JsonResponse(result)
# 创建用户 密码用md5
m = hashlib.md5()
m.update(password.encode())
try:
user = UserProfile.objects.create(username=username,
password=m.hexdigest(),
phone=phone,
email=email)
except Exception as e:
return JsonResponse({
'code': 10100,
"error": 'The username is already existed'
})
token = make_token(username)
code = "%s" % (random.randint(1000, 9999))
code_str = code + "_" + username
code_bs = base64.urlsafe_b64encode(code_str.encode())
cache.set('email_active_%s' % (username), code, 3600 * 24 * 3)
verify_url = 'http://127.0.0.1:7000/dadashop/templates/active.html?code=%s' % (
code_bs.decode())
send_active_email_celery.delay(email, verify_url)
return JsonResponse({
"code": 200,
"username": username,
'data': {
'token': token.decode()
},
'cart_count': 0
})
def get(self, request):
# 获取前端传来的微博code
code = request.GET.get('code')
# 向微博服务器发送请求 用code换取token
# celery.delay()
try:
user_info = get_access_token(code)
except Exception as e:
print('----get_access_token error')
print(e)
result = {'code': 202, 'error': 'Weibo server is busy ~'}
return JsonResponse(result)
print('------------')
print(user_info)
# 微博用户id
wuid = user_info.get('uid')
access_token = user_info.get('access_token')
# 查询weibo用户表，判断是否第一次光临
try:
weibo_user = WeiboUser.objects.get(wuid=wuid)
except Exception as e:
print('weibouser get error')
# 该用户第一次用微博登录
# 创建数据 & 暂时不绑定UserProfile
WeiboUser.objects.create(access_token=access_token, wuid=wuid)
data = {'code': '201', 'uid': wuid}
return JsonResponse(data)
else:
# 该用户非第一次微博登录
# 检查是否进行过绑定
uid = weibo_user.uid
if uid:
# 之前绑定过，则认为当前为正常登陆，照常签发token
username = uid.username
token = make_token(username)
result = {
'code': 200,
'username': username,
'data': {
'token': token.decode()
}
}
return JsonResponse(result)
else:
# 之前微博登陆过，但是没有执行微博绑定注册
data = {'code': '201', 'uid': wuid}
return JsonResponse(data)
return JsonResponse({'code': 200, 'error': 'test'})
def post(self, request):
json_obj = json.loads(request.body)
data = self.check_args(json_obj, 4)
username = data.get('uname')
email = data.get('email')
password = data.get('password')
phone = data.get('phone')
old_user = UserProfile.objects.filter(username=username)
if old_user:
return JsonResponse({
'code': 10103,
'error': 'Your username is already existed'
})
if not phone.isdigit() or len(phone) != 11:
return JsonResponse({
'code': 10104,
'error': 'Your phone is wrong'
})
try:
validate_email(email) #校验邮箱格式
except ValidationError as e:
return JsonResponse({
'code': 10105,
'error': 'Your email is wrong'
})
# 哈希加密
m = hash_pwd(password)
try:
UserProfile.objects.create(username=username,
password=m.hexdigest(),
email=email,
phone=phone)
except Exception as e:
return JsonResponse({'code': 10105, 'error': 'Server is busy'})
# 生成激活链接和激活码
code = '{}'.format(random.randint(1000, 9999))
code_str = code + '/' + username
# 生成激活链接
active_code = base64.urlsafe_b64encode(code_str.encode()).decode()
email_redis.set("email_active_%s" % username, active_code, 3600)
verify_url = settings.ACTIVE_HOST + '/dadashop/templates/active.html?code=%s' % (
active_code)
token = make_token(username)
result = {'code': 200, 'username': username, 'token': token.decode()}
# 异步发送邮箱验证
send_verify.delay(email=email, verify_url=verify_url, sendtype=1)
return JsonResponse(result)
def get(self, request):
'''
根据前端返回的授权码换取token
'''
code = request.GET.get('code')
if not code:
return JsonResponse({'code': 10107, 'error': '你的授权信息有误!'})
token_url = 'https://api.weibo.com/oauth2/access_token'
# 向微博服务器发出post请求,用code换取token,https://api.weibo.com/oauth2/access_token
request_data = {
'client_id': settings.WEIBO_APP_KEY,
'client_secret': settings.WEIBO_APP_SECRET,
'grant_type': 'authorization_code',
'redirect_uri': settings.WEIBO_REDIRECT_URI,
'code': code
}
response = requests.post(token_url, data=request_data)
if response.status_code == 200:
json_data = json.loads(response.text)
else:
return JsonResponse({'code': 10108, 'error': '新浪服务器比较繁忙,请稍后重试!'})
weibo_uid = json_data['uid']
access_token = json_data['access_token']
try:
weibo_user = WeiBoProfile.objects.get(wb_uid=weibo_uid)
except Exception as e:
# 该微博账号第一次登录
WeiBoProfile.objects.create(access_token=access_token,
wb_uid=weibo_uid)
# 返回微博uid信息给前端
return JsonResponse({'code': 201, 'uid': weibo_uid})
else:
# 检查是否绑定注册过
# 1.如果绑定过,正常返回
user = weibo_user.user_profile
if user:
username = user.username
token = make_token(username=username)
return JsonResponse({
'code': 200,
'username': username,
'token': token.decode()
})
else:
# 2.如果没有绑定注册过
return JsonResponse({'code': 201, 'uid': weibo_uid})
def users(request):
'''
用户注册视图函数
'''
json_str = request.body # 提取请求对象的json串
json_obj = json.loads(json_str) # 将json串转化为Python对象
username = json_obj['username']
password = json_obj['password']
phone = json_obj['phone']
email = json_obj['email']
old_user = UserProfile.objects.filter(username=username)
if old_user:
result = {'code': 10100, 'error': '用户名已存在,请重新注册！'}
return JsonResponse(result)
# 密码处理
m = hashlib.md5()
m.update(password.encode())
m_password = m.hexdigest()
# 用户数据插入
try:
UserProfile.objects.create(username=username,
password=m_password,
phone=phone,
email=email)
except Exception as e:
print(e)
result = {'code': 10100, 'error': '用户名已存在,请重新注册！'}
return JsonResponse(result)
# 签发token
token = make_token(username=username) # 返回的是字节串的token
print(token)
result = {
'code': 200,
'username': username,
'data': {
'token': token.decode()
},
'carts_count': 0
}
# 发送激活邮件(二次开发)
try:
send_active_email.delay(username, email=email) # 通过celery执行该函数
except Exception as e:
print(e)
return JsonResponse(result)
def get(self, request):
"""
获取用户的code,以及用户的token
"""
# 首先获取两个参数code 和state
code = request.GET.get('code', None)
if not code:
return JsonResponse({'code': 10100, 'error': 'Invalid parameters'})
try:
oauth_weibo = OAuthWeibo()
userInfo = oauth_weibo.get_access_token(code)
except Exception as e:
return JsonResponse({'code':10142,'error':'cant reach weibo server'})
# 将用户weibo的uid传入到前端
# OAuth 2.0 中授权码模式下 如果错误的请求，响应中会字典中会有error键
if userInfo.get('error'):
return JsonResponse({'code':12345,'error':'unable get token'})
weibo_uid = userInfo.get('uid', None)
access_token = userInfo.get('access_token', None)
try:
weibo_user = WeiboProfile.objects.get(wuid=weibo_uid)
except Exception as e:
# 如果查不到相关的token 则说明该用户第一次来
WeiboProfile.objects.create(access_token=access_token, wuid=weibo_uid)
data = {
'code': 201,
'uid': weibo_uid
}
return JsonResponse(data)
else:
# 如果查询到之前来过，检查是否绑定过
user = weibo_user.user_profile
if user:
#之前成功绑定
username = user.username
token = make_token(username)
return JsonResponse({'code': 200, 'username': username, 'token': token.decode()})
else:
#未绑定
data = {
'code': 201,
'uid': weibo_uid
}
return JsonResponse(data)
def users(request):
if request.method != 'POST':
return JsonResponse({'code': 10100, 'error': 'Please use POST !'})
json_str = request.body
data = json.loads(json_str)
username = data['uname']
email = data['email']
password = data['password']
phone = data['phone']
old_users = UserProfile.objects.filter(username=username)
if old_users:
result = {'code': 10101, 'error': 'Your username is already existed!'}
return JsonResponse(result)
m = hashlib.md5()
m.update(password.encode())
try:
UserProfile.objects.create(username=username,
password=m.hexdigest(),
email=email,
phone=phone)
except Exception as e:
print('---create error is ---')
print(e)
return JsonResponse({
'code': 10102,
'error': 'Your username is already existed~~'
})
token = make_token(username)
send_activation_email(username, email)
return JsonResponse({
'code': 200,
'username': username,
'data': {
'token': token.decode()
},
'carts_count': 0
})
def get(self, request):
code = request.GET.get('code')
# 像微博服务器放松请求，携带code,获取token
result = get_access_token(code)
# result:{'access_token': '2.00SZ9FpDMxdPvB04ace4695ayifbSC',
# 'remind_in': '157679999', 'expires_in': 157679999,
# 'uid': '3503293092', 'isRealName': 'true'}
"""------------------------------------"""
"""#WeiboUser表中是否有这个 weibo用户数据
#如果没有数据, 第一次访问 -> 创建WeiboUser数据
#有的话,1)绑定注册过[uid有值] -> 签发自己token -同普通登陆一样
2) 没绑定[uid为空] -> 给前端返回非200的code,触发绑定注册
"""
# OAuth 2.0 中授权码模式下 如果错误的请求，响应中会字典中会有error键
if result.get('error'):
return JsonResponse({'code': 10128, 'error': 'unable get token'})
wbuid = result.get('uid')
access_token = result.get('access_token')
# 在微博表查找是否存在
try:
weibo_user = WeiboUser.objects.get(uid=wbuid)
except Exception as e:
# 不存在
weibo_user = WeiboUser.objects.create(uid=wbuid,
access_token=access_token)
# 放回前端创建新的数据
return JsonResponse({'code': 201, 'uid': wbuid})
else:
# 存在,查找userpofile是否关联
user = weibo_user.username
if user:
# 正常签发token
username = user.username
token = make_token(username)
return JsonResponse({
'code': 200,
'username': username,
'token': token.decode()
})
else:
return JsonResponse({'code': 201, 'uid': wbuid})
def wxre(request):
if request.method == 'GET':
return JsonResponse({'code': 200})
if request.method == 'POST':
data = request.body
print(data, '->wxloginre')
data_obj = json.loads(data)
openid = data_obj.get('openid')
nickname = data_obj.get('nickname')
passwd = dist1['passwd']
email = dist1['email']
username = dist1['username']
old_user = UserProfile.objects.filter(openid=openid)
m = hashlib.md5()
m.update(passwd.encode())
if old_user:
old_user.update(username=username, password=m.hexdigest(), email=email)
return JsonResponse({'code': 200, 'message': '注册成功'})
else:
user = UserProfile.objects.create(openid=openid, username=username, nickname=nickname,
password=m.hexdigest(),
email=email)
token = make_token(user.id)
return JsonResponse({'code': 200, 'token': token.decode(), 'id': user.id, 'message': '注册成功'})
def get(self, request):
code = request.GET.get('code')
if not code:
return JsonResponse({'code': 10106, 'error': 'Please give me code'})
token_url = 'https://api.weibo.com/oauth2/access_token'
# 发送Post请求
req_data = {
'client_id': settings.WEIBO_APP_KEY,
'client_secret': settings.WEIBO_APP_SECRET,
'grant_type': 'authorization_code',
'redirect_uri': settings.WEIBO_REDIRECT_URI,
'code': code
}
response = requests.post(token_url, data=req_data)
if response.status_code == 200:
json_data = json.loads(response.text)
else:
print(response.status_code)
return JsonResponse({'code': 10107, 'error': 'The weibo server is busy'})
if json_data.get('error'):
print(json_data['error'])
return JsonResponse({'code': 10108, 'error': 'The weibo server is busy'})
print('-----success get token----')
print(json_data)
weibo_uid = json_data['uid']
access_token = json_data['access_token']
try:
weibo_user = WeiboProfile.objects.get(wuid=weibo_uid)
except Exception as e:
# 该微博账号第一次来
WeiboProfile.objects.create(access_token=access_token, wuid=weibo_uid)
data = {
'code': 201,
'uid': weibo_uid
}
return JsonResponse(data)
else:
# 检查 是否绑定注册过
user = weibo_user.user_profile
if user:
# 之前绑定过 - 走正常登录流程
username = user.username
token = make_token(username)
return JsonResponse({'code': 200, 'username': username, 'token': token.decode()})
else:
# 未绑定
data = {
'code': 201,
'uid': weibo_uid
}
return JsonResponse(data)
def oauth_token(request):
if request.method == 'GET':
#获取code
code = request.GET.get('code')
#给微博服务器发请求 用授权码交换用户token
token_url = 'https://api.weibo.com/oauth2/access_token'
req_data = {
'client_id': settings.WEIBO_CLIENT_ID,
'client_secret': settings.WEIBO_CLIENT_SECRET,
'grant_type': 'authorization_code',
'code': code,
'redirect_uri': settings.WEIBO_REDIRECT_URI
}
response = requests.post(token_url, data=req_data)
if response.status_code == 200:
res_data = json.loads(response.text)
else:
print('change code error %s' % (response.status_code))
return JsonResponse({'code': 10110, 'error': 'weibo error'})
if res_data.get('error'):
print('change error')
print(res_data.get('error'))
return JsonResponse({'code': 10111, 'error': 'weibo error'})
print('---weibo token is---')
print(res_data)
weibo_uid = res_data['uid']
access_token = res_data['access_token']
#先检查 该微博用户是否第一次进入到网站
try:
weibo_user = WeiboProfile.objects.get(wuid=weibo_uid)
except Exception as e:
#该用户第一次进入本站
WeiboProfile.objects.create(access_token=access_token,
wuid=weibo_uid)
# 如果是第一次来，存储token,可能没有内部用户进行绑定－外键可以为空。
# 给前端非200响应: 用户第一次进入本站。
return JsonResponse({'code': 201, 'uid': weibo_uid})
else:
# 这个微博账号之前来过
user = weibo_user.user_profile
if user:
# 1.执行过完整流程，完成了绑定注册
token = make_token(user.username)
return JsonResponse({
'code': 200,
'username': user.username,
'token': token.decode()
})
else:
# 2.token来过但无绑定账号
return JsonResponse({'code': 201, 'uid': weibo_uid})
elif request.method == 'POST':
#绑定注册
data = json.loads(request.body)
uid = data['uid']
username = data['username']
password = data['password']
phone = data['phone']
email = data['email']
#检查用户名是否已存在
users = UserProfile.objects.filter(username=username, is_active=True)
if users:
return JsonResponse({
'code': 10112,
'error': 'User already exists.'
})
m = hashlib.md5()
m.update(password.encode())
#创建内部用户&绑定微博用户(要用mysql的事务保证同时执行。)
try:
with transaction.atomic():
user = UserProfile.objects.create(username=username,
password=m.hexdigest(),
email=email,
phone=phone)
weibo_user = WeiboProfile.objects.get(wuid=uid)
weibo_user.user_profile = user
weibo_user.save()
except Exception as e:
return JsonResponse({
'code': 10113,
'error': 'account bind/registration error'
})
#自动登录
token = make_token(username)
return JsonResponse({
'code': 200,
'username': username,
'token': token.decode()
})
return JsonResponse({'code': 200})
def get(self, request):
"""
获取用户的code,以及用户的token
:param request:
:return:
"""
# 首先获取两个参数code 和state
code = request.GET.get('code', None)
if not code:
return JsonResponse({'code': 10100, 'error': 'Invalid parameters'})
try:
oauth_weibo = OAuthWeibo()
except Exception as e:
return JsonResponse({
'code': 10125,
'error': 'Unable to get weibo token'
})
# 返回用户的绑定信息
# 信息格式为
"""
data = {
# 用户令牌，可以使用此作为用户的凭证
"access_token": "2.00aJsRWFn2EsVE440573fbeaF8vtaE",
"remind_in": "157679999", # 过期时间
"expires_in": 157679999,
"uid": "5057766658",
"isRealName": "true"
}
"""
try:
userInfo = oauth_weibo.get_access_token_uid(code)
except Exception as e:
print(e)
return JsonResponse({
'code': 10142,
'error': 'cant reach weibo server'
})
# 将用户weibo的uid传入到前端
# OAuth 2.0 中授权码模式下 如果错误的请求，响应中会字典中会有error键
if userInfo.get('error'):
return JsonResponse({'code': 12345, 'error': 'unable get token'})
weibo_uid = userInfo.get('uid', None)
access_token = userInfo.get('access_token', None)
try:
weibo_user = WeiboUser.objects.get(uid=uid)
except Exception as e:
# 如果查不到相关的token 则说明没用绑定相关的用户
# 没有绑定微博用户则说明用户表中也没有创建用户信息。此时返回access_token,
# 并且让跳转到 绑定用户的页面，填充用户信息，提交 绑定微博信息
if not WeiboUser.objects.filter(uid=weibo_uid):
WeiboUser.objects.create(access_token=access_token,
uid=weibo_uid)
data = {'code': '201', 'uid': weibo_uid}
return JsonResponse(data)
else:
# 如果查询到相关用户绑定的uid
# 此时正常登陆。然后返回jwt_token
user_id = weibo_user.uid
str_user_id = str(user_id)
try:
user = UserProfile.objects.get(id=int(str_user_id))
except Exception as e:
return JsonResponse({'code': 10134, 'error': 'Cant get User'})
username = user.username
token = make_token(username)
result = {
'code': 200,
'username': username,
'data': {
'token': token.decode()
}
}
return JsonResponse(result)
def get(self, request):
code = request.GET.get('code')
if not code:
return JsonResponse({'code': 10109, 'error': 'no code'})
params = {
'client_id': settings.WEIBO_CLIENT_ID,
'client_secret': settings.WEIBO_CLIENT_SECRET,
'grant_type': 'authorization_code',
'code': code,
'redirect_uri': settings.WEIBO_REDIRECT_URI
}
token_url = 'https://api.weibo.com/oauth2/access_token'
# 向服务器发送POST，获得access_token
response = requests.post(token_url, data=params)
if response.status_code == 200:
weibo_data = json.loads(response.text)
else:
print('weibo server error: %s' % response.status_code)
return JsonResponse({
'code': 10110,
'error': 'Oauth server error.'
})
if weibo_data.get('error'):
print(weibo_data.get('error'))
return JsonResponse({
'code': 10111,
'error': 'Oauth server error.'
})
# {'access_token': '2.00lMuI2G5Cw87C59f6f57154CY_aOC', 'remind_in': '157679999', 'expires_in': 157679999, 'uid': '5809222727', 'isRealName': 'true'}
print(weibo_data)
weibo_uid = weibo_data['uid']
access_token = weibo_data['access_token']
try:
weibo_user = WeiboProfile.objects.get(wuid=weibo_uid)
except Exception as e:
print(e)
WeiboProfile.objects.create(access_token=access_token,
wuid=weibo_uid)
return JsonResponse({'code': 201, 'uid': weibo_uid})
else:
# 之前来过，是否绑定
user = weibo_user.user_profile
if user:
# 成功注册并绑定
username = user.username
token = make_token(username)
return JsonResponse({
'code': 200,
'username': username,
'token': token.decode()
})
else:
# 未绑定
return JsonResponse({'code': 201, 'uid': weibo_uid})
def users(request):
if request.method != 'POST':
return JsonResponse({'code': 10100, 'error': 'Please use POST !'})
json_str = request.body
data = json.loads(json_str)
username = data['uname']
email = data['email']
password = data['password']
phone = data['phone']
#TODO 参数判断
#检查用户名是否已经存在
old_users = UserProfile.objects.filter(username=username)
if old_users:
result = {'code': 10101, 'error': 'Your username is already existed!'}
return JsonResponse(result)
m = hashlib.md5()
m.update(password.encode())
#创建用户
try:
user = UserProfile.objects.create(username=username,
password=m.hexdigest(),
email=email,
phone=phone)
except Exception as e:
print('---create error is ---')
print(e)
return JsonResponse({
'code': 10102,
'error': 'Your username is already existed~~'
})
#生成令牌
token = make_token(username)
#容错性
try:
#激活邮件的功能
#1,给用户邮箱中 发邮件，邮件内容 - ‘欢迎来到达达商城，点击如下链接，可完成注册’
#2,邮件中的链接有效期为3天
#3,code的隐私性
# send_mail(html_message='')
#生成随机数
code = "%s" % (random.randint(1000, 9999))
code_str = code + '_' + username
active_code = base64.urlsafe_b64encode(code_str.encode())
#存储随机数 - 3天有效期
cache.set('email_active_%s' % (username), code, 60 * 60 * 24 * 3)
verify_url = 'http://127.0.0.1:7000/dadashop/templates/active.html?code=%s' % (
active_code.decode())
print(verify_url)
#发邮件
#send_active_email(email, verify_url)
send_active_email_async.delay(email, verify_url)
except Exception as e:
print('---active error---')
print(e)
pass
return JsonResponse({
'code': 200,
'username': username,
'data': {
'token': token.decode()
},
'carts_count': 0
})
