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_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 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 rewind(user):
"""
撤销上一次滑动操作记录
撤销上一次创建的好友关系
:param user:
:return:
"""
key = cache_keys.SWIPE_LIMIT_PREFIX.format(user.id)
swipe_times = cache.get(key, 0)
if swipe_times >= config.SWIPE_LIMIT:
raise errors.SwipeLimitError
swipe = Swiped.objects.filter(uid=user.id).latest('created_at')
if swipe.mark in ['lke', 'superlike']:
Friend.cancel_friends(swipe.uid, swipe.sid)
swipe.delete()
now = datetime.datetime.now()
timeout = (24 * 60 * 60) - now.hour * 3600 - now.minute * 60 - now.second
# n = int(time.time())
# timeout = 86400 - (n+ 8*3600) % 86400
cache.set(key, swipe_times + 1, timetout=timeout)
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 go_back(uid):
"""反悔操作逻辑实现 每天每个用户可以反悔3次"""
key = keys.BACK_TIME % uid
back_time = cache.get(key, 0)
if back_time >= config.BACK_TIME:
raise errors.BackLimitError
timeout = 86400 - (time.time() + 8 * 3600) % 86400
cache.set(key, back_time + 1, timeout)
# 根据时间字段查找出最近添加的滑动
try:
swiped = Swiped.objects.filter(uid=uid).latest('time')
# 反悔操作对积分进行恢复
score = config.SWIPE_SCORE.get(swiped.flag, 0)
cache_redis.zincrby(keys.HOTRANK, swiped.sid, -score)
except Swiped.DoesNotExist:
return None
# 已经建立好友关系则撤销
if swiped.flag in ['like', 'superlike']:
Friend.break_friend(uid1=uid, uid2=swiped.sid)
swiped.delete()
def superlike(user, sid):
Swiperd.mark(user.id, sid, 'superlike')
if Swiperd.is_liked(sid, user.id):
Friend.be_friends(user.id, sid)
return True
else:
return False
def superlike_someone(user, sid):
Swiped.like(user.id, sid)
if Swiped.is_liked(sid, user.id): # 检查对方是否喜欢过自己
Friend.make_friends(user.id, sid)
return True
else:
return False
def rewind(user):
"""
撤销当前登录用户的上传一次滑动操作
每天只能撤销三次
:param user:
:return:
"""
key = config.REWIND_CACHE_PREFIX % user.id
rewind_times = cache.get(key, 0)
if rewind_times >= config.REWIND_TIMES:
raise errors.RewindLimitError
swipe = Swiped.objects.filter(uid=user.id).latest('created_at')
if swipe.mark in ['like', 'superlike']:
Friend.cancel_friends(user.id, swipe.sid)
sub_swipe_score(swipe.mark, swipe.sid)
swipe.delete()
now = datetime.datetime.now()
timeout = 86400 - now.hour * 3600 - now.minute * 60 - now.second
cache.set(key, rewind_times + 1, timeout=timeout)
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):
"""
撤销上一次滑动操作
撤销上一次好友关系
:param user:
:return:
"""
key = cache_keys.SWIPE_LIMIT_PREFIX.format(user.id)
swipe_times = cache.get(key, 0)
if swipe_times >= config.SWIPE_LIMIT:
raise errors.SwipeLimitError
swipe = Swiped.objects.filter(uid=user.id).latest('create_at')
if swipe.mark in ['like', 'superlike']:
Friend.cancel_friend(swipe.uid, swipe.sid)
swipe.delete()
now_time = datetime.datetime.now()
timeout = 86400 - now_time.hour * 3600 - now_time.minute * 60 - now_time.second
cache.set(key, swipe_times + 1, timeout=timeout)
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 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 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(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 connect(request, operation, pk):
new_friend = User.objects.get(pk=pk)
if operation == 'add':
Friend.make_friend(request.user, new_friend)
elif operation == 'remove':
Friend.unfriend(request.user, new_friend)
return redirect('social:home')
def like(user, sid):
'''喜欢一个用户'''
Swiperd.mark(user.id, sid, 'like')
if Swiperd.is_liked(sid, user.id):
Friend.be_friends(user.id, sid)
return True
else:
return False
def superlike_some(uid, sid):
if not Users.objects.filter(id=sid).exists():
return False
ret = Swiped.swipe(uid=uid,sid=sid,mark='superlike')
if ret:
Friend.make_friend(uid,sid)
return ret
def superlike_someone(user, sid):
# 添加滑动记录
Swiper.swipe(user.id, sid, 'superlike')
# 检查对方是否喜欢过自己，如果互相喜欢就配对成好友
if Swiper.is_like(sid, user.id):
Friend.make_friend(user.id, sid)
return True
else:
return False
def superlike_someone(user,sid):
Swiped.superlike(user.id, sid) # 调用类方法modles.py的like(),创建滑动喜欢对象
# 检查对方是否喜欢你
if Swiped.is_like(sid, user.id):
Friend.make_friend(user.id, sid)
return True
else:
return False
def superlike(uid, sid):
# 创建一条记录
Swiped.superlike(uid, sid)
# 判断对方还是否喜欢我们
if Swiped.has_like(uid=sid, sid=uid):
# 如果是就建立好友关系
Friend.make_friend(uid1=uid, uid2=sid)
return True
return False
def like(uid, sid):
# 穿件一条记录
Swiped.like(uid, sid)
# 判断对方是否喜欢我们
if Swiped.has_like(uid=uid, sid=sid):
# 如果是,就建立好友关系
Friend.make_friend(uid1=uid, uid2=sid)
return True
return False
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 superlike(uid, sid):
'''超级喜欢'''
Swipe.superlike(uid, sid)
# 对方也喜欢我,添加好友
if Swipe.has_like_me(sid, uid):
uid1, uid2 = (uid, sid) if uid < sid else (sid, uid)
Friend.make_friends(uid1=uid1, uid2=uid2)
return True
return False
def superlike(uid, sid):
Swiped.superlike(uid, sid)
# 判断对方是否喜欢过我们,如果是,则建立好友关系,
if Swiped.has_like(uid=sid, sid=uid):
# 说明对方也喜欢你.建立好友关系
# 保证Friend中的uid1是比较小的id, uid2是大的id
Friend.make_friends(uid, sid)
return True
return False
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 like(user, sid):
'''喜欢一个用户'''
Swiped.mark(user.id, sid, 'like')
# 检查被滑动的用户是否喜欢过自己
if Swiped.is_liked(sid, user.id):
Friend.be_friends(user.id, sid)
return True
else:
return False
def superlike_someone(
user,
sid,
):
Swiped.mark(user.id, sid, 'superlike')
if not Swiped.is_liked(sid, user.id):
Friend.be_friends(user.id, sid)
return True
else:
return False
def superlike_someone(user, sid):
'''超级喜欢了某人'''
Swiped.swipe(user.id, sid, 'like') # 添加了滑动记录
# 检查是否互相喜欢过
if Swiped.is_like_me(user.id, sid):
Friend.make_friends(user.id, sid) # 创建好友关系
return True
else:
return False
