def all_version_ids(cls):
key = cls.ALL_VERSION_IDS
if not Redis.exists(key):
cls._load_all_version_ids()
try:
_ids = Redis.lrange(key, 0, -1)
except exceptions.ResponseError:
_ids = []
return list(_ids)
def all_province_ids(cls):
key = cls.ALL_PROVINCE_IDS
if not Redis.exists(key):
cls._load_all_province_ids()
try:
_ids = Redis.lrange(key, 0, -1)
except exceptions.ResponseError:
_ids = []
return list(_ids)
def user_red_packets(cls, uid):
key = cls.USER_REDPACKET_IDS % ({'uid': uid})
if not Redis.exists(key):
cls._load_user_redpackets(uid)
try:
ids = Redis.lrange(key, 0, -1)
except exceptions.ResponseError:
ids = []
return list(ids)
def all_banners_by_version(cls):
key = cls.ALL_BANNERS_BY_VERSION
if not Redis.exists(key):
cls._load_all_banner_version()
try:
bids = Redis.lrange(key, 0, -1)
except exceptions.ResponseError:
bids = []
return list(bids)
def get_banner_title_color(cls):
key = cls.TITLE_COLOR
if not Redis.exists(key):
cls._load_banner_title_color()
try:
tids = Redis.lrange(key, 0, -1)
except exceptions.ResponseError:
tids = []
return list(tids)
def module_game_ids(cls, mid):
key = cls.ALL_IDS % ({'mid': mid})
if not Redis.exists(key):
cls._load_module_game_ids(mid)
try:
gids = Redis.lrange(key, 0, -1)
except exceptions.ResponseError:
gids = []
return list(gids)
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 all_banner_ids(cls):
key = cls.ALL_BANNER_IDS
if not Redis.exists(key):
cls._load_all_banner_ids()
try:
bids = Redis.lrange(key, 0, -1)
except exceptions.ResponseError:
bids = []
return list(bids)
def all_hot_words(cls):
key = cls.ALL_HOT_WORDS
if not Redis.exists(key):
cls._load_all_hot_words()
try:
_ids = Redis.lrange(key, 0, -1)
except exceptions.ResponseError:
_ids = []
return list(_ids)
def category_object_ids(cls, cate_id):
key = cls.CATEGORY_OBJ_IDS % ({'cate_id': cate_id})
if not Redis.exists(key):
cls._load_category_object_ids(cate_id)
try:
cate_ids = Redis.lrange(key, 0, -1)
except exceptions.ResponseError:
cate_ids = []
return list(cate_ids)
def all_ids(cls):
key = cls.ALL_IDS
if not Redis.exists(key):
cls._load_live_redpackets()
try:
ids = Redis.lrange(key, 0, -1)
except exceptions.ResponseError:
ids = []
return list(ids)
def get_user_gift_code_ids(cls, uid):
key = USER_GIFT_CODE_KEY % {'uid': uid}
if not Redis.exists(key):
cls._load_user_gift_code_ids(uid)
try:
ids = Redis.lrange(key, 0, -1)
except:
ids = []
return ids
def get_history_live(cls, uid):
key = cls.USER_HISTORY_LIVE % {'uid': uid}
if not Redis.exists(key):
cls._load_history_live(uid, key)
try:
_ids = Redis.lrange(key, 0, -1)
except exceptions.ResponseError:
_ids = []
return list(_ids)
def category_game_ids(cls, cid):
key = cls.CATEGORY_GAME_IDS % ({'cid': cid})
if not Redis.exists(key):
cls._load_category_game_ids(cid)
try:
gids = Redis.lrange(key, 0, -1)
except exceptions.ResponseError:
gids = []
return list(gids)
def recommend_sub_ids(cls):
key = cls.GAME_RECOMMEND_SUBSCRIBE
if not Redis.exists(key):
cls._load_recommend_sub_ids()
try:
gids = Redis.lrange(key, 0, -1)
except exceptions.ResponseError:
gids = []
return list(gids)
def hot_game_ids(cls):
key = cls.HOT_GAME_IDS
if not Redis.exists(key):
cls._load_hot_game_ids()
try:
gids = Redis.lrange(key, 0, -1)
except exceptions.ResponseError:
gids = []
return list(gids)
def vip_giftcode_ids(cls, vid):
key = cls.ALL_IDS % ({'vid': vid})
if not Redis.exists(key):
cls._load_giftcode_ids(vid)
try:
gids = Redis.lrange(key, 0, -1)
except exceptions.ResponseError:
gids = []
return list(gids)
def chess_game_ids(cls, tpid):
key = cls.ALL_IDS % ({'cid': tpid})
if not Redis.exists(key):
cls._load_game_ids(tpid)
try:
gids = Redis.lrange(key, 0, -1)
except exceptions.ResponseError:
gids = []
return list(gids)
def get_banner_bottom_photo(cls):
key = cls.BOTTOM_PHOTO
if not Redis.exists(key):
cls._load_banner_bottom_photo()
try:
bids = Redis.lrange(key, 0, -1)
except exceptions.ResponseError:
bids = []
return list(bids)
def get_live_tids(cls):
key = cls.LIVE_TASKS
if not Redis.exists(key):
cls._load_live_tasks()
try:
ids = Redis.lrange(key, 0, -1)
except exceptions.ResponseError:
ids = []
return list(ids)
def all_category_ids(cls):
key = cls.ALL_CATEGORYS_IDS
if not Redis.exists(key):
cls._load_all_category_ids()
try:
cate_ids = Redis.lrange(key, 0, -1)
except exceptions.ResponseError:
cate_ids = []
return list(cate_ids)
def all_ad_ids(cls):
key = cls.ALL_AD_IDS
if not Redis.exists(key):
cls._load_all_ad_ids()
try:
ad_ids = Redis.lrange(key, 0, -1)
except exceptions.ResponseError:
ad_ids = []
return list(ad_ids)
def all_module_ids(cls):
key = cls.ALL_MODULE_IDS
if not Redis.exists(key):
cls._load_all_module_ids()
try:
mids = Redis.lrange(key, 0, -1)
except exceptions.ResponseError:
mids = []
return list(mids)
def all_channel_ids(cls, sid):
key = cls.SHOW_CHANNEL_IDS % {'sid': sid}
if not Redis.exists(key):
cls._load_show_channels(sid)
try:
ids = Redis.lrange(key, 0, -1)
except exceptions.ResponseError:
ids = []
return list(ids)
def all_channels_ids(cls):
key = cls.ALL_CHANNELS_IDS
if not Redis.exists(key):
cls._load_all_channels_ids()
try:
_ids = Redis.lrange(key, 0, -1)
except exceptions.ResponseError:
_ids = []
return list(_ids)
def all_module_game_ids(cls, module_id):
key = cls.ALL_MODULE_GAME_IDS.format(module_id=module_id)
if not Redis.exists(key):
cls._load_all_module_game_ids(module_id)
try:
mids = Redis.lrange(key, 0, -1)
except exceptions.ResponseError:
mids = []
return list(mids)
def popup_platform_ids(cls, os):
key = cls.POPUP_PLATFORM % ({'os': os})
if not Redis.exists(key):
cls._load_popup_platform_ids(os)
try:
pids = Redis.lrange(key, 0, -1)
except exceptions.ResponseError:
pids = []
return list(pids)
def top_video_ids(cls, aid, sort):
key = cls.TOP_COMPETE_VIDEO_IDS % ({'aid': aid})
if not Redis.exists(key):
cls._load_top_video_ids(aid, sort)
try:
tids = Redis.lrange(key, 0, -1)
except exceptions.ResponseError:
tids = []
return list(tids)
def game_hotvideo_ids(cls, gid, page, pagesize, maxs=None):
key = cls.GAME_HOTVIDEO_IDS % ({'date': time.strftime("%Y%m%d"), 'gid': gid})
if not Redis.exists(key):
cls._load_game_hotvideo_ids(gid)
try:
start = (page - 1) * pagesize if page else 0
stop = (start + pagesize - 1) if pagesize else -1
ids = Redis.lrange(key, start, stop)
except exceptions.ResponseError:
ids = []
return list(ids)
def get_show_ids(cls, page, pagesize):
key = cls.ALL_IDS
if not Redis.exists(key):
cls._load_all_ids()
try:
start = (page - 1) * pagesize
stop = start + pagesize - 1
ids = Redis.lrange(key, start, stop)
except exceptions.ResponseError:
ids = []
return list(ids)
