def delete_model(self):
ret = super(Province, self).delete_model()
if ret:
key = self.ALL_PROVINCE_IDS
Redis.delete(key)
return ret
def delete_model(self):
ret = super(Channels, self).delete_model()
if ret:
key = self.ALL_CHANNELS_IDS
Redis.delete(key)
return ret
def create_model(self):
_id = super(Province, self).create_model()
if _id:
key = self.ALL_PROVINCE_IDS
Redis.delete(key)
return _id
def create_model(self):
_id = super(VersionConfig, self).create_model()
if _id:
key = self.ALL_VERSION_IDS
Redis.delete(key)
return _id
def clear_gifts_num(cls, user, is_money):
pdict = {}
for p in Product.get_all_gifts():
pdict[p.product_id] = p.format()
uproducts = cls.get_user_products(str(user._id))
if is_money:
for up in uproducts:
if up.product_id not in pdict and not up.is_money:
continue
cls.update(num=0).where(
UserProduct.user_id == str(user._id),
UserProduct.is_money == is_money,
UserProduct.product_id == int(up.product_id)).execute()
key = USER_PRODUCT_KEY % (str(user._id))
Redis.delete(key)
return
else:
for up in uproducts:
if up.product_id not in pdict and up.is_money:
continue
cls.update(num=0).where(
UserProduct.user_id == str(user._id),
UserProduct.is_money == is_money,
UserProduct.product_id == int(up.product_id)).execute()
key = USER_PRODUCT_KEY % (str(user._id))
Redis.delete(key)
return
def update_model(self, data={}):
ret = super(Province, self).update_model(data)
if ret:
key = self.ALL_PROVINCE_IDS
Redis.delete(key)
return ret
def user_sub_obj_ids(cls, uid, page, pagesize, maxs):
skey = UserSubShow.SUB_SHOW_IDS % {'uid': uid}
gkey = UserSubGame.SUB_GAME_IDS % {'uid': uid}
key = cls.USER_SUB_IDS % {'uid': uid}
if not Redis.exists(skey):
UserSubShow._load_sub_show_ids(uid)
if not Redis.exists(gkey):
UserSubGame._load_sub_game_ids(uid)
# 始终合并以保证实时性
Redis.delete(key)
all_keys = list()
for k in [skey, gkey]:
try:
count = Redis.zcard(k)
except exceptions.ResponseError:
count = 0
count and all_keys.append(k)
all_keys and Redis.zunionstore(key, all_keys)
try:
if maxs:
ids = Redis.zrevrangebyscore(key, '(%.6f' % (maxs), '-inf', start=0, num=pagesize, withscores=True)
else:
start = (page - 1) * pagesize
stop = start + pagesize - 1
ids = Redis.zrevrange(key, start, stop, withscores=True)
except exceptions.ResponseError:
ids = []
return list(ids)
def update_model(self, data={}):
ret = super(Channels, self).update_model(data)
if ret:
key = self.ALL_CHANNELS_IDS
Redis.delete(key)
return ret
def create_model(self):
_id = super(Channels, self).create_model()
if _id:
key = self.ALL_CHANNELS_IDS
Redis.delete(key)
return _id
def do_task(worker, job):
from wanx.base.log import print_log
from wanx.base.xredis import Redis
from wanx.models.video import UserFaverVideo
from wanx.models.user import User
data = job.data
# 记录日志
print_log('modify_video', data)
data = json.loads(data)
vid = data['vid']
# action = data['action']
# delta_count = 0
# if action == 'offline':
# delta_count = -1
# elif action == 'online':
# delta_count = 1
# 更新收藏了此视频的用户计数
uids = UserFaverVideo.favor_video_uids(vid)
for uid in uids:
user = User.get_one(uid, check_online=False)
if user:
key = UserFaverVideo.FAVER_VIDEO_IDS % ({'uid': uid})
Redis.delete(key)
count = UserFaverVideo.faver_video_count(uid)
user.update_model({'$set': {'favor_count': count}})
return ''
def delete_model(self):
ret = super(VersionConfig, self).delete_model()
if ret:
key = self.ALL_VERSION_IDS
Redis.delete(key)
return ret
def update_model(self, data={}):
ret = super(VersionConfig, self).update_model(data)
if ret:
key = self.ALL_VERSION_IDS
Redis.delete(key)
return ret
def refresh_daily_tasks(cls, user_id):
_tasks = []
for task in Task.get_daily_tasks():
tmp = dict(user_id=user_id,
task_id=task.task_id,
task_type=task.task_type,
action=task.action)
# 每日签到任务自动完成
if task.action == DAILY_SIGNIN:
tmp['task_status'] = FINISHED
tmp['finish_num'] = 1
_tasks.append(tmp)
with MYDB.atomic():
# 删除旧的每日任务
cls.delete().where(UserTask.user_id == user_id,
UserTask.task_type == 2).execute()
# 增加新的每日任务
if _tasks:
UserTask.insert_many(_tasks).execute()
# 修改任务刷新时间
UserCredit.update(task_at=datetime.datetime.now()).where(
UserCredit.user_id == user_id).execute()
key = USER_TASK_KEY % (user_id)
Redis.delete(key)
def delete_model(self):
ret = super(Live_Activity, self).delete_model()
if ret:
key = self.LIVE_HOT_USER % ({'aid': str(self.activity_id)})
Redis.delete(key)
key = self.LIVE_NEW_USER % ({'aid': str(self.activity_id)})
Redis.delete(key)
return ret
def update_model(self, data={}):
obj = super(Live_Activity, self).update_model(data)
if obj:
key = self.LIVE_HOT_USER % ({'aid': str(self.activity_id)})
Redis.delete(key)
key = self.LIVE_NEW_USER % ({'aid': str(self.activity_id)})
Redis.delete(key)
return obj
def create_model(self):
_id = super(Live_Activity, self).create_model()
if _id:
key = self.LIVE_HOT_USER % ({'aid': str(self.activity_id)})
Redis.delete(key)
key = self.LIVE_NEW_USER % ({'aid': str(self.activity_id)})
Redis.delete(key)
return _id
def create_model(self):
aid = 'all'
phone = self.phone
device = self.device
for k, xid in {'phone': phone, 'device': device}.iteritems():
key = self.USER_ACTIVITY % ({'aid': aid, 'xid': xid})
Redis.delete(key)
return super(UserShareActivityLog, self).create_model()
def update_model(self, data={}):
ret = super(Config, self).update_model(data)
if ret:
cache_key = self.CONFIG_PREFIX % (self.key)
Redis.delete(cache_key)
cache_key = self.CONFIG_PREFIX % (ret.key)
Redis.delete(cache_key)
return ret
def delete_model(self):
ret = self.collection.delete_one({"_id": ObjectId(self._id)})
key = self.OBJECT_KEY % ({
'name': self.__class__.__name__.lower(),
'oid': str(self._id)
})
Redis.delete(key)
return ret.deleted_count
def delete_model(self):
ret = super(ActivityComment, self).delete_model()
if ret:
key = self.ACTIVITY_COMMENT_IDS % ({'aid': str(self.activity)})
try:
Redis.zrem(key, str(self._id))
except exceptions.ResponseError:
Redis.delete(key)
return ret
def update_model(self, data={}):
ret = super(HomeCategoryConfig, self).update_model(data)
if ret:
key = self.CATEGORY_OBJ_IDS % ({'cate_id': str(self.category)})
Redis.delete(key)
if self.category != ret.category:
key = self.CATEGORY_OBJ_IDS % ({'cate_id': str(ret.category)})
Redis.delete(key)
return ret
def test_cached_set(self):
self._cached_set()
self.assertEqual(Redis.get(self.SET_KEY), 'empty')
with self.assertRaises(exceptions.ResponseError):
Redis.sadd(self.SET_KEY, ('dog', 'pig'))
Redis.delete(self.SET_KEY)
self._cached_set(('dog', 'pig'))
self.assertTrue(Redis.sismember(self.SET_KEY, 'dog'))
self.assertTrue(Redis.sismember(self.SET_KEY, 'pig'))
def test_cached_zset(self):
self._cached_zset()
self.assertEqual(Redis.get(self.ZSET_KEY), 'empty')
with self.assertRaises(exceptions.ResponseError):
Redis.zadd(self.ZSET_KEY, 1, 'dog', 2, 'pig')
Redis.delete(self.ZSET_KEY)
self._cached_zset((1, 'dog', 2, 'pig'))
self.assertListEqual(Redis.zrevrange(self.ZSET_KEY, 0, -1),
['pig', 'dog'])
def test_cached_list(self):
self._cached_list()
self.assertEqual(Redis.get(self.LIST_KEY), 'empty')
with self.assertRaises(exceptions.ResponseError):
Redis.rpush(self.SET_KEY, ['dog', 'pig'])
Redis.delete(self.SET_KEY)
self._cached_list(['dog', 'pig'])
self.assertListEqual(Redis.lrange(self.LIST_KEY, 0, -1),
['dog', 'pig'])
def delete_model(self):
ret = super(DaTangVideo, self).delete_model()
if ret:
key = self.USER_GAME_VIDEO_IDS % ({'uid': str(self.author), 'gid': str(self.game)})
try:
Redis.zrem(key, str(self._id))
except exceptions.ResponseError:
Redis.delete(key)
return ret
def delete_model(self):
ret = super(UserPopularGame, self).delete_model()
if ret:
key = self.POP_GAME_IDS % ({'uid': str(self.source)})
try:
Redis.zrem(key, str(self.target))
except exceptions.ResponseError:
Redis.delete(key)
return ret
def update_model(self, data={}):
data = data or self
self.collection.update_one({'_id': self._id}, data)
key = self.OBJECT_KEY % ({
'name': self.__class__.__name__.lower(),
'oid': str(self._id)
})
Redis.delete(key)
obj = self._load_object(str(self._id))
return obj
def create_model(self):
_id = super(UserPopularGame, self).create_model()
if _id:
key = self.POP_GAME_IDS % ({'uid': str(self.source)})
try:
if Redis.exists(key):
Redis.zadd(key, self.create_at, str(self.target))
except exceptions.ResponseError:
Redis.delete(key)
return _id
def create_model(self):
_id = super(ActivityComment, self).create_model()
if _id:
key = self.ACTIVITY_COMMENT_IDS % ({'aid': str(self.activity)})
# 列表为空时key对应的value是一个string
try:
if Redis.exists(key):
Redis.zadd(key, self.create_at, str(_id))
except exceptions.ResponseError:
Redis.delete(key)
return _id
def delete_removed_tasks(cls, user_id):
# 删除任务已被移除的用户任务
need_to_delete = False
for utask in cls.get_user_tasks(user_id):
if Task.get_task(utask.task_id) is None:
utask.delete_instance()
need_to_delete = True
if need_to_delete:
key = USER_TASK_KEY % (user_id)
Redis.delete(key)