def comment_news():
"""
评论新闻或者回复某条新闻下指定的评论
:return:
"""
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
# 1. 取到请求参数
news_id = request.json.get("news_id")
comment_content = request.json.get("comment")
parent_id = request.json.get("parent_id")
# 2. 判断参数
if not all([news_id, comment_content]):
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
try:
news_id = int(news_id)
if parent_id:
parent_id = int(parent_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 查询新闻，判断新闻是否存在
news = None
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据查询失败")
if not news:
return jsonify(errno=RET.NODATA, errmsg="未查询到数据")
# 3. 初始化评论模型，并且赋值
comment = Comment()
comment.user_id = user.id
comment.news_id = news_id
comment.content = comment_content
if parent_id:
comment.parent_id = parent_id
# 添加到数据库
# 为什么要自己去commit()?， 因为在return的时候需要用到 comment 的id
try:
db.session.add(comment)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.OK, errmsg="OK", data=comment.to_dict())
def news_comment():
"""评论"""
# 1. 获取新闻id，评论，父级评论id
# 2. 校验
# 3. 获取新闻对象
# 4. 创建评论对象
# 5. 提交sql事务，返回评论字典至前端
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
# 1. 取到请求参数
news_id = request.json.get("news_id")
comment_content = request.json.get("comment")
parent_id = request.json.get("parent_id")
# 2. 判断参数
if not all([news_id, comment_content]):
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
try:
news_id = int(news_id)
if parent_id:
parent_id = int(parent_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 查询新闻，并判断新闻是否存在
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据查询错误")
if not news:
return jsonify(errno=RET.NODATA, errmsg="未查询到新闻数据")
# 3. 初始化一个评论模型，并且赋值
comment = Comment()
comment.user_id = user.id
comment.news_id = news_id
comment.content = comment_content
if parent_id:
comment.parent_id = parent_id
# 添加到数据库
# 为什么要自己去commit()?，因为在return的时候需要用到 comment 的 id
try:
db.session.add(comment)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.OK, errmsg="OK", data=comment.to_dict())
def comment_news():
"""
评论新闻或者回复某条新闻下指定的评论
:return:
"""
# 1.获取用户
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
# 2.获取请求参数
news_id = request.json.get("news_id")
content = request.json.get("comment")
parent_id = request.json.get("parent_id")
# 3.判断参数
if not all([news_id, content]):
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
try:
news_id = int(news_id)
if parent_id:
parent_id = int(parent_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 查询新闻，并判断新闻是否存在
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据查询错误")
if not news:
return jsonify(errno=RET.NODATA, errmsg="未查询到新闻数据")
# 4.初始化评论模型，并且赋值
comment = Comment()
comment.user_id = user.id
comment.news_id = news.id
comment.content = content
if parent_id:
comment.parent_id = parent_id
# 5.添加到数据库
# commit的原因，因为需要在commit之后才会生成id，我们需要返回comment_id
try:
db.session.add(comment)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.OK, errmsg="OK", data=comment.to_dict())
def news_comment():
# 判断用户是否登录
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg=error_map[RET.SESSIONERR])
# 获取参数
comment_content = request.json.get("comment")
news_id = request.json.get("news_id")
parent_id = request.json.get("parent_id")
# 校验参数
if not all([comment_content, news_id]):
return jsonify(errno=RET.PARAMERR, errmsg=error_map[RET.PARAMERR])
try:
news_id = int(news_id)
except BaseException as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg=error_map[RET.PARAMERR])
# 判断新闻是否存在
try:
news = News.query.get(news_id)
except BaseException as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=error_map[RET.DBERR])
if not news:
return jsonify(errno=RET.NODATA, errmsg=error_map[RET.NODATA])
# 生成评论模型
comment = Comment()
comment.content = comment_content
comment.user_id = user.id
comment.news_id = news.id
if parent_id:
try:
parent_id = int(parent_id)
except BaseException as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg=error_map[RET.PARAMERR])
comment.parent_id = parent_id
# 添加到数据库中
try:
db.session.add(comment)
db.session.commit(
) # 虽然SQLALCHEMY_COMMIT_ON_TEARDOWN可以在请求结束后自动提交, 但是此处需要返回评论的主键id, 所以需要主动提交先生成主键
except BaseException as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg=error_map[RET.DBERR])
# json返回结果
return jsonify(errno=RET.OK,
errmsg=error_map[RET.OK],
data=comment.to_dict())
def news_comment():
"""新闻评论和回复评论
"""
# 1.获取登录用户信息
user = g.user
if not user:
return jsonify(errno=response_code.RET.SESSIONERR, errmsg='用户未登录')
# 2.接受参数
news_id = request.json.get('news_id')
comment_content = request.json.get('comment')
parent_id = request.json.get('parent_id')
# 3.校验参数:parent_id只有回复评论时才需要传入
if not all([news_id, comment_content]):
return jsonify(errno=response_code.RET.PARAMERR, errmsg='缺少参数')
try:
news_id = int(news_id)
if parent_id:
parent_id = int(parent_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=response_code.RET.PARAMERR, errmsg='参数错误')
# 4.查询要评论的新闻是否存在
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=response_code.RET.DBERR, errmsg='查询新闻数据失败')
if not news:
return jsonify(errno=response_code.RET.NODATA, errmsg='新闻数据不存在')
# 5.实现新闻评论和回复评论逻辑
comment = Comment()
comment.user_id = user.id
comment.news_id = news_id
comment.content = comment_content
# 回复评论
if parent_id:
comment.parent_id = parent_id
# 同步数据到数据库
try:
db.session.add(comment)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=response_code.RET.DBERR, errmsg='评论失败')
# 6.响应评论结果
return jsonify(errno=response_code.RET.OK,
errmsg='OK',
data=comment.to_dict())
def news_comment():
"""用户评论的新闻/回复评论"""
user = g.user
# 判断是否已登录
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
# 获取参数
data_dict = request.json
news_id = data_dict.get("news_id") # 哪一条新闻
comment_str = data_dict.get("content") # 评论内容
parent_id = data_dict.get("parent_id") # 被评论id（要知道回复谁）
# 校验参数
if not all([news_id, comment_str]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不全")
# 如果参数存在,就到数据库查询
try:
news = News.query.get(news_id)
print(news)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询数据失败")
# 判断有没有查询到数据
if not news:
return jsonify(errno=RET.NODATA, errmsg="该新闻不存在")
# 如果查到数据，在数据库操作记录（初始化 Comment 模型）
comment = Comment()
comment.user_id = user.id
comment.news_id = news_id
comment.content = comment_str
if parent_id:
"""如果是回复评论，则需要添加parent_id"""
comment.parent_id = parent_id
# 初始化完后，保存数据
try:
db.session.add(comment)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存评论数据失败")
# 被评论后，评论次数 +1 ，在更新新闻的评论总数 comments_count
news.comments_count += 1
try:
db.session.commit()
except Exception as e:
current_app.logger.error(e) # 无需返回页面
# 返回结果，因为是局部刷新，所以需要把新增的评论一并返回
return jsonify(errno=RET.OK, errmsg="评论成功", data=comment.to_dict())
def news_comment():
"""
- 1.判断用户是否登陆
- 2.获取参数
- 3.校验参数,为空校验
- 4.根据新闻编号,取出新闻对象
- 5.判断新闻对象是否存在
- 6.创建评论对象,设置属性
- 7.保存到数据库
- 8.返回响应
:return:
"""
# - 1.判断用户是否登陆
if not g.user:
return jsonify(errno=RET.NODATA, errmsg="用户未登录")
# - 2.获取参数
news_id = request.json.get("news_id")
content = request.json.get("comment")
parent_id = request.json.get("parent_id")
# - 3.校验参数,为空校验
if not all([news_id, content]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不全")
# - 4.根据新闻编号,取出新闻对象
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取新闻失败")
# - 5.判断新闻对象是否存在
if not news: return jsonify(errno=RET.NODATA, errmsg="新闻不存在")
# - 6.创建评论对象,设置属性
comment = Comment()
comment.user_id = g.user.id
comment.news_id = news_id
comment.content = content
if parent_id:
comment.parent_id = parent_id
# - 7.保存到数据库
try:
db.session.add(comment)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg="评论失败")
# - 8.返回响应
return jsonify(errno=RET.OK, errmsg="评论成功", data=comment.to_dict())
def news_comment():
"""
思路分析:
1.判断用户是否登陆状态
2.获取参数
3.校验,为空校验
4.根据编号取出新闻对象,并判断是否存在
5.创建评论对象,设置评论对象属性
6.添加评论对象到数据库
7.返回响应
:return:
"""
# 1.判断用户是否登陆状态
if not g.user:
return jsonify(errno=RET.NODATA, errmsg="该用户未登录")
# 2.获取参数
news_id = request.json.get("news_id")
content = request.json.get("comment")
parent_id = request.json.get("parent_id")
# 3.校验,为空校验
if not all([news_id, content]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不全")
# 4.根据编号取出新闻对象,并判断是否存在
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="新闻查询失败")
if not news:
return jsonify(errno=RET.NODATA, errmsg="该新闻不存在")
# 5.创建评论对象,设置评论对象属性
comment = Comment()
comment.user_id = g.user.id
comment.news_id = news.id
comment.content = content
if parent_id:
comment.parent_id = parent_id
# 6.添加评论对象到数据库
try:
db.session.add(comment)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg="添加评论失败")
# 7.返回响应
return jsonify(errno=RET.OK, errmsg="评论成功", data=comment.to_dict())
def comment_video():
"""
评论新闻或者回复某条新闻下指定的评论
:return:
"""
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
# 1. 取到请求参数
video_id = request.json.get("video_id")
comment_content = request.json.get("comment")
parent_id = request.json.get("parent_id")
# 2. 判断参数
if not all([video_id, comment_content]):
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
try:
video_id = int(video_id)
if parent_id:
parent_id = int(parent_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 查询并判断视频是否存在
try:
video = Videos.query.get(video_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据查询错误")
if not video:
return jsonify(errno=RET.NODATA, errmsg="未查询到新闻数据")
# 3. 初始化一个评论模型，并且赋值
comment = Comment()
comment.user_id = user.id
comment.class_id = video_id
comment.content = comment_content
if parent_id:
comment.parent_id = parent_id
# 添加到数据库
# 为什么要自己去commit()?，因为在return的时候需要用到 comment 的 id
try:
db.session.add(comment)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.OK, errmsg="OK", data=comment.to_dict())
def news_comment():
"""
1.判断用户是否登陆
2.获取参数
3.校验参数，为空校验
4.根据新闻编号，取出新闻对象
5.判断新闻对象是否存在
6.创建评论对象，设置属性
7.保存到数据库
8.返回响应
:return:
"""
# 1.判断用户是否登陆
if not g.user:
return jsonify(errno=RET.NODATA,errmsg="用户未登陆")
# 2.获取参数
news_id = request.json.get("news_id")
content = request.json.get("comment")
parent_id = request.json.get("parent_id")
# 3.校验参数，为空校验
if not all([news_id,content]):
return jsonify(errno=RET.PARAMERR,errmsg="参数不全")
# 4.根据新闻编号，取出新闻对象
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR,errmsg="获取新闻失败")
# 5.判断新闻对象是否存在
if not news: return jsonify(errno=RET.NODATA,errmsg="新闻不存在")
# 6.创建评论对象，设置属性
comment = Comment()
comment.user_id = g.user.id
comment.news_id = news_id
comment.content = content
if parent_id:
comment.parent_id = parent_id
# 7.保存到数据库
try:
db.session.add(comment)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR,errmsg="评论失败")
# 8.返回响应
return jsonify(errno=RET.OK,errmsg="评论成功",data=comment.to_dict())
def news_comment():
"""评论新闻或者回复某条的评论"""
# 获取用户登陆信息
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg='用户未登陆')
# 接收参数
news_id = request.json.get('news_id')
comment_content = request.json.get('comment')
parent_id = request.json.get('parent_id')
if not all([news_id, comment_content]):
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
try:
news_id = int(news_id)
if parent_id:
parent_id = int(parent_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
# 查询新闻区判断该news_id是否存在
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='数据查询错误')
if not news:
return jsonify(errno=RET.NODATA, errmsg='未查询到新闻数据')
# 添加评论到数据库
comment = Comment()
comment.user_id = user.id
comment.news_id = news_id
comment.content = comment_content
if parent_id:
comment.parent_id = parent_id
# 添加到数据库
# 因为在return之前需要用到comment的id(用于显示前段评论是否嵌套),因为自动的commit_tear_down是发生在return之后
# 因为是在数据库插入一个新的模型，而不是get获取，所以甭能直接返回comment=comment，因为这样的话前段只知道comment的user_id和comemnt.comment_content
# comment表因为是子关联的所以其id很重要，需要在return之前获取该comment
try:
db.session.add(comment)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg="保存评论数据失败")
return jsonify(errno=RET.OK, errmsg="评论成功", data=comment.to_dict())
def news_comment():
"""用户评论新闻
1.获取参数信息
2.验证参数信息
3.添加用户评论
4.返回数据
"""
# 获取用户信息
user = g.user
# 判断用户是否登录
if not user:
return jsonify(errno=response_code.RET.SESSIONERR, errmsg="用户未登录")
# 获取参数信息
json_dic = request.json
news_id = json_dic.get('news_id')
comment = json_dic.get('comment')
parent_id = json_dic.get('parent_id')
# 验证参数信息
if not all([news_id, comment]):
return jsonify(errno=response_code.RET.PARAMERR, errmsg="参数不足")
# 查询新闻是否存在
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=response_code.RET.DBERR, errmsg="数据查询不到")
if not news:
return jsonify(errno=response_code.RET.NODATA, errmsg="新闻不存在")
# 添加评论对象
com = Comment()
com.content = comment
com.news_id = news_id
com.user_id = user.id
if parent_id:
com.parent_id = parent_id
# 添加评论对象到数据库
try:
db.session.add(com)
db.session.commit()
except Exception as e:
current_app.logger.error()
db.session.rollback()
return jsonify(errno=response_code.RET.DBERR, errmsg="评论失败")
data = {'comment': com.to_dict()}
# 返回响应信息
return jsonify(errno=response_code.RET.OK, errmsg="OK", data=data)
def news_comment():
#1.判断是否登陆
user = g.user
if not user:
return jsonify(errno=response_code.RET.SESSIONERR, errmsg='用户未登录')
#2.接受参数,news_id,comment,parent_id
json_dict = request.json
news_id = json_dict.get('news_id')
comment = json_dict.get('comment')
parent_id = json_dict.get('parent_id')
#3.校验参数齐全,判断news_id,parent_id是整数
if not all([news_id, news_id]):
return jsonify(errno=response_code.RET.PARAMERR, errmsg='参数不全')
#4.根据news_id判断新闻是否存在
try:
news_id = int(news_id)
#如果没有parent_id,就表示评论新闻,传入表示评论别人回复
if parent_id:
parent_id = int(parent_id)
except Exception as e:
logging.error(e)
return jsonify(errno=response_code.RET.PARAMERR, errmsg='参数不是整数')
try:
news = News.query.get(news_id)
except Exception as e:
logging.error(e)
return jsonify(errno=response_code.RET.DBERR, errmsg='查询新闻失败')
if not news:
return jsonify(errno=response_code.RET.DBERR, errmsg='新闻不存在')
#5.创建comment模型
comment_obj = Comment()
comment_obj.content = comment
comment_obj.user_id = user.id
comment_obj.news_id = news.id
if parent_id:
comment_obj.parent_id = parent_id
# 6.同步到数据库
try:
db.session.add(comment_obj)
db.session.commit()
except Exception as e:
logging.error(e)
db.session.rollback()
return jsonify(errno=response_code.RET.DBERR, errmsg='保存数据失败')
#7.响应评论结果,讲评论数据返回前端渲染
return jsonify(errno=response_code.RET.OK,
errmsg='评论成功',
data=comment_obj.to_dict())
def news_comment():
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
news_id = request.json.get('news_id')
content = request.json.get('content')
parent_id = request.json.get('parent_id')
try:
news_id = int(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg="参数格式错误")
print(news_id, content, parent_id)
print(type(news_id))
if not all([news_id, content]):
return jsonify(errno=RET.PARAMERR, errmsg="请求参数缺失")
try:
new = News.query.get(news_id)
print(new)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库读取错误")
print(new)
if not new:
return jsonify(errno=RET.NODATA, errmsg="未找到该新闻")
comment = Comment()
comment.news_id = news_id
comment.content = content
comment.user_id = user.id
if parent_id:
try:
parent_id = int(parent_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg="参数格式错误")
comment.parent_id = parent_id
try:
db.session.add(comment)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库存储错误")
return jsonify(errno=RET.OK, errmsg="评论成功", data=comment.to_dict())
def news_comment():
"""新闻评论和回复评论
"""
# 1.获取登录用户信息
user = g.user.to_dict()
if not user:
return jsonify(errno=response_code.RET.SESSIONERR, errmsg='用户未登录')
# 2.获取参数
news_id = request.json.get('news_id')
comment_content = request.json.get('comment')
parent_id = request.json.get('parent_id')
# 3.校验参数：parent_id非必传的参数
if not all([news_id,comment_content]):
return jsonify(errno=response_code.RET.PARAMERR, errmsg='缺少参数')
try:
news_id = int(news_id)
if parent_id:
parent_id = int(parent_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=response_code.RET.PARAMERR, errmsg='参数错误')
# 4.查询当前要评论的新闻是否存在
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=response_code.RET.DBERR, errmsg='查询新闻数据失败')
if not news:
return jsonify(errno=response_code.RET.NODATA, errmsg='新闻不存在')
# 5.实现评论新闻和回复评论
comment = Comment()
comment.user_id = user.id
comment.news_id = news_id
comment.content = comment_content
# 评论回复
if parent_id:
comment.parent_id = parent_id
# 同步新闻评论和评论回复到数据库
try:
db.session.add(comment)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=response_code.RET.DBERR, errmsg='评论失败')
# 提示:为了在评论后可以在界面上刷新出评论内容，需要将评论内容响应给用户
# 6.响应评论新闻和回复评论的结果
return jsonify(errno=response_code.RET.OK, errmsg='评论成功', data=comment.to_dict())
def news_comment():
# 判断用户是否登录
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg=error_map[RET.SESSIONERR])
# 获取参数
comment_content = request.json.get("comment")
news_id = request.json.get("news_id")
parent_id = request.json.get("parent_id")
# 校验参数
if not all([comment_content, news_id]):
return jsonify(errno=RET.PARAMERR, errmsg=error_map[RET.PARAMERR])
try:
news_id = int(news_id)
except BaseException as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg=error_map[RET.PARAMERR])
try:
news = News.query.get(news_id)
except BaseException as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=error_map[RET.DBERR])
if not news:
return jsonify(errno=RET.PARAMERR, errmsg=error_map[RET.PARAMERR])
# 生成一个评论数据, 添加到数据库中
comment = Comment()
comment.content = comment_content
comment.news_id = news_id
comment.user_id = user.id
if parent_id: # 子评论
try:
parent_id = int(parent_id)
comment.parent_id = parent_id
except BaseException as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg=error_map[RET.PARAMERR])
try:
db.session.add(comment)
db.session.commit() # 此处必须手动提交, 否则不生成评论id, 前端就获取不到评论id
except BaseException as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=error_map[RET.DBERR])
# json返回结果
return jsonify(errno=RET.OK,
errmsg=error_map[RET.OK],
data=comment.to_dict())
def news_comment():
"""评论新闻和回复其他人的评论(一个视图函数实现两个功能)"""
# 0:评论也需要用户登入
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户不存在")
# 1:获取请求参数
news_id = request.json.get("news_id")
comment_content = request.json.get("comment")
parent_id = request.json.get("parent_id") # 因为一条评论可能没有人回复,导致parent_id不存在
# 2:判断参数
if not all([news_id,comment_content]):
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
try:
news_id = int(news_id)
if parent_id:
parent_id = int(parent_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询数据失败")
if not news:
return jsonify(errno=RET.NODATA, errmsg="新闻数据不存在")
# 3:初始化一个评论模型,并赋值评论数据到数据库
comment = Comment()
comment.user_id = user.id
comment.news_id = news_id
comment.content = comment_content
if parent_id:
comment.parent_id = parent_id
# 4:添加到数据库
try:
db.session.add(comment)
db.session.commit()
except Exception as e:
comment_content.logger.error(e)
db.session.rollback()
# 5:再查询数据库的评论数据,返回给前端:comment.to_dict()
return jsonify(errno=RET.OK, errmsg="OK", data=comment.to_dict())
def add_news_comment():
"""
评论新闻
:return:
"""
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
# 1.获取参数
data_dict = request.json
news_id = data_dict.get("news_id")
comment_str = data_dict.get("comment")
parent_id = data_dict.get("parent_id")
# 2.判断参数
if not all([news_id, comment_str]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不足")
try:
news_id = int(news_id)
if parent_id:
parent_id = int(parent_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数不足")
# 查询新闻并判断新闻是否存在
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询数据失败")
if not news:
return jsonify(errno=RET.NODATA, errmsg="该新闻不存在")
# 3.初始化一个评论模型，并且赋值
comment = Comment()
comment.user_id = user.id
comment.news_id = news_id
comment.content = comment_str
if parent_id:
comment.parent_id = parent_id
# 4.保存到数据库
try:
db.session.add(comment)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存评论数据失败")
# 5.返回响应
return jsonify(errno=RET.OK, errmsg="评论成功", data=comment.to_dict())
def news_comment():
"""只有在用户登录的情况下才能进行评论操作
"""
user = g.user.to_dict()
if not user:
return jsonify(errno=response_code.RET.SESSIONERR, errmsg='用户未登录')
# 接收请求参数 1.被评论新闻id 2.评论内容
news_id = request.json.get('news_id')
comment_context = request.json.get("comment")
parent_id = request.json.get('parent_id')
# 校验参数
# parent_id 非必要
if not all([news_id, comment_context]):
return jsonify(errno=response_code.RET.PARAMERR, errmsg='缺少参数')
# 将news_id和parent_id(如果其存在)转成整型,目的是为了限制参数格式
try:
news_id = int(news_id)
if parent_id:
parent_id = int(parent_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=response_code.RET.PARAMERR, errmsg='缺少参数')
# 查询新闻是否存在
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=response_code.RET.DBERR, errmsg='查询新闻数据失败')
if not news:
return jsonify(errno=response_code.RET.NODATA, errmsg='新闻不存在')
# 创建评论对象
comment = Comment()
# 给评论对象赋值
comment.user_id = user.id
comment.news_id = news_id
comment.content = comment_context
if parent_id:
comment.parent_id = parent_id
# 将评论数据存储入数据库
try:
db.session.add(comment)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=response_code.RET.DBERR, errmsg='存储评论数据失败')
return jsonify(errno=response_code.RET.OK,
errmsg='ok',
data=comment.to_dict())
def comment_news():
"""文章评论"""
# 获取参数
params = request.json
news_id = params.get('news_id')
comment_content = params.get("comment")
parent_id = params.get("parent_id")
# 过滤尖括号，防止xss
if '<' or '>' in comment_content:
comment_content = comment_content.replace('<', '(')
comment_content = comment_content.replace('>', ')')
if not all([news_id, comment_content]):
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
try:
news_id = int(news_id)
if parent_id:
parent_id = int(parent_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg='参数类型错误')
# 查询新闻数据，判断新闻是否存在
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='数据查询失败')
if not news:
return jsonify(errno=RET.NODATA, errmsg='新闻数据不存在')
# 初始化评论模型
comment = Comment()
comment.news_id = news_id
comment.content = comment_content
if parent_id:
comment.parent_id = parent_id
# 提交到数据库
try:
db.session.add(comment)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=RET.OK, errmsg='ok', data=comment.to_dict())
def post_comment():
user = flask.g.user
if not user:
return flask.jsonify(errno=RET.SESSIONERR, errmsg='用户未登录')
parameters = flask.request.json
news_id = parameters.get('news_id', None)
comment = parameters.get('comment', None)
parent_id = parameters.get('parent_id', None)
if not all([news_id, comment]):
return flask.jsonify(errno=RET.PARAMERR, errmsg='参数错误')
try:
news_id = int(news_id)
if parent_id:
parent_id = int(parent_id)
except Exception as e:
flask.current_app.logger.error(e)
return flask.jsonify(errno=RET.PARAMERR, errmsg='参数错误')
try:
news_model = News.query.get(news_id)
except Exception as e:
flask.current_app.logger.error(e)
return flask.jsonify(errno=RET.DBERR, errmsg='数据库查询错误')
if not news_model:
return flask.jsonify(errno=RET.NODATA, errmsg='未查询到新闻数据')
comment_model = Comment()
comment_model.user_id = user.id
comment_model.news_id = news_id
comment_model.content = comment
if parent_id:
comment_model.parent_id = parent_id
# 注意：没有使用SQLALCHEMY自动commit的功能是因为执行完retun才会进行数据commit
# return时需要使用到评论的id
try:
db.session.add(comment_model)
db.session.commit()
except Exception as e:
db.session.rollback()
flask.current_app.logger.error(e)
return flask.jsonify(errno=RET.DBERR, errmsg='数据库插入错误')
data = {
'comment': comment_model.to_dict()
}
return flask.jsonify(errno=RET.OK, errmsg='评论成功', data=data)
def news_comment():
# 校验用户是否登陆
user = g.user
if not user:
return jsonify(errno=RET.USERERR, errmsg='用户未登陆')
# 获取参数， new_id, comment, parent_id
data_json = request.json
news_id = data_json.get('news_id')
comment_str = data_json.get('comment')
parent_id = data_json.get('parent_id')
print(parent_id)
# 校验参数是否齐全
if not all([news_id, comment_str]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不全')
# 储存数据
# news = None
try:
news = News.query.get(news_id) # 根据新闻id返回查询对象
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询数据库失败')
# 新闻不存在
if not news:
return jsonify(errno=RET.NODATA, errmsg='新闻数据不存在')
# 添加评论信息
comment = Comment()
comment.content = comment_str
comment.user_id = user.id
comment.news_id = news.id
if parent_id:
comment.parent_id = parent_id
try:
db.session.add(comment) # 添加新的评论
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='保存评论数据失败')
# news_comments = news.comments
# comments_list = []
# for per_comment in news_comments:
# comments_list.append(per_comment.to_dict())
# 返回成功
return jsonify(errno=RET.OK, errmsg='OK', data=comment.to_dict())
def news_comment():
"""
新闻评论功能
:return:
"""
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
news_id = request.json.get("news_id")
comment_str = request.json.get("comment")
parent_id = request.json.get("parent_id")
if not all([news_id, comment_str]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不全")
try:
news_id = int(news_id)
if parent_id:
parent_id = int(parent_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数格式不正确")
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库查询错误")
if not news:
return jsonify(errno=RET.NODATA, errmsg="没有这条新闻")
# 初始化模型对象, 并往数据库添加一条评论
comment = Comment()
comment.news_id = news_id
comment.user_id = user.id
comment.content = comment_str
if parent_id:
comment.parent_id = parent_id
try:
db.session.add(comment)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库保存失败")
return jsonify(errno=RET.OK, errmsg="OK", data=comment.to_dict())
def news_comment():
# 1. 判断用户是否登录
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
# 2. 获取参数
news_id = request.json.get("news_id", None)
comment = request.json.get("comment", None)
parent_id = request.json.get("parent_id", None)
# 3. 校验参数
if not all([news_id, comment]): # news_id 和 comment 不能为空
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
try:
news_id = int(news_id) # news_id 和 parent_id（如果存在） 必须整数
if parent_id:
parent_id = int(parent_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
try:
news = News.query.get(news_id) # news_id 对应的新闻必须存在
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库查询操作失败")
if not news:
return jsonify(errno=RET.NODATA, errmsg="新闻数据不存在")
# 4. 创建一个comment对象
comment_obj = Comment()
comment_obj.user_id = user.id
comment_obj.news_id = news_id
comment_obj.content = comment
if parent_id:
comment_obj.parent_id = parent_id
# 5. 添加comment对象进数据库：必须手动而非依赖commit_on_teardown，因视图函数需返回comment_id
try:
db.session.add(comment_obj)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg="数据库添加失败")
return jsonify(errno=RET.OK,
errmsg="评论添加成功",
comment=comment_obj.to_dict())
def comment_news():
'''评论新闻或者回复某条新闻下指定的评论'''
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="User is not logged in！")
# 获取请求参数
news_id = request.json.get("news_id")
comment_content = request.json.get('comment')
parent_id = request.json.get('parent_id')
# 判断参数 不判断parent_id是因为在自己发表评论的时候，不需要parent_id
if not all([news_id, comment_content]):
return jsonify(errno=RET.PARAMERR, errmsg="Parameter error！")
try:
news_id = int(news_id)
if parent_id:
parent_id = int(parent_id)
except Exception as e:
current_app.logger.errno(e)
return jsonify(errno=RET.PARAMERR, errmsg="Parameter error！")
# 查询新闻，判断新闻是否存在
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.errno(e)
return jsonify(errno=RET.DBERR, errmsg="Data query error！")
if not news:
return jsonify(errno=RET.NODATA, errmsg="No data is queried！")
# 初始化一个评论模型 并赋值
comment = Comment()
comment.user_id = user.id
comment.news_id = news_id
comment.content = comment_content
if parent_id:
comment.parent_id = parent_id
try:
# 这里需要自己commit是因为在return的时候能用到comment里面的数据，如果用不到可以不用commit，让sqlalchemy在return以后帮我们
# 自动提交
db.session.add(comment)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.OK, errmsg="OK", data=comment.to_dict())
def news_comment():
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登陆")
# 获取参数
params_dict = request.json
news_id = params_dict.get("news_id")
comment_content = params_dict.get("comment")
parent_id = params_dict.get("parent_id")
if not all([news_id, comment_content]):
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 校验参数
try:
news_id = int(news_id)
if parent_id:
parent_id = int(parent_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 查询新闻数据,并判断是否存在
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据查询错误")
if not news:
return jsonify(errno=RET.NODATA, errmsg="未查询到新闻数据")
# 初始化评论模型
comment = Comment()
comment.user_id = user.id
comment.news_id = news_id
comment.content = comment_content
if parent_id:
comment.parent_id = parent_id
try:
db.session.add(comment)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存评论到数据库失败")
return jsonify(errno=RET.OK, errmsg="OK", data=comment.to_dict())
def news_comment():
"""评论功能"""
# 判断是否登录,登陆后才能评论
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登陆")
# 获取数据(news_id/comment评论内容/parent_id)
data_dict = request.json
news_id = data_dict.get('news_id')
comment_content = data_dict.get('comment')
parent_id = data_dict.get('parent_id', None)
# 判断数据是否为空
if not all([news_id, comment_content]):
return jsonify(errno=RET.PARAMERR, errmsg="未能获取参数")
# 校验数据类型
try:
news_id = int(news_id)
if parent_id:
parent_id = int(parent_id)
except Exception as e:
current_app.logger.debug(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 判断news是否存在
try:
news_ob = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据查询错误")
if not news_ob:
return jsonify(errno=RET.NODATA, errmsg="未查询到新闻数据")
# 向数据库写入数据
comment = Comment()
comment.news_id = news_id
comment.user_id = user.id
comment.content = comment_content
# 如果是子评论,需要保存父评论的id
if parent_id:
comment.parent_id = parent_id
try:
db.session.add(comment)
db.session.commit()
except Exception as e:
current_app.logger.debug(e)
return jsonify(errno=RET.DBERR, errmsg="数据库异常")
# 将数据传输到前端进行显示
return jsonify(errno=RET.OK, errmsg="评论成功", data=comment.to_dict())
def news_comment():
"""
发布主/子评论后端接口
news_id:新闻id，user:当前登录的用户，comment:评论的内容，parent_id:区分主评论和子评论字段【非必传】
"""
news_id = request.json.get("news_id")
content = request.json.get("comment")
parent_id = request.json.get("parent_id")
user = g.user
if not all([news_id, content]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不足")
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
# 3.1 根据news_id获取新闻对象，新闻对象存在才能发布评论
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询新闻对象异常")
if not news:
return jsonify(errno=RET.NODATA, errmsg="新闻不存在不能发布评论")
# 3.2 创建评论对象
comment = Comment()
# 给各个属性赋值
comment.user_id = user.id
comment.news_id = news.id
comment.content = content
# 3.3 parent_id没有值： 创建主评论对象
# 3.4 parent_id有值：创建子评论对象
if parent_id:
comment.parent_id = parent_id
# 3.5 将评论对象保存回数据库
try:
db.session.add(comment)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
# 数据回滚
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg="保存评论对象异常")
# 考虑到前端发布完评论后，页面需要局部刷新数据，所以需要将评论数据返回
comment_dic = comment.to_dict() if comment else None
data = {"comment": comment_dic}
return jsonify(errno=RET.OK, errmsg="发布评论成功", data=data)
def news_comment():
"""
发表评论
:return:
"""
# 获取登陆用户信息
user = g.user
# 如果没有登陆
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
# 获取请求体
data_dict = request.json
# 新闻ID
news_id = data_dict.get("news_id")
# 评论
content = data_dict.get("content")
# 回复评论ID
parent_id = data_dict.get("parent_id")
# 判断请求体参数是否都有数据
if not all([content, news_id]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不齐")
try:
# 根据新闻ID获取新闻信息
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询数据失败")
# 没有新闻信息
if not news:
return jsonify(errno=RET.NODATA, errmsg="该新闻不存在")
# 初始化评论模型, 保存数据
comment = Comment()
comment.user_id = user.id
comment.news_id = news_id
comment.content = content
comment.parent_id = parent_id
# 添加新闻评论数量
news.comments_count += 1
# 保存到数据库
try:
mysql_db.session.add(comment)
mysql_db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存评论数据失败")
# 返回响应
return jsonify(errno=RET.OK, errmsg="评论成功", data=comment.to_dict())
def news_comment():
"""
新闻评论功能
1.接收参数 用户 新闻 评论内容 parant_id
2.效验参数
3.业务逻辑 往数据库中添加一条评论
4. 返回响应 返回响应烦人评论
:return:
"""
# 用户登录状态
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
# 接收参数
news_id = request.json.get("news_id")
comment_str = request.json.get("comment")
parent_id = request.json.get("parent_id")
# 效验参数
if not all([news_id, comment_str]):
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
try:
news_id = int(news_id)
if parent_id:
parent_id = int(parent_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数类型错误")
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库查询错误")
if not news:
return jsonify(errno=RET.NODATA, errmsg="该条新闻不存在")
# 添加新闻评论
comment = Comment()
comment.user_id = user.id
comment.news_id = news_id
comment.content = comment_str
if parent_id:
comment.parent_id = parent_id
try:
db.session.add(comment)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库保存错误")
return jsonify(errno=RET.OK, errmsg="OK", data=comment.to_dict())
