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 {}