def super_like_someone(uid, sid):
'''超级喜欢(右划)某人'''
# 1. 在数据库中添加滑动记录
try:
Swiped.objects.create(uid=uid, sid=sid, stype='superlike')
except IntegrityError:
# 重复滑动时, 直接返回当前用户是否已匹配成好友
return Friend.is_friends(uid, sid)
# 强制将对方从自己的优先推荐队列删除
rds.lrem(keys.FIRST_RCMD_Q % uid, 0, sid)
# 2. 检查对方是否右划或者上划过自己
like_status = Swiped.is_liked(sid, uid)
if like_status is True:
# 3.如果双方互相喜欢的话, 匹配成好友
Friend.make_friends(uid, sid)
return True
elif like_status is False:
return False
else:
# 对方未滑动过自己时, 将自己的uid 添加到对方'优先推荐'列表
key = keys.FIRST_RCMD_Q % sid
# 从右边推进去
rds.rpush(key, uid)
return False
def superlike_someone(uid, sid):
'''超级喜欢某人'''
# 添加滑动记录
Swiped.swiper(uid, sid, 'superlike')
# 将sid从自己的优先推荐队列中删除
rds.lrem(keys.FIRST_CRMD_K % uid, 1, sid)
# 积分
score = config.HOT_RANK_SCORE['superlike']
# 调整被滑动者的积分
rds.zincrby(keys.HOT_RANK_K, score, sid)
# 检查对方有没有喜欢自己(右滑或上滑过自己)
liked_me = Swiped.is_liked(sid, uid)
if liked_me:
# 添加好友列表
Friend.make_friends(int(uid), int(sid))
return True
elif liked_me == False:
return False
else:
# 对方没有滑动过自己，需要将自己的uid添加到对方的“优先推荐队列”
rds.rpush(keys.FIRST_CRMD_K % sid, uid)
return False
def rewind_last_swipe(uid):
'''反悔上一次滑动 (每天允许反悔 3 次， 反悔的记录只能是五分钟之内的)'''
now = datetime.datetime.now()
# 检查今天是否已经反悔 3 次
rewind_key = keys.REWIND_TIMES_K % (now.date(), uid)
rewind_times = rds.get(rewind_key, 0)
if rewind_times >= config.REWIND_TIMES:
raise errors.RewindLimit
# 找到最后一次滑动
last_swipe = Swiped.objects.filter(uid=uid).latest('stime')
# 检查最后一次滑动是否在 5 分钟之内
time_past = (now - last_swipe.stime).total_seconds()
if time_past >= config.REWIND_TIMEOUT:
raise errors.RewindTimeout
with atomic(): # 将多次数据修改在事务中执行
if last_swipe.stype in ['like', 'superlike']:
# 如果之前匹配成了好友，则删除好友关系
Friend.breakoff(uid, last_swipe.sid)
# 如果上一次是超级喜欢，则删除优先推荐队列中的数据
if last_swipe.stype == 'superlike':
rds.lrem(keys.FIRST_RCMD_Q % last_swipe.sid, 0, uid)
# 撤销被滑动者改变的积分
score = config.SWIPE_SCORE[last_swipe.stype]
rds.zincrby(keys.HOT_RANK, -score, last_swipe.sid)
# 删除最后一次的滑动
last_swipe.delete()
# 今日反悔次数加一
rds.set(rewind_key, rewind_times + 1, 86460) # 缓存过期时间为一天零60秒
def dislike_someone(user_id, sid):
'''添加滑动记录'''
Swiped.objects.create(user_id=user_id, sid=sid, stype='dislike')
'''不喜欢对方，给对方的增加分数'''
rds.zincrby(keys.HOT_RANK, sid, config.RANK_SCORE['dislike'])
'''删除自己Redis缓存的优先推荐列表里，对方的id'''
rds.lrem(keys.PRIOR_RCMD_LIST % user_id, value=sid)
def dislike_someone(uid, sid):
'''不喜欢（左滑）'''
# 添加滑动记录
Slider.slide(uid, sid, 'dislike')
# 删除优先从喜欢我的人队列里面的推荐 sid
rds.lrem(keys.FIRST_RCMD_Q % uid, count=0, value=sid)
def rewind_last_swiped(user_id):
''' 撤销最后⼀次滑动,每天允许反悔三次，反悔时间距上一次滑动时间不超过5分钟'''
now = datetime.datetime.now()
rewind_key = keys.REWIND_TIMES_K % (now.date(), user_id)
# 1检查今天的反悔次数是否超过三次
rewind_times = rds.get(rewind_key, 0)
if rewind_times > config.REWIND_TIMES:
raise errors.RewindLimit()
# 2找到最后一次滑动
last_swpied = Swiped.objects.filter(user_id=user_id).latest('stime')
# 3检查最后一次滑动时间距离现在是否在5分钟内
past_time = (now - last_swpied.stime).total_seconds()
if past_time > config.REWIND_TIMEOUT:
raise errors.RewindTimeout()
with atomic():
# 4删除好友关系（只要上一次滑动类型是喜欢或超级喜欢，都有可能匹配为好友）
if last_swpied.stype in ['like', 'superlike']:
Friend.remove_relation(user_id, last_swpied.sid)
# 5如果最后一次滑动是超级喜欢删除自己在对方的优先推荐列表
if last_swpied.stype == 'superlike':
rds.lrem(keys.PRIOR_RCMD_LIST % last_swpied.sid, value=user_id)
# 6删除滑动记录
last_swpied.delete()
# 今日反悔次数加一
rds.set(rewind_key, rewind_times + 1, 86500) # 缓存过期时间为一天零100秒
'''撤回最后一次滑动所改变的对方的积分，'''
rds.zincrby(keys.HOT_RANK, last_swpied.sid,
-config.RANK_SCORE[last_swpied.stype])
def rewind_swiper(uid):
"""
反悔一次滑动
每天允许反悔3次，反悔记录只能是5分子之内的
"""
now = datetime.datetime.now() # 取出当前时间
# 取出当天的反悔次数
rewind_k = keys.REWIND_k % (now.date(), uid)
rewind_times = rds.get(rewind_k, 0) # 取出当天反悔次数 取不到的时候默认为0
# 检查当前反悔次数
if rewind_times >= config.REWIND_TIMES:
raise stat.RewindLimit
# 取出最后一次滑动记录
latest_swipe = Swiped.objects.filter(uid=uid).latest('time')
# 检查滑动记录时间是否超过5分钟
pass_time = now - latest_swipe.time
if pass_time.total_seconds() >= config.REWIND_TIMEOUT:
raise stat.RewindTimeout
# 如果是超级喜欢，需要将自己从对方的优先队列中删除
# 如果之前是喜欢或者超级喜欢,需要撤销好友关系
if latest_swipe.stype == 'superlike':
rds.lrem(keys.FIRST_RCMD_K % latest_swipe.sid, 1, uid)
Friend.break_off(uid, latest_swipe.sid)
elif latest_swipe.stype == 'like':
Friend.break_off(uid, latest_swipe.sid)
# 删除滑动记录
latest_swipe.delete()
# 更新反悔次数
rds.set(rewind_k, rewind_times + 1, 86400)
def dislike_someone(uid, sid):
'''不喜欢某人（左滑）'''
# 添加滑动记录
Swiped.swipe(uid, sid, 'dislike')
# 强制删除优先推荐队列中的 sid
rds.lrem(keys.FIRST_RCMD_Q % uid, count=0, value=sid)
def rewind_last_swipe(uid):
'''反悔上一次滑动 (每天允许反悔 3 次，反悔的记录只能是五分钟之内的)'''
now = datetime.datetime.now()
# 检查今天是否已经反悔 3 次
rewind_key = keys.REWIND_TIMES_K % (now.date(), uid)
rewind_times = rds.get(rewind_key, 0)
if rewind_times >= config.REWIND_TIMES:
raise errors.RewindLimit
# 找到最后一次的滑动
# select * from swiped where uid=1001 order by stime desc limit 1;
last_swipe = Swiped.objects.filter(uid=uid).latest('stime')
# 检查最后一次滑动是否在 5 分钟内
time_past = (now - last_swipe.stime).total_seconds()
if time_past >= config.REWIND_TIMEOUT:
raise errors.RewindTimeout
with atomic(): # 将多次数据修改在事务中执行
if last_swipe.stype in ['like', 'superlike']:
# 如果之前匹配成了好友，则删除好友关系
Friend.breakoff(uid, last_swipe.sid)
# 如果上一次是超级喜欢，则从对方的优先推荐队列中删除自己的 UID
if last_swipe.stype == 'superlike':
rds.lrem(keys.FIRST_RCMD_Q % last_swipe.sid, 0, uid)
# 删除最后一次的滑动
last_swipe.delete()
# 今日反悔次数加一
rds.set(rewind_key, rewind_times + 1, 86460) # 缓存过期时间为一天零60秒
def dislike_someone(uid, sid):
Swiped.swipe(uid, sid, stype='dislike')
# 删除滑动过的推荐
rds.lrem(keys.FIRST_RCMD_K % uid, 1, sid)
# 调整用户的积分
score = config.HOT_RANK_SCORE['dislike']
rds.zincrby(keys.HOT_RANK_K, score, sid)
def dislike_someone(uid, sid):
'''不喜欢'''
# 1.添加滑动记录
Slide.slide(uid=uid, sid=sid, slide_type='dislike')
# 2.强制删除优先推荐队列里的id
rds.lrem(keys.FIRST_RCMD_Q % uid, count=0, value=sid)
# 给被滑动者添加积分
rds.zincrby(keys.HOT_RANK, config.SLIDE_SCORE['dislike'], sid)
def dislike_someone(uid, sid):
'''不喜欢(左划)某人'''
# 1. 在数据库中添加滑动记录
try:
Swiped.objects.create(uid=uid, sid=sid, stype='dislike')
except IntegrityError:
pass
# 强制将对方从自己的优先推荐队列删除
rds.lrem(keys.FIRST_RCMD_Q % uid, 0, sid)
def dislike_someone(uid, sid):
'''不喜欢(左滑)'''
# 添加滑动记录
Swiped.swiped(uid, sid, 'dislike')
# 强制删除优先推荐队列中的 sid
rds.lrem(keys.FIRST_RCMD_Q + str(f'{uid}'), count=0, value=sid)
# 增加对方的滑动积分
rds.zincrby(keys.HOT_RANK, config.SWIPE_SCORE['dislike'], sid)
def dislike_someone(uid, sid):
'''左滑 (不喜欢) 某人'''
# 添加一条滑动记录
Swiped.swipe(uid, sid, 'dislike')
# 强制从自己优先队列删除 sid
rds.lrem(keys.FIRST_RCMD_K % uid, 1, sid)
# 为被滑动用户减少积分
rds.zincrby('HotRank', conf.SWIPE_SCORE['dislike'], sid)
def dislike_someone(uid, sid):
'''不喜欢某人（左滑）'''
# 添加滑动记录
Swiped.swipe(uid, sid, 'dislike')
# 强制删除优先推荐队列中的 sid
rds.lrem(keys.FIRST_RCMD_Q % uid, count=0, value=sid)
# 给被滑动者增加滑动积分
rds.zincrby(keys.HOT_RANK, config.SWIPE_SCORE['dislike'], sid)
def dislike_someone(uid, sid):
'''不喜欢'''
Swiped.swiper(uid, sid, 'dislike')
# 将sid从自己的优先推荐队列中删除
rds.lrem(keys.FIRST_CRMD_K % uid, 1, sid)
# 积分
score = config.HOT_RANK_SCORE['dislike']
# 调整被滑动者的积分
rds.zincrby(keys.HOT_RANK_K, score, sid)
def dislike_someone(uid, sid):
'''不喜欢的操作'''
# 添加滑动记录
Swiped.swipe(uid, sid, 'dislike')
# 将 sid 从自己的优先推荐队列中删除
rds.lrem(keys.FIRST_RCMD_K % uid, 1, sid)
# 调整对方的滑动积分
score = config.HOT_RANK_SCORE['dislike']
rds.zincrby(keys.HOT_RANK_K, score, sid)
def rewind_last_slide(uid):
'''返回上一次滑动（每天允许返回三次，返回的记录只能是五分钟以内的）'''
now = datetime.datetime.now()
# 检查今天是否已经反悔3次 ---> 适合缓存
rewind_key = keys.REWIND_LIMIT_K % (now.date(), uid) # now.date() 是日期
rewind_limit = rds.get(rewind_key, 0)
'''
每日更新三次
# 错误方式
1.过期时间
2.定时任务 ---> 人数多了，异步任务太多处理不了
3.建立redis库 ---> 保存key，到时间清空，在清空的时候也会出现临界点问题
# 正确方式
将日期拼接在用户的key上面
※时间临界点：
23：59：59.123 使用了2次反悔，现在要准备用第三次
当用了之后时间变成 00：00：00.321了，此时变成了3
用户一天都不能用返回了，这就是临界点可能出现的问题
'''
if rewind_limit >= config.REWIND_LIMIT:
raise errors.RewindLimit
# 找当最后一次的滑动
# 对应的SQL语句 select * from slider where uid=1001 order by stime desc limit 1;
last_slide = Slider.objects.filter(uid=uid).latest('stime') # 不分对方和方向
# latest() ---> 最新的（按照时间最新的），这个latest强调时间
# 检查最后一次滑动是否在5分钟以内
# (now - last_slide.stime)两个相减的值是datetime.timedelta(天,秒,毫秒),是一个特殊的对象
# (now - last_slide.stime).seconds 忽略了天和毫秒，单位是秒
# (now - last_slide.stime).total_seconds() 天秒毫秒全加起来，单位是秒
time_past = (now - last_slide.stime).total_seconds() # 已经过去的时间
if time_past >= config.REWIND_TIMEOUT:
raise errors.RewindTimeout
with atomic(): # 将多次数据修改在事务中执行
# 衍生的功能 +
# ↓
# 1.如果之前匹配成了好友，则删除好友关系
if last_slide.stype in ['like', 'superlike']:
Friend.breakoff(uid, last_slide.sid)
# 2.如果之前是超级喜欢，则找到对方的优先推荐队列把我的数据删除
if last_slide.stype == 'superlike':
rds.lrem(keys.FIRST_RCMD_Q % last_slide.sid, 0, uid)
# 3.删除最后一次的滑动
last_slide.delete()
# 4.今日返回次数加一，缓存过期时间一天(86400秒)，+ N秒 是为了避免时间临界点问题
rds.set(rewind_key, rewind_limit + 1, 86400 + 1)
def rewind_swipe(uid):
'''
反悔上一次的滑动
Redis 中记录的数据: {
'rewind_date': '2020-03-18', # 反悔的日期
'rewind_cnt': 0, # 当天的反悔次数
}
'''
# 从 Redis 中取出反悔数据
rewind_key = 'Rewind-%s' % uid
rewind_data = rds.hgetall(rewind_key)
rewind_date = rewind_data.get(b'rewind_date', '1970-01-01')
rewind_cnt = rewind_data.get(b'rewind_cnt', 0)
# 取出当前时间
now = datetime.datetime.today()
today = str(now.date())
# 检查当天 “反悔次数” 是否超过 3 次
if today == rewind_date:
if rewind_cnt >= 3:
raise err.RewindLimitErr
else:
rewind_cnt = 0
# 从数据库获取最后一条滑动记录, 并检查是否为 None
last_swipe = Swiped.objects.filter(uid=uid).latest('stime')
if last_swipe is None:
raise err.NonSwipe
# 检查时间是否超过 5 分钟
if (now - last_swipe.stime) > datetime.timedelta(minutes=5):
raise err.RewindTimeout
# 操作时开启事务
with atomic():
# 之前匹配成好友，需要解除好友关系
if last_swipe.stype in ['like', 'superlike']:
Friend.break_off(uid, last_swipe.sid)
# 删除滑动记录
last_swipe.delete()
# 之前是超级喜欢，需要将 ID 从对方推荐队列删除
rds.lrem(keys.FIRST_RCMD_Q % last_swipe.sid, 0, uid)
# 更新反悔数据
rds.hmset(rewind_key, {'rewind_cnt': rewind_cnt + 1, 'rewind_date': today})
def like_someone(uid, sid):
"""喜欢某人"""
# 添加一条滑动记录
Swiped.swiped(uid, sid, 'like')
# 将sid从优先队列中删除
rds.lrem(keys.FIRST_RCMD_K % uid, 0, sid)
# 检查对方有没有右滑或者上滑过字节
if Swiped.is_liked(sid, uid):
# 如果对方有喜欢过自己,匹配成好友
Friend.make_friend(uid, sid)
return True
else:
return False
def like_someone(uid, sid):
'''喜欢某人（右滑）'''
# 添加滑动记录
Swiped.swipe(uid, sid, 'like')
# 强制删除优先推荐队列中的 sid
rds.lrem(keys.FIRST_RCMD_Q % uid, count=0, value=sid)
# 检查对方是否喜欢(右滑或上滑)过自己
if Swiped.is_liked(sid, uid):
# 将互相喜欢的两人添加成好友
Friend.make_friends(uid, sid)
return True
else:
return False
def like_someone(user_id, sid):
'''添加滑动记录'''
Swiped.swpied(user_id, sid, 'like')
'''在自己的优先推荐列表里删除对方id'''
rds.lrem(keys.PRIOR_RCMD_LIST % user_id, value=sid)
'''喜欢对方，给对方的增加分数'''
rds.zincrby(keys.HOT_RANK, sid, config.RANK_SCORE['like'])
'''检查对方是否上滑（superlike）或右滑（like）过你'''
liked = Swiped.is_liked(user_id, sid)
if liked is True:
'''如果对方也喜欢过你，将你们匹配为好友'''
Friend.make_friends(user_id, sid)
return True
else:
return False
def like_someone(uid, sid):
'''喜欢（右滑）'''
# 添加滑动记录
Slider.slide(uid, sid, 'like')
# 删除优先从喜欢我的人队列里面的推荐 sid
rds.lrem(keys.FIRST_RCMD_Q % uid, count=0, value=sid)
# raise ValueError 事务回滚测试
# 检查对方是否喜欢（右滑或上滑）过自己
if Slider.is_like(sid, uid):
# 将互相喜欢的两人添加好友
Friend.make_friends(uid, sid)
return True
else:
return False
def like_someone(uid, sid):
'''喜欢的人'''
# 1.添加滑动记录
Slide.slide(uid=uid, sid=sid, slide_type='like')
# 2.强制删除优先推荐队列里的id
rds.lrem(keys.FIRST_RCMD_Q % uid, count=0, value=sid)
# 给被滑动者添加积分
rds.zincrby(keys.HOT_RANK, config.SLIDE_SCORE['like'], sid)
# 3.检查对方是否喜欢自己，如果喜欢那么建立好友关系
is_like = Slide.is_liked(uid=sid, sid=uid)
if is_like is True:
Friend.make_friend(uid, sid)
return True
else:
return False
def like_someone(uid, sid):
'''右滑：喜欢某人'''
# 添加一条滑动记录
Swiped.swipe(uid, sid, 'like')
# 强制从自己优先队列删除 sid
rds.lrem(keys.FIRST_RCMD_K % uid, 1, sid)
# 为被滑动用户增加积分
rds.zincrby('HotRank', conf.SWIPE_SCORE['like'], sid)
# 检查是否对方是否右滑或上滑过自己
if Swiped.has_liked(sid, uid):
# 匹配成好友关系
Friend.make_friends(uid, sid)
return True
else:
return False
def super_like_someone(uid, sid):
"""超级喜欢"""
# 添加滑动记录
Swiped.swiped(uid, sid, 'superlike')
# 将sid从优先队列中删除
rds.lrem(keys.FIRST_RCMD_K % uid, 0, sid)
liked_me = Swiped.is_liked(sid, uid)
if liked_me:
Friend.make_friend(uid, sid)
return True
elif not liked_me:
return False
else:
# 对方没有滑动过自己，将自己的uid添加到对方的 “优先推荐队列”
rds.rpush(keys.FIRST_RCMD_K % sid, uid)
return False
def rewind_last_swipe(uid):
'''
反悔最后一次滑动的记录(确定逻辑顺序):
:param uid: 用户的 ID
:return:
'''
# 1.检查今天是否已经达到3次
# 还需要拼接一个时间, 确保删除的次数是当天的, 避免时间跨界的问题
now = datetime.datetime.now()
key = 'Rewind-%s-%s' % (uid, now.date())
# 取出当天反悔的次数, 默认为0
rewind_times = rds.get(key, 0)
if rewind_times >= 3:
print('反悔次数达到限制')
# 此时直接跳出去, 就不需要再进行后面的操作了
raise stat.RewindLimited
# return 1007 # TODO: 需要给前端反回状态码
# 2.从数据库里面取出最后一次滑动的记录
latest_swiped = Swiped.objects.filter(uid=uid).latest('stime')
# 3.检查反悔记录是否是五分钟以内的
past_time = now - latest_swiped.stime
if past_time.seconds > 300:
print('反悔超时')
raise stat.RewindTimeout
# return 1008 # TODO: 需要给前端反回状态码
# 给下面操作数据库的代码添加事务:
with atomic():
# 4.检查上次滑动记录是否匹配成功, 如果匹配成功的话, 需要删除好友
# 不管之前有没有, 都来一次删除, 强删的话是不会报错的
if latest_swiped.stype in ['like', 'superlike']:
Friend.break_off(uid, latest_swiped.sid)
# 5.检查上次是否是超级喜欢, 如果是, 将自己的ID从对方的优先队列中删除
if latest_swiped.stype == 'superlike':
# 把对方优先队列中自己的记录给删除
rds.lrem(keys.FIRST_RCMD_Q % latest_swiped.sid, 0, uid)
# 6.删除滑动记录
latest_swiped.delete()
# 7. 累加当天反悔次数
rds.set(key, rewind_times + 1)
def rewind_last_swipe(uid):
'''
反悔最后一次的滑动
- 每天允许反悔 3 次
- 反悔的记录只能是五分钟之内的
'''
# 取出当前时间
now = datetime.datetime.now()
# 检查当前是否达到了 3 次
key = keys.REWIND_K % (now.date(), uid)
rewind_times = rds.get(key, 0) # 取出当天的反悔次数，默认为 0 次
if rewind_times >= 3:
raise stat.RewindLimited # 当天达到额定次数: 直接给用户提示
latest_swipe = Swiped.objects.filter(uid=uid).latest(
'stime') # 找到最后一次的滑动记录
# 对比当前时间和最后一次的滑动时间，差值是否在五分钟内
passed_time = (now -
latest_swipe.stime).total_seconds() # 计算距离上一次滑动已经过去的秒数
if passed_time >= 300:
raise stat.RewindTimeout # 超过 5 分钟，直接给用户提示
# 撤销滑动式可能受影响的其他相关数据
# 好友关系删掉
if latest_swipe.stype in ['like', 'superlike']:
Friend.break_off(uid, latest_swipe.sid)
# 优先推荐队列里的数据删掉
if latest_swipe.stype == 'superlike':
rds.lrem(keys.FIRST_RCMD_K % latest_swipe.sid, 1, uid)
# 撤销滑动积分
rds.zincrby(keys.RANK_K, -conf.SWIPE_SCORE[latest_swipe.stype],
latest_swipe.sid)
# 删除最后一次滑动记录
latest_swipe.delete()
# 全部完成后，累加反悔次数
rds.set(key, rewind_times + 1, 86400 * 2) # 过期时间是为了让当天的反悔次数自然消失
def like_someone(uid, sid):
'''喜欢某人(右滑)'''
# 添加滑动记录
Swiped.swiped(uid, sid, 'like')
# 强制删除优先推荐队列中的 sid
rds.lrem(keys.FIRST_RCMD_Q + str(f'{uid}'), count=0, value=sid)
# 增加对方的滑动积分
rds.zincrby(keys.HOT_RANK, config.SWIPE_SCORE['like'], sid)
# 检查对方是否喜欢过自己
is_liked = Swiped.objects.filter(uid=sid, sid=uid, stype__in=['like', 'superlike']).exists()
if is_liked:
# 将互相喜欢的两个人添加为好友
Friend.make_friends(uid, sid)
return True
else:
return False
def like_someone(uid, sid):
'''喜欢某人'''
# 添加滑动记录
Swiped.swipe(uid, sid, 'like')
# 将 sid 从自己的优先推荐队列中删除
rds.lrem(keys.FIRST_RCMD_K % uid, 1, sid)
# 调整对方的滑动积分
score = config.HOT_RANK_SCORE['like']
rds.zincrby(keys.HOT_RANK_K, score, sid)
# 检查对方有没有右滑或者上滑过自己
if Swiped.is_liked(sid, uid):
# 如果对方喜欢过自己，匹配成好友
Friend.make_friends(uid, sid)
return True
else:
return False
