def get_comments_by_content(cls, content_id, start, count):
cache = CacheManager().cache
cache_key = CONTENT_COMMENT_CACHE_KEY % content_id
end = start + count - 1
comment_ids = cache.lrange(cache_key, start, end)
comments = [cls.get(comment_id) for comment_id in comment_ids]
return comments
def left_change_times(self):
cache = CacheManager().cache
redis_key = flower_user_name_update_limit_key % self.user_id
if cache.exists(redis_key):
update_count = cache.get(redis_key)
return 3 - int(update_count)
else:
return 3
def get_contents_by_user(cls, user_id, start, count):
cache = CacheManager().cache
end = start + count - 1
content_ids = cache.zrevrange(USER_CREATED_CONTENT_KEY % user_id,
start, end)
return content_ids and [
Content.get(content_id) for content_id in content_ids
]
def get_user_reward_rank(cls, start=0, count=10):
cache = CacheManager().cache
end = start + count - 1
rst = cache.zrevrange(USER_REWARD_RANK_CACHE_KEY, start, end, True)
if rst:
return [{'user_id': d[0], 'amount': d[1]} for d in rst]
else:
return []
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_reward_rank(self, start, count):
cache = CacheManager().cache
redis_key = ROOM_USER_REWARD_CACHE_KEY % self.id
end = start + count - 1
rst = cache.zrevrange(redis_key, start, end, True)
if rst:
return [{'user_id': info[0], 'amount': info[1]} for info in rst]
else:
return []
def get_user_amount_by_room(cls, room_id):
cache = CacheManager().cache
cache_key = ROOM_USER_CACHE_KEY % room_id
if cache.exists(cache_key):
return cache.zcard(cache_key)
else:
db = DbManager().db
sql = 'select count(id) from {table} where room_id=%s'.format(table=cls.table)
return db.get(sql, room_id).get('count(id)')
def get_rooms_increase_rank(cls, year, month, start=0, count=10):
redis_key = ROOM_INCREASE_RANK_CACHE_KEY % (year, month)
cache = CacheManager().cache
end = start + count - 1
rst = cache.zrevrange(redis_key, start, end, True)
if rst:
return [{'room_id': d[0], 'increase': d[1]} for d in rst]
else:
return []
def get_follows_by_user(cls, user_id, start=0, count=10):
cache = CacheManager().cache
end = start + count - 1
user_follow_key = USER_FOLLOW_KEY % user_id
rst = cache.zrevrange(user_follow_key, start, end, True)
if rst:
return [{'user_id': d[0], 'follow_time': d[1]} for d in rst]
else:
return []
def flush_reward_cache(self):
cache = CacheManager().cache
now = datetime.now()
for delta in xrange(1, 5):
month = now.month - 1 + delta
year = now.year + month / 12
month = month % 12 + 1
max_day = calendar.monthrange(year, month)[1]
end_day = (datetime(year=year, month=month, day=max_day) + timedelta(days=1)).strftime('%Y-%m-%d')
user_cache_key = USER_DATE_REWARD_CACHE % (self.room_id, end_day)
cache.delete(user_cache_key)
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 has_followed(cls, user_id, follow_id):
cache = CacheManager().cache
cache_key = USER_FOLLOW_KEY % user_id
if cache.exists(cache_key):
return cache.zscore(cache_key, follow_id)
else:
db = DbManager().db
sql = 'select id from {table} where user_id=%s and follow_id=%s'.format(table=cls.table)
try:
return db.query(sql, user_id, follow_id)[0]
except:
return None
def room_exists_user(cls, room_id, user_id):
cache = CacheManager().cache
cache_key = ROOM_USER_CACHE_KEY % room_id
if cache.exists(cache_key):
return cache.zscore(cache_key, user_id)
else:
db = DbManager().db
sql = 'select id from {table} where room_id=%s and user_id=%s'.format(table=cls.table)
try:
return db.query(sql, room_id, user_id)[0]
except:
return None
def post(self):
try:
user_id = self.get_argument('user_id')
name = self.get_argument('name')
except MissingArgumentError:
return self.error(MISSING_PARAMS)
if FlowerUser.exists_name(name):
return self.error(FLOWER_USER_NAME_EXISTS)
if get_str_length(name) < 2:
return self.error(FLOWER_NAME_LESS_MINIMUM_LIMIT)
if get_str_length(name) > 20:
return self.error(FLOWER_NAME_OVER_MAXIMUM_LIMIT)
group_user_info = FlowerUser.get_by_user(user_id)
if not group_user_info:
try:
random_name = random.choice(FLOWER_AVATAR_ARR)
avatar_uri = 'static/avatar/flower/image_huaming_%[email protected]' % random_name
group_user_info = FlowerUser.add(user_id, name, avatar_uri)
except Exception as e:
logger.error(u'添加用户花名成功。Error:[%s]' % e)
return self.error(SYSTEM_ERROR)
else:
try:
cache = CacheManager().cache
redis_key = flower_user_name_update_limit_key % user_id
if cache.exists(redis_key):
update_count = cache.get(redis_key)
if int(update_count) >= 3:
return self.error(FLOWER_USER_NAME_UPDATE_OVER_LIMIT)
else:
group_user_info.update_name(name)
cache.incr(redis_key, 1)
else:
group_user_info.update_name(name)
cache.set(redis_key, 1)
cache.expire(redis_key, flower_user_name_update_limit_time)
except Exception as e:
logger.error(u'更新用户花名失败。Error:[%s]', e)
return self.error(SYSTEM_ERROR)
if UserChatStatus.is_flower_identity(user_id):
rong_client.user_refresh(user_id, name=name)
return self.render({
'status': 0,
'data': {
'left_change_times': group_user_info.left_change_times(),
}
})
def remove_and_black_user(cls, room_id, user_id):
remove_time = datetime.now()
db = DbManager().db
db.execute('begin;')
try:
sql = 'delete from {table} where room_id=%s and user_id=%s'.format(table=cls.table)
db.execute(sql, room_id, user_id)
sql = 'insert into {table} (room_id, user_id, create_time) values (%s, %s, %s)'.format(table=RoomBlackUser.table)
db.execute(sql, room_id, user_id, remove_time)
db.execute('commit;')
logger.info(u'在mysql中从房间中移除用户成功。Room:[%s], User:[%s]' % (room_id, user_id))
except:
db.execute('rollback;')
logger.error(u'在mysql中从房间中移除用户失败。Room:[%s], User:[%s]' % (room_id, user_id))
raise
cache = CacheManager().cache
room_user_key = ROOM_USER_CACHE_KEY % room_id
user_room_key = USER_ROOM_CACHE_KEY % user_id
try:
cache.zrem(room_user_key, user_id)
cache.zrem(user_room_key, room_id)
logger.info(u'在redis中从房间中移除用户成功。Room:[%s], User:[%s]' % (room_id, user_id))
except Exception as e:
logger.error(u'从redis中删除房间用户关系失败。Error:[%s]' % e)
raise
cache.zincrby(ROOM_USER_COUNT_KEY, room_id, -1)
room_increase_rank_key = ROOM_INCREASE_RANK_CACHE_KEY % (remove_time.year, remove_time.month)
cache.zincrby(room_increase_rank_key, room_id, -1)
def add(cls,
creator_id,
name,
intro,
tag_ids,
avatar,
limit_user_number,
create_time,
status=ROOM_PUBLIC,
question_info=None):
from starmachine.model.room_tag import RoomTag
from starmachine.model.room_user import RoomUser
db = DbManager().db
cache = CacheManager().cache
db.execute('begin;')
try:
sql = 'insert into {table} (creator_id, name, intro, avatar, limit_user_number, status, create_time) ' \
'values (%s, %s, %s, %s, %s, %s, %s)'.format(table=cls.table)
room_id = db.execute(sql, creator_id, name, intro, avatar,
limit_user_number, status, create_time)
if int(status) == ROOM_PRIVATE_NEED_VERIFY and question_info:
question_name = question_info.get('question_name')
options = question_info.get('options')
sql = 'insert into {table} (room_id, name, create_time) values (%s, %s, %s)'.format(
table=RoomQuestion.table)
room_question_id = db.execute(sql, room_id, question_name,
create_time)
for option in options:
text = option.get('text')
is_right_answer = option.get('is_right_answer')
sql = 'insert into {table} (question_id, text, is_right_answer) values (%s, %s, %s)'.format(
table=RoomQuestionOption.table)
db.execute(sql, room_question_id, text, is_right_answer)
for tag_id in tag_ids:
sql = 'insert into {table} (room_id, tag_id) values (%s, %s)'.format(
table=RoomTag.table)
db.execute(sql, room_id, tag_id)
sql = 'insert into {table} (room_id, balance) values (%s, %s)'.format(
table=StarFund.table)
db.execute(sql, room_id, '0.00')
db.execute('commit;')
except:
db.execute('rollback;')
raise
cache_key = USER_CREATED_ROOM_KEY % creator_id
cache.sadd(cache_key, room_id)
RoomUser.add(room_id, creator_id, ROOM_USER_CREATOR)
return room_id
def add(cls, user_id, reply_user_id, content_id, text):
db = DbManager().db
create_time = datetime.now()
cache = CacheManager().cache
cache_key = CONTENT_COMMENT_CACHE_KEY % content_id
sql = 'insert into {table} (user_id, reply_user_id, content_id, text, create_time) values ' \
'(%s, %s, %s, %s, %s)'.format(table=cls.table)
comment_id = db.execute(sql, user_id, reply_user_id, content_id, text,
create_time)
if comment_id:
content = Content.get(content_id)
content.update(last_comment_time=create_time)
cache.lpush(cache_key, comment_id)
return cls(comment_id, user_id, reply_user_id, content_id, text,
create_time)
def delete(self):
db = DbManager().db
content_id = self.id
db.execute('begin;')
try:
sql = 'delete from {table} where id=%s'.format(table=self.table)
db.execute(sql, content_id)
db.execute('commit;')
except:
db.execute('rollback;')
raise
cache = CacheManager().cache
posts_cache_key = POSTS_CACHE_KEY % content_id
cache.delete(posts_cache_key)
def get_liked_message_by_group(cls, group_id, start=0, count=10):
cache = CacheManager().cache
group_message_list_key = GROUP_MESSAGE_LIKED_LIST % group_id
end = start + count - 1
rst = cache.zrevrange(group_message_list_key, start, end, True)
data = []
for d in rst:
message_id = d[0]
amount = d[1]
message = GroupMessage.get(message_id)
if message:
data.append({
'message_id': message.id,
'content': message.content,
'amount': amount,
})
return data
def get_liked_message_amount_by_group(cls, group_id):
cache = CacheManager().cache
group_message_list_key = GROUP_MESSAGE_LIKED_LIST % group_id
rst = cache.zrevrange(group_message_list_key, 0, -1, True)
data = []
for d in rst:
message_id = d[0]
amount = d[1]
message = GroupMessage.get(message_id)
if message:
message_creator_id = message.creator_id
data.append({
'message_id': message_id,
'amount': amount,
'creator_id': message_creator_id,
})
return data
def add(cls, user_id, vote_id, option_id):
db = DbManager().db
cache = CacheManager().cache
create_time = datetime.now()
date = create_time.date()
vote_cache_key = VOTE_PEOPLE_CACHE_KEY % vote_id
option_cache_key = VOTE_OPTION_PEOPLE_CACHE_KEY % option_id
vote_daily_count_redis_key = USER_DAILY_VOTE_COUNT % (user_id, date)
sql = 'insert into {table} (user_id, vote_id, option_id, create_time) values (%s, %s, %s, %s)'.format(
table=cls.table)
db.execute(sql, user_id, vote_id, option_id, create_time)
cache.zadd(vote_cache_key, get_int_date(create_time), user_id)
cache.zadd(option_cache_key, get_int_date(create_time), user_id)
cache.incr(vote_daily_count_redis_key, 1)
def add_verify_code(cls, verify_type, telephone, verify_code):
cache = CacheManager().cache
key = VERIFY_CODE_CACHE_KEY.get(verify_type) % telephone
cache.mset({
key: verify_code,
})
cache.expire(key, settings.VERIFY_CODE_EXPIRE_TIME)
def delete_room_user(cls, room_id, user_id):
cache = CacheManager().cache
delete_time = datetime.now()
room_user_key = ROOM_USER_CACHE_KEY % room_id
user_room_key = USER_ROOM_CACHE_KEY % user_id
try:
cache.zrem(room_user_key, user_id)
cache.zrem(user_room_key, room_id)
logger.info(u'从redis中删除房间用户关系成功。')
except Exception as e:
logger.error(u'从redis中删除房间用户关系失败。Error:[%s]' % e)
raise
job_delete_room_user.delay(room_id, user_id)
cache.zincrby(ROOM_USER_COUNT_KEY, room_id, -1)
room_increase_rank_key = ROOM_INCREASE_RANK_CACHE_KEY % (delete_time.year, delete_time.month)
cache.zincrby(room_increase_rank_key, room_id, -1)
return
def add(cls, room_id, user_id, status=ROOM_USER_NORMAL):
join_time = datetime.now()
cache = CacheManager().cache
room_user_key = ROOM_USER_CACHE_KEY % room_id
user_room_key = USER_ROOM_CACHE_KEY % user_id
score = get_int_date(join_time)
try:
cache.zadd(room_user_key, score, user_id)
cache.zadd(user_room_key, score, room_id)
logger.info(u'添加房间用户关系到redis成功。')
except Exception as e:
logger.error(u'添加房间关系用户到redis失败。Error:[%s]' % e)
raise
add_room_user.delay(room_id, user_id, join_time, status)
cache.zincrby(ROOM_USER_COUNT_KEY, room_id)
room_increase_rank_key = ROOM_INCREASE_RANK_CACHE_KEY % (join_time.year, join_time.month)
cache.zincrby(room_increase_rank_key, room_id, 1)
return
def add(cls, creator_id, proverbs, status=CHECK_STATUS_PENDING):
create_time = datetime.now()
db = DbManager().db
cache = CacheManager().cache
sql = 'insert into {table} (creator_id, proverbs, status, create_time) values (%s, %s, %s, %s)'.format(
table=cls.table)
proverbs_id = db.execute(sql, creator_id, proverbs, status,
create_time)
if proverbs_id:
user_tag_proverbs_limit_key = user_tag_proverbs_24_hours_limit % creator_id
cache.set(user_tag_proverbs_limit_key, 'true')
cache.expire(user_tag_proverbs_limit_key, LIMIT_SECONDS)
return cls(proverbs_id, creator_id, proverbs, status, create_time,
None, None)
def post(self):
try:
user_id = self.get_argument('user_id')
room_id = self.get_argument('room_id')
question_id = self.get_argument('question_id')
option_id = self.get_argument('option_id')
except MissingArgumentError:
return self.error(MISSING_PARAMS)
user = User.get(user_id)
room = Room.get(room_id)
question = RoomQuestion.get(question_id)
option = RoomQuestionOption.get(option_id)
if not question:
return self.error(ROOM_QUESTION_NOT_FOUND)
if int(question.room_id) != int(room_id) or option.question_id != int(question_id):
return self.error(ACCESS_NOT_ALLOWED)
user_room_question_24_hours_limit = 'user:%s:room:%s:question:24:limit'
LIMIT_SECONDS = 24 * 60 * 60
redis_key = user_room_question_24_hours_limit % (user_id, room_id)
cache = CacheManager().cache
if cache.exists(redis_key):
return self.error(ROOM_QUESTION_ANSWER_LIMIT)
cache.set(redis_key, 'true')
cache.expire(redis_key, LIMIT_SECONDS)
if option.is_right_answer:
try:
RoomUser.add(room_id, user_id, ROOM_USER_NORMAL)
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)
else:
return self.error(ROOM_QUESTION_ANSWER_WRONG)
def unfollow(cls, user_id, follow_id):
cache = CacheManager().cache
db = DbManager().db
user_follow_key = USER_FOLLOW_KEY % user_id
user_fans_key = USER_FANS_KEY % follow_id
cache.zrem(user_follow_key, follow_id)
cache.zrem(user_fans_key, user_id)
db.execute('begin;')
try:
sql = 'select follow_type from {table} where user_id=%s and follow_id=%s'.format(table=cls.table)
follow_type = int(db.get(sql, user_id, follow_id).get('follow_type'))
sql = 'delete from {table} where user_id=%s and follow_id=%s'.format(table=cls.table)
db.execute(sql, user_id, follow_id)
sql = 'delete from {table} where user_id=%s and fans_id=%s'.format(table=UserFans.table)
db.execute(sql, follow_id, user_id)
if follow_type == FOLLOW_BOTH_TYPE:
sql = 'update {table} set type=%s where user_id=%s and follow_id=%s'.format(table=cls.table)
db.execute(sql, FOLLOW_SINGLE_TYPE, follow_id, user_id)
db.execute('commit;')
except:
db.execute('rollback;')
raise
def follow(cls, user_id, follow_id, follow_type):
db = DbManager().db
cache = CacheManager().cache
create_time = datetime.now()
score = get_int_date(create_time)
follow_type = int(follow_type)
user_follow_key = USER_FOLLOW_KEY % user_id
user_fans_key = USER_FANS_KEY % follow_id
cache.zadd(user_follow_key, score, follow_id)
cache.zadd(user_fans_key, score, user_id)
db.execute('begin;')
try:
sql = 'insert into {table} (user_id, follow_id, follow_type, create_time) values (%s, %s, %s, %s)'.format(table=cls.table)
db.execute(sql, user_id, follow_id, follow_type, create_time)
sql = 'insert into {table} (follow_id, user_id, create_time) values (%s, %s, %s)'.format(table=UserFans.table)
db.execute(sql, follow_id, user_id, create_time)
if follow_type == FOLLOW_BOTH_TYPE:
sql = 'update {table} set follow_type=%s where user_id=%s and follow_id=%s'.format(table=cls.table)
db.execute(sql, FOLLOW_BOTH_TYPE, follow_id, user_id)
db.execute('commit;')
except:
db.execute('rollback;')
raise
def delete(self):
db = DbManager().db
content_id = self.id
db.execute('begin;')
try:
sql = 'delete from {table} where id=%s'.format(table=self.table)
db.execute(sql, content_id)
sql = 'delete from comment where content_id=%s'
db.execute(sql, content_id)
sql = 'delete from content_liked where content_id=%s'
db.execute(sql, content_id)
db.execute('commit;')
except:
db.execute('rollback;')
raise
cache = CacheManager().cache
cache.zrem(USER_CREATED_CONTENT_KEY % self.creator_id, content_id)
# 删除内容的评论和点赞记录
content_comment_key = CONTENT_COMMENT_CACHE_KEY % content_id
comment_ids = cache.lrange(content_comment_key, 0, -1)
with cache.pipeline() as pipe:
for comment_id in comment_ids:
comment_cache_key = COMMENT_CACHE_KEY % comment_id
pipe.delete(comment_cache_key)
pipe.delete(content_comment_key)
content_liked_key = CONTENT_LIKED_CACHE_KEY % content_id
pipe.delete(content_liked_key)
pipe.zrem(CONTENT_LIKED_RANK_KEY, content_id)
pipe.execute()
ContentTypeMap = getContentTypeMap()
content_model = ContentTypeMap.get(self.content_type)
content_obj = content_model.get(self.id)
content_obj.delete()
def flush_comment_cache(self):
cache = CacheManager().cache
cache_obj_key = COMMENT_CACHE_KEY % self.id
cache_list_key = CONTENT_COMMENT_CACHE_KEY % self.content_id
cache.delete(cache_obj_key)
cache.lrem(cache_list_key, 0, self.id)