def news_dashang():
user = g.user
if not user:
#tkinter.messagebox.showwarning('警告','没登陆')
return jsonify(errno=RET.SESSIONERR, errmsg='用户未登录')
a = request.form.get('dashang')
b = request.form.get('newsid')
try:
c = int(a)
except Exception as e:
return jsonify(errno=RET.OK, errmsg='不是数字')
if c <= user.money:
user.money = user.money - c
db.session.commit()
news1 = News.query.filter(News.id == b).first()
user1 = User.query.filter(User.id == news1.user_id).first()
user1.money = user1.money + c
db.session.commit()
comment = Comment()
comment.user_id = 999
comment.news_id = b
comment.content = "%s打赏了%s金币，真是任性啊！！！" % (user.nick_name, c)
db.session.add(comment)
db.session.commit()
return redirect('http://127.0.0.1:5000/news/%s' % b)
else:
return jsonify(errno=RET.OK, errmsg='金币不足')
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_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
print(comment.content)
print(comment.user_id)
print(comment.news_id)
if parent_id:
comment.parent_id = parent_id
# 保存到数据库
try:
db.session.add(comment)
db.session.commit()
print("bbbbbbbbbbbbb")
except Exception as e:
current_app.logger.error(e)
print("aaaaaaa")
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg="保存评论数据失败")
# 返回响应
print(comment.to_dict())
c1 = Comment.query.all()
print(c1)
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=error_map[RET.SESSIONERR])
# 获取参数
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=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 = content
comment.news_id = news_id
comment.create_time = datetime.now()
comment.user_id = user.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()
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 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="参数错误")
# 查询新闻，并判断新闻是否存在
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
# db.session.add(comment)
'''
报错: to_dict(self) 方法中需要使用self 看一下里边全是self
"create_time": self.create_time.strftime("%Y-%m-%d %H:%M:%S"),
AttributeError: 'NoneType' object has no attribute 'strftime'
'''
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.OK, 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 = News.query.get(news_id)
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)
db.session.rollback()
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")
"""
新闻评论：
１ : 如果需要对新闻进行评论，那么当前用户必须要先登陆
2 : 如果需要对新闻进行评论，那么当前新闻肯定是需要存在的，所以直接通过新闻的id可以查询当前这条新闻
3 : 如果评论成功之后，那么我肯定希望下次在进来的时候，能够看到当前的评论，所以这个评论必须存到数据库里面
"""
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
news = News.query.get(news_id)
comment = Comment()
comment.news_id = news_id
comment.user_id = user.id
comment.content = comment_str
# 这个地方需要注意：不可能所有的评论都是有父id,所以需要判断
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():
"""
json:news_id user_id content parant_id
查询评论情况
:return:json
"""
user = g.user
news_id = request.json.get('news_id')
content_str = request.json.get('comment')
parent_id = request.json.get('parent_id')
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg='未登录')
if not all([news_id, content_str]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不完整')
comment = Comment()
comment.user_id = user.id
comment.news_id = news_id
comment.content = content_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")
# 评论的父id
parent_id = request.json.get("parent_id")
"""
用户评论：
用户如果在登录的情况下，可以进行评论，未登录，点击评论弹出登录框
用户可以直接评论当前新闻，也可以回复别人发的评论
1:用户必须先登陆才能进行评论，如果不登陆，直接返回
2:如果需要评论，那么就需要知道当前评论的是哪条新闻，如果想知道是哪条新闻，那么就可以通过news_id 查询出来新闻
3:如果评论成功之后，那么我们需要把用户的评论信息存储到数据库，为了方便下次用户在进来的时候可以看到评论
"""
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():
"""
思路分析:
1.判断用户是否有登陆
2.获取参数
3.校验参数
4.根据新闻编号获取新闻对象
5.判断新闻是否存在
6.创建评论对象
7.设置评论对象属性
8.保存到数据库
9.返回响应
: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()
# 7.设置评论对象属性
comment.user_id = g.user.id
comment.news_id = news_id
comment.content = content
#判断是否父评论
if parent_id:
comment.parent_id = parent_id
# 8.保存到数据库
try:
db.session.add(comment)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="评论失败")
# 9.返回响应
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")
# 评论的父id
parent_id = request.json.get("parent_id")
"""
用户评论:
用户如果在登录的情况下,可以进行评论,未登录,点击评论弹出登录框
用户可以直接评论当前新闻,也可以回复别人发的评论
1:用户必须先登陆才能进行评论,如果不登录,直接返回
2:如果需要评论,那么就需要知道当前评论的是哪条新闻,如果想知道是哪条新闻,那么就可以通过news_id查询出来新闻
3:如果评论成功之后,那么我们需要把用户的评论信息存储到数据库以便下次用户进来的时候可以看到评论
"""
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="参数不足")
news = News.query.get(news_id)
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
db.session.add(comment)
db.session.commit()
return jsonify(errno=RET.OK, errmsg="评论成功", data=comment.to_dict())
def news_comment():
if not g.user:
return jsonify(errno=RET.USERERR, errmsg="用户未登陆")
dict_data = request.json
news_id = dict_data.get('news_id')
content = dict_data.get('comment')
parent_id = dict_data.get('parent_id')
if not all([news_id, content]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
comment = Comment()
comment.user_id = g.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:
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():
#新闻id
news_id = request.json.get("news_id")
#评论内容
comment_str = request.json.get("comment")
#回复的评论id
parent_id = request.json.get("parent_id")
# 根据用户传过来的新闻id从数据库中获取这条新闻
news = News.query.get(news_id)
# 新闻评论是一个用户行为,所以需要用户必须登陆,判断user必须有值
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, 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
# 评论是第一次进行提交,所以需要进行add操作,保存到数据库
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_news():
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="请登录")
news_id = request.json.get('news_id')
print(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:
return jsonify(errno=RET.PARAMERR, 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()
return jsonify(errno=RET.OK, errmsg='OK', data=comment.to_dict())
def news_comment():
user = g.user
if not user:
return redirect(url_for("/login"))
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, comment_str]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不足")
news = News.query.get(news_id)
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:
return jsonify(errno=RET.DBERR, errmsg="保存评论数据失败")
return jsonify(errno=RET.OK, errmsg="评论成功", data=comment.to_dict())
def news_comment():
"""新闻评论"""
# 新闻评论是一个用户行为,所以需要用户必须登陆,判断user必须有值
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
# 评论是第一次进行提交,所以需要进行add操作
db.session.add(comment)
db.session.commit()
return jsonify(errno=RET.OK, errmsg="评论成功", data=comment.to_dict())
def set_news_comment():
"""
新闻评论
1.接收参数：new_id(必须), comment(必须), parent_id(非必须)
2.校验参数
3.初始化一个评论模型，并赋值
4.返回相应，把相关评论返回及评论数
:return:
"""
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
# 1.接收参数
news_id = request.json.get("news_id")
comment_str = request.json.get("comment")
parent_id = request.json.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="参数错误")
# 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:
return jsonify(errno=RET.NODATA, errmsg="未查询到新闻数据")
# 4.初始化一个评论模型，并赋值
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="数据库保存失败")
# 查询出该条新闻下的评论条数
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.1 news_id:新闻id，comment_str:评论的内容， parent_id:子评论的父评论id（非必传）
2.校验参数
2.1 非空判断
3.逻辑处理
3.0 根据news_id查询当前新闻
3.1 parent_id没有值：创建主评论模型对象，并赋值
3.2 parent_id有值： 创建子评论模型对象，并赋值
3.3 将评论模型对象保存到数据库
4.返回值
"""
#1.1 news_id:新闻id，comment_str:评论的内容， parent_id:子评论的父评论id（非必传）
params_dict = request.json
news_id = params_dict.get("news_id")
comment_str = params_dict.get("comment")
parent_id = params_dict.get("parent_id")
# 获取用户登录信息
user = g.user
#2.1 非空判断
if not all([news_id, comment_str]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不足")
#2.2 用户是否登录判断
if not user:
return jsonify(errno=RET.SESSIONERR, 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 parent_id没有值：创建主评论模型对象，并赋值
comment_obj = Comment()
comment_obj.user_id = user.id
comment_obj.news_id = news_id
comment_obj.content = comment_str
# 3.2 parent_id有值： 创建子评论模型对象，并赋值
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)
return jsonify(errno=RET.DBERR, errmsg="保存评论对象异常")
# 4.返回值
return jsonify(errno=RET.OK, errmsg="发布评论成功", data=comment_obj.to_dict())
def add_news_comment():
"""添加评论"""
# 用户是否登陆
user = g.user
if not user:
return jsonify(errno=RET.LOGINERR, errmsg="请先进行登录")
# 获取参数
news_id = request.json.get("news_id")
news_comment = request.json.get("comment")
parent_id = request.json.get("parent_id")
# 判断参数是否正确
if not all([news_id, news_comment]):
return jsonify(errno=RET.DATAERR, errmsg="参数不完整")
# 查询新闻是否存在并校验
new_info = News.query.get(news_id)
if not new_info:
return jsonify(errno=RET.DBERR, errmsg="新闻不存在")
# 初始化评论模型，保存数据
comment = Comment()
# 配置文件设置了自动提交,自动提交要在return返回结果以后才执行commit命令,如果有回复
# 评论,先拿到回复评论id,在手动commit,否则无法获取回复评论内容
comment.user_id = user.id
comment.news_id = news_id
comment.content = news_comment
comment.parent_id = parent_id
db.session.add(comment)
db.session.commit()
# 返回响应
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")
comments = request.json.get("comment")
parent_id = request.json.get("parent_id")
if not all([news_id, comments]):
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="参数错误")
comment = Comment()
comment.user_id = user.id
comment.news_id = news_id
comment.content = comments
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="成功", comment=comment.to_dict())
def news_comment():
"""
添加新闻评论
1.校验用户是否登录
2.获取参数
3.校验参数
4.查询当前新闻
5.初始化评论模型
6.返回数据
:return:
"""
# 1.校验用户是否登录
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg='用户未登录')
# 2.获取参数
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.DATAERR, 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:
return jsonify(errno=RET.NODATA, errmsg='数据不存在')
# 4.初始化评论模型
comment = Comment()
comment.news_id = news_id
comment.user_id = user.id
comment.content = comment_content
if parent_id:
comment.parent_id = parent_id
# 5.保存到数据库
try:
db.session.add(comment)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='评论保存出错')
# 6.返回数据
return jsonify(errno=RET.OK, errmsg='OK', data=comment.to_dict())
def news_comment():
"""
思路类似收藏
1. 获取参数 news_id comment_content parent_id
2. 校验参数
3. 在数据库添加评论,
4. 返回给前端进行渲染
注意: 当前只是返回到ajax是局部刷新,当重新加载新闻页面评论会消失
:return:
"""
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是为了获取父评论,为了回复,可以不存在
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="新闻不存在")
# 新建评论对象,将评论添加到数据库,并传到前端进行渲染json格式
# parent_id是Comment模型类的字段,存在就说明是回复
# 且评论是News模型类中的comments字段,
comment = Comment()
comment.news_id = news_id
comment.user_id = user.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.PARAMERR, errmsg="参数错误")
return jsonify(errno=RET.OK, errmsg="评论成功", data=comment.to_dict())
def news_comment():
"""
新闻评论
1、尝试获取用户信息，如果用户未登录，直接结束程序
2、获取参数，news_id,comment,parent_id
3、检查参数的完整性，news_id,comment
4、把news_id转换数据类型，如果parent_id存在
5、查询数据库，确认新闻的存在
6、保存评论信息
coments = Comment()
7、提交数据到数据库
8、返回结果
: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='新闻不存在')
# 构造模型类对象，存储评论信息
comments = Comment()
comments.user_id = user.id
comments.news_id = news_id
comments.content = content
if parent_id:
comments.parent_id = parent_id
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():
"""发布评论接口（主评论，子评论）"""
"""
1.获取参数
1.1 comment_str:评论内容，news_id:新闻id， parent_id：父评论id（非必传参数）
2.校验参数
2.1 非空判断
3.逻辑处理
3.0 根据news_id查询新闻是否存在
3.1 parent_id没有值：发布主评论
3.2 parent_id有值：发布子评论
4.返回值
"""
#1.1 comment_str:评论内容，news_id:新闻id， parent_id：父评论id（非必传参数）
params_dict = request.json
comment_str = params_dict.get("comment")
news_id = params_dict.get("news_id")
parent_id = params_dict.get("parent_id")
# 获取用户对象
user = g.user
#2.1 非空判断
if not all([news_id, comment_str]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不足")
#2.2 用户是否登录判断
if not user:
return jsonify(errno=RET.SESSIONERR, 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 parent_id没有值：发布主评论
comment_obj = Comment()
comment_obj.user_id = user.id
comment_obj.news_id = news_id
comment_obj.content = comment_str
# 3.2 parent_id有值：发布子评论
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.返回值
return jsonify(errno=RET.OK, errmsg="评论成功", data=comment_obj.to_dict())
def news_comment():
"""
思路分析:
0.判断用户是否存在
1.获取参数
2.校验参数
3.通过新闻编号取出新闻对象
4.判断新闻对象是否存在
5.创建评论对象,设置属性
6.保存评论到数据库
7.返回响应
:return:
"""
#0. 判断用户是否存在
if not g.user:
return jsonify(errno=RET.NODATA, errmsg="用户未登录")
# 1.获取参数
news_id = request.json.get('news_id')
content = request.json.get('comment')
parent_id = request.json.get('parent_id')
# 2.校验参数
if not all([news_id, content]):
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="新闻查询失败")
# 4.判断新闻对象是否存在
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 comments_news():
"""
评论新闻
1、判断用户是否登录
2、获取参数，news_id,comment,parent_id
3、检查参数的完整
4、校验news_id,parent_id转成整型
5、根据news_id查询数据库
6、实例化评论表对象，保存评论id、新闻id，新闻内容，如果有父评论id
7、提交数据返回data = comment.to_dict()
:return:
"""
# 确定用户已登录
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg='用户未登录')
# 获取参数，新闻id、父评论id、评论内容
news_id = request.json.get('news_id')
parent_id = request.json.get('parent_id')
content = request.json.get('comment')
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='参数格式错误')
# 根据新闻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 = 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.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.接收参数，用户 新闻 评论内容 parant_id
2.校验参数
3.业务逻辑
4.返回响应
:return:
"""
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
# 1. 取到请求参数
news_id = request.json.get("news_id")
comment_str = request.json.get("comment")
parent_id = request.json.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
# 添加到数据库
# 为什么要自己去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.DBERR, errmsg="数据库保存失败")
return jsonify(errno=RET.OK, errmsg="OK", data=comment.to_dict())
def news_comment():
"""
评论新闻和回复别人评论
1、接收三个参数
2、对参数进行校验
3、新闻是否存在校验
4、存入评论的数据库
:return:
"""
# 先判断用户是否登录
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
# 获取参数
news_id = request.json.get("news_id", None)
comment_content = request.json.get("comment", None)
parent_id = request.json.get("parent_id", None)
# 校验参数
if not all([news_id, comment_content]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不足")
# 校验新闻id是否正确
try:
news_id = int(news_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_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="操作成功", 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. 判断错误
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. 添加到数据库
# 为什么手动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():
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", 0)
# 校验参数
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])
# 根据news_id查询新闻模型
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.user_id = user.id
comment.news_id = news_id
comment.content = comment_content
if parent_id: # 判断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])
# 存在父评论id,保存到数据库
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())
