def migu_create_comment(vid):
"""咪咕平台创建评论 (GET|POST)
:uri: /migu/videos/<string:vid>/comments/submit
:param user_id: 咪咕用户id
:param content: 评论内容
:returns: {}
"""
params = request.values
openid = params.get('user_id', '')
content = params.get('content', '')
if len(openid) < 1 or len(content) < 1:
return error.InvalidArguments
video = Video.get_one(vid)
if not video:
return error.VideoNotExist
user = User.get_platform_user('migu', openid)
if not user:
info = dict(name='$mg$%s%s' %
(openid[-4:], random.randint(1000, 9999)))
user = User.create_platform_user('migu', openid, data=info)
comment = Comment.init()
comment.author = ObjectId(str(user._id))
comment.content = content
comment.video = ObjectId(vid)
comment.create_model()
return {}
def login():
"""用户登录 (GET|POST)
:uri: /users/login
:param name: 用户名
:param password: 密码
:param type: 登陆类型(name, phone,)
:returns: {'user': object, 'ut': string}
"""
params = request.values
login_type = params.get('type', 'name')
name = params.get("name", None)
password = params.get("password", None)
if name is None or password is None or login_type not in ['name', 'phone']:
return error.InvalidArguments
user = User.login(name, password, login_type=login_type)
if not user:
return error.LoginFailed
# 初始化用户任务
UserTask.create_and_init_user_tasks(str(user._id))
token = User.gen_token(str(user._id))
return {'user': user.format(), 'ut': token}
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 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 reset_password():
"""重置密码 (GET|POST)
:uri: /users/reset_password
:param phone: 手机号
:param password: 密码
:param code: 短信验证码
:returns: {}
"""
params = request.values
phone = params.get('phone', None)
code = params.get('code', None)
password = params.get("password", None)
if not phone or not code or not password:
return error.InvalidArguments
invalid_error = User.invalid_password(password)
if invalid_error:
return invalid_error
user = User.get_by_phone(phone)
if not user:
return error.UserNotExist
if not SMS.verify_code(phone, code):
return error.VerifyCodeFailed
User.change_pwd(user, password)
return {}
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 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 migu_change_pwd():
"""更改密码（GET|POST）
:uri: /migu/change_password
:param phone: 手机号
:param old_pwd: 旧密码
:param new_pwd: 新密码
:returns: {}
"""
user = request.authed_user
params = request.values
old_pwd = params.get('old_pwd', None)
new_pwd = params.get('new_pwd', None)
phone = params.get('phone', None) or (user and user.phone)
if not old_pwd or not new_pwd or not phone:
return error.InvalidArguments
invalid_error = User.invalid_password(new_pwd)
if invalid_error:
return invalid_error
openid = Migu.get_identityid(phone, old_pwd, const.CENTER_ACCOUNT_PHONE)
if isinstance(openid, error.ApiError):
return openid
ret = Migu.center_update_pwd(openid, old_pwd, new_pwd)
if isinstance(ret, error.ApiError):
return ret
return {}
def migu_reset_password():
"""重置密码 (GET|POST)
:uri: /migu/reset_password
:param phone: 手机号
:param password: 密码
:param code: 短信验证码
:param sessionid: 短信sessionid
:returns: {}
"""
params = request.values.to_dict()
phone = params.get('phone', None)
code = params.get('code', None)
sessionid = params.get('sessionid', None)
password = params.get("password", None)
if not phone or not code or not password or not sessionid:
return error.InvalidArguments
invalid_error = User.invalid_password(password)
if invalid_error:
return invalid_error
ret = Migu.center_reset_pwd(phone, password, const.CENTER_ACCOUNT_PHONE,
code, sessionid)
if isinstance(ret, error.ApiError):
return ret
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 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 followers(uid):
"""获取用户粉丝 (GET)
:uri: /users/<string:uid>/followers
:param maxs: 最后时间, 0代表当前时间, 无此参数按page来分页
:param page: 页码(数据可能有重复, 建议按照maxs分页)
:param nbr: 每页数量
:returns: {'users': list}
"""
params = request.values
maxs = params.get('maxs', None)
maxs = time.time() if maxs is not None and int(
float(maxs)) == 0 else maxs and float(maxs)
page = int(params.get('page', 1))
pagesize = int(params.get('nbr', 10))
users = list()
uids = list()
while len(users) < pagesize:
uids = FriendShip.follower_ids(uid, page, pagesize, maxs)
users.extend([u.format() for u in User.get_list(uids)])
# 如果按照maxs分页, 不足pagesize个记录则继续查询
if maxs is not None:
obj = FriendShip.get_by_ship(uids[-1], uid) if uids else None
maxs = obj.create_at if obj else 1000
if len(uids) < pagesize:
break
else:
break
return {'users': users, 'end_page': len(uids) != pagesize, 'maxs': maxs}
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 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 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 refresh_token():
"""刷新用户token时间 (GET|POST&LOGIN)
:uri: /users/refresh_token
:returns: {'user': Object}
"""
ut = request.values.get("ut", None)
user = request.authed_user
token = User.set_token(ut, str(user._id))
if token:
User.recommend_users(str(user._id))
# 更新用户活跃时间
user.update_model({'$set': {'update_at': time.time()}})
# 初始化用户任务
UserTask.create_and_init_user_tasks(str(user._id))
return {'user': user.format(include_fields=['passid'])}
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 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 binding():
"""用户绑定 (GET|POST&LOGIN)
:uri: /users/binding
:param platform: 平台标识 (phone, weixin, qq)
:param openid: 平台id/手机号
:param token: 用户平台token/短信验证码
:returns: {}
"""
user = request.authed_user
params = request.values
platform = params.get('platform', None)
openid = params.get('openid', None)
token = params.get('token', None)
if platform == 'phone':
if not SMS.verify_code(openid, token):
return error.VerifyCodeFailed
# 用户已经存在
if User.get_by_phone(openid):
return error.UserExists
info = {'phone': openid}
user.update_model({'$set': info})
elif platform == 'weixin':
# 用户已经存在
if User.get_platform_user(platform, openid):
return error.UserExists
if not WeiXin(token, openid).get_open_info():
return error.LoginFailed
key = 'partner_%s' % (platform)
info = {key: {'id': openid}}
user.update_model({'$set': info})
elif platform == 'qq':
# 用户已经存在
if User.get_platform_user(platform, openid):
return error.UserExists
if not QQ(token, openid).get_open_info():
return error.LoginFailed
key = 'partner_%s' % (platform)
info = {key: {'id': openid}}
user.update_model({'$set': info})
return {}
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 apply(self, query, value):
reload(sys)
sys.setdefaultencoding('utf-8')
value = apply(self.field_func, [value])
user = User.get_by_nickname(value)
uidobj = []
if user:
uidobj = [user._id]
query.append({self.column: {'$in': uidobj}})
return query
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 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 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 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 recommend_users():
"""获取推荐关注 (GET&LOGIN)
:uri: /recommend/users
:returns: {'users': list}
"""
user = request.authed_user
uids = []
gids = UserSubGame.sub_game_ids(str(user._id))
for gid in gids:
uids.extend(Game.popular_user_ids(gid))
if not uids:
uids = User.user_recommend_attention()
uids = list(set(uids))
if str(user._id) in uids:
uids.remove(str(user._id))
if len(uids) > const.RECOMMEND_ATTENTION:
uids = random.sample(uids, const.RECOMMEND_ATTENTION)
users = [u.format() for u in User.get_list(uids)]
return {'users': users}
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 migu_register():
"""用户注册（GET|POST）
:uri: /migu/register_phone
:param phone: 手机号
:param password: 密码
:param code: 验证码
:param sessionid: 短信sessionid
:returns: {'user': object, 'ut': string}
"""
params = request.values.to_dict()
phone = params.get('phone', None)
code = params.get('code', None)
sessionid = params.get('sessionid', None)
password = params.get('password', None)
if not phone or not code or not password or not sessionid:
return error.InvalidArguments
invalid_error = User.invalid_password(password)
if invalid_error:
return invalid_error
# 用户中心注册
ret = Migu.center_register(phone, password, const.CENTER_ACCOUNT_PHONE,
code, sessionid)
if isinstance(ret, error.ApiError):
return ret
# 进行用户绑定
migu_uid = Migu.get_identityid(phone, password, const.CENTER_ACCOUNT_PHONE)
if isinstance(migu_uid, error.ApiError):
return migu_uid
user = User.get_platform_user('migu', migu_uid)
if not user:
user = User.get_by_phone(phone)
if user:
info = dict(partner_migu={'id': migu_uid},
nickname=u'咪咕用户%s%s' %
(migu_uid[-4:], random.randint(1000, 9999)),
gender=random.randint(1, 2),
name='$mg$%s%s' %
(migu_uid[-4:], random.randint(1000, 9999)))
user = user.update_model({'$set': info})
else:
info = dict(phone=phone,
nickname=u'咪咕用户%s%s' %
(migu_uid[-4:], random.randint(1000, 9999)),
gender=random.randint(1, 2),
name='$mg$%s%s' %
(migu_uid[-4:], random.randint(1000, 9999)))
user = User.create_platform_user('migu', migu_uid, data=info)
else:
# 如果用户没有绑定手机并且手机号没有被绑定, 则自动进行手机号绑定
if not user.phone and not User.get_by_phone(phone):
info = dict(phone=phone)
user.update_model({'$set': info})
ut = User.gen_token(str(user._id))
return {'user': user.format(), 'ut': ut}