def post(self):
if Users.filter_by_query(username=self.input.username).all():
raise LogicError("username重复，请使用其他username")
if Users.filter_by_query(email=self.input.email).all():
raise LogicError("email重复，请更换email地址或使用原地址找回密码")
email_code_key = f'{session.sid}:email:code'
email_code_raw = redis_store.get(email_code_key)
if email_code_raw is None:
raise LogicError('邮箱验证码不正确，请重新发送')
code, email = email_code_raw.decode('utf-8').split('|')
if self.input.email_code.upper() != code or self.input.email != email:
raise LogicError('邮箱验证码不正确，请重新发送')
user_obj = Users.create_by_uid()
user_obj.email = email
user_obj.username = self.input.username
user_obj.set_password(password=self.input.password)
update_dict = dict()
for k in ['sex', 'avatar_url']:
if getattr(self.input, k) is not None:
update_dict[k] = getattr(self.input, k)
user_obj.update(**update_dict)
def get(self):
if self.input.uid:
obj = Users.get_by_uid(self.input.uid)
data = obj.to_dict(remove_fields_list=['password'])
else:
data = Users.filter_by_query()
if self.input.sk_ and self.input.sv_:
data = data.filter(getattr(Users, self.input.sk_).like(f'%{self.input.sv_}%'))
if self.input.odb_ and self.input.odt_ in ['asc', 'desc']:
data = data.order_by(getattr(getattr(Users, self.input.odb_), self.input.odt_)())
else:
data = data.order_by(Users.time_create.desc())
total = None
if self.input.page and self.input.page_size:
total = data.count()
data = data.offset(
(int(self.input.page) - 1) * int(self.input.page_size)
).limit(int(self.input.page_size))
data = [_t.to_dict(remove_fields_list=['password']) for _t in data]
if total is not None:
data = {'total': total, 'list': data}
return data
def init_app(username, password):
# check
if Users.filter_by_query(role_id=1).first():
print('重复初始化！退出')
exit(1)
# create admin
user_obj = Users.create_by_uid()
user_obj.username = username
user_obj.email = '*****@*****.**'
user_obj.role_id = 1
user_obj.set_password(password)
user_obj.save()
# create base tab
with open(os.path.join(BASE_DIR, 'tabs.json'), 'r') as f:
tab_data = json.loads(f.read())
for t in tab_data:
t_obj = Tabs.create_by_uid()
t_obj.name = t['name']
t_obj.zh = t['zh']
if t.get('sort_num'):
t_obj.sort_num = t['sort_num']
t_obj.save()
for st in t.get('sub_tabs'):
st_obj = SubTabs.create_by_uid()
st_obj.tab_id = t_obj.id
st_obj.name = st['name']
st_obj.zh = st['zh']
if st.get('sort_num'):
st_obj.sort_num = st['sort_num']
st_obj.desc = st['desc']
st_obj.save()
print(f'init success! admin username: {username}, password: {password}')
def check_login(username, password):
user_obj = Users.filter_by_query(username=username).first()
if not user_obj:
raise AuthError("用户不存在")
if not user_obj.check_password(password):
raise AuthError("密码错误")
if not user_obj.status:
raise AuthError("账户已经停用")
return user_obj
def post(self):
code_key = f'{session.sid}:code'
code = redis_store.get(code_key)
if code is None or self.input.code.upper() != code.decode('utf-8'):
raise VerifyError('图形验证码不正确,请重试')
if not self.is_valid_email(self.input.email):
raise ParamsError('email 不合法')
if Users.filter_by_query(email=self.input.email).all():
raise LogicError("该email地址已经注册过，请更换email地址")
# 加计数锁
lock_key_name = f'lock:send_mail_count:{session.sid}'
lock_value = self.generate_hash_uuid(12)
set_status = redis_store.set(lock_key_name, lock_value, ex=600, nx=True)
if not set_status:
return LogicError('正在发送，请稍后重试')
# 获取发送次数 + 1
send_count_key = f'{session.sid}:email:send'
send_count = redis_store.get(send_count_key)
if send_count:
send_count = int(send_count.decode('utf-8'))
if send_count >= 5:
raise LogicError('发送次数太频繁，请稍后再发送')
else:
send_count = 0
send_count += 1
code = self.generate_hash_uuid(5).upper()
send_register_mail.delay(self.input.email, code)
# 设置发送的验证码
email_code_key = f'{session.sid}:email:code'
redis_store.set(email_code_key, f'{code}|{self.input.email}', ex=180)
# 设置新的发送次数
redis_store.set(send_count_key, send_count, ex=180)
# 释放锁
ret = release_redis_lock(lock_key_name, lock_value)
if not ret:
raise LogicError('发送解锁失败')
def get(self):
data = dict()
sub_tab_dict_list = defaultdict(list)
for sub_tab in SubTabs.filter_by_query().order_by(
SubTabs.sort_num.asc()):
sub_tab_dict_list[sub_tab.tab_id].append(sub_tab.to_dict())
tab_list = [
t.to_dict()
for t in Tabs.filter_by_query().order_by(Tabs.sort_num.asc())
]
for _d in tab_list:
_d['sub_tabs'] = sub_tab_dict_list.get(_d['id']) or []
data['tabs'] = tab_list
if self.input.tab:
tab_obj = Tabs.filter_by_query(name=self.input.tab).first()
if not tab_obj:
tab_obj = Tabs.get_by_query(name='tech')
else:
tab_obj = Tabs.get_by_query(name='tech')
topic_objs = Topics.filter_by_query(tab_id=tab_obj.id).order_by(
Topics.time_create.desc())
data['tab_topic_count'] = topic_objs.count()
topic_list = [_t.to_dict() for _t in topic_objs[:80]]
user_dict = {
i.id: i.to_dict(remove_fields_list=['password'])
for i in Users.query.filter(
Users.id.in_(set(
i['user_id'] for i in topic_list)), Users.available == 1)
}
last_reply_user_dict = {
i.id: i.to_dict(remove_fields_list=['password'])
for i in Users.query.filter(
Users.id.in_(set(i['last_reply_user_id']
for i in topic_list)), Users.available == 1)
}
tab_dict = {
i.id: i.to_dict()
for i in Tabs.query.filter(
Tabs.id.in_(set(
i['tab_id'] for i in topic_list)), Tabs.available == 1)
}
sub_tab_dict = {
i.id: i.to_dict()
for i in SubTabs.query.filter(
SubTabs.id.in_(set(
i['sub_tab_id']
for i in topic_list)), SubTabs.available == 1)
}
comment_count_dict = dict()
for c in Comments.query.filter(
Comments.topic_id.in_(set(i['id'] for i in topic_list)),
Comments.available == 1):
if comment_count_dict.get(c.topic_id):
comment_count_dict[c.topic_id] += 1
else:
comment_count_dict[c.topic_id] = 1
up_down_dict_list = defaultdict(list)
for up_down_obj in TopicUpDown.query.filter(
TopicUpDown.topic_id.in_(set(i['id'] for i in topic_list)),
TopicUpDown.available == 1):
up_down_dict_list[up_down_obj.topic_id].append(up_down_obj.action)
for _t in topic_list:
_t['user'] = user_dict[_t['user_id']]
if _t['last_reply_user_id']:
_t['last_reply_user'] = last_reply_user_dict[
_t['last_reply_user_id']]
_t['tab'] = tab_dict[_t['tab_id']]
_t['sub_tab'] = sub_tab_dict[_t['sub_tab_id']]
_t['comment_count'] = comment_count_dict.get(_t['id'], 0)
# 获取up和down数量
if up_down_dict_list.get(_t['id']):
_t['up_count'] = len(
[i for i in up_down_dict_list[_t['id']] if i is True])
_t['down_count'] = len(
[i for i in up_down_dict_list[_t['id']] if i is False])
else:
_t['up_count'] = 0
_t['down_count'] = 0
data['topics'] = topic_list
data['user_count'] = Users.filter_by_query().count()
data['topic_count'] = Topics.filter_by_query().count()
data['comment_count'] = Comments.filter_by_query().count()
today_time_start = self.strptime(
self.get_datetime_now().strftime('%Y-%m-%d'), '%Y-%m-%d')
today_topic_list = [
i.to_dict() for i in Topics.query.filter(
Topics.time_create >= today_time_start, Topics.available == 1)
]
if today_topic_list:
today_comment_dict = dict()
for _c in Comments.query.filter(
Comments.topic_id.in_(
set([i['id'] for i in today_topic_list])),
Comments.available == 1):
if today_comment_dict.get(_c.topic_id):
today_comment_dict[_c.topic_id] += 1
else:
today_comment_dict[_c.topic_id] = 1
for today_topic in today_topic_list:
today_topic['comment_count'] = today_comment_dict.get(
today_topic['id'], 0)
today_hot_topic_list = sorted(today_topic_list,
key=lambda x: x['comment_count'],
reverse=True)
if len(today_hot_topic_list) >= 10:
today_hot_topic_list = today_hot_topic_list[:10]
else:
today_hot_topic_list = []
data['hot_topics'] = today_hot_topic_list
if session.get('is_login'):
fav_sub_tab_id_list = [
i.sub_tab_id for i in SubTabFav.filter_by_query(
user_id=session['user_info']['id'])
]
sub_tab_list = [
i.to_dict() for i in SubTabs.query.filter(
SubTabs.id.in_(set(fav_sub_tab_id_list)), SubTabs.available
== 1)
]
data['fav_tabs'] = sub_tab_list
return data
