def news_comment():
# 1. 这个试图必须是登陆用户才可以访问
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg='用户未登录')
# 2. 要接收参数， news_id, content
news_id = request.json.get('news_id')
content = request.json.get('comment')
parent_comment_id = request.json.get('parent_id')
# 3. 2个参数必须有，
if not all([news_id,content]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不全')
# 4. 判断 news 必须存在
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 = user.id
comment.news_id = news.id
comment.content = content
# 根据用户传递过来的 评论的父ID 来判断用户是否跟帖
# 如果parent_comment_id有值则是跟帖
if parent_comment_id:
comment.parent_id = parent_comment_id
try:
db.session.add(comment)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
# 6. 返回响应 同时把 新增的数据传递给前端
return jsonify(errno=RET.OK, errmsg='OK',data ={'comment':comment.to_dict()})
def set_news_comment():
# 1,获取参数 user, news_id, comment, parent_id
user = g.user
if not user:
current_app.logger.error("用户未登录")
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
param = request.json
news_id = param.get("news_id")
comment_str = param.get("comment")
parent_id = param.get("parent_id")
# 2,校验参数
if not all([news_id, comment_str]):
current_app.logger.error("参数错误")
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 3,逻辑处理
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:
current_app.logger.error("新闻不存在")
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="保存错误")
# 4,返回值
return jsonify(errno=RET.OK, errmsg="评论成功", data=comment.to_dict())
def news_comment():
# 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.创建评论对象，设置属性
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_news():
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="参数错误")
# 查询新闻，判断新闻是否存在
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:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.OK, errmsg="OK", comment=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')
content = request.json.get('comment')
parent_id = request.json.get('parent_id') # 父评论id（回复的评论的id）
comment = Comment() # 实例化评论对象
comment.user_id = user.id
comment.news_id = news_id
comment.content = content # 评论内容
if parent_id: # 不是所有的评论都有回复
comment.parent_id = parent_id
# 将评论保存到数据库中
db.session.add(comment)
db.session.commit()
# 前端需要comment对象数据， 所以响应中要添加data
return jsonify(errno=RET.OK, errmsg='评论成功', data=comment.to_dict())
def add_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("comment")
parent_id = data_dict.get("parent_id")
if not all([news_id, comment_str]):
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:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存评论数据失败")
# 返回响应
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_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="参数错误")
# 通过新闻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_str
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)
return jsonify(errno=RET.DBERR, errmsg="评论提交到数据库错误")
return jsonify(errno=RET.OK, errmsg="评论成功", data=comment.to_dict())
def comment_comment():
"""用户回复评论"""
# 获取当前用户登录状态
user = g.user
if not user:
return jsonify(errno=response_code.RET.SESSIONERR, errmsg='您还未登录')
# 接收参数 comment_id, comment_content并校验
comment_parent_id = request.json.get('comment_id')
comment_content = request.json.get('comment_content')
# 由于表new_id不能为空
news_id = request.json.get('news_id')
try:
news_id = int(news_id)
comment_parent_id = int(comment_parent_id)
except Exception as e:
logging.error(e)
return jsonify(errno=response_code.RET.PARAMERR, errmsg='参数错误')
# if not comment_id:返回评论不存在
if not comment_parent_id:
return jsonify(errno=response_code.RET.NODATA, errmsg='该评论不存在')
# if comment_id 创建子评论
children_comment = Comment()
children_comment.user_id = user.id
# 由于表中设计news_id不能为空, 需要添加
children_comment.news_id = news_id
children_comment.content = comment_content
children_comment.parent_id = comment_parent_id
# 同步数据库
try:
db.session.add(children_comment)
db.session.commit()
except Exception as e:
logging.error(e)
return jsonify(errno=response_code.RET.DBERR, errmsg='评论失败!')
# 构造响应数据
data = {'children_comment': children_comment.to_dict()}
# 响应结果
return jsonify(errno=response_code.RET.OK, errmsg='评论成功!', data=data)
def news_comment():
# 新闻评论
news_id = request.json.get("news_id")
# 获得新闻的内容
msg = request.json.get("comment")
# 父子评论的id comment.id
parent_id = request.json.get("parent_id")
if not all([news_id, msg]):
return jsonify(errno=RET.NODATA, errmsg="数据不全")
if g.user is None:
return jsonify(errno=RET.NODATA, errmsg="用户没有登录")
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='数据库连接失败')
if news is None:
return jsonify(errno=RET.NODATA, errmsg="数据无效")
comment_new = Comment()
if parent_id:
# 向评论表中加id 自关联id 代表是子评论
comment_new.parent_id = parent_id
comment_new.user_id = g.user.id
comment_new.news_id = int(news_id)
comment_new.content = msg
try:
db.session.add(comment_new)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库链接失败")
if parent_id:
data = comment_new.to_back_dict()
else:
data = comment_new.to_dict()
return jsonify(errno=RET.OK, errmsg="", data=data)
def news_comment():
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")
# 我评论的是哪条新闻
news = News.query.get(news_id)
comment = Comment()
comment.user_id = user.id
comment.news_id = news_id
comment.content = comment_str
# 这个地方需要判断,是因为不可能所有的评论都有父类
if parent_id:
comment.parent_id = parent_id
db.session.add(comment)
db.session.commit()
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_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 = 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:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存评论数据失败")
return jsonify(errno=RET.OK, errmsg="评论成功", data=comment.to_dict())
def news_comment():
user = g.user
news_id = request.json.get("news_id")
comment_str = request.json.get("comment")
parent_id = request.json.get("parent_id")
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登陆")
news = News.query.get(news_id)
comment = Comment()
comment.user_id = user.id
comment.news_id = news_id
comment.content = comment_str
if parent_id:
comment.parent_id = parent_id
db.session.add(comment)
db.session.commit()
# data = comment.to_dict()
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')
content = request.json.get('comment')
parent_id = request.json.get('parent_id')
comment = Comment()
comment.user_id = user.id
comment.news_id = news_id
comment.content = content
# 不是所有的评论都有回复评论,所以需要判断
if parent_id:
comment.parent_id = parent_id
# 如果是第一次往数据库里面添加数据,需要添加add,如果更新数据,就不需要add,直接commit
db.session.add(comment)
db.session.commit()
return jsonify(errno=RET.OK, errmsg='ok', data=comment.to_dict())
def sub_comment():
"""
用户评论提交
:return:
"""
if not g.user:
return jsonify(errno=RET.SESSIONERR, errmsg='请登录后再试')
comment_info = request.json
news_id = comment_info.get('news_id')
comment_content = comment_info.get('comment')
comment_parent_id = comment_info.get('parent_id') if comment_info.get('parent_id') else None
try:
news = News.query.filter(News.id == news_id).first()
new_comment = Comment()
new_comment.user_id = g.user.id
new_comment.news_id = news_id
new_comment.content = comment_content
new_comment.parent_id = comment_parent_id
news.comments.append(new_comment)
db.session.commit()
return jsonify(errno=RET.OK, errmsg='评论成功', data=new_comment.to_dict())
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=error_map[RET.DBERR])
def news_comment():
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='参数不足')
'''
用户登陆才能评论
评论前需要知道新闻id,-----
评论之后,只要把评论信息存到数据库,为了方便下次用户可以看到评论
'''
news = News.query.get(news_id)
comment = Comment()
comment.user_id = user.id
comment.news_id = news.id
comment.content = comment_str
if parent_id:
comment.parent_id = parent_id
db.session.add(comment)
db.session.commit()
return jsonify(errno=RET.OK, errmsg='评论成功', data=comment.to_dict())
def commit():
# 判断用户登录状态
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
request_data = request.json
news_id = request_data.get('news_id')
comment_from_user = request_data.get('comment')
parent_comment_id = request_data.get('parent_comment_id')
try:
news_id = int(news_id)
except Exception as e:
current_app.logger.debug(e)
return jsonify(errno=RET.DATAERR, errmsg="参数错误或者新闻不存在")
if not all([comment_from_user, news_id]):
return jsonify(errno=RET.DATAERR, errmsg="参数错误或者新闻不存在")
# 评论写到数据库中
comment = Comment()
try:
comment.user_id = user.id
comment.news_id = news_id
comment.content = comment_from_user
comment.parent_id = parent_comment_id
db.session.add(comment)
db.session.commit()
except Exception as e:
current_app.logger.debug(e)
# 将结果返回给前段
comment_ret = comment.to_dict()
print(comment_ret)
return jsonify(errno=RET.OK, errmsg="评论成功", comment=comment_ret)
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, 校验参数
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.DBERR, errmsg='参数错误')
# 4, 查看新闻是否存在
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=response_code.RET.PARAMERR, 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='评论失败')
# 为了评论显示给用户看, 需要将评论内容响应给页面.
# 构造响应数据
# data = {
# 'comment':comment.to_dict()
# }
# 6, 响应评论和回复结果
return jsonify(errno=response_code.RET.OK,
errmsg='评论成功',
data=comment.to_dict())
def news_comment():
"""
新闻评论和回复评论
1、判断用户是否登录
2、获取参数，news_id,comment,parent_id
3、检查参数的完整性news_id,comment
4、转换参数的类型，需要判断parent_id是否存在
5、根据新闻id查询新闻数据
6、判断查询结果
7、构造模型类对象Comment，保存新闻评论数据
8、提交数据到mysql
9、返回评论数据
:return:
"""
# 尝试获取用户信息
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg='用户未登录')
# 获取参数
news_id = request.json.get('news_id')
comment = request.json.get('comment')
parent_id = request.json.get('parent_id')
# 检查参数的完整性
if not all([news_id, comment]):
return jsonify(errno=RET.PARAMERR, errmsg='参数缺失')
# 转换参数的数据类型
try:
news_id = int(news_id)
# 判断如果父评论id存在
if parent_id:
parent_id = int(parent_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg='参数类型错误')
# 根据新闻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='无新闻数据')
# 构造模型类对象，保存新闻评论数据
comments = Comment()
comments.user_id = user.id
comments.news_id = news.id
comments.content = comment
# 判断如果有父评论
if parent_id:
comments.parent_id = parent_id
# 提交数据到mysql数据
try:
db.session.add(comments)
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='OK', data=comments.to_dict())
def news_comment():
# 首先判断用户存在，才可以评论
user = g.user
if not user:
return jsonify(erron=response_code.RET.DBERR, errsmg="用户未登录")
# form表但提交是post请求，用后台传递数据通过form
# 获取前端传过来的数据
news_id = request.json.get("news_id")
# 获取评论信息
comment_context = request.json.get("comment")
parent_id = request.json.get("parent_id")
if not all([news_id, comment_context]):
return jsonify(erron=response_code.RET.PARAMERR, errsmg="缺少参数")
# 如果新闻存在
# 将新闻放入评论的数据库中
# 获取新闻数据
news_id = int(news_id)
try:
news = News.query.filter(News.id == news_id).all()
print(news)
# print(comment.content)
# 将获取的评论信息放入Comment的和use_id相同的表里面，是个列表
# 谁评论的就将用户和评论信息加入到数据库
# 列表对象没有append，还可以采用赋值的方式放入数据库
# 当前用户当前评论
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.DBERR, errmsg='新闻不存在')
comment = Comment()
comment.user_id = user.id
comment.news_id = news_id
comment.content = comment_context
# parent_id = int(parent_id)
# 数据库中少了一个点赞条数
if parent_id:
comment.parent_id = parent_id
print(comment)
# 当前评论完毕，
# 回复评论
# 如果有父parent——id表示是回复评论
# 后台需要将comment新增数据传过去
# 将从前台获取的数据放入数据库
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='评论失败')
return jsonify(errno=response_code.RET.OK,
errmsg='操作成功',
data=comment.to_dict())
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.1判断参数(先判断有没有，再判断是否是对应的类型)
# parent_id 如果没有父评论则为空
if not all([news_id, comment_content]):
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
try:
news_id = int(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="参数错误")
# 2.2查询新闻，并判断新闻是否存在
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.添加到数据库
# 为什么要主动提交到数据库，因为我们要获取评论id,而这个id是需要在评论模型提交到数据库之后由数据库自动生成
# 而数据库生成是需要提交，如果不主动设置而采用配置中的自动提交，配置中是通过调用teardown方法实现的，这个方法是在
# 视图函数(当前请求结束，即return结束之后才执行)，所以没有办法满足需求，这才需要主动提交。
try:
db.session.add(comment)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
# 这里没有执行转字典列表操作，因为数据比较简单，只需要调用to_dict方法即可
# 前端能直接获取评论的content和评论的id,不能获取用户的id,图片等,所以需要返回to_dict
# print(comment.to_dict().parent) 为何独独这个parent属性获取不到,说明父类不是一个字典对象
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="用户未登录")
comment_id = request.json.get("comment_id")
action = request.json.get("action")
if not all([comment_id, action]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
if action not in ["add", "remove"]:
return jsonify(errno=RET.PARAMERR, 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:
comment_id = int(comment_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
try:
comment_obj = Comment.query.get(comment_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库查询错误")
if not comment_obj:
return jsonify(errno=RET.NODATA, errmsg="该评论不存在")
comment_like_obj = CommentLike.query.filter_by(comment_id=comment_id, user_id=user.id).first()
# 业务逻辑
if action == "add":
if not comment_like_obj:
# 如果我是添加一条点赞，要初始化一个点赞对象，并将数据添加进去，add，commit
comment_like = CommentLike()
comment_like.comment_id = comment_id
comment_like.user_id = user.id
db.session.add(comment_like)
comment_obj.like_count += 1
else:
# 如果这条点赞存在，我才能删除点赞
if comment_like_obj:
db.session.delete(comment_like_obj)
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="数据库保存失败")
# 查询出该条新闻下的评论条数
comment_count = Comment.query.filter(Comment.news_id == news_id).count()
return jsonify(errno=RET.OK, errmsg="ok", data=comment.to_dict(), comment_count=comment_count)
def news_comment():
# 评论接口（主评论，子评论）
# 1.获取参数
# 1.用户对象，新闻id，评论内容，主评论id
params_dict = request.json
news_id = params_dict.get("news_id")
comment = params_dict.get("comment")
parent_id = params_dict.get("parent_id")
user = g.user
# 2.校验参数
# 1.非空判断
if not all([news_id, comment]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不足")
# 2.判断用户是否登录
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
# 3.逻辑处理
# 1.新闻id查询该新闻（新闻存在就去评论）
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询新闻对象异常")
# 2.创建评论模型
comment_obj = Comment()
comment_obj.user_id = user.id
comment_obj.news_id = news_id
comment_obj.content = comment
# 3.判断主评论id是否有值
if parent_id:
# parent_id有值表示是子评论
comment_obj.parent_id = parent_id
# 4.将模型对象保存到数据库
try:
db.session.add(comment_obj)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存评论对象到数据库异常")
# 4.返回值处理
return jsonify(errno=RET.OK, errmsg="评论成功", data=comment_obj.to_dict())
def news_comment():
"""发布主/子评论后端接口"""
"""
1.获取参数
1.1 news_id:新闻id，user:当前登录的用户对象，content:评论内容，parent_id:区分子评论&主评论
2.参数校验
2.1 非空判断
3.逻辑处理
3.1 根据新闻id查询新闻对象
3.2 创建评论对象，给其各个属性赋值
3.3 将评论对象保存到数据库
4.返回值
4.1 将评论对象转化成字典
"""
# 1.1 news_id:新闻id，user:当前登录的用户对象，content:评论内容，parent_id:区分子评论&主评论
param_dict = request.json
news_id = param_dict.get("news_id")
content = param_dict.get("comment")
parent_id = param_dict.get("parent_id")
user = g.user
# 2.1 非空判断
if not all([news_id, content]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不足")
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
# 3.1 根据新闻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_obj = Comment()
# 当前登录的用户发布的评论
comment_obj.user_id = user.id
# 评论属于那条新闻
comment_obj.news_id = news.id
# 评论内容
comment_obj.content = content
# 区分子、主评论
if parent_id:
# 子评论
comment_obj.parent_id = parent_id
# 3.3 将评论对象保存到数据库
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="查询用户对象异常")
# 4.1 将评论对象转化成字典
comment_dict = comment_obj.to_dict() if comment_obj else None
return jsonify(errno=RET.OK, errmsg="发布评论成功", data=comment_dict)
def news_comment():
# 判断是否登录
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg=error_map[RET.SESSIONERR])
# 获取参数
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=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.PARAMERR, errmsg=error_map[RET.PARAMERR])
# 创建模型对象
comment = Comment()
comment.news_id = news.id
comment.user_id = user.id
comment.content = comment_content
if parent_id:
#判断父评论是否存在
try:
parent_comment = Comment.query.filter_by(id=parent_id,
news_id=news_id).first()
except BaseException as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=error_map[RET.DBERR])
if not parent_comment:
return jsonify(errno=RET.PARAMERR, errmsg=error_map[RET.PARAMERR])
# 校验参数
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()
except BaseException as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg=error_map[RET.DBERR])
# 返回结果给前端
return jsonify(errno=RET.OK,
errmsg=error_map[RET.OK],
data=comment.to_dict())
def news_comments():
"""
新闻评论
获取参数－－检查参数－－处理参数－－返回结果
1.用户必要登录
2.检查参数 news_id , comment, parent_id(可选)
3.转换参数的数据类型，判断parent_id是否存在
4．查询新闻，确认新闻的存在
5.保存评论信息，判断parent_id是否存在
6.提交数据
7.返回结果
:return:
"""
# 判断用户是否已经登录
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg='用户未登录')
# 获取参数
news_id = request.json.get('news_id')
content = request.json.get('comment')
parent_id = request.json.get('parent_id')
# 检查参数
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='无新闻数据')
# 构造评论的模型对象
comment = Comment()
comment.user_id = user.id
comment.news_id = news.id
comment.content = content
# 如果父评论存在，保存父评论信息
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='保存评论失败')
# 返回结果
return jsonify(errno=RET.OK, errmsg='OK', data=comment.to_dict())
def comment():
"""
评论功能分析：
１．评论新闻
接收评论新闻的id、评论内容
２．评论其他用户的评论
接收评论新闻的id、评论内容＋其他用户评论的id
所以：同时实现评论新闻和评论其他用户的评论
:return:
"""
# 先判断用户是否登录
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')
# 校验参数--parent_id可有可无
if not all([news_id, comment_content]):
return jsonify(errno=RET.PARAMERR, errmsg='参数错误1')
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='参数错误2')
# 判断该新闻是否存在
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
comment.parent_id = parent_id
comment.user_id = user.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='保存数据异常')
data = {
'comment': comment.to_dict() # 该字典中的内容还包含user相关信息
}
return jsonify(errno=RET.OK, errmsg='评论成功', data=data)
def news_comment():
'''新闻的评论和回复
'''
# 1 只要用户在登陆的状态下才能评论
# 2 哪个用户平轮的是哪个新闻 新闻是否存在
# 3 评论的内容提交数据库 并返给客户端
# 4 评论的评论是评论的哪个评论
# 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 校验参数
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(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='评论失败')
# 为了将评论可以展示到界面上 需要将内容响应给用户
data = {'comment': comment.to_dict()}
# 6 响应评论新闻和回复评论结果
return jsonify(errno=response_code.RET.OK,
errmsg='评论成功',
data=comment.to_dict())
def news_comments():
"""
新闻评论
获取参数－－检查参数－－业务处理－－返回结果
用户必须登录
1. 获取参数，news_id/comment/parent_id（可选）
2. 检查参数
3. 转换参数的数据类型，判断parent_id是否存在
4. 根据新闻，确认新闻的存在
5. 保存评论信息，判断parent_id是否存在
6. 提交数据
7. 返回结果
:return:
"""
# 判断用户是否登录
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
# 获取参数
news_id = request.json.get('news_id')
content = request.json.get('comment')
parent_id = request.json.get('parent_id')
# 检查参数
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="没有新闻数据")
# 构造评论的模型类对象
comment = Comment()
comment.user_id = user.id
comment.news_id = news.id
comment.content = content
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="评论失败")
# 返回结果
return jsonify(errno=RET.OK, errmsg="OK", data=comment.to_dict())
def news_comment():
"""主评论、子评论后端接口"""
"""
1.获取参数
1.1 user:当前登录的用户，news_id:新闻id，comment:评论内容，parent_id:主评论id（非必传）
2.校验参数
2.1 非空判断
3.逻辑处理
3.0 根据news_id查询出新闻对象(本身可以直接使用news_id给comment赋值，但是防止绕开前端发送请求的时候新闻不存在情况发送)
3.1 创建评论模型
3.2 保存到数据库
4.返回值
登录成功
"""
# 1.1 user:当前登录的用户，news_id:新闻id，comment:评论内容，parent_id:主评论id（非必传）
user = g.user
if not user:
# 用户未登录
current_app.logger.error("用户未登录")
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
param_dict = request.json
news_id = param_dict.get("news_id")
comment_str = param_dict.get("comment")
# 如果有值表示是子评论，反之就是主评论
parent_id = param_dict.get("parent_id")
# 2.1 非空判断
if not all([news_id, comment_str]):
current_app.logger.error("参数不足")
return jsonify(errno=RET.PARAMERR, errmsg="参数不足")
# 3.0 根据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.1 创建评论模型，并给各个属性赋值
comment = Comment()
# 那个用户发表评论
comment.user_id = user.id
# 评论的那条新闻
comment.news_id = news.id
# 评论内容
comment.content = comment_str
if parent_id:
# 子评论
comment.parent_id = parent_id
# 3.2 保存到数据库
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="保存评论对象异常")
# 4.返回值
# 注意：评论完毕需要返回数据给前端显示
return jsonify(errno=RET.OK, errmsg="OK", data=comment.to_dict())
