def rewind_swipe(user):
# 检查当天是否超过指定次数
key = keys.REMIND_KEY % user.id
# 取出当前剩余次数
remain_times = cache.get(key, config.DAILY_REMIND)
if remain_times <= 0:
raise status.RewindLimited
# 取出最后滑动记录
latest_swipe = Swiper.objects.filter(uid=user.id).latest('stime')
# 检查上一次滑动是否在5分钟之内
now = datetime.datetime.now() # 当前时间
if (now - latest_swipe.stime).total_seconds() > config.REMIND_TIMEOUT:
raise status.RewindTimeOut
# 检查是否曾经匹配成好友，如果是撤销好友关系
if latest_swipe.stype in ['like', 'superlike']:
Friend.break_off(user.id, latest_swipe.sid)
# 反悔后减去已添加的积分
score = -config.SWIPE_SCORE[latest_swipe]
rds.zincrby('HotRank', score, latest_swipe.sid)
# 删除滑动记录
latest_swipe.delete()
# 重新计算并记录剩余次数
# 下一个零点时间
next_zero = datetime.datetime(now.year, now.month,
now.day) + datetime.timedelta(1)
# 到凌晨的剩余时间，total_seconds()获得秒数
expire_seconds = (next_zero - now).total_seconds()
# 重新写入缓存
remain_times -= 1
cache.set(key, remain_times, expire_seconds)
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 rewind(user):
'''反悔操作, 撤销上一次滑动操作'''
# 检查今天是否已经达到 3 次
key = keys.REWIND_TIMES % user.id
rewind_times = cache.get(key, 0)
if rewind_times >= config.REWIND_TIMES:
raise errors.RewindLimit
else:
# 获取当天剩余秒数
now = datetime.datetime.now()
timeout = 86400 - now.hour * 3600 - now.minute * 60 - now.second
# 通过时间戳计算今天的剩余秒数
# timeout = 86400 - (time.time() + 3600 * 8) % 86400
cache.set(key, rewind_times + 1, timeout) # 计数加一，并设置有效期到今晚 0 点
# 取出上一次操作
try:
swiped = Swiped.objects.filter(uid=user.id).latest('time')
except Swiped.DoesNotExist:
return
# 检查上一次是否完成过匹配，如果完成匹配需撤销好友关系
if swiped.flag in ['like', 'superlike']:
Friend.break_off(user.id, swiped.sid)
# 撤销之前滑动的积分
score = config.SWIPE_SCORE.get(swiped.flag, 0) # 根据函数名取出对应的积分
rds.zincrby(keys.HOT_RANK, swiped.sid, -score) # 撤销之前的积分
swiped.delete()
def rewind_swipered(user):
'''反悔一次滑动记录'''
# 获取今天的反悔次数
rewind_times = rds.get(keys.REWIND_KEY % user.id, 0)
# 检查今天返回是否达到了反悔上限
if rewind_times >= cfg.DAILY_REWIND:
raise stat.RewindLimit
# 找到最近的一次滑动记录
latest_swiped = Swiped.objects.filter(uid=user.id).latest('stime')
# 检查反悔的记录是否是五分钟之内的
now = datetime.datetime.now()
if (now - latest_swiped.stime).total_seconds() >= cfg.REWIND_TIMEOUT:
raise stat.RewindTimeout
# 检查上一次滑动是否有可能匹配了好友关系
if latest_swiped.stype in ['like', 'superlike']:
# 删除好友关系
Friend.break_off(user.id, latest_swiped.sid)
# 如果上一次是超级喜欢 将自身的uid从对方的优先推荐队列里面删除
if latest_swiped.stype == 'superlike':
rds.zrem(keys.SUPERLIKED_KEY % latest_swiped.sid, user.id)
# 删除滑动记录
latest_swiped.delete()
# 更新当天的滑动词数,同时设置过期时间到下一个凌晨
next_zero = datetime.datetime(now.year, now.month,
now.day) + datetime.timedelta(1)
remain_seconds = (next_zero - now).total_seconds()
rds.set(keys.REWIND_KEY % user.id, rewind_times + 1, int(remain_seconds))
def rewind(user):
#次数检查 一天只能3次反悔
key = keys.REWIND_TIMES % user.id
rewind_times = cache.get(key, 0)
if rewind_times >= config.REWIND_TIMES:
raise errors.RewindLimit
else:
now = datetime.datetime.now()
timeout = 86400 - now.hour * 3600 - now.minute * 60 - now.second
#通过时间戳计算剩余秒数
#timeout=86400-(time.time()+3600*8)%86400
cache.set(key, rewind_times + 1, timeout=timeout) #计数+1
#取出上一次操作
try:
swiped = Swiped.objects.filter(uid=user.id).latest('time')
except Swiped.DoesNotExist:
return
#检查上一次是否完成匹配
if swiped.flag in ['like', 'superlike']:
Friend.break_off(user.id, swiped.sid)
#撤销之前滑动的积分
sid = swiped.sid
score = config.SWIPE_SCORE.get(swiped.flag, 0) # 根据函数名取出对应的积分
rds.zincrby(keys.HOT_RANK, -score, sid) # 撤销之前积分
swiped.delete()
def rewind(user):
'''反悔操作'''
key = keys.REWIND_TIMES % user.id
# 检查当天反悔操作是否已达上限
rewind_times = cache.get(key, 0)
if rewind_times >= config.REWIND_LIMIT:
raise errors.RewindLimited
# 找出最后一次滑动记录
latest_swiped = Swiped.objects.filter(uid=user.id).latest('stime')
# 检查之前是否成功匹配为好友，如果是好友则断交
if latest_swiped.stype in ['like', 'superlike']:
Friend.break_off(user.id, latest_swiped.sid) # 有则删除，没有则什么也不做
# 恢复滑动积分
score = config.SWIPE_SCORE[latest_swiped.stype]
rds.zincrby(keys.SWIPE_RANK, -score, latest_swiped.sid)
# 删除滑动记录
latest_swiped.delete()
# 重设缓存
rewind_times += 1
now_time = datetime.datetime.now().time()
remain_time = 86400 - now_time.hour * 3600 - now_time.minute * 60 - now_time.second
cache.set(key, rewind_times, remain_time)
def rewind(user):
'''反悔'''
'''取出最后一次滑动记录'''
swiped = Swiped.objects.filter(uid=user.id).latest('id')
'''删除好友关系'''
if swiped.flag in ['superlike', 'like']:
Friend.break_off(user.id, swiped.sid)
'''删除好友记录'''
swiped.delete()
def regreted(user):
# 反悔
# 取出最后一次滑动记录
swiped = Swiped.objects.filter(uid=user.id).latest()
# 删除好友记录
if swiped.flag in ['like', 'superlike']:
Friend.break_off(user.id, swiped.sid)
# 删除滑动记录
swiped.delete()
def rewind(user, sid):
'''反悔'''
try:
#取消滑动记录
Swiped.objects.get(uid=user.id, sid=sid).delete()
except Swiped.DoesNotExist:
pass
#删除好友关系
Friend.break_off(user.id, sid)
def rewind(user):
'''反悔'''
# 取出最后一次滑动记录
swiped = Swiped.objects.filter(uid=user.id).latest()
# 删除好友关系
if swiped.flag in ['superlike', 'like']:
Friend.break_off(user.id, swiped.sid)
# 删除滑动记录
swiped.delete()
def rewind(user):
# 反悔操作
"""
latest()最新的数据（根据时间）=last()最后插入进去的（根据id）
earliest()=first()
"""
swiped = Swiped.objects.filter(uid=user.id).latest() # 检查取出最后一次滑动记录
if swiped.flag in ['superlike','like']:
Friend.break_off(user.id,swiped.sid) #删除好友关系
swiped.delete() #删除滑动记录
def rewind_swiper(uid):
'''反悔上一次的滑动
Redis 中记录的数据:{
'count':0, #当天的反悔次数
'rewind_date':'2020-5-22', #反悔的日期
'last_swiper':155445,# 最后一次滑动的时间 时间戳，方便计算
'last_sid':98,# 最后一次滑动的 SID
}
'''
# 从 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)
last_stime = rewind_data.get(b'last_stime', 0)
last_sid = rewind_data.get(b'last_sid', 0)
# 取出当前时间
now = datetime.date.today()
today = str(now.date())
# 检查当天返回次数 超过 3 次 -> 返回状态码
if today == rewind_data:
if rewind_cnt >= 3:
raise error.RewindLimitErr
else:
rewind_cnt = 0
# 从数据库中获取最后一条滑动记录并检查是否为None
last_swiper = Swiperd.objects.filter(uid=uid).latest('stime')
if last_swiper is None:
raise error.NonSwiper
# 检查时间是否超过 5 分钟
if (now - last_swiper.stime) > datetime.timedelta(minutes=5):
raise error.RewindTimeout
with atomic():
# 之前匹配成好友， 需要解除好友关系
if last_swiper.stype in ['like', 'superlike']:
Friend.break_off(uid, last_swiper.sid)
# 删除滑动记录
last_swiper.delet()
# 之前是超级喜欢， 需要将 ID 从对方推荐队列删除
rds.lrem(keys.FIRST_RCMD_Q % last_swiper.sid, 0, uid)
# 更新反悔数据
rds.hmset(rewind_key, {
'rewind_cnt': rewind_cnt + 1,
'rewind_date': today
})
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 rewind_swiped(user):
'''
1.获取反悔次数 ---存储位置
2.返回一次滑动记录 --- 找到最近一次的滑动记录;[返回的记录只能为5min之内]
3.每天允许反悔3次 --- 需要对当天返回次数进行记录;并作出检查确定哪一次是最近一次;
4.返回记录只能是5min以内 --- 找到最近的滑动记录,检查反悔记录是否为5mins以内,判断当前时间与滑动时的时间操作；
5.检查上一次滑动是否匹配为好友,如果是,则需要先删除好友记录;
6.如果上一次是超级喜欢,将自身uid从对方的右滑推荐队列中删除
7.删除滑动记录； --- 需要更新滑动记录
'''
# 获取今天的反悔次数
# 默认0次反悔次数,参数最好写入配置文件；
rewind_times = rds.get(keys.REWWIND_KEY % user.id, 0)
# 检查是否达到限制次数
if rewind_times >= cfg.DAILY_REWIND:
raise stat.RewindLimit
# 根据时间找到最近的一次的滑动记录:filter的内容无顺序;
# 取最近的一次滑动的方法:last(),latest()对比区别
latest_swiped = Swiper.objects.filter(uid=user.id).latest('stime')
# 检查返回记录在五分钟以内:当前时间与滑动时间的差值
now = datetime.datetime.now()
if (now - latest_swiped.stime).total_seconds() >= cfg.REWIND_TIMEOUT:
raise stat.RewindTimeout
# 检查上一次滑动是否匹配成好友
if latest_swiped.stype in ['like', 'superlike']:
# 如果是好友,删除好友关系
Friend.break_off(user.id, latest_swiped.sid)
# 如果上一次超级喜欢,将自身uid从对方的优先推荐队列中删除
if latest_swiped.stype == 'superlike':
rds.zrem(keys.SUPERLIKED_KEY % latest_swiped.sid, user.id)
# 如果反悔的话,需要还原用户的滑动积分
score = -cfg.SWIPE_SCORE[latest_swiped.stype] # 查找反悔的滑动积分
rds.zincrby(keys.HOT_RANK_KEY, score, latest_swiped.sid)
# 删除滑动记录
latest_swiped.delete()
# 更新当天的滑动次数
rds.set(keys.REWWIND_KEY % user.id, rewind_times + 1)
# 更新过期过期时间(次日零点过期),需要计算过期时间,由于date在月末临界点,不够安全,采用timedelta()
next_zero = datetime.datetime(now.year, now.month,
now.day) + datetime.timedelta()
remain_seconds = next_zero - now
rds.set(keys.REWWIND_KEY % user.id, rewind_times + 1, remain_seconds)
def rewind(user):
'''
每天允许撤销 3 次
'''
# 获取当前日期已撤销的次数
now = datetime.datetime.now()
key = keys.REWIND_KEY % (user.id, now.date())
rewind_times = cache.get(key, 0)
# 次数检查
if rewind_times < config.REWIND_TIMES:
rewind_times += 1
# 计算到晚上凌晨剩余的秒数
remain_second = 86400 - (now.hour * 3600 + now.minute * 60 +
now.second)
# 添加缓存记录
cache.set(key, rewind_times, remain_second)
# 执行撤销操作
record = Swiped.objects.filter(uid=user.id).latest('stime')
# 撤销好友记录
Friend.break_off(user.id, record.sid)
# 还原积分
# 直接的思路
# if record.flag == 'like':
# rds.zincrby(keys.HOT_RANK, record.sid, -config.SCORE_LIKE)
# elif record.flag == 'superlike':
# rds.zincrby(keys.HOT_RANK, record.sid, -config.SCORE_SUPERLIKE)
# else:
# rds.zincrby(keys.HOT_RANK, record.sid, -config.SCORE_DISLIKE)
# 简化版思路
score_mapping = {
'like': -config.SCORE_LIKE,
'superlike': -config.SCORE_SUPERLIKE,
'dislike': -config.SCORE_DISLIKE
}
rds.zincrby(keys.HOT_RANK, record.sid, score_mapping[record.flag])
# 前置操作完成后，删除滑动记录
record.delete()
else:
raise errors.RewindLimited('反悔次数达到每日上限')
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 rewind_swipe(uid):
'''
反悔上一次的滑动
Redis 中记录的数据: {
'rewind_date': '2020-03-18', # 反悔的日期
'rewind_cnt': 0, # 当天的反悔次数
}
'''
# 从 Rides 中取出反悔数据
rewind_key = keys.REWIND_K % 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 = Swiper.objects.filter(uid=uid).latest('stime')
if last_swipe is None:
raise err.NoneSwipe('当前没有反悔数据')
# 检查时间是否超过五分钟
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 rewind_swipe(uid):
'''
反悔一次滑动
每天允许反悔 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('stime')
# 检查滑动记录的时间否超是过 5 分钟
pass_time = now - latest_swipe.stime
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)
# 调整对方的滑动积分
score = config.HOT_RANK_SCORE[latest_swipe.stype]
rds.zincrby(keys.HOT_RANK_K, -score, latest_swipe.sid)
# 将滑动记录删除
latest_swipe.delete()
# 更新反悔次数
rds.set(rewind_k, rewind_times + 1, 86400)
return config.REWIND_TIMES, rds.get(rewind_k, 0)
def rewind_last_swiped(user):
'''反悔上一次滑动'''
# 查找上一次操作
last_swiped = Swiped.objects.filter(uid=user.id).last()
if last_swiped is None:
# 如果用户没有任何操作记录,直接返回
raise errors.NotFoundSwiped
# 检查反悔的记录是否是五分钟之内的
time_zone = last_swiped.stime.tzinfo
now = datetime.datetime.now(tz=time_zone)
if (now - last_swiped.stime).seconds > cfg.LAST_SWIPED_SECONDS:
raise errors.LastSwipedTimeout
# 检查是否达到当天反悔次数上限
rewind_key = keys.REWIND_TIMES % (user.id, now.date())
current_rewind_times = cache.get(rewind_key, 0) # 当天反悔次数
if current_rewind_times >= 3:
raise errors.RewindTimesLimit
# 计算当前时刻到凌晨零点的剩余秒数
year, month, day, *_ = now.timetuple() # 取出今天的年,月,日
remain_time = datetime.datetime(year, month, day + 1,
tzinfo=time_zone) - now # 计算剩余时间
# 更新缓存
current_rewind_times += 1
cache.set(rewind_key, current_rewind_times, remain_time.total_seconds())
# 如何记录反悔次数
# 每天凌晨如何清零
# 喜欢类型的撤销操作,需要先检查是否匹配过好友
if last_swiped.stype in ['like', 'superlike']:
# 如果是好友,撤销好友关系
Friend.break_off(user.id, last_swiped.sid)
# 删除
last_swiped.delete()
def rewind_swiped(user):
'''反悔一次滑动纪录'''
# 获取今天的反悔次数
rewind_times = rds.get(keys.REWIND_KEY % user.id, 0)
# 检查今天反悔是否达到限制次数
if rewind_times >= cfg.DAILY_REWIND:
raise stat.RewindLimit
# 找到最近一次的滑动记录
latest_swiped = Swiped.objects.filter(uid=user.id).latest('stime')
# 检查反悔的记录是否是五分钟之内的
now = datetime.datetime.now()
if (now - latest_swiped.stime).total_seconds() >= cfg.REWIND_TIMEOUT:
raise stat.RewindTimeout
# 检查上一次滑动是否有可能匹配成了好友
if latest_swiped.stype in ['like', 'superlike']:
# 删除好友关系
Friend.break_off(user.id, latest_swiped.sid)
# 如果上一次是超级喜欢，将自身uid从对方的优先推荐队列中删除
if latest_swiped.stype == 'superlike':
rds.zrem(keys.SUPERLIKED_KEY % latest_swiped.sid, user.id)
# 还原用户的滑动积分
score = -cfg.SWIPE_SCORE[latest_swiped.stype]
rds.zincrby(keys.HOT_RANK_KEY, score, latest_swiped.sid)
# 删除滑动记录
latest_swiped.delete()
# 更新当天的滑动次数, 同时设置过期时间到下一个凌晨
next_zero = datetime.datetime(now.year, now.month,
now.day) + datetime.timedelta(1)
remain_seconds = (next_zero - now).total_seconds()
rds.set(keys.REWIND_KEY % user.id, rewind_times + 1, int(remain_seconds))
def rewind(user):
'''
每天允许撤销 3 次
'''
# 获取当前日期已撤销的次数
now = datetime.datetime.now()
key = 'Rewind-%s-%s' % (user.id, now.date())
rewind_times = cache.get(key, 0)
# 次数检查
if rewind_times < config.REWIND_TIMES:
rewind_times += 1
# 计算到晚上凌晨剩余的秒数
remain_second = 86400 - (now.hour * 3600 + now.minute * 60 + now.second)
# 添加缓存记录
cache.set(key, rewind_times, remain_second)
# 执行撤销操作
record = Swiped.objects.filter(uid=user.id).latest('stime')
# 撤销好友记录
Friend.break_off(user.id, record.sid)
record.delete()
else:
raise errors.RewindLimited('反悔次数达到每日上限')
def rewind(user, sid):
try:
Swiperd.objects.get(uid=user.id, sid=sid).delete()
except Swiperd.DoesNotExist:
pass
Friend.break_off(user.id, sid)
def remove_friend(request):
'''删除好友'''
friend_id = int(request.GET.get('friend_id'))
print(friend_id)
Friend.break_off(request.uid, friend_id)
return render_json()
