def delete_article(article_id: str,
current_user: User = Depends(get_current_user)):
article = Article.filter(Article.id == article_id, Article.user_id == current_user.uuid).first()
if not article:
return fail_response('此文章不存在')
title = article.title
try:
# 之前这个是 物理删除
# result = article.delete_instance()
# 删除改为逻辑删除
query = Article.update(is_delete=True).where(
Article.id == article_id, Article.user_id == current_user.uuid)
result = query.execute()
# print(result, "运行后的结果")
if result:
res = redis_client.exists("article_rank_list")
if res:
# 存在了但是这个文章
res_score = redis_client.zscore("article_rank_list", "article_%s_%s" % (article_id, title))
if res_score:
# 删除之前的分数记录
redis_client.zrem("article_rank_list", "article_%s_%s" % (article_id, title))
return success_response('删除博客文章成功')
return fail_response('删除博客文章失败')
except Exception as e:
db.rollback()
logger.error(f'删除博客文章失败，失败原因：{e}')
return fail_response('删除博客文章失败')
def update_blog_site(site_id: int = Path(None, title="站点ID"),
the_blog_site: UpdateBlogSite = None,
current_user: User = Depends(get_current_user)):
title = the_blog_site.title
site_name = the_blog_site.site_name
theme = the_blog_site.theme
if current_user.user_type != 0:
fail_response("用户权限不足")
blog_site = BlogSite.filter(BlogSite.id == site_id).first()
if blog_site is None:
return fail_response('博客站点不存在')
try:
# 法一：
query = BlogSite.update(title=title, site_name=site_name, theme=theme,
update_time=str(datetime.now())).where(
BlogSite.id == site_id)
query.execute()
# 法二：
# blog_site.title = title
# blog_site.site_name = site_name
# blog_site.theme = theme
# blog_site.save()
return success_response('更新修改博客站点成功')
except Exception as e:
db.rollback()
logger.error(f'更新修改博客站点失败，失败原因：{e}')
return fail_response('更新修改博客站点失败')
def user_login(*, user_in: UserLogin):
"""
用户登陆借口
:param user_in:
:return:
"""
if not user_in.username and not user_in.email and not user_in.mobile:
return fail_response('必须使用用户名、电子邮箱和手机号码中的其中一种方式登陆')
elif user_in.username:
user = User.select().where(User.username == user_in.username)
elif user_in.mobile:
user = User.select().where(User.mobile == user_in.mobile)
else:
user = User.select().where(User.email == user_in.email)
if user:
login_user = user.first()
if login_user.verify_password(user_in.password):
token_expire_timedelta = timedelta(
minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
user_id = login_user.uuid.hex
redis_key = f'Token_{user_id}'
access_token = create_access_token(
data={'user_id': user_id},
expires_delta=token_expire_timedelta)
redis_client.set(redis_key,
access_token,
ex=token_expire_timedelta)
return success_response({
'access_token': access_token,
"token_type": "bearer"
})
return fail_response('用户名、电子邮箱、手机号码或密码错误')
def reply_comment(create_comment: CreateComment,
article_id: str = Path(2, description="博客文章id"),
comment_id: str = Path(2, description="评论id"),
current_user: User = Depends(get_current_user)):
content = create_comment.content
article = Article.filter(Article.id == article_id).first()
if not article:
return fail_response('此文章不存在')
if article.user_id == current_user.uuid:
# 博主的情况
comment = Comment.filter(Comment.id == comment_id, Comment.article_id == article_id,
Comment.user_id != current_user.uuid).first()
else:
# 用户
comment = Comment.filter(Comment.id == comment_id, Comment.article_id == article_id,
Comment.user_id != current_user.uuid,
Comment.parent_id != '').first()
if not comment:
return fail_response('此评论不存在或原评论你不能进行回复！')
try:
Comment.create(article_id=article_id, user_id=current_user.uuid, content=content, parent_id=comment.id)
except Exception as e:
db.rollback()
logger.error(f'评论回复失败，失败原因：{e}')
return fail_response('评论回复失败')
return success_response('评论回复成功！')
def user_profile(*,
user_update: UserUpdate,
current_user: User = Depends(get_current_user)):
"""
修改的字段都需要重新提交
修改数据的所有参数字段都需要重新提交，无论修改的数据有没有修改
:param user_update:
:param current_user:
:return:
"""
user_obj = User.filter(User.uuid == current_user.uuid).first()
password = user_update.password
email = user_update.email
mobile = user_update.mobile
if password and email and mobile:
ex_email = User.filter(User.uuid != current_user.uuid,
User.email == user_obj.email).first()
if ex_email:
return fail_response('用户名不能重复')
ex_mobile = User.filter(User.uuid != current_user.uuid,
User.email == user_obj.email).first()
if ex_mobile:
return fail_response('手机号已经被注册,不能修改为这个手机号！')
user_obj.email = email
user_obj.mobile = mobile
user_obj.password = password
user_obj.save()
else:
return fail_response('修改参数错误')
return success_response(current_user)
def get_category_info(category_id: str, current_user: User = Depends(get_current_user)):
blog_site = BlogSite.filter(BlogSite.user_id == current_user.uuid).first()
if blog_site is None:
return fail_response('此用户未创建博客站点，请先创建')
category = Category.filter(Category.id == category_id, Category.blog_id == blog_site.id).first()
if category is None:
return fail_response("博客分类不存在")
return success_response(category.to_dict())
def get_article_info(article_id: str):
article = Article.filter(Article.id == article_id).first()
if not article:
return fail_response('此文章不存在')
try:
up_count = ArticleUpDown.filter(ArticleUpDown.article_id == article.id, ArticleUpDown.is_up == True).count()
except Exception as e:
db.rollback()
logger.error(f'更新博客文章失败，失败原因：{e}')
return fail_response('删除博客文章失败')
return success_response({"article_id": article_id,
"up_count": up_count})
def add_comment(create_comment: CreateComment,
article_id: str = Path(2, description="博客文章id"),
current_user: User = Depends(get_current_user)):
content = create_comment.content
article = Article.filter(Article.id == article_id).first()
if not article:
return fail_response('此文章不存在')
try:
Comment.create(article_id=article_id, user_id=current_user.uuid, content=content, parent_id=None)
except Exception as e:
db.rollback()
logger.error(f'博客文章评论失败，失败原因：{e}')
return fail_response('删除博客文章失败')
return success_response('新增评论成功！')
def get_article_up_count(article_id: str,
current_user: User = Depends(get_current_user)):
article = Article.filter(Article.id == article_id, Article.user_id == current_user).first()
if not article:
return fail_response('此文章不存在')
try:
article_likes = ArticleUpDown.filter(ArticleUpDown.article_id == article.id, ArticleUpDown.is_up == True)
user_list = [article_like.user_id.username for article_like in article_likes]
up_count = article_likes.count()
except Exception as e:
db.rollback()
logger.error(f'更新博客文章失败，失败原因：{e}')
return fail_response('删除博客文章失败')
return success_response({"user_list": user_list,
"up_count": up_count})
def get_article_info(article_id: str):
"""
在排行榜这款 需要把 标题也存进去
:param article_id:
:return:
"""
article = Article.filter(Article.is_delete == 0, Article.id == article_id).first()
if article:
title = article.title
res = redis_client.exists("article_rank_list")
if not res:
# 连有序集合都没有的情况 初始化分数
redis_client.zadd("article_rank_list", {"article_%s_%s" % (article_id, title): 1})
# print(redis_client.zscore("article_rank_list", "article_id_1"))
else:
# 存在了但是这个文章
res_score = redis_client.zscore("article_rank_list", "article_%s_%s" % (article_id, title))
if res_score is None:
# 初始化分数
redis_client.zadd("article_rank_list", {"article_%s_%s" % (article_id, title): 1})
# 存在这个key的时候就分值增加 1
redis_client.zincrby("article_rank_list", 1, "article_%s_%s" % (article_id, title))
page_view = redis_client.zscore("article_rank_list", "article_%s_%s" % (article_id, title))
# return success_response(score)
# redis_client.incr('article_id:%s' % article_id)
# page_view = redis_client.get('article_id:%s' % article_id)
data = {"title": article.title,
"desc": article.desc,
"content": article.content,
"create_time": str(article.create_time),
"update_time": str(article.update_time),
"page_view": page_view}
return success_response(data)
return fail_response("文章不存在")
def article_down(article_id: str,
up_down: UpDown,
current_user: User = Depends(get_current_user)):
is_up = up_down.is_up
article = Article.filter(Article.id == article_id).first()
if not article:
return fail_response('此文章不存在')
article_like = ArticleUpDown.filter(ArticleUpDown.user_id == current_user.uuid,
ArticleUpDown.article_id == article_id).first()
if article_like and article_like.is_up == is_up:
pass
elif article_like and article_like.is_up != is_up:
article_like.is_up = is_up
article_like.save()
else:
return fail_response('点赞操作失败')
return success_response('点赞操作成功')
def get_category_info(category_id: str, up_category: UpdateCategory, current_user: User = Depends(get_current_user)):
blog_site = BlogSite.filter(BlogSite.user_id == current_user.uuid).first()
if blog_site is None:
return fail_response('此用户未创建博客站点，请先创建')
category = Category.filter(Category.id == category_id, Category.blog_id == blog_site.id).first()
if not category:
return fail_response("博客分类不存在")
try:
query = Category.update(title=up_category.title, description=up_category.description,
update_time=str(datetime.now)).where(
Category.id == category_id, Category.blog_id == blog_site.id)
query.execute()
return success_response('更新博客分类成功')
except Exception as e:
db.rollback()
logger.error(f'更新博客分类失败，失败原因：{e}')
return fail_response('更新博客分类失败')
def delete_blog_site(site_id: int = Path(..., title="站点ID"),
current_user: User = Depends(get_current_user)
):
if current_user.user_type != 0:
fail_response("用户权限不足")
blog_site = BlogSite.filter(BlogSite.id == site_id).first()
if not blog_site:
return fail_response('此博客站点不存在')
try:
result = blog_site.delete_instance()
if not result:
return fail_response('更新博客文章失败')
except Exception as e:
db.rollback()
logger.error(f'更新博客文章失败，失败原因：{e}')
return fail_response('删除博客文章失败')
return success_response('删除博客文章成功')
def create_category(*, new_category: CreateCategory, current_user: User = Depends(get_current_user)):
title = new_category.title
description = new_category.description
blog_site = BlogSite.filter(BlogSite.user_id == current_user.uuid).first()
if blog_site is None:
return fail_response('此用户未创建博客站点，请先创建')
category = Category.filter(Category.title == title, Category.blog_id == blog_site.id).first()
if category:
return fail_response("相同分类已存在！")
try:
Category.create(title=title,
description=description,
blog_id=blog_site.id)
except Exception as e:
db.rollback()
logger.error(f'创建博客文章失败，失败原因：{e}')
return fail_response('创建博客文章失败')
return success_response('创建博客文章成功')
async def get_picture(picture_name: str):
# 保存上传的文件
# print(settings.BASE_DIR + settings.PICTURE_DIR, "123456")
# picture_url = settings.BASE_DIR + settings.PICTURE_DIR + "test.png"
if picture_name:
picture_url = settings.BASE_DIR + settings.PICTURE_DIR + picture_name
return FileResponse(picture_url, media_type="image/png")
else:
return fail_response("没有相关图片")
def get_comment_list(article_id: str):
article = Article.filter(Article.id == article_id).first()
if not article:
return fail_response('此文章不存在')
comment_query = Comment.select().order_by(Comment.create_time.desc())
count = comment_query.count()
comment_list = [comment.to_dict() for comment in comment_query]
return success_response({"count": count,
"comment_list": comment_list})
def create_blog_site(*, new_site: CreateBlogSite, current_user: User = Depends(get_current_user)):
title = new_site.title
site_name = new_site.site_name
theme = new_site.theme
blog_site = BlogSite.select().where(BlogSite.user_id == current_user.uuid)
if blog_site:
return fail_response('您的博客站点已存在,不能重复创建')
try:
BlogSite.create(title=title,
site_name=site_name,
theme=theme,
user_id=current_user.uuid)
logger.info(f'创建博客站点name={site_name}站点成功')
return success_response('添加成功')
except Exception as e:
db.rollback()
logger.info(f'创建博客站点name={site_name}站点成功，失败原因：{e}')
return fail_response('创建博客站点失败')
def delete_comment(article_id: str,
comment_id: str,
current_user: User = Depends(get_current_user)):
article = Article.filter(Article.id == article_id).first()
if not article:
return fail_response('此文章不存在')
comment = Comment.filter(Comment.article_id == article_id, Comment.id == comment_id,
Comment.user_id == current_user.uuid).first()
if not comment:
return fail_response('此评论不存在或你没有删除权限')
try:
result = comment.delete_instance()
if not result:
return fail_response('删除评论失败')
except Exception as e:
db.rollback()
logger.error(f'删除评论失败失败，失败原因：{e}')
return fail_response('删除评论失败！')
return success_response('删除评论成功！')
def verification_code(request: Request, verification: VerificationCode):
ip = request.client.host
# 获取客户端ip
print(ip, "11111111111111111")
mobile_phone = verification.mobile
code_type = verification.type
if not re.match(r'^1[3456789]\d{9}$', mobile_phone):
return fail_response('手机格式不正确')
user = User.filter(User.mobile == mobile_phone).first()
if code_type == "register" or code_type == 'bind':
if user:
return fail_response('该手机号码已注册')
redis_key = '%s_%s' % (code_type, mobile_phone)
last_time = redis_client.ttl("%s_%s" % (code_type, mobile_phone))
if last_time > settings.SMS_EXPIRE_TIME - settings.SMS_REPEAT_TIME:
return fail_response('请勿重复获取验证码')
# 3.1 生成随机的短信验证码
code = "%06d" % random.randint(0, 999999)
# template = {
# 'code': code,
# }
# # 第三方短信接口返回成功的一个判断
# try:
# res = send_sms(template, phone=mobile_phone)
# except:
# return fail_response('获取验获取失败')
# print(res)
# res_dict = json.loads(res)
# print(res)
# if res_dict.get('Message') == 'OK' and res_dict.get('Code') == 'OK':
res = 1
if res == 1:
redis_client.set(redis_key, code)
redis_client.expire(redis_key, settings.SMS_EXPIRE_TIME)
# redis_key
# 在生产中需要将 下面code的返回数据去掉
data = {'code': code}
return success_response(data)
elif code_type == "login" or code_type == "forget":
if not user:
return fail_response('该手机号码未注册')
def update_comment(article_id: str,
comment_id: str,
create_comment: CreateComment,
current_user: User = Depends(get_current_user)):
content = create_comment.content
article = Article.filter(Article.id == article_id).first()
if not article:
return fail_response('此文章不存在')
comment = Comment.filter(Comment.article_id == article_id, Comment.id == comment_id,
Comment.user_id == current_user.uuid).first()
if not comment:
return fail_response('此评论不存在')
try:
comment.content = content
comment.save()
except Exception as e:
db.rollback()
logger.error(f'博客文章评论修改失败，失败原因：{e}')
return fail_response('博客文章评论修改失败！')
return success_response('博客文章评论修改成功！')
async def create_upload_file(
file: UploadFile = File(...),
):
filename = file.filename
# ALLOWED_EXTENSIONS = set('png', 'jpg', 'JPG', 'PNG')
# and filename.rsplit('.', 1)[1] not in ALLOWED_EXTENSIONS
if '.' not in filename:
fail_response("图片格式不正确")
# 保存上传的文件
contents = await file.read()
now_time = datetime.now().strftime("%Y%m%d%H%M%S")
random_num = random.randint(0, 100)
ext = filename.rsplit('.', 1)[1]
picture_name = settings.BASE_DIR + settings.PICTURE_DIR + now_time + "_" + str(random_num) + ext
with open(picture_name, "wb") as f:
f.write(contents)
picture_url = "/api/v1.0/blog/article/picture_url/" + now_time + "_" + str(random_num) + ext
return {
"picture_url": picture_url,
}
def update_article(article_id: str,
new_article: UpdateArticle,
current_user: User = Depends(get_current_user)):
title = new_article.title
desc = new_article.desc
content = new_article.content
category_id = new_article.category_id
article = Article.filter(Article.id == article_id, Article.user_id == current_user.uuid,
Article.is_delete == 0).first()
if not article:
return fail_response('此文章不存在')
try:
query = Article.update(title=title, desc=desc, content=content, category_id=category_id,
update_time=str(datetime.now)).where(
Article.id == article_id, Article.user_id == current_user.uuid)
query.execute()
# 修改排行榜的标题
res = redis_client.exists("article_rank_list")
if not res:
# 连有序集合都没有的情况 初始化分数 0
redis_client.zadd("article_rank_list", {"article_%s_%s" % (article_id, title): 0})
# print(redis_client.zscore("article_rank_list", "article_id_1"))
else:
# 存在了但是这个文章
res_score = redis_client.zscore("article_rank_list", "article_%s_%s" % (article_id, title))
if res_score is None:
# 初始化分数
redis_client.zadd("article_rank_list", {"article_%s_%s" % (article_id, title): 0})
else:
# 删除之前的分数记录
redis_client.zrem("article_rank_list", "article_%s_%s" % (article_id, title))
# 重新建立一个并将之前的分数给这个
redis_client.zadd("article_rank_list", {"article_%s_%s" % (article_id, title): res_score})
# 存在这个key的时候就分值增加 1
redis_client.zincrby("article_rank_list", 1, "article_%s_%s" % (article_id, title))
return success_response('更新博客文章成功')
except Exception as e:
db.rollback()
logger.error(f'更新博客文章失败，失败原因：{e}')
return fail_response('更新博客文章失败')
def create_article(*, new_article: CreateArticle,
current_user: User = Depends(get_current_user)):
title = new_article.title
desc = new_article.desc
content = new_article.content
category_id = new_article.category_id
article = Article.filter(Article.user_id == current_user.uuid).first()
if article:
fail_response("您的博客文章已创建,不能重复创建")
try:
new_article = Article.create(title=title,
desc=desc,
content=content,
user_id=current_user.uuid,
category_id=category_id)
print(new_article.title)
except Exception as e:
db.rollback()
logger.error(f'创建博客文章失败，失败原因：{e}')
return fail_response('创建博客文章失败')
return success_response('创建博客文章成功')
def get_article_rank_list():
"""
获取排行榜 有排行榜id 和 排行榜标题
:return:
"""
try:
article_rank_list = []
# if not search:
# articles = Article.select().order_by(Article.create_time.desc())
# else:
# # 法二：
# articles = Article.select().where(
# Article.title.contains(search) |
# Article.desc.contains(search) |
# Article.content.contains(search)).order_by(Article.create_time.desc())
res = redis_client.exists("article_rank_list")
if not res:
# 初始化分数
return fail_response("暂时没有排行榜")
rank_list = redis_client.zrange("article_rank_list", 0, 4, desc=True, withscores=True)
# print(rank_list)
# res = Article.filter(Article.id == 1).first()
# print(res.id)
for article_key_val in rank_list:
# article = Article.filter(Article.id == article_key_val[0].decode('utf-8').split("_")[2]).first()
article_info = {
"article_id": int(article_key_val[0].decode('utf-8').split("_")[1]),
"article_title": article_key_val[0].decode('utf-8').split("_")[2],
"page_view": article_key_val[1]
}
article_rank_list.append(article_info)
# if len(article_rank_list) > 5:
# article_rank_list = article_rank_list[:4]
return success_response(article_rank_list)
except Exception as e:
# print(e)
logger.error(f'获取文章列表失败，失败原因：{e}')
return fail_response('获取文章列表失败')
def article_up(article_id: str,
up_down: UpDown,
current_user: User = Depends(get_current_user)):
is_up = up_down.is_up
article = Article.filter(Article.id == article_id).first()
if not article:
return fail_response('此文章不存在')
article_like = ArticleUpDown.filter(ArticleUpDown.user_id == current_user.uuid,
ArticleUpDown.article_id == article_id).first()
if article_like and article_like.is_up == is_up:
pass
elif article_like and article_like.is_up != is_up:
article_like.is_up = is_up
article_like.save()
else:
try:
ArticleUpDown.create(user_id=current_user, article_id=article, is_up=is_up)
except Exception as e:
db.rollback()
logger.error(f'点赞操作失败，失败原因：{e}')
return fail_response('点赞操作失败')
return success_response('操作成功成功')
def get_category_list(page: int = Query(1, description='页码'),
page_size: int = Query(settings.PAGE_SIZE, description='每页条数'),
search: str = Query(None, description='查询参数'),
current_user: User = Depends(get_current_user)):
try:
blog_site = BlogSite.filter(BlogSite.user_id == current_user.uuid).first()
if blog_site is None:
return fail_response('此用户未创建博客站点，请先创建')
if not search:
categories = Category.select().where(Category.blog_id == blog_site.id).order_by(Category.create_time.desc())
else:
categories = Category.select().where(
Category.blog_id == blog_site.id,
Category.title % f'%{search}%' |
Category.description % f'%{search}%'
).order_by(Category.create_time.desc())
paginate_categories = categories.paginate(page, page_size)
paginate = {
'page': page,
'page_size': page_size,
'total': categories.count()
}
category_list = []
if not paginate_categories:
return success_response({
'paginate': paginate,
'product_list': []
})
for category in paginate_categories:
category_list.append(category.to_dict())
data = {
'paginate': paginate,
'article_list': category_list
}
except Exception as e:
logger.error(f'获取个人博客分类列表失败，失败原因：{e}')
return fail_response('获取个人博客分类列表失败')
return success_response(data)
def delete_category(category_id: str, current_user: User = Depends(get_current_user)):
# 法一：
# blog_site = BlogSite.filter(BlogSite.user_id == current_user.uuid).first()
# if blog_site is None:
# return fail_response('此用户未创建博客站点，请先创建')
# category = Category.filter(Category.id == category_id, Category.blog_id == blog_site.id).first()
# if not category:
# return fail_response("博客分类不存在")
# try:
# result = category.delete_instance()
# if result:
# return success_response('删除博客文章成功')
# return fail_response('更新博客文章失败')
# except Exception as e:
# db.rollback()
# logger.error(f'更新博客文章失败，失败原因：{e}')
# return fail_response('删除博客文章失败')
# 法二：使用联表查询的方式
category = Category.select().join(BlogSite, on=(Category.blog_id == BlogSite.id)).where(
BlogSite.user_id == current_user.uuid, Category.id == category_id)
if not category:
return fail_response("博客分类不存在")
try:
# 先将这个用户下这个分类的文章的分类改为空值
articles = Article.filter(Article.category_id == category_id)
for article in articles:
article.category_id = None
article.save()
# 再将这个文章分类删掉
query = Category.delete().where(Category.id == category_id)
result = query.execute() # 删除成功返回 1 所以不等于1为失败
if result != 1:
return fail_response('更新博客文章失败')
except Exception as e:
db.rollback()
logger.error(f'更新博客文章失败，失败原因：{e}')
return fail_response('删除博客文章失败')
return success_response('删除博客文章成功')
def user_register(
*,
user_in: UserCreate,
):
"""
注册用户
:param user_in:
:return:
"""
user = User.select().where(User.username == user_in.username)
if user:
return fail_response('该用户名已注册')
if not user_in.email and not user_in.mobile:
return fail_response('电子邮箱和手机号码必须选择一个')
if user_in.email:
user = User.select().where(User.email == user_in.email)
if user:
return fail_response('该电子邮箱已注册')
if user_in.mobile:
user = User.select().where(User.mobile == user_in.mobile)
if user:
return fail_response('该手机号码已注册')
user = User.create(**user_in.dict())
return success_response(user)
def get_article_list(
category_id: str = Path(0, description="博客分类id"),
page: int = Query(1, description='页码'),
page_size: int = Query(settings.PAGE_SIZE, description='每页条数'),
search: str = Query(None, description='查询参数'),
# start_time: datetime = Query(None, description='工单开始时间'),
# end_time: datetime = Query(None, description='工单结束时间'),
):
try:
if category_id == '0':
category_id = None
if not search:
articles = Article.select().where(Article.category_id == category_id).order_by(Article.create_time.desc())
else:
# 法二：
articles = Article.select().where(
Article.category_id == category_id,
Article.title.contains(search) |
Article.desc.contains(search) |
Article.content.contains(search)).order_by(Article.create_time.desc())
# # 参数校验
# if (not start_time or not end_time) and (start_time or end_time):
# return fail_response('时间错误')
# if start_time and end_time:
# if start_time > end_time or (end_time - datetime.now()).total_seconds() > 24 * 60 * 60:
# return fail_response('时间错误')
# if start_time and end_time:
# articles = articles.where(Article.create_time >= start_time, Article.create_time <= end_time)
paginate_articles = articles.paginate(page, page_size)
paginate = {
'page': page,
'page_size': page_size,
'total': articles.count()
}
if not paginate_articles:
return success_response({
'paginate': paginate,
'product_list': []
})
article_list = [article.to_dict() for article in paginate_articles]
data = {
'paginate': paginate,
'article_list': article_list
}
return success_response(data)
except Exception as e:
logger.error(f'获取文章列表失败，失败原因：{e}')
return fail_response('获取文章列表失败')
def get_article_list(
page: int = Query(1, description='页码'),
page_size: int = Query(settings.PAGE_SIZE, description='每页条数'),
article_id: int = Query(None, description='文章ID'),
title: str = Query(None, description='文章标题'),
desc: str = Query(None, description='文章描述'),
content: str = Query(None, description='文章内容'),
):
try:
article_query = Article.select()
if article_id:
article_query = article_query.where(Article.id.contains(article_id))
if title:
article_query = article_query.where(Article.title.contains(title))
if desc:
article_query = article_query.where(Article.desc.contains(desc))
if content:
article_query = article_query.where(Article.content.contains(content))
# paginate_articles = article_query.limit(page_size).offset((page-1)*page_size) # 得到的结果同下
paginate_articles = article_query.paginate(page, page_size)
paginate = {
'page': page,
'page_size': page_size,
'total': article_query.count()
}
if not paginate_articles:
return success_response({
'paginate': paginate,
'product_list': []
})
article_list = [article.to_dict() for article in paginate_articles]
data = {
'paginate': paginate,
'article_list': article_list
}
return success_response(data)
except Exception as e:
logger.error(f'获取文章列表失败，失败原因：{e}')
return fail_response('获取文章列表失败')
