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(): """ 评论功能分析: 1.评论新闻 接收评论新闻的id、评论内容 2.评论其他用户的评论 接收评论新闻的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())