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 get_user(uid):
"""获取用户详细信息 (GET)
:uri: /users/<string:uid>
:returns: object
"""
user = User.get_one(uid)
if not user:
return error.UserNotExist
user_lives = Xlive.get_user_lives(uid)
live_ids = [ul['event_id'] for ul in user_lives]
user_info = user.format()
user_info.update({'live_id': live_ids[0] if live_ids else ''})
# 如果是登录用户自己返回货币信息
if request.authed_user and str(request.authed_user._id) == uid:
uc = UserCredit.get_or_create_user_credit(user_id=uid)
uproducts = UserProduct.get_user_products(str(uid))
gift_num = sum([up.num for up in uproducts])
user_info.update({
'gem': uc.gem,
'gold': uc.gold,
'gift_num': gift_num
})
return user_info
def validate(self):
if not form.Form.validate(self):
return False
if not self.user.data and not self.phone.data:
self.phone.errors.append(u'用户和手机号必须要填一个')
user1 = User.get_one(self.user.data) if self.user.data else None
user2 = User.get_by_phone(self.phone.data) if self.phone.data else None
if self.user.data and not user1:
self.user.errors.append(u'用户不存在')
return False
if self.phone.data and not user2:
self.phone.errors.append(u'用户不存在')
return False
if self.phone.data and self.user.data:
if user1 != user2:
self.user.errors.append(u'用户字段和手机号字段对应的用户不匹配')
self.phone.errors.append(u'用户字段和手机号字段对应的用户不匹配')
return False
user = user1 or user2
if UserGroup.user_in_group(str(self.group.data), str(user._id)):
if user1:
self.user.errors.append(u'该组已包含此用户')
if user2:
self.phone.errors.append(u'该组已包含此用户')
return False
return True
def follow_user():
"""关注用户 (GET|POST&LOGIN)
:uri: /user/opt/follow-user
:param target_user_id: 被关注用户id
:returns: {}
"""
user = request.authed_user
params = request.values
target_uid = params.get('target_user_id', None)
target_user = User.get_one(target_uid)
if not target_user:
return error.UserNotExist
if target_uid == str(user._id):
return error.FollowFailed("不能关注自己哦")
fs = FriendShip.get_by_ship(str(user._id), target_uid)
if not fs:
key = 'lock:follow:%s:%s' % (str(user._id), target_uid)
with util.Lockit(Redis, key) as locked:
if locked:
return error.FollowFailed
fs = FriendShip.init()
fs.source = ObjectId(str(user._id))
fs.target = ObjectId(target_uid)
fs.create_model()
# 关注主播任务检查
if user:
UserTask.check_user_tasks(str(user._id), FOLLOW_USER, 1)
return {}
def format(self):
from wanx.models.user import User
from wanx.models.comment import Comment
from wanx.models.video import Video
operator = User.get_one(str(self.operator), check_online=False)
if self.ctype == 'comment':
obj = Comment.get_one(str(self.obj_id), check_online=False)
obj = obj and obj.format()
elif self.ctype == 'video':
obj = Video.get_one(str(self.obj_id), check_online=False)
obj = obj and obj.format()
elif self.ctype == 'reply':
obj = Reply.get_one(str(self.obj_id), check_online=False)
comment_id = obj and str(obj.comment)
obj = obj and obj.format()
if obj:
comment = Comment.get_one(comment_id, check_online=False)
obj['video_id'] = comment.video and str(comment.video)
else:
obj = None
data = {
'msg_id': str(self._id),
'ctype': self.ctype,
'obj': obj,
'action': self.action,
'operator': operator and operator.format(),
'create_at': self.create_at
}
return data
def get_export_csv(self):
if not self.export_columns:
self.export_columns = [
column_name for column_name, _ in self._list_columns
]
io = StringIO()
rows = csv.DictWriter(io, self.export_columns)
data = self._get_data_for_export()
rows.writeheader()
for item in data:
row = dict()
for column in self.export_columns:
if column == 'author':
obj = User.get_one(item[column], check_online=False)
item[column] = obj.nickname
elif column == 'activity':
obj = ActivityConfig.get_one(item[column],
check_online=False)
item[column] = obj.name
elif column == 'create_at':
item[column] = datetime.fromtimestamp(
item[column]).strftime('%Y-%m-%d %H:%M:%S')
elif column not in item:
item[column] = None
row.update({column: unicode(item[column]).encode("utf8")})
# print row
rows.writerow(row)
io.seek(0)
return io.getvalue()
def format(self):
author = User.get_one(str(self.author), check_online=False)
data = {
'activity_video': str(self._id),
'activity_id': self.activity_id,
'video_id': self.video_id,
'author': author and author.format(),
'title': self.title,
'cover': urljoin(app.config.get("MEDIA_URL"), self.cover),
'url': '%s/videos/%s/play' % (app.config.get('SERVER_URL'), self.video_id),
'vv': self.vv,
'vote': self.vote,
'like_count': self.like_count,
'comment_count': self.comment_count,
'duration': self.duration and int(self.duration),
'create_at': self.create_at,
'is_voted': False,
'top': self.top_author if self.top_author else None
}
uid = request.authed_user and str(request.authed_user._id)
device = request.values.get('device', None)
is_voted = True if VoteVideo.get_vote(uid, device, self.video_id) else False
data['is_voted'] = is_voted
return data
def format(cls, live, exclude_fields=[]):
user_ex_fields = []
game_ex_fields = []
for field in exclude_fields:
if field.startswith('user__'):
_, _field = field.split('__')
user_ex_fields.append(_field)
elif field.startswith('game__'):
_, _field = field.split('__')
game_ex_fields.append(_field)
ut = request.values.get("ut", None)
uid = User.uid_from_token(ut)
user_id = live.get('user_id', None)
from wanx.models.home import Share
share_title = None
if str(user_id) == uid:
share_title = Share.get_by_self_live().title
else:
share_title = Share.get_by_others_live().title
game = Game.get_one(str(live['game_id']), check_online=False)
user = User.get_one(str(live['user_id']), check_online=False)
live['user'] = user and user.format(exclude_fields=user_ex_fields)
live['game'] = game and game.format(exclude_fields=game_ex_fields)
live['from_following'] = live.get('from_following', False)
live['share_title'] = share_title
# 强行移除ut
live.pop('ut', None)
return live
def format_user_phone(view, context, model, name):
_value = model.get('source', None)
obj = User.get_one(str(_value), check_online=False)
if obj:
_value = '%s' % (obj.phone)
else:
_value = u'用户不存在'
return _value
def format(self):
author = User.get_one(str(self.user_id), check_online=False)
data = {
'author': author and author.format(),
'content': self.content,
'duration': self.duration,
'create_at': self.create_at,
}
return data
def process_form_data(self, data):
if data['phone'] and not data['user']:
user = User.get_by_phone(data['phone'])
data['user'] = user._id
if data['user'] and not data['phone']:
user = User.get_one(data['user'])
data['phone'] = user.phone
return data
def format(self):
from wanx.models.user import User
sender = User.get_one(str(self.sender), check_online=False)
data = {
'msg_id': str(self._id),
'sender': sender and sender.format(),
'content': Spam.replace_words(self.content),
'create_at': self.create_at
}
return data
def do_task(worker, job):
from wanx.base.log import print_log
from wanx.base import const
from wanx.models.video import Video
from wanx.models.user import User
from wanx.models.game import Game
data = job.data
# 记录日志
print_log('create_live_video', data)
data = json.loads(data)
# 记录日志
print_log('create_live_video',
'%s ==========================> Start' % (data['event_id']))
user = User.get_one(data['user_id'], check_online=False)
if not user:
return ''
game = Game.get_one(data['game_id'], check_online=False)
if not game:
return ''
video_id = Video.get_video_by_event_id(data['event_id'], str(user._id))
video = Video.get_one(str(video_id), check_online=False)
if not video:
video = Video.init()
video.author = ObjectId(data['user_id'])
video.game = ObjectId(data['game_id'])
video.title = data['title']
video.duration = data['duration']
video.ratio = data['ratio']
video.cover = data['cover']
video.url = data['url']
video.event_id = data['event_id']
video.status = const.ONLINE
video.create_model()
else:
data['author'] = ObjectId(data.pop('user_id'))
data['game'] = ObjectId(data.pop('game_id'))
video.update_model({'$set': data})
# 记录日志
print_log('create_live_video',
'%s ==========================> Finished' % (data['event_id']))
from wanx.models.activity import Battle
battle = Battle.get_live_battle(
data['user_id'],
data['title'].decode('unicode-escape').encode('utf-8'), None)
if battle:
Battle.set_video_id(battle['_id'], video_id)
return ''
def format(self):
_reply = Reply.get_one(str(self.reply), check_online=False)
from_user = User.get_one(str(self.owner), check_online=False)
to_user = User.get_one(str(_reply.owner),
check_online=False) if _reply else None
data = {
'reply_id':
str(self._id),
'reply_from':
from_user and from_user.format(exclude_fields=['is_followed']),
'reply_to':
to_user and to_user.format(exclude_fields=['is_followed']),
'content':
self.content,
'reply_count':
self.reply_count or 0,
'create_at':
self.create_at
}
return data
def format_user(view, context, model, name):
model = model if isinstance(model, dict) else model_to_dict(model)
_value = model.get(name, None)
obj = User.get_one(str(_value), check_online=False)
if obj:
_value = '%s (%s)' % (obj.nickname, _value)
html = u'<a href="/admin/usersview/?flt1_0=%s">%s</a>' % (str(
obj._id), _value)
_value = widgets.HTMLString(html)
else:
_value = u'用户不存在'
return _value
def format(self):
product = Product.get_product(self.product_id)
data = {
'from_user':
User.get_one(
self.from_user).format(exclude_fields=['is_followed']),
'product':
product and product.format(),
'num':
self.num,
'create_at':
util.datetime2timestamp(self.create_at)
}
return data
def format(self):
author = User.get_one(str(self.author), check_online=False)
uid = request.authed_user and str(request.authed_user._id)
data = {
'author': author and author.format(),
'comment_id': str(self._id),
'activity_id': self.activity and str(self.activity),
'content': self.content,
'create_at': self.create_at,
'like': self.like or 0,
'liked': UserLikeActivityComment.get_by_ship(uid, str(
self._id)) is not None if uid else False,
}
return data
def register_phone():
"""用户手机注册 (GET|POST)
:uri: /users/register_phone
:param phone: 手机号
:param password: 密码
:param nickname: 昵称
:param code: 短信验证码
:param gender: 性别(可选)(1:男, 2:女)
:returns: {'user': object, 'ut': string}
"""
params = request.values
phone = params.get('phone', None)
code = params.get('code', None)
password = params.get("password", None)
nickname = params.get("nickname", None)
gender = params.get("gender", 0)
if not phone or not code or not password or not nickname:
return error.InvalidArguments
invalid_error = User.invalid_password(password)
if invalid_error:
return invalid_error
invalid_error = User.invalid_nickname(nickname)
if invalid_error:
return invalid_error
if User.get_by_phone(phone):
return error.UserExists
if not SMS.verify_code(phone, code):
return error.VerifyCodeFailed
user = User.init()
name = '$mb$%s%s' % (phone[-4:], random.randint(1000, 9999))
user.name = name
user.phone = phone
user.nickname = nickname
user.gender = gender
salt = os.urandom(const.PWD_HASH_LEN)
pwd = User.gen_pwd_hash(password, salt)
user._salt = Binary(salt)
user._password = Binary(pwd)
uid = user.create_model()
new_user = User.get_one(uid)
token = User.gen_token(str(uid))
return {'user': new_user.format(), 'ut': token}
def format_log(self):
product = Product.get_product(self.product_id)
uid = self.user_id if 'user_id' in self.__dict__[
'_data'] else self.from_user
user = User.get_one(uid)
data = {
'user': user and user.format(exclude_fields=['is_followed']),
'product': product and product.format(),
'num': self.daily_sum,
'credit_type': self.credit_type,
'credit_value': self.credit_value,
'send_success': self.send_success,
'create_at': util.datetime2timestamp(self.create_at)
}
return data
def live_hot_user(aid):
"""获取热门主播
:uri: activity/live/hot_user/<string:aid>
:param maxs: 分页标示, 0最新
:param nbr: 每页数量
:returns: {'hot_users': list, 'end_page': bool, 'maxs': long}
"""
params = request.values
maxs = params.get('maxs', 0)
maxs = time.time() * 10000000000 if maxs is not None and int(
float(maxs)) == 0 else maxs and float(maxs)
pagesize = int(params.get('nbr', 10))
activity_config = ActivityConfig.get_one(aid, check_online=True)
if not activity_config:
return error.ActivityNotExist
hot_users = list()
while len(hot_users) < pagesize:
user_scores = Live_Activity.get_live_hot_user(aid, pagesize,
activity_config.begin_at,
activity_config.end_at,
maxs)
for us in user_scores:
user = User.get_one(str(us[0]), check_online=True)
if user:
total_gold = UserGiftLog.get_user_total_gold(
str(us[0]), activity_config.begin_at,
activity_config.end_at)
hot_users.append({
'user': user.format(),
'gold': total_gold,
'top': us[2]
})
# 如果按照maxs分页, 不足pagesize个记录则继续查询
obj = user_scores[-1] if user_scores else None
maxs = obj[1] if obj else time.time() * 10000000000
if len(user_scores) < pagesize:
break
return {
'hot_users': hot_users,
'end_page': len(hot_users) != pagesize,
'maxs': maxs
}
def create_model(self):
_id = super(UserSubGame, self).create_model()
if _id:
# 更新游戏订阅人数
game = Game.get_one(str(self.target), check_online=False)
game.update_model({'$inc': {'sub_count': 1}})
# 更新用户订阅游戏数量
from wanx.models.user import User
user = User.get_one(str(self.source), check_online=False)
user.update_model({'$inc': {'subscription_count': 1}})
key = self.SUB_GAME_IDS % ({'uid': str(self.source)})
# 订阅后需要删除Redis缓存以便与订阅游戏合并
Redis.delete(key)
return _id
def get_export_csv(self):
if not self.export_columns:
self.export_columns = [
column_name for column_name, _ in self._list_columns
]
io = StringIO()
rows = csv.DictWriter(io, self.export_columns)
data = self._get_data_for_export()
rows.writeheader()
for item in data:
row = dict()
for column in self.export_columns:
if column == 'phone':
obj = User.get_one(item['source'], check_online=False)
item[column] = obj.phone
elif column == 'create_at':
item[column] = util.timestamp2str(item['column'])
elif column == 'status':
_value = item[column]
if _value is None or int(
_value) == const.TRAFFIC_RECEIVED_SUCCESS:
_value = u'流量到账成功'
elif int(_value) == const.TRAFFIC_FAIL:
_value = u'充值失败'
elif int(_value) == const.TRAFFIC_RECEIVED_PROCESS:
_value = u'流量到账正在处理中'
elif int(_value) == const.TRAFFIC_SUCCESS:
_value = u'充值成功'
elif int(_value) == const.TRAFFIC_PROCESS:
_value = u'充值中'
item[column] = _value
elif column not in item:
item[column] = None
row.update({column: unicode(item[column]).encode("utf8")})
# print row
rows.writerow(row)
io.seek(0)
return io.getvalue()
def ban_user(self):
result = {"status": 0, "errmsg": "成功"}
values = request.values
user_id = values.get("user_id", None)
day_choice = values.get("day_choice", None)
ban_days = values.get("ban_days", None)
limits = values.getlist("limits[]", None)
reason = values.get("reason", None)
if filter(lambda x: x is None, [user_id, day_choice, ban_days, limits, reason]):
return jsonify({"status": -10001, "errmsg": "参数错误"})
try:
day_choice = int(day_choice)
ban_days = int(ban_days)
limits = sorted([int(i) for i in limits])
except:
return jsonify({"status": -10001, "errmsg": "参数错误1"})
now = datetime.datetime.now()
days = (7, 15, 182, 36524, ban_days)
lift_day = now + datetime.timedelta(days=days[day_choice])
lift_at = time.mktime(lift_day.timetuple())
user = User.get_one(user_id)
create_mode = user['status'] == 0
User.user_bans(user_id, lift_at, limits, reason)
# 给被封禁用户发送私信
if create_mode:
mode = u"因违反社区规则您的帐号已被封禁"
else:
mode = u"您的帐号封禁状态被修改"
limits_txts = (u"禁止开直播", u"禁止上传视频", u"禁止发评论/弹幕",
u"禁止私信", u"禁止登录")
limits_str = u"、".join([limits_txts[i] for i in limits])
msg = u"{5}，封禁原因为：{0}，解封日期为{1}年{2}月{3}日，在此期间您将被限制{4}。"
content = msg.format(reason, lift_day.year, lift_day.month, lift_day.day, limits_str, mode)
sysmsg = SysMessage.init()
sysmsg.title = u"用户封禁通知"
sysmsg.owner = ObjectId(user_id)
sysmsg.content = content
_id = sysmsg.create_model()
return jsonify(result)
def register():
"""用户注册 (GET|POST)
:uri: /users/register
:param name: 用户名
:param password: 密码
:param nickname: 昵称
:returns: {'user': object, 'ut': string}
"""
params = request.values.to_dict()
name = params.get("name", None)
# delete password from data so that we don't save it to mongo
password = str(params.pop("password", None))
nickname = params.get('nickname', None)
if not name or not password or not nickname:
return error.InvalidArguments
invalid_error = User.invalid_password(password)
if invalid_error:
return invalid_error
invalid_error = User.invalid_nickname(nickname)
if invalid_error:
return invalid_error
if User.get_by_name(name):
return error.UserExists
user = User.init()
user.update(params)
salt = os.urandom(const.PWD_HASH_LEN)
pwd = User.gen_pwd_hash(password, salt)
user._salt = Binary(salt)
user._password = Binary(pwd)
uid = user.create_model()
new_user = User.get_one(uid)
# 初始化用户任务
UserTask.create_and_init_user_tasks(str(new_user._id))
token = User.gen_token(str(uid))
return {'user': new_user.format(), 'ut': token}
def delete_model(self):
ret = super(UserSubGame, self).delete_model()
if ret:
# 更新游戏订阅人数
game = Game.get_one(str(self.target), check_online=False)
game.update_model({'$inc': {'sub_count': -1}})
# 更新用户订阅游戏数量
from wanx.models.user import User
user = User.get_one(str(self.source), check_online=False)
user.update_model({'$inc': {'subscription_count': -1}})
key = self.SUB_GAME_IDS % ({'uid': str(self.source)})
try:
Redis.zrem(key, str(self.target))
except exceptions.ResponseError:
Redis.delete(key)
return ret
def certify():
"""实名认证 (GET|POST)
:uri: /users/certify
:param name: 用户名
:param user_id: 用户ID
:param ID_number: 身份证号码
:returns: {'uid': uid}
"""
ut = request.values.get("ut", None)
user_id = User.uid_from_token(ut)
params = request.values.to_dict()
name = params.get("name", None)
ID_number = params.get("ID_number", None)
kwargs = dict()
if 'ut' in params.keys():
kwargs['user_id'] = ObjectId(user_id)
kwargs['content'] = ''
kwargs['ID_number'] = ID_number
kwargs['status'] = '2'
kwargs['name'] = name
if not name or not ID_number:
return error.InvalidArguments
if not User.get_one(ObjectId(user_id)):
return error.UserNotExist
user_certify = UserCertify.get_untreated_user_certify(user_id)
if user_certify:
user = user_certify
user.update(kwargs)
uid = user.edit_model()
else:
user = UserCertify.init()
user.update(kwargs)
uid = user.create_model()
return {'uid': uid}
def live_new_user(aid):
"""获取新秀主播
:uri: activity/live/new_user/<string:aid>
:param maxs: 分页标示, 0最新
:param nbr: 每页数量
:returns: {'new_users': list, 'end_page': bool, 'maxs': long}
"""
params = request.values
maxs = params.get('maxs', 0)
maxs = time.time() if maxs is not None and int(
float(maxs)) == 0 else maxs and float(maxs)
pagesize = int(params.get('nbr', 10))
activity_config = ActivityConfig.get_one(aid, check_online=True)
if not activity_config:
return error.ActivityNotExist
users = list()
uids = list()
while len(users) < pagesize:
uids = Live_Activity.get_live_new_user(aid, pagesize, maxs)
for u in User.get_list(uids):
top = Live_Activity.get_live_user_top(aid, str(u._id),
activity_config.begin_at,
activity_config.end_at)
total_gold = UserGiftLog.get_user_total_gold(
u._id, activity_config.begin_at, activity_config.end_at)
users.append({'user': u.format(), 'gold': total_gold, 'top': top})
# 如果按照maxs分页, 不足pagesize个记录则继续查询
if maxs is not None:
obj = User.get_one(uids[-1]) if uids else None
maxs = obj.create_at if obj else 1000
if len(uids) < pagesize:
break
else:
break
return {
'new_users': users,
'end_page': len(uids) != pagesize,
'maxs': maxs
}
def format(self, uid, device):
user = User.get_one(uid)
shared = False
if user:
shared = UserShareActivityLog.check_user_activity(self._id, user.phone, device)
today_used = int(ShareActivityConfig.get_used_today(self._id))
today_left = max(0, min(self.daily_num - today_used, self.left_num))
data = {
'id': str(self._id),
'today_left': today_left,
'shared': shared,
'begin_at': self.begin_at,
'end_at': self.end_at,
'icon': urljoin(app.config.get("MEDIA_URL"), self.icon),
'title': self.title,
'share_video_topic': str(self.share_video_topic),
'share_url': self.share_url,
}
return data
def certify_status():
"""获取实名认证状态 (GET|POST)
:uri: /users/certify_status
:returns: {'uid': uid}
"""
ut = request.values.get("ut", None)
user_id = User.uid_from_token(ut)
if not User.get_one(ObjectId(user_id)):
return error.UserNotExist
user = UserCertify.get_user_certify(user_id)
if not user:
return error.UserNotExist
user_certify = user.format()
return user_certify
def unfollow_user():
"""取消关注用户 (GET|POST&LOGIN)
:uri: /user/opt/unfollow-user
:param target_user_id: 被取消关注用户id
:returns: {}
"""
user = request.authed_user
params = request.values
target_uid = params.get('target_user_id', None)
target_user = User.get_one(target_uid)
if not target_user:
return error.UserNotExist
key = 'lock:unfollow:%s:%s' % (str(user._id), target_uid)
with util.Lockit(Redis, key) as locked:
if locked:
return error.FollowFailed('取消关注失败')
fs = FriendShip.get_by_ship(str(user._id), target_uid)
fs.delete_model() if fs else None
return {}