def func_enquiry_qrcode(self):
"""
web 询问接口
:return:
"""
qrcode = self.extra_data.get('qrcode', '')
if qrcode == "":
raise response_code.ParamERR(errmsg='qrcode can not be empty!')
try:
qr_state = (redis_conn.get('{}'.format(qrcode)))
except Exception as e:
raise response_code.DatabaseERR(errmsg='{}'.format(e))
if qr_state == "0":
resp = set_resjson(err=1, errmsg='未扫描')
elif qr_state == "1":
resp = set_resjson(err=-2, errmsg='已扫描未登录')
elif qr_state is None:
resp = set_resjson(err=-4, errmsg='验证码已过期')
else:
try:
user_info = mongo.db.user.find_one({"_id": qr_state}, {
"name": 1,
"headshot": 1,
"_id": 0
})
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
resp = make_response(set_resjson(res_array=[user_info]))
resp.headers["Authorization"] = encode_auth_token(qr_state)
return resp
def qq_login(code):
"""
QQ 登录
:param code:
:return:
"""
oauth_qq = OAuthQQ()
access_token = oauth_qq.get_access_token(code)
unionid, openid = oauth_qq.get_unionid(access_token)
try:
user_info = mongo.db.user.find_one({"qq_unionid": unionid})
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
if not user_info:
# 第一次登录
user_info = oauth_qq.get_user_info(access_token, openid)
try:
pl = redis_conn.pipeline()
pl.set("unionid_name_%s" % unionid, user_info['nickname'],
constants.SMS_CODE_REDIS_EXPIRES)
pl.set("unionid_photo_url_%s" % unionid,
user_info['figureurl_qq_1'],
constants.SMS_CODE_REDIS_EXPIRES)
pl.execute()
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
access_token = generate_save_user_token(unionid, 'qq')
return set_resjson(res_array=[{"access_token": access_token}])
else:
response = not_first_login(user_info)
return response
def func_code_login(self):
"""
login
:return:
"""
_id = None
mobile = self.extra_data.get("mobile", "")
code = self.extra_data.get('code', "")
if not mobile_re.match('{}'.format(mobile)):
raise response_code.ParamERR(errmsg="手机号码不正确")
# 手机验证码验证
sms_verify(mobile, code)
try:
user_info = mongo.db.user.find_one({"mobile": '{}'.format(mobile)},
{
"headshot": 1,
"name": 1
})
except Exception as error:
current_app.logger.error(error)
raise response_code.DatabaseERR(errmsg='{}'.format(error))
now_time = time.time()
if not user_info:
_id = get_user_id("id")
try:
mongo.db.user.insert_one({
"gender": "男",
"birthday": str(datetime.date.today()),
"name": ranstr(16),
"mobile": '{}'.format(mobile),
"_id": _id,
"headshot": self.head_shot_path,
"create_time": now_time,
"login_time": now_time,
"background": self.background_path,
"introduction": self.introduction
})
except Exception as error:
current_app.logger.error(error)
raise response_code.DatabaseERR(errmsg='{}'.format(error))
user_info = {"name": ranstr(16), "headshot": self.head_shot_path}
else:
_id = user_info.pop("_id")
try:
mongo.db.user.update_one({"mobile": '{}'.format(mobile)},
{"$set": {
"login_time": now_time
}})
except Exception as err:
current_app.logger.error(err)
raise response_code.DatabaseERR(errmsg='{}'.format(err))
# set the token information in the response
response = make_response(set_resjson(res_array=[user_info]))
response.headers["Authorization"] = encode_auth_token(_id)
return response
def func_quick_login(self):
"""
手机一键登陆
"""
login_token = self.extra_data.get("login_token", "")
if login_token == "":
raise response_code.ParamERR(
errmsg="[ login_token ] must be provided")
curl = 'https://api.verification.jpush.cn/v1/web/loginTokenVerify'
dict_body = {"loginToken": login_token}
json_body = json.dumps(dict_body)
encrypt_phone = get_phone(curl, json_body)
if not encrypt_phone:
raise response_code.ParamERR(errmsg="登陆失败")
phone = get_num(encrypt_phone, config.JI_GUANG_PRIKEY)
user_info = mongo.db.user.find_one({"mobile": phone}, {
"headshot": 1,
"name": 1
})
now_time = time.time()
if not user_info:
_id = get_user_id("id")
try:
mongo.db.user.insert_one({
"gender": "男",
"birthday": str(datetime.date.today()),
"name": ranstr(16),
"mobile": '{}'.format(phone),
"_id": _id,
"headershot": self.head_shot_path,
"create_time": now_time,
"login_time": now_time,
"background": self.background_path,
"introduction": self.introduction
})
except Exception as error:
current_app.logger.error(error)
raise response_code.DatabaseERR(errmsg='{}'.format(error))
user_info = {"name": ranstr(16), "headshot": self.head_shot_path}
else:
_id = user_info.pop("_id")
try:
mongo.db.user.update_one({"mobile": '{}'.format(phone)},
{"$set": {
"login_time": now_time
}})
except Exception as err:
current_app.logger.error(err)
raise response_code.DatabaseERR(errmsg='{}'.format(err))
# set the token information in the response
response = make_response(set_resjson(res_array=[user_info]))
response.headers["Authorization"] = encode_auth_token(_id)
return response
def func_view_file(self):
"""
查看课件
"""
video_id = self.extra_data.get('video_id')
video_document = {}
res_list = []
try:
video_document_cursor = mongo.db.document.find(
{"video_id": video_id})
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
for document in video_document_cursor:
video_document["file_id"] = document["_id"]
video_document["file_name"] = document["file_name"]
video_document["file_path"] = document["file_path"]
video_document["image_path"] = document["image_path"]
video_document["price"] = document["price"]
video_document["time"] = document["time"]
res_list.append(deepcopy(video_document))
if not video_document:
raise response_code.RoleERR(errmsg="这个视频没有课件")
return set_resjson(res_array=res_list)
def func_get_information(self):
"""
获取个人信息
@return:
"""
user = g.user
res_dict = {}
if not user:
raise response_code.ParamERR(errmsg="用户未登陆")
try:
subscription_counts = mongo.db.subscription.find({
"user_id":
user["_id"],
"state":
0
}).count()
fans_counts = mongo.db.subscription.find({
"relation_id": user["_id"],
"state": 0
}).count()
video_id_list = [
video.get("_id") for video in mongo.db.video.find(
{"user_id": user["_id"]}, {"_id": 1})
]
like_counts = mongo.db.like.find({
"user_id": user["_id"],
"relation_id": {
"$in": video_id_list
}
}).count()
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
res_dict["user_name"] = user["name"]
res_dict["user_id"] = user["_id"]
res_dict["birthday"] = user.get(
"birthday",
time.strftime("%Y-%m-%d", time.localtime(user["create_time"])))
res_dict["gender"] = user.get("gender", "男")
res_dict["introduction"] = user["introduction"]
res_dict["headshot"] = user["headshot"]
res_dict["background"] = user["background"]
res_dict["like_counts"] = like_counts
res_dict["video_counts"] = len(video_id_list)
res_dict["user_name"] = user["name"]
res_dict["binding_webchat"] = 1 if user.get("wechat_unionid",
None) else 0
res_dict["binding_qq"] = 1 if user.get("qq_unionid", None) else 0
res_dict["binding_microblog"] = 1 if user.get("microblog_unionid",
None) else 0
res_dict["subscription_counts"] = subscription_counts
res_dict["fans_counts"] = fans_counts
return set_resjson(res_array=[res_dict])
def func_get_category(self):
"""
查看标签信息
"""
try:
category_info = mongo.db.tool.find_one({
"type": "category"
}).get("data")
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
return set_resjson(res_array=category_info)
def func_generate_code(self):
"""
Send SMS verification code
:return:
"""
mobile = self.extra_data.get("mobile", "")
if not mobile_re.match('{}'.format(mobile)):
raise response_code.ParamERR(errmsg="手机号码不正确")
send_flag = redis_conn.get("send_flag_{}".format(mobile))
if send_flag:
raise response_code.ReqERR(errmsg="请求次数过于频繁")
# sms_code = "%04d" % random.randint(0, 9999)
sms_code = "6666"
# encrypted message
hash1 = hashlib.sha256()
hash1.update(bytes(sms_code, encoding="utf-8"))
hash_sms_code = hash1.hexdigest()
# Using redis transactions, save SMS and flag to redis,
# SMS expiration time is 300 seconds, flag expiration time is 60 seconds
try:
pl = redis_conn.pipeline()
pl.set("sms_code_%s" % mobile, sms_code,
constants.SMS_CODE_REDIS_EXPIRES)
pl.set("send_flag_%s" % mobile, sms_code,
constants.SEND_SMS_CODE_INTERVAL)
pl.execute()
except Exception as error:
current_app.logger.error(error)
raise response_code.DatabaseERR(errmsg='{}'.format(error))
# try:
#
# resp = send_sms(mobile, constants.SMS_LOGIN_TEMPLATE_ID, constants.SMS_SIGN, sms_code)
# except Exception as e:
# current_app.logger.error('[send_verification_code] {}'.format(e))
# raise response_code.ThirdERR(errmsg='{}'.format(e))
# resp_dict = json.loads(resp.decode('utf-8'))
# resp_code = resp_dict.get('Code', 'OK')
# if resp_code != 'OK':
# redis_conn.delete("send_flag_{}".format(mobile))
# message = resp_dict.get('Message', '')
# current_app.logger.error(message)
# raise response_code.ThirdERR(errmsg=message)
response = make_response(
set_resjson(res_array=[{
"code": hash_sms_code,
'real_code': sms_code
}]))
return response
def func_scan_qrcode(self):
"""
移动端扫描二维码
:return:
"""
user = g.user
if not user:
raise response_code.UserERR(errmsg='用户未登录')
qrcode = self.extra_data.get('qrcode', '')
try:
qr_state_byte = redis_conn.get('{}'.format(qrcode))
except Exception as e:
raise response_code.DatabaseERR(errmsg='{}'.format(e))
if not qr_state_byte:
raise response_code.ParamERR(errmsg='验证码过期')
try:
redis_conn.set(qrcode, user['_id'],
constants.QR_CODE_REDIS_EXPIRES)
except Exception as e:
raise response_code.DatabaseERR(errmsg='{}'.format(e))
return set_resjson()
def wehcat_login(code):
"""
微信登陆
:param code:
:return:
"""
wechatlogin = WeChat(state='')
access_token, openid, unionid, refresh_token = wechatlogin.get_access_token(
code)
try:
user_info = mongo.db.user.find_one({"wechat_unionid": unionid})
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
if not user_info:
# 第一次登录
nickname, headimgurl, _, gender = wechatlogin.get_user_info(
access_token, openid)
try:
pl = redis_conn.pipeline()
pl.set("unionid_name_%s" % unionid, nickname,
constants.SMS_CODE_REDIS_EXPIRES)
pl.set("unionid_gender_%s" % unionid, gender,
constants.SMS_CODE_REDIS_EXPIRES)
pl.set("unionid_refresh_token_%s" % unionid, refresh_token,
constants.SMS_CODE_REDIS_EXPIRES)
pl.set("unionid_photo_url_%s" % unionid, headimgurl,
constants.SMS_CODE_REDIS_EXPIRES)
pl.execute()
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
access_token = generate_save_user_token(unionid, 'wechat')
return set_resjson(res_array=[{"access_token": access_token}])
else:
response = not_first_login(user_info, refresh_token)
return response
def not_first_login(user_info, refresh_token=None):
""" 已经登陆过 """
_id = user_info['_id']
login_time = time.time()
try:
mongo.db.user.update_one({"_id": '{}'.format(_id)},
{"$set": {
"login_time": login_time
}})
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
response = make_response(
set_resjson(res_array=[{
"name": user_info['name'],
'headshot': user_info.get('headshot', "")
}]))
response.headers["Authorization"] = encode_auth_token(_id, refresh_token)
return response
def sms_verify(mobile, sms_code):
"""
手机验证码验证
:param mobile:
:param sms_code:
:return:
"""
try:
real_sms_code = redis_conn.get("sms_code_{}".format(mobile))
except Exception as error:
current_app.logger.error(error)
raise response_code.DatabaseERR(errmsg="{}".format(error))
if not real_sms_code:
raise response_code.DataExistERR
elif '{}'.format(sms_code) != real_sms_code:
raise response_code.DataERR(errmsg="短信验证码输入错误")
def func_check_mobile(self):
"""
查看手机号码重复
@return:
"""
mobile = self.extra_data.get('mobile', '')
if not mobile_re.match('{}'.format(mobile)):
raise response_code.ParamERR(errmsg="手机号码不正确")
try:
user_info = mongo.db.user.find_one({"mobile": '{}'.format(mobile)})
except Exception as error:
current_app.logger.error(error)
raise response_code.DatabaseERR(errmsg='{}'.format(error))
if user_info:
resp = set_resjson(err=-1, errmsg='This mobile is already exist!')
else:
resp = set_resjson(err=0, errmsg="This mobile can be registered!")
return resp
def generate_subtitle(task_id, lang):
"""
生成字幕
:param task_id:
:param lang:
:return:
"""
from main import app, mongo
try:
with app.app_context():
current_app.logger.info("生成字幕开始")
subtitle = Subtitle(task_id)
subtitle.generate_configs(video_id=task_id, lang=lang)
current_app.logger.info("生成字幕结束")
except Exception as e:
print(e)
try:
mongo.db.video.update_one({'_id': task_id},
{'$unset': {'subtitling': ''}})
except Exception as e:
raise response_code.DatabaseERR(errmsg='{}'.format(e))
def func_download_file(self):
"""
课件下载
@return:
"""
res_list = []
file_id = self.extra_data.get("file_id", "")
if file_id == "" or type(file_id) != list:
raise response_code.ParamERR(
errmsg="file_id be provide or type must array")
for document_id in file_id:
try:
video_document = mongo.db.document.find_one(
{"_id": document_id}, {
"_id": 0,
"file_path": 1,
"download_counts": 1
})
if not video_document:
video_document = {document_id: "此ID不存在"}
else:
if "download_counts" in video_document.keys():
download_counts = video_document.pop("download_counts")
else:
download_counts = 0
mongo.db.document.update_one(
{"_id": document_id},
{"$set": {
"download_counts": download_counts + 1
}})
res_list.append(deepcopy(video_document))
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
return set_resjson(res_array=res_list)
def func_give_like(self):
"""
视频点赞
:return:
"""
user = g.user
if not user:
raise response_code.UserERR(errmsg='用户未登录')
relation_id = self.extra_data.get("relation_id", "")
value = self.extra_data.get("value", "")
like_type = self.extra_data.get("type", "")
try:
value = int(value)
except Exception as e:
raise response_code.ParamERR(
errmsg="value type error: {}".format(e))
if relation_id == "":
raise response_code.ParamERR("[relation_id] must be provided")
elif like_type not in ["video", "series", "comment"]:
raise response_code.ParamERR(errmsg="type must be video or series")
elif value not in [1, 0]:
raise response_code.ParamERR(errmsg="value must be 1 or 0")
if like_type == "video":
try:
video_info = mongo.db.video.find_one({"_id": relation_id})
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
elif like_type == "series":
try:
video_info = mongo.db.document.find_one({"_id": relation_id})
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
else:
try:
video_info = mongo.db.comment.find_one({"_id": relation_id})
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
if not video_info:
raise response_code.DatabaseERR(
errmsg="relation_id is incorrect !")
else:
try:
like_info = mongo.db.like.find_one(
{"user_id": user["_id"], "relation_id": relation_id})
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
like_time = time.time()
if value == 1:
if not like_info:
try:
mongo.db.like.insert_one(
{"_id": create_uuid(), "user_id": user["_id"],
"relation_id": relation_id, "type": like_type,
"time": like_time, "read_state": 0})
except Exception as e:
raise response_code.DatabaseERR(
errmsg="{}".format(e))
else:
raise response_code.ParamERR(errmsg="你已经点过赞了")
else:
if like_info:
try:
mongo.db.like.delete_one({"user_id": user["_id"],
"relation_id": relation_id})
except Exception as e:
raise response_code.DatabaseERR(
errmsg="{}".format(e))
else:
raise response_code.ParamERR(errmsg="你没有点赞过此视频，无法取消")
return set_resjson()
def func_third_phone_login(self):
"""
第三方移动端登陆
"""
access_token = self.extra_data.get("access_token", "")
openid = self.extra_data.get("openid", "")
mode = self.extra_data.get('type', "")
if access_token == "" or openid == "":
raise response_code.ParamERR(
errmsg="[ access_token, openid ] must be provided")
elif mode not in ["qq", "wechat"]:
raise response_code.ParamERR(errmsg='type must be qq or wechat')
elif mode == "qq":
oauth_qq = OAuthQQ(client_id=config.QQ_PHONE_APP_ID,
client_secret=config.QQ_PHONE_APP_Key)
unionid, openid = oauth_qq.get_unionid(access_token)
try:
user_info = mongo.db.user.find_one({"qq_unionid": unionid})
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
if not user_info:
user_info = oauth_qq.get_user_info(access_token, openid)
try:
pl = redis_conn.pipeline()
pl.set("unionid_name_%s" % unionid, user_info['nickname'],
constants.SMS_CODE_REDIS_EXPIRES)
pl.set("unionid_photo_url_%s" % unionid,
user_info['figureurl_qq_1'],
constants.SMS_CODE_REDIS_EXPIRES)
pl.execute()
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
access_token = generate_save_user_token(unionid, 'qq')
return set_resjson(res_array=[{"access_token": access_token}])
else:
response = not_first_login(user_info)
return response
elif mode == 'wechat':
wechatlogin = WeChat(appid=config.WECHAT_APP_ID,
secret_key=config.WECHAT_APP_SECRET)
nickname, headimgurl, unionid, gender = wechatlogin.get_user_info(
access_token, openid)
try:
user_info = mongo.db.user.find_one({"wechat_unionid": unionid})
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
if not user_info:
# 第一次登录
nickname, headimgurl, unionid = wechatlogin.get_user_info(
access_token, openid)
try:
pl = redis_conn.pipeline()
pl.set("unionid_name_%s" % unionid, nickname,
constants.SMS_CODE_REDIS_EXPIRES)
pl.set("unionid_photo_url_%s" % unionid, headimgurl,
constants.SMS_CODE_REDIS_EXPIRES)
pl.execute()
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
access_token = generate_save_user_token(unionid, 'wechat')
return set_resjson(res_array=[{"access_token": access_token}])
else:
response = not_first_login(user_info)
return response
def func_post_comment(self):
"""
发表评论
"""
user = g.user
if not user:
raise response_code.UserERR(errmsg='用户未登录')
video_id = self.extra_data.get("video_id", "")
parent_id = self.extra_data.get("parent_id", "")
content = self.extra_data.get("content", "")
# to_user_id = self.extra_data.get("to_user_id", "")
# to_user_name = self.extra_data.get("to_user_name", "")
collect_time = time.time()
try:
parent_id = int(parent_id)
except Exception as e:
raise response_code.ParamERR(errmsg="parent_id is incorrect !")
if video_id == "" or content == "" or parent_id == "":
raise response_code.UserERR(
errmsg="[ video_id, parent_id, content ] must be provided")
try:
video_info = mongo.db.video.find_one({"_id": video_id})
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
if not video_info:
raise response_code.ParamERR(errmsg="video_id is incorrect")
_id = create_uuid()
if parent_id != 0:
try:
comment_info = mongo.db.comment.find_one(
{"_id": "{}".format(parent_id)})
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
if not comment_info:
raise response_code.ParamERR(errmsg="parent_id is incorrect")
try:
mongo.db.comment.insert({
"_id":
_id,
"parent_id":
"{}".format(parent_id),
"content":
content,
"time":
collect_time,
"video_id":
video_id,
"to_user_id":
comment_info["user_id"],
"user_name":
user["name"],
"headshot":
user["headshot"],
"user_id":
user["_id"],
"to_user_name":
comment_info["user_name"],
"state":
2
})
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
else:
try:
mongo.db.comment.insert({
"_id": _id,
"parent_id": "{}".format(parent_id),
"content": content,
"time": collect_time,
"video_id": video_id,
"user_id": user["_id"],
"user_name": user["name"],
"headshot": user["headshot"],
"state": 2
})
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
return set_resjson(res_array=[{"comment_id": _id}])
def func_get_comment(self):
'''
获取评论
:param video_id:
:param parent_id:
:param max_size:
:param page:
:return res_data:
'''
video_id = self.extra_data.get("video_id", "")
parent_id = self.extra_data.get("parent_id", "")
max_size = self.extra_data.get("max_size", "")
page = self.extra_data.get("page", "")
try:
max_size = int(max_size)
page = int(page)
except Exception as e:
raise response_code.ParamERR(errmsg="max_size, page must be int")
res_data = []
try:
likes = mongo.db.like.find(
{
'relation_id': video_id,
'type': 'comment'
}, {'_id': 1})
like_list = []
if likes:
for like in likes:
like_list.append(like['_id'])
if parent_id:
comments = mongo.db.comment.find({
'video_id': video_id,
'parent_id': parent_id,
"state": 2
}).sort('time', -1).limit(max_size).skip(max_size * (page - 1))
else:
comments = mongo.db.comment.find({
'video_id': video_id,
'parent_id': "0"
}).sort('time', -1).limit(max_size).skip(max_size * (page - 1))
if comments:
for comment in comments:
if comment['_id'] in like_list:
comment['is_like'] = 1
else:
comment['is_like'] = 0
like_counts = mongo.db.like.find({
"relation_id":
comment['_id'],
"type":
"comment"
}).count()
comment['like_counts'] = like_counts
if parent_id == "0":
comment_counts = mongo.db.comment.find({
"parent_id":
comment['_id'],
"state":
2
}).count()
comment['comment_counts'] = comment_counts
res_data.append(comment)
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
return set_resjson(res_array=res_data)
def func_add_collection(self):
"""
收藏
:return:
"""
user = g.user
if not user:
raise response_code.UserERR(errmsg='用户未登录')
relation_id = self.extra_data.get("relation_id", "")
value = self.extra_data.get("value", "")
collect_type = self.extra_data.get("type", "")
collect_time = time.time()
try:
value = int(value)
except Exception as e:
raise response_code.ParamERR(
errmsg="value type error: {}".format(e))
if relation_id == "":
raise response_code.ParamERR("[relation_id] must be provided")
elif collect_type not in ["video", "series"]:
raise response_code.ParamERR(errmsg="type must be video or series")
elif value not in [1, 0]:
raise response_code.ParamERR(errmsg="value must be 1 or 0")
if collect_type == "video":
try:
video_info = mongo.db.video.find_one({"_id": relation_id})
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
else:
try:
video_info = mongo.db.series.find_one({"_id": relation_id})
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
if not video_info:
raise response_code.DatabaseERR(
errmsg="relation_id is incorrect !")
else:
try:
collect_info = mongo.db.collection.find_one({
"user_id":
user["_id"],
"relation_id":
relation_id
})
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
if value == 1:
if not collect_info:
try:
mongo.db.collection.insert_one({
"_id": create_uuid(),
"user_id": user["_id"],
"relation_id": relation_id,
"type": collect_type,
"time": collect_time,
"state": 0
})
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
elif collect_info["state"] == -1:
mongo.db.collection.update_one(
{"_id": collect_info["_id"]}, {"$set": {
"state": 0
}})
else:
raise response_code.ParamERR(errmsg="该视频已经收藏")
else:
if collect_info:
if collect_info["state"] == 0:
try:
mongo.db.collection.update_one(
{
"user_id": user["_id"],
"relation_id": relation_id
}, {"$set": {
"state": -1
}})
except Exception as e:
raise response_code.DatabaseERR(
errmsg="{}".format(e))
else:
raise response_code.ParamERR(errmsg="没有收藏此视频")
else:
raise response_code.ParamERR(errmsg="没有收藏此视频")
return set_resjson()
def func_third_bind_mobile(self):
"""
第一次登录绑定账号
:return:
"""
access_token = self.extra_data.get('access_token', "")
mobile = self.extra_data.get('mobile', "")
code = self.extra_data.get('code', "")
refresh_token = None
if access_token == "" or mobile == "" or code == "":
raise response_code.ParamERR(
'[access_token, mobile, code] can not be empty!')
elif not mobile_re.match('{}'.format(mobile)):
raise response_code.ParamERR(errmsg="Wrong phone number format!")
sms_verify(mobile, code)
now_time = time.time()
unionid, third_type = check_save_user_token(access_token)
if unionid is None:
raise response_code.ReqERR(errmsg="access_token is wrong!")
else:
try:
user_info = mongo.db.user.find_one(
{"mobile": '{}'.format(mobile)}, {
'name': 1,
'headshot': 1
})
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
if user_info:
try:
_id = user_info.pop('_id')
mongo.db.user.update_one({"mobile": '{}'.format(mobile)}, {
'$set': {
'{}_unionid'.format(third_type): unionid,
"login_time": now_time
}
})
except Exception as e:
raise response_code.DatabaseERR(errmsg="{}".format(e))
else:
_id = get_user_id("id")
try:
name = redis_conn.get("unionid_name_%s" % unionid)
headshot = redis_conn.get("unionid_photo_url_%s" % unionid)
gender = redis_conn.get("unionid_gender_%s" % unionid)
refresh_token = redis_conn.get("unionid_refresh_token_%s" %
unionid)
mongo.db.user.insert_one({
"gender":
gender,
"birthday":
str(datetime.date.today()),
"name":
name,
"mobile":
'{}'.format(mobile),
"_id":
_id,
'{}_unionid'.format(third_type):
unionid,
"headshot":
headshot,
"create_time":
now_time,
"login_time":
now_time,
"background":
self.background_path,
"introduction":
self.introduction
})
except Exception as error:
current_app.logger.error(error)
raise response_code.ThirdERR(errmsg="{}".format(error))
user_info = {'name': name, 'headshot': headshot}
response = make_response(set_resjson(res_array=[user_info]))
response.headers["Authorization"] = encode_auth_token(
_id, refresh_token)
return response