def get_limit_config(cls, report_type):
key = cls.REPORT_CONFIG % {'rtype': report_type}
if not Redis.exists(key):
cfg = cls.collection.find_one({'report_type': report_type})
_id = cfg and str(cfg['_id'])
Redis.set(key, _id, 86400)
return Redis.get(key)
def delete_model(self):
ret = super(Province, self).delete_model()
if ret:
key = self.ALL_PROVINCE_IDS
Redis.delete(key)
return ret
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(Province, self).create_model()
if _id:
key = self.ALL_PROVINCE_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 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 setUpClass(cls):
Redis.flushall()
if app.config.get('MONGO_DBNAME') in client.database_names():
client.drop_database(app.config.get('MONGO_DBNAME'))
print 'Create database(%s) for unittest ... ok' % (
app.config.get('MONGO_DBNAME'))
kw_path = app.config.get('BASE_DIR') or os.path.abspath(
os.path.join(app.root_path, '../'))
data_path = os.path.join(kw_path, 'wanx/tests/fixtures/')
for fname in os.listdir(data_path):
if not fname.startswith('.') and fname.endswith('.json'):
collection = fname.split('.')[0]
with open(os.path.join(data_path, fname), 'r') as f:
data = f.read()
if data:
data = bjson.loads(data.strip('\n'))
DB.create_collection(collection)
DB.get_collection(collection).insert_many(data)
print 'Create mysql database(%s) for unittest ... ok' % (MYDB.database)
sql = 'mysql -e "create database if not exists %s DEFAULT CHARACTER SET utf8 \
DEFAULT COLLATE utf8_general_ci;"' % (MYDB.database)
os.popen(sql)
for fname in os.listdir(data_path):
if not fname.startswith('.') and fname.endswith('.sql'):
sql_path = os.path.join(data_path, fname)
sql = 'mysql %s < %s' % (MYDB.database, sql_path)
os.popen(sql)
def create_model(self):
_id = super(Channels, self).create_model()
if _id:
key = self.ALL_CHANNELS_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 get_all_lives(cls):
"""所有直播间列表
"""
# 后台配置是否开启直播服务, 默认开启
api_url = Config.fetch('live_api_url', None, str)
if not api_url:
return []
api_url = urljoin(api_url, '/events')
lives = Redis.get(cls.ALL_LIVES)
if not lives:
try:
resp = requests.get(api_url, timeout=2)
except requests.exceptions.Timeout:
print_log('xlive', '[get_all_lives]: connection timeout')
return []
except:
print_log('xlive', '[get_all_lives]: connection error')
return []
if resp.status_code != requests.codes.ok:
print_log('xlive', '[get_all_lives]: status_code not ok')
return []
lives = resp.content
lives = json.loads(lives)['data']['live']
Redis.setex(cls.ALL_LIVES, 5, json.dumps(lives))
else:
lives = json.loads(lives)
# 按照人气排序
lives.sort(key=lambda x: x['count'], reverse=True)
return lives
def delete_model(self):
ret = super(Channels, self).delete_model()
if ret:
key = self.ALL_CHANNELS_IDS
Redis.delete(key)
return ret
def send_code(cls, phone):
ts = datetime.now().strftime('%Y%m%d%H%M%S')
sig_str = '%s%s%s' % (cls.sid, cls.token, ts)
sign = hashlib.md5(sig_str).hexdigest().upper()
code = random.randint(1000, 9999)
_send_uri = cls.send_uri % (cls.sid, sign)
url = '%s%s' % (cls.send_url, _send_uri)
data = dict(
to=phone,
appId=cls.appid,
templateId='1',
datas=[code, 10],
)
data = json.dumps(data)
headers = {
'Accept': 'application/json',
'Content-Type': 'application/json;charset=utf-8',
'Content-Length': len(data),
'Authorization': base64.b64encode('%s:%s' % (cls.sid, ts))
}
resp = requests.post(url, data=data, headers=headers)
if resp.status_code != requests.codes.ok:
return False
data = resp.json()
ret = data['statusCode'] == '000000'
if ret:
key = 'sms:code:%s' % (phone)
Redis.setex(key, 600, code)
return ret
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 verify_interval(cls, key, interval, valid_count):
count = Redis.incr(key)
Redis.expire(key, interval)
if count > valid_count:
return False
return True
def tearDownClass(cls):
Redis.flushall()
print 'Drop database(%s) for unittest ... ok' % (
app.config.get('MONGO_DBNAME'))
client.drop_database(app.config.get('MONGO_DBNAME'))
print 'Drop mysql database(%s) for unittest ... ok' % (MYDB.database)
sql = 'mysql -e "drop database if exists %s;"' % (MYDB.database)
os.popen(sql)
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 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(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 get_user_live_history(cls, uid):
today = datetime.date.today().strftime('%y%m%d')
key = cls.USER_LIVE_DAILY_HISTORY % {'today': today, 'uid': uid}
if not Redis.exists(key):
cls._load_user_live_history(uid, key)
logs = Redis.get(key)
history = cjson.loads(logs) if logs else []
return history
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 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 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 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 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_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_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)
