def get(self):
try:
user_id = self.get_argument('user_id')
room_id = self.get_argument('room_id')
start = int(self.get_argument('start', 0))
count = int(self.get_argument('count', 10))
except:
return self.error(MISSING_PARAMS)
user = User.get(user_id)
# if not user.has_room_access(room_id):
# return self.error(ACCESS_NOT_ALLOWED)
room = Room.get(room_id)
rst = room.get_reward_rank(start, count)
data = []
for info in rst:
user_id = info.get('user_id')
user = User.get(user_id)
data.append({
'user': {
'id': user.id,
'name': user.user_name,
'avatar': user.avatar_url,
},
'reward_amount': info.get('amount') / 100,
})
return self.render({
'status': 0,
'data': data,
})
def post(self):
try:
user_id = self.get_argument('user_id')
reply_user_id = self.get_argument('reply_user_id', None)
room_id = self.get_argument('room_id')
content_id = self.get_argument('content_id')
text = self.get_argument('text')
except MissingArgumentError:
return self.error(MISSING_PARAMS)
if filter.check_sensitive(text):
return self.error(SENSITIVE_WORD_EXISTS)
user = User.get(user_id)
if not user:
return self.error(USER_NOT_FOUND)
# if reply_user_id:
# reply_user = User.get(reply_user_id)
# if not reply_user:
# return self.error(USER_NOT_FOUND)
room = Room.get(room_id)
if not room:
return self.error(ROOM_NOT_FOUND)
if not user.has_room_access(room_id):
return self.error(ACCESS_NOT_ALLOWED)
if not user.has_room_speak_access(room_id):
return self.error(USER_IN_ROOM_SILENT_LIST)
content = Content.get(content_id)
if not content:
return self.error(CONTENT_NOT_FOUND)
try:
comment = Comment.add(user_id, reply_user_id, content_id, text)
if not reply_user_id:
if int(user_id) != int(content.creator_id):
notify_content_comment.delay(user, content, comment)
handle_daily_comment.delay(user_id, comment.id)
else:
reply_user = User.get(reply_user_id)
if not reply_user:
return self.error(USER_NOT_FOUND)
if int(user.id) != int(reply_user_id):
notify_comment_reply.delay(user, reply_user, content,
comment)
handle_daily_comment.delay(user_id, comment.id)
return self.render({
'status': 0,
'data': comment.jsonify(),
})
except Exception as e:
logger.error(u'发表评论失败。User:[%s], Content:[%s], Error:[%s]' %
(user_id, content_id, e))
return self.error(SYSTEM_ERROR)
def post(self):
try:
user_id = self.get_argument('user_id')
group_id = self.get_argument('group_id')
message_id = self.get_argument('message_id')
except MissingArgumentError:
return self.error(MISSING_PARAMS)
message = GroupMessage.get(message_id)
helper = User.get(user_id)
receiver = User.get(message.creator_id)
try:
liked_count = GroupMessageLiked.add(user_id, group_id, message_id)
GroupMessage.update_amount(message_id, liked_count)
if liked_count and liked_count % 2 == 0:
chat_user_reward.delay(receiver, helper, group_id, message_id, liked_count)
has_liked = GroupMessageLiked.has_liked(user_id, group_id, message_id)
except Exception as e:
logger.error(u'添加点赞失败。Error:[%s]' % e)
return self.error(SYSTEM_ERROR)
return self.render({
'status': 0,
'data': {
'has_liked': bool(has_liked),
'liked_count': liked_count,
}
})
def post(self):
try:
group_id = self.get_argument('group_id')
user_id = self.get_argument('user_id')
remove_user_id = self.get_argument('remove_user_id')
except MissingArgumentError:
return self.error(MISSING_PARAMS)
operator = User.get(user_id)
remove_user = User.get(remove_user_id)
if not remove_user:
return self.error(USER_NOT_FOUND)
group = Group.get(group_id)
if not group:
return self.error(GROUP_NOT_FOUND)
group_operator = GroupUser.get_by_group_and_user(group_id, user_id)
remove_group_user = GroupUser.get_by_group_and_user(group_id, remove_user_id)
if not group_operator.has_group_user_handle_access(remove_group_user):
return self.error(ACCESS_NOT_ALLOWED)
try:
GroupUser.remove_and_black_user(group_id, remove_user_id)
except Exception as e:
logger.error(u'群组删除拉黑用户失败。User:[%s], GROUP:[%s], Error:[%s]' % (remove_user_id, group_id, e))
return self.error(SYSTEM_ERROR)
self.render({
'status': 0,
})
# 先不加上通知
# room_remove_user_notify(operator, room_operator.status, room, remove_user)
return
def get_users_by_room(cls, room_id):
cache = CacheManager().cache
cache_key = ROOM_USER_CACHE_KEY % room_id
if cache.exists(cache_key):
user_ids = cache.zrevrange(cache_key, 0, -1)
return user_ids and [User.get(user_id) for user_id in user_ids]
else:
db = DbManager().db
sql = 'select user_id from {table} where room_id=%s'.format(table=cls.table)
user_ids_dict = db.query(sql, room_id)
return user_ids_dict and [User.get(user_id_dict.get('user_id')) for user_id_dict in user_ids_dict]
def post(self, *args, **kwargs):
try:
telephone = self.get_argument('telephone')
password = self.get_argument('password')
verify_code = self.get_argument('verify_code')
except MissingArgumentError:
return self.error(MISSING_PARAMS)
if not verify_telephone(telephone):
return self.error(PHONE_NOT_RIGHT)
# 检测是否有相同手机号的用户
exist_user_telephone = User.exists_user_by_telephone(telephone)
if exist_user_telephone:
return self.error(EXIST_USER_TELEPHONE)
# 检测验证码是否正确
if str(verify_code) != str(Verify.get_verify_code(REGISTER_VERIFY_CODE_TYPE, telephone)):
return self.error(MISMATCHED_VERIFY_CODE)
password = encrypt_password(password)
try:
user_id = User.add(telephone, password)
user_amount = User.get_user_count()
account = Account.add(user_id, 0.00)
# UserIntegral.add(user_id, 0)
# if user_amount <= 500:
# account.add_balance(10.00)
# PresentedBalance.add(user_id, 10.00, PRESENT_BEFORE_500)
#
# if int(telephone) in NEICE_TELEPHONES:
# account.add_balance(10.00)
# PresentedBalance.add(user_id, 10.00, PRESENT_NEICE)
access_token = gen_access_token(user_id)
UserAuth.add(user_id, access_token)
user = User.get(user_id)
rst = {
'status': 0,
'data': {
'user': user.jsonify(),
'access_token': access_token,
},
}
return self.render(rst)
except Exception as e:
logger.error(u'添加用户失败。Error:%s', e)
return self.error(SYSTEM_ERROR)
def post(self):
try:
reporter_id = self.get_argument('user_id')
content_id = self.get_argument('content_id')
room_id = int(self.get_argument('room_id'))
reason = self.get_argument('reason', '')
except MissingArgumentError:
return self.error(MISSING_PARAMS)
content = Content.get(content_id)
if int(content.room_id) != room_id:
return self.error(ACCESS_NOT_ALLOWED)
user = User.get(reporter_id)
if not user.has_room_access(room_id):
return self.error(ACCESS_NOT_ALLOWED)
try:
Report.add(reporter_id, REPORT_ROOM_CONTENT, content_id, reason)
return self.render({
'status': 0,
})
except Exception as e:
logger.error(u'添加举报失败。Error:[%s]' % e)
return self.error(SYSTEM_ERROR)
def get(self):
now = datetime.now()
start = int(self.get_argument('start', 0))
count = int(self.get_argument('count', 10))
user_id = self.get_argument('user_id')
year = self.get_argument('year', now.year)
month = self.get_argument('month', now.month)
user = User.get(user_id)
rst = Room.get_rooms_increase_rank(year, month, start, count)
data = []
for d in rst:
room_id = d.get('room_id')
increase = d.get('increase')
room = Room.get(room_id)
data.append({
# 'room': {
# 'id': room.id,
# 'name': room.name,
# 'avatar_url': room.avatar_url,
# 'user_amount': room.user_amount,
# },
'room': room.jsonify(user),
'increase': increase,
})
return self.render({
'status': 0,
'data': {
'year': year,
'month': month,
'data': data
},
})
def get(self):
try:
user_id = self.get_argument('user_id')
room_id = self.get_argument('room_id')
except MissingArgumentError:
return self.error(MISSING_PARAMS)
user = User.get(user_id)
if not user:
return self.error(USER_NOT_FOUND)
room = Room.get(room_id)
if not room:
return self.error(ROOM_NOT_FOUND)
result = []
now = datetime.now()
for delta in xrange(1, 5):
year, month, max_day = self.add_months(now, delta)
# start_day = datetime(year=year, month=month, day=1).strftime('%Y-%m-%d')
end_day = (datetime(year=year, month=month, day=max_day) +
timedelta(days=1)).strftime('%Y-%m-%d')
# amount = RoomOrder.get_fund_amount_by_room_and_month(room_id, end_day)
amount = 0
result.append({'month': month, 'amount': amount})
return self.render({'status': 0, 'data': result})
def post(self):
try:
user_id = self.get_argument('user_id')
room_id = self.get_argument('room_id')
status = int(self.get_argument('status'))
except MissingArgumentError:
return self.error(MISSING_PARAMS)
user = User.get(user_id)
if not user:
return self.error(USER_NOT_FOUND)
room = Room.get(room_id)
if not room:
return self.error(ROOM_NOT_FOUND)
if int(room.creator_id) != int(user_id):
return self.error(ACCESS_NOT_ALLOWED)
try:
if status != int(room.status):
room.update(status=status)
return self.render({
'status': 0,
'data': {
'status': status,
}
})
except Exception as e:
logger.error(u'修改房间状态失败。Error:[%s]' % e)
return self.error(SYSTEM_ERROR)
def post(self):
try:
user_id = self.get_argument('user_id')
city_id = int(self.get_argument('city_id'))
except MissingArgumentError:
return self.error(MISSING_PARAMS)
user = User.get(user_id)
if not user:
return self.error(USER_NOT_FOUND)
city = City.get(city_id)
if not city:
return self.error(CITY_NOT_FOUND)
try:
if city_id != user.city_id:
user.update(city_id=city_id)
return self.render({
'status': 0,
'data': {
'city': city.jsonify(),
}
})
except Exception as e:
logger.error(u'修改用户所在地失败。Error:[%s]' % e)
return self.error(SYSTEM_ERROR)
def post(self):
try:
user_id = self.get_argument('user_id')
tag_id = self.get_argument('tag_id')
except MissingArgumentError:
return self.error(MISSING_PARAMS)
user = User.get(user_id)
if not user:
return self.error(USER_NOT_FOUND)
tag = Tag.get(tag_id)
if not tag:
return self.error(TAG_NOT_FOUND)
if UserTag.exists_tag(user_id, tag_id):
return self.error(USER_TAG_EXISTS)
try:
UserTag.add(user_id, tag_id)
return self.render({
'status': 0
})
except:
return self.error(SYSTEM_ERROR)
def post(self):
user_id = self.get_argument('user_id')
group_id = self.get_argument('group_id')
group = Group.get(group_id)
user = User.get(user_id)
if not group:
return self.error(GROUP_NOT_FOUND)
if group.exists_user(user_id):
return self.error(USER_ALREADY_IN_GROUP)
if GroupUser.is_over_join_limit(user_id):
return self.error(USER_JOIN_GROUP_OVER_LIMIT)
if GroupBlackUser.is_group_black_user(group_id, user_id):
return self.error(USER_IN_GROUP_BLACK_LIST)
if group.user_amount >= group.limit_user:
pressed_user_id = GroupUser.get_pressed_user_by_group(group_id)
if not pressed_user_id:
return self.error(GROUP_IS_FULL)
else:
group_user = GroupUser.get_by_group_and_user(group_id, user_id)
group_user.delete()
try:
GroupUser.add_group_user(group.id, group.name, user_id, GROUP_USER_NORMAL)
except Exception as e:
logger.error(u'加入群组失败。Error:[%s]' % e)
return self.error(SYSTEM_ERROR)
return self.render({
'status': 0,
})
def get(self):
try:
user_id = self.get_argument('user_id')
room_id = self.get_argument('room_id')
start = int(self.get_argument('start', 0))
count = int(self.get_argument('count', 10))
except MissingArgumentError:
return self.error(MISSING_PARAMS)
user = User.get(user_id)
if not user:
return self.error(USER_NOT_FOUND)
room = Room.get(room_id)
if not room:
return self.error(ROOM_NOT_FOUND)
if user.has_room_access(room_id):
return self.error(ACCESS_NOT_ALLOWED)
try:
users = room.get_users(start, count)
return self.render({
'status': 0,
'data': [user.jsonify() for user in users]
})
except Exception as e:
logger.error(u'获取房间用户失败。Error:[%s]' % e)
return self.error(SYSTEM_ERROR)
def get(self):
try:
user_id = self.get_argument('user_id')
room_id = self.get_argument('room_id')
vote_id = self.get_argument('vote_id')
except MissingArgumentError:
return self.error(MISSING_PARAMS)
user = User.get(user_id)
if not user:
return self.error(USER_NOT_FOUND)
room = Room.get(room_id)
if not room:
return self.error(ROOM_NOT_FOUND)
if not user.has_room_access(room_id):
return self.error(ACCESS_NOT_ALLOWED)
vote = Vote.get(vote_id)
if not vote:
return self.error(VOTE_NOT_FOUND)
return self.render({
'status': 0,
"data": {
'vote': vote.jsonify(user),
},
})
def post(self):
try:
user_id = self.get_argument('user_id')
vote_id = self.get_argument('vote_id')
option_id = self.get_argument('option_id')
except MissingArgumentError:
return self.error(MISSING_PARAMS)
user = User.get(user_id)
if not user:
return self.error(USER_NOT_FOUND)
vote = Vote.get(vote_id)
if not vote:
return self.error(VOTE_NOT_FOUND)
option = VoteOption.get(option_id)
if not option:
return self.error(VOTE_OPTION_NOT_FOUND)
if int(option.vote_id) != int(vote_id):
return self.error(OPTION_NOT_IN_VOTE)
if VoteResult.has_voted(vote_id, user_id):
return self.error(USER_HAS_ALREADY_VOTED)
VoteResult.add(user_id, vote_id, option_id)
handle_daily_vote_integral.delay(user_id, vote_id)
return self.render({'status': 0})
def post(self):
try:
user_id = self.get_argument('user_id')
room_id = self.get_argument('room_id')
vote_id = self.get_argument('vote_id')
option_id = self.get_argument('vote_option_id')
except MissingArgumentError:
return self.error(MISSING_PARAMS)
user = User.get(user_id)
if not user:
return self.error(USER_NOT_FOUND)
room = Room.get(room_id)
if not room:
return self.error(ROOM_NOT_FOUND)
if not user.has_room_access(room_id):
return self.error(ACCESS_NOT_ALLOWED)
vote = Vote.get(vote_id)
if not vote:
return self.error(VOTE_NOT_FOUND)
option = VoteOption.get(option_id)
if not option:
return self.error(VOTE_OPTION_NOT_FOUND)
try:
VoteResult.add(user_id, vote_id, option_id)
return self.render({'status'})
except:
return self.error(SYSTEM_ERROR)
def post(self):
try:
user_id = self.get_argument('user_id')
trade_id = self.get_argument('trade_id')
order_id = self.get_argument('order_id')
except MissingArgumentError:
return self.error(MISSING_PARAMS)
user = User.get(user_id)
if not user:
return self.error(USER_NOT_FOUND)
trade = Trade.get(trade_id)
if not trade:
return self.error(TRADE_NOT_FOUND)
if int(trade.order_id) != int(order_id):
return self.error(ACCESS_NOT_ALLOWED)
try:
if int(trade.pay_method) == PAYMETHOD_WEIXIN:
WxPay(trade,
self.remote_ip).get_parameters(self.wx_on_response)
elif int(trade.pay_method) == PAYMETHOD_ALIPAY:
alipay_request = build_mobile_securitypay_request(trade)
return self.render({
'status': 0,
'pay_method': PAYMETHOD_ALIPAY,
'data': alipay_request
})
except Exception as e:
logger.error(u'请求第三方支付数据失败。Error:[%s]' % e)
return self.error(SYSTEM_ERROR)
def get(self):
user_id = self.get_argument('user_id')
user = User.get(user_id)
if not user:
return self.error(USER_NOT_FOUND)
system_latest_notify = Notify.get_user_latest_notify_by_type(user_id, NOTIFY_TYPE_SYSTEM)
liked_latest_notify = Notify.get_user_latest_notify_by_type(user_id, NOTIFY_TYPE_LIKED)
comment_latest_notify = Notify.get_user_latest_notify_by_type(user_id, NOTIFY_TYPE_COMMENT)
reward_latest_notify = Notify.get_user_latest_notify_by_type(user_id, NOTIFY_TYPE_REWARD)
return self.render({
'status': 0,
'data': {
'user_id': user_id,
'notify': {
NOTIFY_TYPE_SYSTEM: {
'count': Notify.get_user_unread_notify_count_by_type(user_id, NOTIFY_TYPE_SYSTEM),
'latest_notify': system_latest_notify.jsonify() if system_latest_notify else None,
},
NOTIFY_TYPE_LIKED: {
'count': Notify.get_user_unread_notify_count_by_type(user_id, NOTIFY_TYPE_LIKED),
'latest_notify': liked_latest_notify.jsonify() if liked_latest_notify else None,
},
NOTIFY_TYPE_COMMENT: {
'count': Notify.get_user_unread_notify_count_by_type(user_id, NOTIFY_TYPE_COMMENT),
'latest_notify': comment_latest_notify.jsonify() if comment_latest_notify else None,
},
NOTIFY_TYPE_REWARD: {
'count': Notify.get_user_unread_notify_count_by_type(user_id, NOTIFY_TYPE_REWARD),
'latest_notify': reward_latest_notify.jsonify() if reward_latest_notify else None,
}
},
}
})
def post(self):
try:
user_id = self.get_argument('user_id')
device_token = str(self.get_argument('device_token'))
except:
return self.error(MISSING_PARAMS)
user = User.get(user_id)
if not user:
return self.error(USER_NOT_FOUND)
if len(device_token) == 32:
os = ANDROID_DEVICE
elif len(device_token) == 64:
os = IOS_DEVICE
else:
os = OTHER_DEVICE
device = Device.get_by_user(user_id)
if not device:
device = Device.add(user_id, device_token, os)
elif (str(device.device_token) != device_token or int(device.os) != os):
device.update_device_token(device_token, os)
if not device:
return self.error(SYSTEM_ERROR)
return self.render({
'status': 0,
'data': device.jsonify()
})
def post(self):
try:
user_id = self.get_argument('user_id')
follow_id = self.get_argument('follow_id')
except MissingArgumentError:
return self.error(MISSING_PARAMS)
follow = User.get(follow_id)
if not follow:
return self.error(USER_NOT_FOUND)
if UserFollows.has_followed(user_id, follow_id):
return self.error(ALREADY_HAS_FOLLOWED)
if UserFollows.has_followed(follow_id, user_id):
follow_type = FOLLOW_BOTH_TYPE
else:
follow_type = FOLLOW_SINGLE_TYPE
try:
UserFollows.follow(user_id, follow_id, follow_type)
notify_be_followed.delay(user_id, follow_id)
return self.error({
'status': 0,
})
except Exception as e:
logger.error(u'添加关注失败。User:[%s] Follow:[%s] Error:[%s]' %
(user_id, follow_id, e))
return self.error(SYSTEM_ERROR)
def get(self):
user_id = self.get_argument('user_id')
user = User.get(user_id)
if not user:
return self.error(USER_NOT_FOUND)
rong_token = RongToken.get_rong_token_by_user(user_id)
if not rong_token:
rst = rong_client.user_get_token(user_id, user.name, user.avatar_url)
if rst.get('code') == 200:
token = rst.get('token')
RongToken.add(user_id, token)
else:
logger.error(u'获取融云token失败。Info:[%s]' % (json.dumps(rst)))
return self.error(GET_RONG_TOKEN_FAIL)
else:
token = rong_token.token
return self.render({
'status': 0,
'data': {
'token': token,
'flower_identity': UserChatStatus.is_flower_identity(user_id),
}
})
def post(self):
user_id = self.get_argument('user_id')
user = User.get(user_id)
name = self.get_argument('name')
announcement = self.get_argument('announcement', '')
avatar = self.get_argument('avatar', '')
if Group.is_over_create_limit(user_id):
return self.error(GROUP_CREATED_COUNT_OVER_LIMIT)
if Group.exists_group(name):
return self.error(GROUP_NAME_EXISTS)
if get_str_length(name) < 4:
return self.error(GROUP_NAME_LESS_MINIMUM_LIMIT)
if get_str_length(name) > 60:
return self.error(GROUP_NAME_OVER_MAXIMUM_LIMIT)
if announcement:
if get_str_length(announcement) > 100:
return self.error(GROUP_ANNOUNCEMENT_OVER_MAXIMUM_LIMIT)
try:
group = Group.add(user_id, avatar, name, announcement)
except Exception as e:
logger.error(u'创建群组失败。Error:[%s]' % e)
return self.error(SYSTEM_ERROR)
return self.render({
'status': 0,
'data': group.jsonify(user),
})
def delete(self):
try:
user_id = self.get_argument('user_id')
room_id = self.get_argument('room_id')
except MissingArgumentError:
return self.error(MISSING_PARAMS)
user = User.get(user_id)
if not user:
return self.error(USER_NOT_FOUND)
room = Room.get(room_id)
if not room:
return self.error(ROOM_NOT_FOUND)
if int(room.creator_id) == int(user_id):
return self.error(CREATOR_COULD_NOT_EXIT_ROOM)
try:
RoomUser.delete_room_user(room_id, user_id)
except Exception as e:
logger.error(u'用户退出房间失败。User:[%s], Room:[%s], Error:[%s]' % (user_id, room_id, e))
return self.render({
'status': 0,
})
def get(self):
query = self.get_argument('query', '')
start = int(self.get_argument('start', 0))
count = int(self.get_argument('count', 10))
user_id = self.get_argument('user_id')
user = User.get(user_id)
if query:
rst = []
groups = Group.search_group(query, start ,count)
for group in groups:
rst.append(group.jsonify(user))
return self.render({
'status': 0,
'data': {
'items': rst,
},
})
return self.render({
'status': 0,
'data': {
'items': [],
}
})
def post(self):
try:
telephone = self.get_argument('telephone')
verify_type = int(self.get_argument('verify_type'))
except MissingArgumentError:
return self.error(MISSING_PARAMS)
if not verify_telephone(telephone):
return self.error(PHONE_NOT_RIGHT)
if verify_type == REGISTER_VERIFY_CODE_TYPE and User.exists_user_by_telephone(telephone):
return self.error(EXIST_USER_TELEPHONE)
verify_code = Verify.gen_verify_code()
try:
Verify.add_verify_code(verify_type, telephone, verify_code)
if not settings.DEBUG:
send_register_verify_code_sms.delay(telephone, verify_code)
return self.render({
'status': 0,
'data': {
'telephone': telephone,
'verify_code': str(verify_code),
}
})
except Exception as e:
logger.warning(u'获取注册验证码失败。Error:[%s]' % e)
return self.error(SYSTEM_ERROR)
def post(self):
user_id = self.get_argument('user_id')
chat_status = int(self.get_argument('chat_status'))
obj = UserChatStatus.get_by_user(user_id)
flower_user = FlowerUser.get_by_user(user_id)
user = User.get(user_id)
if not obj:
if not flower_user and chat_status == CHAT_FLOWER_IDENTITY:
return self.error(FLOWER_USER_INFO_NOT_SET)
UserChatStatus.add(user_id, chat_status)
else:
if not flower_user and chat_status == CHAT_FLOWER_IDENTITY:
return self.error(FLOWER_USER_INFO_NOT_SET)
obj.update(chat_status)
if chat_status == CHAT_FLOWER_IDENTITY:
rong_client.user_refresh(user_id, flower_user.name, flower_user.avatar_url)
flower_identity = True
else:
rong_client.user_refresh(user_id, user.user_name, user.avatar_url)
flower_identity = False
return self.render({
'status': 0,
'data': {
'flower_identity': flower_identity,
}
})
def post(self):
try:
user_id = self.get_argument('user_id')
room_id = self.get_argument('room_id')
intro = self.get_argument('intro')
except MissingArgumentError:
return self.error(MISSING_PARAMS)
if filter.check_sensitive(intro):
return self.error(SENSITIVE_WORD_EXISTS)
user = User.get(user_id)
if not user:
return self.error(USER_NOT_FOUND)
room = Room.get(room_id)
if not room:
return self.error(ROOM_NOT_FOUND)
if int(room.creator_id) != int(user_id):
return self.error(ACCESS_NOT_ALLOWED)
try:
if intro != room.intro:
room.update(intro=intro)
return self.render({
'status': 0,
'data': {
'intro': intro,
}
})
except Exception as e:
logger.error(u'修改房间介绍失败。Error:[%s]' % e)
return self.error(SYSTEM_ERROR)
def jsonify(self):
data = {
'id':
self.id,
'user': {
'id': self.creator.id,
'name': self.creator.user_name,
'avatar': self.creator.avatar_url,
},
'user_id':
self.user_id,
'content_id':
self.content_id,
'text':
self.text,
'create_time':
self.create_time if isinstance(self.create_time, basestring) else
self.create_time.strftime('%Y-%m-%d %H:%M:%S'),
}
reply_user = User.get(self.reply_user_id)
if reply_user:
data.update({
'reply': {
'id': reply_user.id,
'name': reply_user.user_name,
'avatar': reply_user.avatar_url,
}
})
return data
def post(self):
try:
user_id = self.get_argument('user_id')
room_id = self.get_argument('room_id')
tag_ids = self.get_argument('tag_ids')
tag_ids = json.loads(tag_ids)
except (MissingArgumentError, TypeError):
return self.error(MISSING_PARAMS)
user = User.get(user_id)
if not user:
return self.error(USER_NOT_FOUND)
room = Room.get(room_id)
if not room:
return self.error(ROOM_NOT_FOUND)
if int(room.creator_id) != int(user_id):
return self.error(ACCESS_NOT_ALLOWED)
try:
RoomTag.update_tags(room_id, tag_ids)
tags = RoomTag.get_tags_by_room(room_id)
return self.render({
'status': 0,
'data': {
'tags': [tag.jsonify() for tag in tags]
}
})
except Exception as e:
logger.error(u'修改房间标签信息失败。Error:[%s]' % e)
return self.error(SYSTEM_ERROR)
