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 post(self):
try:
user_id = self.get_argument('user_id')
content_id = self.get_argument('content_id')
room_id = self.get_argument('room_id')
status = self.get_argument('status')
except MissingArgumentError:
return self.error(MISSING_PARAMS)
content = Content.get(content_id)
if not content:
return self.error(CONTENT_NOT_FOUND)
room = Room.get(room_id)
if not room:
return self.error(ROOM_NOT_FOUND)
user = User.get(user_id)
if not user:
return self.error(USER_NOT_FOUND)
if not user.has_room_access(room_id):
return self.error(ACCESS_NOT_ALLOWED)
content.update(status=status)
return self.render({
'status': 0,
})
def get(self):
try:
user_id = self.get_argument('user_id')
content_id = self.get_argument('content_id')
room_id = self.get_argument('room_id')
start = int(self.get_argument('start', 0))
count = int(self.get_argument('count', 20))
except AttributeError:
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)
content = Content.get(content_id)
if not content:
return self.error(CONTENT_NOT_FOUND)
if not user.has_room_access(room_id) or int(
content.room_id) != int(room_id):
return self.error(ACCESS_NOT_ALLOWED)
liked_users = ContentLiked.get_liked_people(content_id, start, count)
return self.render({
'status': 0,
'data': {
'start': start,
'count': count,
'liked_users': [user.jsonify() for user in liked_users],
}
})
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 add(cls,
creator_id,
room_id,
text,
images,
video,
room_user_status,
status=CONTENT_PUBLIC):
room = Room.get(room_id)
db = DbManager().db
create_time = datetime.now()
db.execute('begin;')
try:
sql = 'insert into {table} (creator_id, room_id, content_type, status, create_time, last_comment_time, room_user_status) values' \
' (%s, %s, %s, %s, %s, %s, %s)'.format(table=Content.table)
content_id = db.execute(sql, creator_id, room_id, POSTS_TYPE,
status, create_time, create_time,
room_user_status)
sql = 'insert into {table} (id, creator_id, room_id, text, images, video, create_time) values ' \
'(%s, %s, %s, %s, %s, %s, %s)'.format(table=cls.table)
db.execute(sql, content_id, creator_id, room_id, text, images,
video, create_time)
db.execute('commit;')
except:
db.execute('rollback;')
raise
room.update(last_content_updated=create_time, update_time=create_time)
cls.save_created_content_to_redis(creator_id, content_id, create_time)
return content_id and cls.get(content_id)
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')
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')
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)
def add(cls, creator_id, room_id, welfare_type, price, count, name, start_time, deadline, images, room_user_status,
amount, content_status=CONTENT_PUBLIC, welfare_status=WELFARE_ROB_UNDER_WAY):
create_time = datetime.now()
room = Room.get(room_id)
star_fund = StarFund.get_by_room(room_id)
if float(star_fund.balance) < amount:
raise StarFundInsufficient
db = DbManager().db
db.execute('begin;')
try:
sql = 'insert into {table} (creator_id, room_id, content_type, status, create_time, last_comment_time, room_user_status) values' \
' (%s, %s, %s, %s, %s, %s, %s)'.format(table=Content.table)
content_id = db.execute(sql, creator_id, room_id, WELFARE_TYPE, content_status, create_time, create_time, room_user_status)
sql = 'insert into {table} (id, creator_id, room_id, welfare_type, price, count, name, start_time, deadline, images, status, ' \
'create_time) values (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)'.format(table=cls.table)
db.execute(sql, content_id, creator_id, room_id, welfare_type, price, count, name, start_time, deadline, images,
welfare_status, create_time)
sql = 'update {table} set balance=balance-%s where room_id=%s'.format(table=StarFund.table)
db.execute(sql, amount, room_id)
sql = 'insert into {table} (room_id, source, amount, create_time, extra, extra_info) values (%s, %s, %s, %s, %s, %s)'.\
format(table=StarFundRecord.table)
db.execute(sql, room_id, STAR_FUND_WELFARE_EXPAND, -amount, create_time, content_id, name)
db.execute('commit;')
except:
db.execute('rollback;')
raise
room.update(last_content_updated=create_time, update_time=create_time)
return cls.get(content_id)
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 add(cls,
creator_id,
room_id,
name,
deadline,
options,
room_user_status,
status=CONTENT_PUBLIC):
room = Room.get(room_id)
db = DbManager().db
create_time = datetime.now()
db.execute('begin;')
try:
sql = 'insert into {table} (creator_id, room_id, content_type, status, create_time, last_comment_time, room_user_status) values ' \
'(%s, %s, %s, %s, %s, %s, %s)'.format(table=Content.table)
content_id = db.execute(sql, creator_id, room_id, VOTE_TYPE,
status, create_time, create_time,
room_user_status)
sql = 'insert into {table} (id, creator_id, room_id, name, deadline, create_time) values ' \
'(%s, %s, %s, %s, %s, %s)'.format(table=cls.table)
db.execute(sql, content_id, creator_id, room_id, name, deadline,
create_time)
for option in options:
sql = 'insert into {table} (vote_id, content, create_time) values (%s, %s, %s)'.format(
table=VoteOption.table)
db.execute(sql, content_id, option, create_time)
db.execute('commit;')
except:
db.execute('rollback;')
raise
cls.save_created_content_to_redis(creator_id, content_id, create_time)
room.update(last_content_updated=create_time, update_time=create_time)
return content_id and cls.get(content_id)
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')
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 post(self):
try:
room_id = self.get_argument('room_id')
user_id = self.get_argument('user_id')
except MissingArgumentError:
return self.error(MISSING_PARAMS)
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_NOT_NEED_JOIN_ROOM)
if RoomUser.room_exists_user(room_id, user_id):
return self.error(ROOM_EXISTS_USER)
if RoomBlackUser.is_room_black_user(room_id, user_id):
return self.error(USER_IN_ROOM_BLACK_LIST)
if room.private_not_join:
return self.error(ROOM_NOT_JOIN)
try:
RoomUser.add(room_id, user_id, ROOM_USER_NORMAL)
return self.render({
"status": 0,
"data": room.jsonify(),
})
except Exception as e:
logger.error(u'用户加入房间失败。User:[%s] Room:[%s] Error:[%s]' % (user_id, room_id, e))
return self.error(SYSTEM_ERROR)
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 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 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 = int(self.get_argument('user_id'))
room_id = self.get_argument('room_id')
admin_id = int(self.get_argument('admin_id'))
except MissingArgumentError:
return self.error(MISSING_PARAMS)
room = Room.get(room_id)
if not room:
return self.error(ROOM_NOT_FOUND)
if int(room.creator_id) != user_id or user_id == admin_id:
return self.error(ACCESS_NOT_ALLOWED)
if not RoomUser.room_exists_user(room_id, admin_id):
return self.error(ACCESS_NOT_ALLOWED)
room_admin_count = RoomUser.get_room_admin_count(room_id)
if room_admin_count >= ROOM_ADMIN_USER_MAX_AMOUNT:
return self.error(ROOM_ADMIN_USER_OVER_LIMIT)
try:
RoomUser.set_room_admin(room_id, admin_id)
except Exception as e:
logger.error(u'添加房间管理员失败。Error:[%s]' % e)
return self.error(SYSTEM_ERROR)
return self.render({
'status': 0,
})
def post(self, *args):
try:
user_id = self.get_argument('user_id')
name = self.get_argument('name')
tag_ids = self.get_argument('tag_ids', '[]')
intro = self.get_argument('intro', '')
limit_user_number = self.get_argument('limit_user_number',
LIMIT_USER_NUMBER)
status = self.get_argument('status', ROOM_PUBLIC)
avatar_url = self.get_argument('avatar', '')
question_info = self.get_argument('question_info', None)
create_time = datetime.now()
except MissingArgumentError:
return self.error(MISSING_PARAMS)
if filter.check_sensitive(name) or filter.check_sensitive(
intro) or filter_name.check_sensitive(name):
return self.error(SENSITIVE_WORD_EXISTS)
try:
tag_ids = json.loads(tag_ids)
except ValueError:
tag_ids = []
if not name:
return self.error(ROOM_NAME_COULD_NOT_NONE)
if Room.exist_room(name):
return self.error(ROOM_NAME_EXISTS)
try:
avatar = json.loads(avatar_url)[0]
except:
avatar = avatar_url
if question_info:
question_info = json.loads(question_info)
try:
room_id = Room.add(user_id, name, intro, tag_ids, avatar,
limit_user_number, create_time, status,
question_info)
add_open_search_room.delay(room_id, name, intro, create_time,
tag_ids)
except Exception, e:
logger.error(u'创建房间失败。error:[%s]', e)
return self.error(ROOM_CREATE_ERROR)
def created_rooms(self):
from starmachine.model.room import Room
cache = CacheManager().cache
cache_key = USER_CREATED_ROOM_KEY % self.id
room_ids = list(cache.smembers(cache_key))
return room_ids and [
Room.get(room_id).jsonify(self) for room_id in room_ids
]
def get(self, room_id):
room = Room.get(room_id)
if not room:
raise HTTPError(404)
context = {
'room': room,
}
self.render('share.html', **context)
def post(self):
try:
user_id = self.get_argument('user_id')
room_id = self.get_argument('room_id')
welfare_type = self.get_argument('welfare_type',
WELFARE_TYPE_SPECIAL)
price = float(self.get_argument('price'))
count = int(self.get_argument('count'))
name = self.get_argument('name')
images = self.get_argument('images')
start_time = self.get_argument('start_time')
deadline = self.get_argument('deadline')
except MissingArgumentError:
return self.error(MISSING_PARAMS)
user = User.get(user_id)
room = Room.get(room_id)
if not room:
return self.error(ROOM_NOT_FOUND)
star_fund = StarFund.get_by_room(room_id)
amount = price * count + count * WELFARE_POSTAGE
if float(star_fund.balance) < amount:
return self.error(ROOM_STAR_FUND_NOT_ENOUGH)
room_user = RoomUser.get_by_room_and_user(room_id, user_id)
if not room_user or not int(
room_user.status) in (ROOM_USER_ADMIN, ROOM_USER_CREATOR):
return self.error(ACCESS_NOT_ALLOWED)
try:
welfare = Welfare.add(user_id, room_id, welfare_type, price, count,
name, start_time, deadline, images,
room_user.status, amount)
except Exception as e:
logger.error(u'创建福利失败。Error:[%s]' % e)
return self.error(SYSTEM_ERROR)
self.render({
'status': 0,
'data': welfare.jsonify(),
})
handle_daily_create_welfare.delay(user_id, welfare.id)
welfare_created_notify.delay(room, welfare)
# scheduler = TornadoScheduler()
# scheduler.add_jobstore('redis', jobs_key='welfare:jobs', run_times_key='welfare:deadline')
# tornado_scheduler.add_jobstore('redis', jobs_key='welfare:jobs', run_times_key='welfare:deadline')
tornado_scheduler.add_job(welfare_end_notify,
'date',
run_date=welfare.deadline,
args=[welfare])
return
def put(self):
try:
user_id = self.get_argument('user_id')
room_id = self.get_argument('room_id')
name = self.get_argument('name')
tag_ids = self.get_argument('tag_ids', [])
intro = self.get_argument('intro', '')
limit_user_number = self.get_argument('limit_user_number',
LIMIT_USER_NUMBER)
status = self.get_argument('status', ROOM_PUBLIC)
avatar_url = self.get_argument('avatar', '')
except MissingArgumentError:
return self.error(MISSING_PARAMS)
if filter.check_sensitive(name) or filter.check_sensitive(
intro) or filter_name.check_sensitive(name):
return self.error(SENSITIVE_WORD_EXISTS)
try:
tag_ids = json.loads(tag_ids)
except ValueError:
tag_ids = []
try:
avatar = json.loads(avatar_url)[0]
except:
avatar = avatar_url
o = urlparse(avatar)
img_path = o.path
if img_path.startswith('/'):
avatar = re.sub(r'/', '', img_path, 1)
else:
avatar = img_path
room = Room.get(room_id)
if not room:
return self.error(ROOM_NOT_FOUND)
if RoomTag.get_tag_ids_by_room(room_id) != tag_ids:
RoomTag.update_tags(room_id, tag_ids)
try:
room.update(name=name,
intro=intro,
limit_user_number=limit_user_number,
status=status,
avatar=avatar)
update_open_search_room.delay(room_id, name, intro, tag_ids)
except Exception, e:
logger.error(u'更新房间失败。error:[%s]', e)
return self.error(SYSTEM_ERROR)
def post(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)
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_NOT_NEED_JOIN_ROOM)
if RoomUser.room_exists_user(room_id, user_id):
return self.error(ROOM_EXISTS_USER)
if RoomBlackUser.is_room_black_user(room_id, user_id):
return self.error(USER_IN_ROOM_BLACK_LIST)
# 房主自身也属于房间成员之一
if room.limit_user_number:
room_user_amount = RoomUser.get_user_amount_by_room(room_id)
if room_user_amount == room.limit_user_number:
return self.error(ROOM_USER_FULL)
if room.private_not_join:
return self.error(ROOM_NOT_JOIN)
if room.private_need_verify:
room_question = RoomQuestion.get_question_by_room(room_id)
return self.render({
'status': 0,
'data': room_question.jsonify() if room_question else None
})
else:
try:
RoomUser.add(room_id, user_id, ROOM_USER_NORMAL)
# handle_join_room_integral.delay(user_id, room_id)
# user_amount = room.user_amount
# if user_amount == 500:
# handle_room_user_over_500_integral.delay(room.creator_id, room.id)
return self.render({
"status": 0,
"data": room.jsonify(user),
})
except Exception as e:
logger.error(u'用户加入房间失败。User:[%s] Room:[%s] Error:[%s]' % (user_id, room_id, e))
return self.error(SYSTEM_ERROR)
def has_room_access(self, room_id):
from starmachine.model.room_user import RoomUser
from starmachine.model.room import Room
room = Room.get(room_id)
if self.super_user:
return True
if int(room.creator_id) == int(self.id):
return True
if RoomUser.room_exists_user(room_id, self.id):
return True
return False
def post(self):
try:
user_id = self.get_argument('user_id')
room_id = self.get_argument('room_id')
name = self.get_argument('name')
deadline = self.get_argument('deadline')
options = self.get_argument('options')
options = json.loads(options)
except (MissingArgumentError, TypeError):
return self.error(MISSING_PARAMS)
if filter.check_sensitive(name):
return self.error(SENSITIVE_WORD_EXISTS)
for op in options:
if filter.check_sensitive(op):
return self.error(SENSITIVE_WORD_EXISTS)
if len(op) > 24:
return self.error(OPTION_TEXT_TOO_LONG)
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)
room_user = RoomUser.get_by_room_and_user(room_id, user_id)
if not user.super_user:
if not room_user:
return self.error(ACCESS_NOT_ALLOWED)
if int(room_user.status) == ROOM_USER_SILENT:
return self.error(USER_IN_ROOM_SILENT_LIST)
try:
vote = Vote.add(user_id, room_id, name, deadline, options,
room_user.status)
except Exception as e:
logger.error(u'添加投票失败。Error:[%s]' % e)
return self.error(SYSTEM_ERROR)
handle_daily_create_content.delay(user_id, vote.id)
return self.render({
'status': 0,
'data': vote.jsonify(),
})
def get_rooms_by_tags(cls, tags):
db = DbManager().db
params = ['tag_id=%s' % tag.id for tag in tags if tag]
union_str = ' or '.join(params)
if union_str:
sql = 'select room_id from {table} where %s'.format(
table=cls.table) % union_str
room_ids_dict = db.query(sql)
room_ids = [
room_id_dict.get('room_id') for room_id_dict in room_ids_dict
]
room_ids = list(set(room_ids))
return room_ids and [Room.get(room_id) for room_id in room_ids]
return []
def post(self):
try:
room_id = self.get_argument('room_id')
user_id = self.get_argument('user_id')
silent_user_id = self.get_argument('silent_user_id')
except MissingArgumentError:
return self.error(MISSING_PARAMS)
set_time = datetime.now()
operator = User.get(user_id)
silent_user = User.get(silent_user_id)
if not silent_user:
return self.error(USER_NOT_FOUND)
room = Room.get(room_id)
if not room:
return self.error(ROOM_NOT_FOUND)
room_operator = RoomUser.get_by_room_and_user(room_id, user_id)
room_silent_user = RoomUser.get_by_room_and_user(
room_id, silent_user_id)
operator_status = room_operator.status
if not room_operator.has_room_user_handle_access(room_silent_user):
return self.error(ACCESS_NOT_ALLOWED)
try:
RoomUser.set_user_silent(room_id, silent_user_id, set_time)
except Exception as e:
logger.error(u'用户房间禁言失败。User:[%s], Room:[%s], Error:[%s]' %
(silent_user_id, room_id, e))
return self.error(SYSTEM_ERROR)
self.render({
'status': 0,
})
room_silent_user_notify.delay(operator, operator_status, room,
silent_user)
# scheduler = TornadoScheduler()
# scheduler.add_jobstore('redis', jobs_key='room_user:silent:jobs', run_times_key='room_user:remove_silent')
run_date = set_time + timedelta(days=1)
tornado_scheduler.add_job(
remove_room_silent_user,
'date',
run_date=run_date,
args=[room_id, user_id, room_silent_user.status])
# scheduler.start()
return
def get(self):
try:
user_id = self.get_argument('user_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)
has_joined_rooms = RoomUser.get_rooms_by_user(user_id, 0, 1)
if has_joined_rooms:
join_rooms = RoomUser.get_rooms_by_user_order_by_update_time(user_id, start, count)
return self.render({
'status': 0,
'data': {
'recommend': 'joined',
'data': [room.jsonify(user) for room in join_rooms],
}
})
user_tags = UserTag.get_tags_by_user(user_id)
if user_tags:
rooms = RoomTag.get_rooms_by_tags(user_tags)
if rooms:
rooms = sorted(rooms, key=lambda room: room.user_amount, reverse=True)
end = start + count - 1
rooms = rooms[start: end]
return self.render({
'status': 0,
'data': {
'recommend': 'tags',
'data': [room.jsonify(user) for room in rooms],
}
})
rooms = Room.get_rooms_by_user_amount(start, count)
return self.render({
'status': 0,
'data': {
'recommend': 'hot',
'data': [room.jsonify(user) for room in rooms if int(room.id) not in [100043, 100053]],
}
})
def get(self):
try:
user_id = self.get_argument('user_id')
content_id = self.get_argument('content_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)
content = Content.get(content_id)
if not content:
return self.error(CONTENT_NOT_FOUND)
room = Room.get(room_id)
if not room:
return self.error(ROOM_NOT_FOUND)
if not user.has_room_access(room_id) or int(
content.room_id) != int(room_id):
return self.error(ACCESS_NOT_ALLOWED)
reward_orders = RewardOrder.get_reward_orders_by_content(
content_id, start, count)
data = []
for reward_order in reward_orders:
creator = User.get(reward_order.creator_id)
amount = float(reward_order.amount)
pay_time = reward_order.pay_time.strftime('%Y-%m-%d %H:%M:%S')
data.append({
'user': {
'id': creator.id,
'name': creator.user_name,
'avatar': creator.avatar_url,
},
'amount': amount,
'pay_time': pay_time
})
return self.render({'status': 0, 'data': data})
