def news_release():
"""
GET 正常渲染 分类
POST json 参数：新闻 title category digest content index_image
:return:
"""
if not g.user:
return redirect('/')
if request.method == 'POST':
title = request.form.get('title')
source = '个人发布'
digest = request.form.get('digest')
content = request.form.get('content')
image_file = request.files.get('image_file')
category = request.form.get('category')
category_id = Category.query.filter(
Category.name == category).first().id
user_id = g.user.id
status = 1
reason = ''
if not all([title, digest, content, image_file, category]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不全')
try:
image_file_byte = image_file.read()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.SERVERERR, errmsg='图片读取错误')
try:
key = qiniuyun(image_file_byte)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.UNKOWNERR, errmsg='七牛云错误')
index_image_url = constants.QINIU_DOMIN_PREFIX + key
news = News()
news.title = title
news.source = source
news.digest = digest
news.content = content
news.index_image_url = index_image_url
news.category_id = category_id
news.user_id = g.user.id
news.status = status
news.reason = reason
try:
db.session.add(news)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='发布失败')
return jsonify(errno=RET.OK, errmsg='OK')
category_li = []
try:
category = Category.query.all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='数据库错误')
for cate in category:
category_li.append(cate.to_dict())
category_li.pop(0)
data = {'category_li': category_li}
return render_template('news/user_news_release.html', data=data)
def news_release():
# GET请求
if request.method == 'GET':
# 1. 获取新闻分类数据
categories = []
try:
# 获取所有的分类数据
categories = Category.query.all()
except Exception as e:
current_app.logger.error(e)
# 2. 移除最新分类
# 定义列表保存分类数据
categories_dicts = []
for category in categories:
# 获取字典
cate_dict = category.to_dict()
# 拼接内容
categories_dicts.append(cate_dict)
categories_dicts.pop(0)
# 返回数据
return render_template('news/user_news_release.html',
data={'categories': categories_dicts})
# 1. 获取要提交的数据
title = request.form.get('title')
source = '个人发布'
digest = request.form.get('digest')
content = request.form.get('content')
index_image = request.files.get("index_image")
category_id = request.form.get("category_id")
# 校验参数
if not all([title, source, digest, content, index_image, category_id]):
return jsonify(errno=RET.PARAMERR, errmsg="参数有误")
# 3.取到图片，将图片上传到七牛云
try:
index_image_data = index_image.read()
# 上传到七牛云
key = storage(index_image_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数有误")
# 保存数据
news = News()
news.title = title
news.digest = digest
news.source = source
news.content = content
news.index_image_url = constants.QINIU_DOMIN_PREFIX + key
news.category_id = category_id
news.user_id = g.user.id
# 新闻状态,将新闻设置为1代表待审核状态
news.status = 1
# 手动设置新闻状态,在返回前commit提交
try:
db.session.add(news)
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='发布成功，等待审核')
def news_release():
"""
新闻发布
1.获取用户信息，如果是get请求，查询新闻分类信息，移除最新分类，传给模板
2.获取参数，title category_id digest index_image,content
3.检查参数的完整性
4.转换分类id的数据类型
5.读取数据内容，调用七牛云上传新闻图片
6.构造模型类对象，保存新闻数据
7.返回结果
:return:
"""
user = g.user
if request.method == 'GET':
# 查询新闻分类，查询出不是最新的所有分类
try:
categories = Category.query.all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询数据失败')
# 判断查询结果
if not categories:
return jsonify(errno=RET.NODATA, errmsg='无新闻分类信息')
# 定义容器存储新闻分类数据
category_list = []
for category in categories:
category_list.append(category.to_dict())
# 移除索引为０的新闻分类（最新)
category_list.pop(0)
# 定义字典
data = {'categories': category_list}
return render_template('news/user_news_release.html', data=data)
# 用户提交数据，获取参数:title category_id,digest,index_image,content
title = request.form.get('title')
category_id = request.form.get('category_id')
digest = request.form.get('digest')
index_image = request.files.get('index_image')
content = request.form.get('content')
print(title, category_id, digest, index_image, content)
# 检查参数的完整性
if not all([title, category_id, digest, index_image, content]):
return jsonify(errno=RET.PARAMERR, errmsg='参数缺失')
# 转换参数类型
try:
category_id = int(category_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg='参数类型错误')
# 读取图片数据
try:
image_data = index_image.read()
except Exception as e:
current_app.logger.errnor(e)
return jsonify(errno=RET.PARAMERR, errmsg='参数格式错误')
# 上传封面图片
try:
image_name = storage(image_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg='上传图片失败')
# 保存新闻数据
news = News()
news.title = title
news.category_id = category_id
news.digest = digest
news.index_image_url = constants.QINIU_DOMIN_PREFIX + image_name
news.content = content
news.user_id = user.id
news.source = '个人发布'
news.status = 1
# 提交数据
try:
db.session.add(news)
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')
def news_release():
'''用户新闻发布'''
#1判断用户登录信息
user = g.user
if not user:
return redirect(url_for('index.index'))
#2.请求方法为GET方法：渲染新闻分类
if request.method == 'GET':
#2.1渲染新闻分类
categories = []
try:
categories = Category.query.all()
except Exception as e:
current_app.logger.error(e)
#删除最新分类
categories.pop(0)
context = {'categories': categories}
return render_template('news/user_news_release.html', context=context)
#3.请求方法为POST
if request.method == 'POST':
#3.1接收参数
title = request.form.get('title')
source = '个人发布'
digest = request.form.get('digest')
content = request.form.get('content')
indext_image = request.files.get('index_image')
category_id = request.form.get('category_id')
#3.2校验参数
if not all([title, source, digest, content, indext_image, category_id
]):
return jsonify(errno=response_code.RET.PARAMERR, errmsg='缺少参数')
#3.3读取用户上传的新闻图片
try:
indext_image_data = indext_image.read()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=response_code.RET.PARAMERR, errmsg='读取新闻数据失败')
#3.4将用户上传的图片转存到七牛云
try:
key = upload_file(indext_image_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=response_code.RET.THIRDERR, errmsg='上传新闻图片失败')
#3.5创建News新闻模型对象，并赋值和同步到数据库
news = News()
news.title = title
news.digest = digest
news.source = source
news.content = content
news.index_image_url = constants.QINIU_DOMIN_PREFIX + key
news.category_id = category_id
news.user_id = user.id
news.status = 1
try:
db.session.add(news)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=response_code.RET.DBERR, errmsg='保存新闻数据失败')
#3.6响应新闻发布的结果
return jsonify(errno=response_code.RET.OK, errmsg='新闻发布成功')
def news_release():
# - 0.判断是否是GET请求,携带分类数据展示
if request.method == "GET":
try:
categories = Category.query.all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取分类失败")
#分类对象列表 转字典列表
category_list = []
for category in categories:
category_list.append(category.to_dict())
return render_template("news/user_news_release.html",
categories=category_list)
# - 1.如果是POST,获取参数
title = request.form.get("title")
category_id = request.form.get("category_id")
digest = request.form.get("digest")
# index_image = request.files.get("index_image")
content = request.form.get("content")
# - 2.校验参数,为空校验
if not all([title, category_id, digest, content]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不全")
# - 3.上传新闻图片
# try:
# image_name = image_storage(index_image.read())
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(errno=RET.THIRDERR, errmsg="七牛云上传失败")
#
# # - 4.判断图片是否上传成功
# if not image_name:
# return jsonify(errno=RET.NODATA, errmsg="上传失败")
# - 5.创建新闻对象,设置新闻属性
news = News()
news.title = title
news.source = g.user.nick_name
news.digest = digest
# news.index_image_url = constants.QINIU_DOMIN_PREFIX + image_name
news.content = content
news.category_id = category_id
news.user_id = g.user.id
news.status = 1
# - 6.保存到数据库
try:
db.session.add(news)
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="发布成功")
def publicNews():
if request.method == 'POST':
news_info = request.form
title = news_info.get('title')
category = news_info.get('category_id')
digest = news_info.get('digest')
image = None
content = news_info.get('content')
outter_url = None
try:
image = news_info.get('image').read()
print(image)
except Exception as err:
flash('image transform failed.')
if not all([title, category, digest, content]):
return jsonify(errno = RET.NODATA, errmsg = 'data missing.')
try:
category = int(category)
except Exception as err:
return jsonify(errno = RET.DATAERR, errmsg = 'data type error.')
if not re.match(r'(.|\n){1,20}$', title) or not re.match(r'(.|\n){2,200}$', digest) or not re.match(r'(.|\n){20,200000}$', content):
return jsonify(errno =RET.PARAMERR, errmsg = '字数不符合要求:标题1-20字符，摘要2-200字符，内容20-20w字符')
if image:
try:
from info.utils.image_storage import storage
outter_url = storage(image)
if not outter_url:
pass
# return jsonify(errno = 100, errmsg = '发布成功，但图片上传失败')
except Exception as err:
current_app.logger.error(err)
return jsonify(errno = RET.DBERR, errmsg = '数据库操作失败')
try:
from info.models import News
public_news = News()
public_news.title = title
public_news.source = g.login_user.nick_name
public_news.user_id = g.login_user.id
public_news.category_id = category
public_news.digest = digest
public_news.content = content
public_news.status = 1
public_news.index_image_url = constants.QINIU_DOMIN_PREFIX + outter_url if outter_url else None
db.session.add(public_news)
db.session.commit()
except Exception as err:
current_app.logger.error(err)
return jsonify(errno = RET.DBERR, errmsg = '数据库操作失败')
return jsonify(errno=RET.OK, errmsg='OK')
elif request.method == 'GET':
from info.models import Category
all_categories = Category.query.filter(Category.id != 1).all()
all_categories = [item.to_dict() for item in all_categories]
return render_template('news/html/user_news_release.html', datas = {'all_categories':all_categories})
def news_release():
# GET请求传递分类数据并渲染模板
if request.method == 'GET':
# 查询分类
category_models = []
try:
category_models = Category.query.all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库错误")
# 模型转字典
category_list = []
for category in category_models:
category_list.append(category.to_dict())
# 删除第一个元素
category_list.pop(0)
data = {'category_list': category_list}
return render_template('news/user_news_release.html', data=data)
# POST请求
# 一. 获取参数
title = request.form.get("title")
source = "个人发布"
digest = request.form.get("digest")
content = request.form.get("content")
index_image = request.files.get("index_image")
category_id = request.form.get("category_id")
# 二. 校验参数
# 1. 完整性
if not all([title, source, digest, content, index_image, category_id]):
return jsonify(errno=RET.PARAMERR, errmsg="参数有误")
# 2. 读取图片
try:
image_data = index_image.read()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数有误")
# 3. 分类ID(类型, 查询是否已存在)
try:
category_id = int(category_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数有误")
try:
category_model = Category.query.get(category_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库错误")
if not category_model:
return jsonify(errno=RET.NODATA, errmsg="无分类数据")
# 三. 逻辑处理
# 1. 上传图片
try:
image_name = storage(image_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库错误")
# 2. 创建新闻模型
news = News()
news.title = title
news.digest = digest
news.source = source
news.content = content
# 新闻很多是爬来的. 网址前缀并非统一. 为了读取方便, 我们统一都加上前缀
news.index_image_url = constants.QINIU_DOMIN_PREFIX + image_name
news.category_id = category_id
news.user_id = g.user.id # 发布新闻的人
# 1代表待审核状态
news.status = 1
# 3. 保存到数据库
try:
db.session.add(news)
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="发布成功，等待审核")
def news_release():
"""
思路分析:
1.第一次进来GET请求,携带数据返回页面
2.获取参数
3.校验参数
4.上传图片
5.判断是否上传成功
6.创建新闻对象,设置属性
7.保存新闻到数据库
8.返回响应
:return:
"""
# 1.第一次进来GET请求,携带数据返回页面
if request.method == "GET":
#查询所有分类信息
try:
catetories = Category.query.all()
catetories.pop(0) #弹出最新
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取新闻分类失败")
#将对象列表转成字典列表
catetory_list = []
for catetory in catetories:
catetory_list.append(catetory.to_dict())
return render_template('news/user_news_release.html',
catetories=catetory_list)
# 2.获取参数
title = request.form.get("title")
category_id = request.form.get("category_id")
digest = request.form.get("digest")
index_image = request.files.get("index_image")
content = request.form.get("content")
# 3.校验参数
if not all([title, category_id, digest, index_image, content]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不全")
# 4.上传图片
try:
image_name = image_storage(index_image.read())
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg="七牛云上传失败")
# 5.判断是否上传成功
if not image_name:
return jsonify(errno=RET.NODATA, errmsg="图片上传失败")
# 6.创建新闻对象,设置属性
news = News()
news.title = title
news.source = "个人发布"
news.digest = digest
news.content = content
news.index_image_url = constants.QINIU_DOMIN_PREFIX + image_name
news.category_id = category_id
news.user_id = g.user.id
news.status = 1 #当前新闻状态 如果为0代表审核通过，1代表审核中，-1代表审核不通过
# 7.保存新闻到数据库
try:
db.session.add(news)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg="新闻发布失败")
# 8.返回响应
return jsonify(errno=RET.OK, errmsg="发布成功")
def news_release():
# 发布新闻页面显示
# 若果是get请求，那么就是渲染页面
if request.method == "GET":
categories = []
try:
# 查询出所有的新闻分类
categories = Category.query.all()
except Exception as e:
current_app.logger.error(e)
category_dict_li = []
for category in categories:
category_dict_li.append(category)
# 在发布新闻的时候不应该有最新这一项，所以我们给这个最新给删除
category_dict_li.pop(0)
return render_template("news/user_news_release.html",
data={"categories": category_dict_li})
# 到此处说明请方式是post请求
# 1,先获取提交过来的的数据
# 获取标题
title = request.form.get("title")
# 新闻来源
source = "个人发布"
# 摘要
digest = request.form.get("digest")
# 新闻内容
content = request.form.get("content")
# 索引图片
index_image = request.files.get("index_image")
# 分类id
category_id = request.form.get("category_id")
# 校验参数
# 2.1 判断数据是否有值
if not all([title, source, digest, content, index_image, category_id]):
return jsonify(errno=RET.PARAMERR, errmsg="参数有误")
try:
category_id = int(category_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数有误")
# 取到图片，讲图片上传到七牛云
try:
# 将收到的图片读取
index_image_data = index_image.read()
# 上传到七牛云
key = storage(index_image_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数有误")
# 创建一个新闻对象
news = News()
news.title = title
news.source = source
news.digest = digest
news.content = content
news.index_image_url = constants.QINIU_DOMIN_PREFIX + key
news.category_id = category_id
news.title = title
news.user_id = g.user.id
# 审核状态
news.status = 1
try:
db.session.add(news)
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")
def news_release():
"""用户个人中心新闻发布"""
if request.method == "GET": # 加载页面不需要获取用户对象
# 新闻分类查询
# 1.查询排除Home/Archives/About的所有分类，并拼接数据为字典
filters = [
Category.name != "Home", Category.name != "Archives",
Category.name != "Project", Category.name != "About"
]
categories = []
try:
categories = Category.query.filter(*filters).all()
except Exception as e:
current_app.logger.error(e)
# 空列表保存分类数据
categories_archives_li = []
# 查询所有，遍历后分别将属性转成字典存入新列表
for category in categories:
categories_archives_li.append(category.to_dict())
return render_template("news/user_news_release.html",
data={"categories": categories_archives_li})
else:
# POST 提交，执行发布新闻操作
# 1.获取要提交的数据
title = request.form.get("title") # 标题
source = g.user.nick_name
digest = request.form.get("digest")
content = request.form.get("content")
index_image = request.files.get("index_image")
category_id = request.form.get("category_id")
# 2.校参 判断数据是否有值
if not all([title, source, digest, content, category_id]):
return jsonify(errno=RET.PARAMERR, errmsg="参数有误")
try:
category_id = int(category_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 3. 初始化新闻模型，并设置相关数据
news = News()
news.title = title
news.digest = digest # 摘要
news.source = source # 新闻来源
news.content = content
news.category_id = category_id
news.user_id = g.user.id
# 代表待审核状态
news.status = 1
# 4.尝试读取图片(将来显示到主页),上传到七牛
if index_image:
try:
index_image_data = index_image.read() # 上面已经验证有值，不用分开try
key = storage(index_image_data) # 将主页图片数据上传给七牛返回生成图片url
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg="上传图片错误")
# 加url前缀,index_image_url表示首页图片地址
news.index_image_url = constants.QINIU_DOMIN_PREFIX + key
# 5. 保存到数据库，不自己提交也没事，会自动提交
try:
db.session.add(news)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg="保存数据失败")
# 5. 返回结果
return jsonify(errno=RET.OK, errmsg="发布成功，等待审核")
def news_release():
"""
- 1.判断请求方式是否是GET
- 2.如果是GEt,携带参数渲染页面
- 3.获取post请求参数
- 4.校验参数
- 6.上传图片
- 7.判断图片是否上传成功
- 8.创建新闻对象,设置新闻属性
- 9.保存新闻到数据库中
- 10.返回响应
:return:
"""
# - 1.判断请求方式是否是GET
if request.method == "GET":
#查询分类
try:
categoies = Category.query.all()
categoies.pop(0) #弹出最新
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取分类失败")
# - 2.如果是GEt,携带参数渲染页面
return render_template("news/user_news_release.html",
categoies=categoies)
# - 3.获取post请求参数
title = request.form.get("title")
category_id = request.form.get("category_id")
digest = request.form.get("digest")
index_image = request.files.get("index_image")
content = request.form.get("content")
# - 4.校验参数
if not all([title, category_id, digest, index_image, content]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不全")
# - 6.上传图片
try:
image_name = image_storage(index_image.read())
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg="七牛云异常")
# - 7.判断图片是否上传成功
if not image_name:
return jsonify(errno=RET.NODATA, errmsg="图片上传视图")
# - 8.创建新闻对象,设置新闻属性
news = News()
news.title = title
news.source = g.user.nick_name
news.digest = digest
news.content = content
news.index_image_url = constants.QINIU_DOMIN_PREFIX + image_name
news.category_id = category_id
news.user_id = g.user.id
news.status = 1 #审核中
# - 9.保存新闻到数据库中
try:
db.session.add(news)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg="新闻发布失败")
# - 10.返回响应
return jsonify(errno=RET.OK, errmsg="新闻发布成功")
def news_release():
"""
1.判断是否是GET请求，携带分类数据展示
2.如果是POST，获取参数
3.校验参数，为空校验
4.判断图片是否上传成功
5.创建新闻镀锡，设置新闻属性
6.保存到数据库
7.返回响应
:return:
"""
# 1.判断是否是GET请求，携带分类数据展示
if request.method == "GET":
try:
categories = Category.query.all()
categories.pop(0)
except Exception as e:
current_app.logger(e)
return jsonify(errno=RET.DBERR, errmsg="获取分类失败")
# 分类对象列表，转字典列表
category_list = []
for category in categories:
category_list.append(category)
return render_template("news/user_news_release.html",
categories=category_list)
# 2.如果是POST，获取参数
title = request.form.get("title")
category_id = request.form.get("category_id")
digest = request.form.get("digest")
index_image = request.files.get("index_image")
content = request.form.get("content")
# 3.校验参数，为空校验
if not all([title, category_id, digest, content, index_image]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不全")
# # 上传图片
try:
image_name = image_storage(index_image.read())
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg="七牛云上传异常")
# 4.判断图片是否上传成功
if not image_name:
return jsonify(errno=RET.NODATA, errmsg="上传失败")
# 5.创建新闻属性，设置新闻属性
news = News()
news.title = title
news.source = g.user.nick_name
news.digest = digest
news.index_image_url = constants.QINIU_DOMIN_PREFIX + image_name
news.content = content
news.category_id = category_id
news.user_id = g.user.id
news.status = 1 # 表示正审核中
# 6.保存到数据库
try:
db.session.add(news)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="新闻发布失败")
# 7.返回响应
return jsonify(errno=RET.OK, errmsg="发布成功")
def news_release():
"""展示新闻发布页面&发布新闻"""
# GET请求：查询分类数据，展示新闻发布页面
if request.method == "GET":
# 查询分类数据
try:
categories = Category.query.all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询分类对象异常")
# 对象列表转换成字典
category_dict_list = []
for category in categories if categories else []:
category_dict_list.append(category.to_dict())
# 弹出列表第一个元素，移除最新分类
category_dict_list.pop(0)
# 渲染模板
return render_template("user/user_news_release.html",
data={"categories": category_dict_list})
# POST请求：发布新闻
"""
1.获取参数
1.1 title:新闻标题，category_id:分类id，digest:新闻摘要，index_image:新闻主图片,
content:新闻内容，user:当前登录的用户，source:个人发布
2.校验参数
2.1 非空判断
3.逻辑处理
3.1 新建新闻对象，并且给各个属性赋值
3.2 保存回数据库
4.返回值
登录成功
"""
# 1.1 title:新闻标题，category_id:分类id，digest:新闻摘要，index_image:新闻主图片,
# content:新闻内容，user:当前登录的用户，source:个人发布
title = request.form.get("title")
category_id = request.form.get("category_id")
digest = request.form.get("digest")
content = request.form.get("content")
# 新闻图片是文件数据
index_image = request.files.get("index_image")
user = g.user
source = "个人发布"
# 2.1 非空判断
if not all([title, category_id, digest, content, index_image]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不足")
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
# 3.0 将图片数据上传到七牛云
try:
image_name = upload_image(index_image.read())
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="上传图片数据到七牛云异常")
# 图片名称没有值
if not image_name:
return jsonify(errno=RET.DBERR, errmsg="上传图片数据到七牛云异常")
# 3.1 新建新闻对象，并且给各个属性赋值
news = News()
# 新闻标题
news.title = title
# 新闻分类
news.category_id = category_id
# 摘要
news.digest = digest
# 内容
news.content = content
# 注意：拼接完整url地址
news.index_image_url = constants.QINIU_DOMIN_PREFIX + image_name
# 新闻发布的作者
news.user_id = user.id
# 新闻来源
news.source = source
# 发布的新闻默认处于：审核中
news.status = 1
# 3.2 保存回数据库
try:
db.session.add(news)
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="发布新闻成功")
def news_release():
"""发布新闻的页面显示&发布新闻的逻辑处理"""
# GET请求：发布新闻的页面展示，同时将分类数据返回
if request.method == "GET":
# 1.查询所有分类的数据
try:
categories = Category.query.all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询分类对象异常")
# 2. 分类列表对象转换成字典对象
category_dict_list = []
for category in categories if categories else []:
category_dict_list.append(category.to_dict())
# 移除'最新'分类
category_dict_list.pop(0)
return render_template("profile/user_news_release.html",
data={"categories": category_dict_list})
# POST请求：发布新闻逻辑处理
"""
1.获取参数(表单请求数据)
1.1 title:新闻标题,cid:新闻分类，digest:新闻的摘要，index_image:新闻主图片，
content：新闻的内容，user:当前用户对象
2.参数检验
2.1 非空判断
3.逻辑处理
3.1 新闻主图片保存到七牛云
3.2 创建新闻对象，给各个属性赋值，保存会收据库
4.返回值
"""
# 1.1 title:新闻标题,cid:新闻分类，digest:新闻的摘要，index_image:新闻主图片，
# content：新闻的内容，user:当前用户对象
param_dict = request.form
title = param_dict.get("title")
cid = param_dict.get("category_id")
digest = param_dict.get("digest")
content = param_dict.get("content")
index_image = request.files.get("index_image")
user = g.user
source = "个人发布"
# 2.1 非空判断
if not all([title, cid, content, index_image]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不足")
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登陆")
try:
cid = int(cid)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="分类id格式错误")
# 3.1 新闻主图片保存到七牛云
pic_data = None
try:
pic_data = index_image.read()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="读取图片数据异常")
try:
pic_name = pic_storage(pic_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg="上传图片到七牛云异常")
# 3.2 创建新闻对象，给各个属性赋值，保存会收据库
news = News()
# 新闻标题
news.title = title
# 新闻分类
news.category_id = cid
# 新闻摘要
news.digest = digest
# 新闻内容
news.content = content
# 新闻主图片的url
news.index_image_url = constants.QINIU_DOMIN_PREFIX + pic_name
# 新闻来源
news.source = source
# 新闻id
news.user_id = user.id
# 新发布的新闻处于审核中
news.status = 1
# 保存数据回数据库
try:
db.session.add(news)
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="新闻发布成功")
def user_news_release():
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
if request.method == "GET":
news_id = request.args.get('news_id')
news = None
if news_id:
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库读取错误")
try:
categories = Category.query.all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库读取错误")
if not categories:
return jsonify(errno=RET.NODATA, errmsg="无新闻分类")
category_list = []
for category in categories:
category_list.append(category.to_dict())
category_list.pop(0)
data = {"category_list": category_list, "news": news}
return render_template('news/user_news_release.html', data=data)
title = request.form.get('title')
digest = request.form.get('digest')
category_id = request.form.get('category_id')
content = request.form.get('content')
index_image = request.files.get('index_image')
if not all([title, digest, category_id, content, index_image]):
return jsonify(errno=RET.PARAMERR, errmsg="提交参数缺失")
num = random_string()
try:
index_image.save('./info/static/news/images/index/index' + num +
'.png')
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.IOERR, errmsg="文件保存错误")
# # 读取图片数据
# try:
# image_data = index_image.read()
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(errno=RET.DATAERR, errmsg="参数格式错误")
# try:
# image_name = storage(image_data)
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(errno=RET.THIRDERR, errmsg="上传图片失败")
news = News()
news.title = title
news.digest = digest
news.category_id = category_id
news.content = content
# news.index_image_url = constants.QINIU... + image_name
news.index_image_url = './info/static/news/images/index/index' + num + '.png'
news.user_id = user.id
news.source = '用户发布'
news.status = 0
try:
db.session.add(user)
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="新闻已提交")
def news_release():
#1、第一次进来GET请求，直接渲染页面
if request.method == "GET":
#获取所有的分类列表
try:
categoies = Category.query.all()
categoies.pop(0) #弹出编号为0最新分类
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="分类获取失败")
#转成字典列表
category_list = []
for category in categoies:
category_list.append(category.to_dict())
return render_template('news/user_news_release.html',
data={"categories": category_list})
# 2.获取参数
title = request.form.get("title") #新闻标题
category_id = request.form.get("category_id") #分类id
digest = request.form.get("digest") #摘要
content = request.form.get("content") #内容
index_image = request.files.get("index_image") #图片
# 3.校验参数
if not all([title, category_id, digest, content, index_image]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 4.上传新闻图片
# try:
# # 读取图片内容
# image_data = index_image.read()
#
# # 上传图片
# image_name = image_storage(image_data)
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(errno=RET.THIRDERR, errmsg="七牛云异常")
#
# if not image_name:
# return jsonify(errno=RET.NODATA, errmsg="图片上传失败")
# 5.创建新闻对象,设置新闻对象属性
news = News()
news.title = title
news.source = "个人发布"
news.digest = digest
news.content = content
# news.index_image_url = constants.QINIU_DOMIN_PREFIX + image_name
news.category_id = category_id
news.user_id = g.user.id
#审核状态1
news.status = 1
# 6.提交到数据库中
try:
db.session.add(news)
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="新闻发布成功")
def news_release():
'''个人中心新闻发布'''
# 1, 判断用户是否登陆
user = g.user
if not user:
return redirect(url_for('index.index'))
# GET请求
if request.method == 'GET':
# 渲染分类列表、
categories = []
try:
categories = Category.query.all()
except Exception as e:
current_app.logger.error(e)
# 删除‘最新’
categories.pop(0)
context = {'categories': categories}
return render_template('news/user_news_release.html', context=context)
# POST请求
if request.method == 'POST':
"发布新闻内容"
# 1, 获取要发布的内容信息
title = request.form.get("title")
source = "个人发布"
digest = request.form.get("digest")
content = request.form.get("content")
index_image = request.files.get("index_image")
category_id = request.form.get("category_id")
# 2, 校验参数
if not all([title, source, digest, content, index_image, category_id]):
return jsonify(errno=response_code.RET.PARAMERR, errmsg='参数不全')
try:
index_image_data = index_image.read()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=response_code.RET.PARAMERR, errmsg='读取图片失败')
# 3, 把图片上传到七牛云
try:
key = upload_file(index_image_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=response_code.RET.THIRDERR, errmsg='上传图片失败')
# 4, 把数据存储到数据库
news = News()
news.title = title
news.source = source
news.digest = digest
news.content = content
news.index_image_url = constants.QINIU_DOMIN_PREFIX + key
news.category_id = category_id
# status = 1代表审核中
news.status = 1
news.user_id = user.id
try:
db.session.add(news)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=response_code.RET.PARAMERR, errmsg='存储新闻失败')
# 5, 响应结果
return jsonify(errno=response_code.RET.OK, errmsg='新闻发布成功')
def user_news_release():
user = flask.g.user
if not user:
return flask.jsonify(errno=RET.SESSIONERR, errmsg='用户未登录')
if flask.request.method == "GET":
try:
category_model_list = Category.query.all()
except Exception as e:
flask.current_app.logger.error(e)
return flask.jsonify(errno=RET.DBERR, errmsg='数据库查询错误')
category_json_list = []
for category in category_model_list:
category_json_list.append(category.to_dict())
# 移除最新的分类
category_json_list.pop(0)
data = {'user': user.to_dict(), 'categories': category_json_list}
return flask.render_template('user/user_news_release.html', data=data)
title = flask.request.form.get("title")
source = "个人发布"
digest = flask.request.form.get("digest")
content = flask.request.form.get("content")
index_image = flask.request.files.get("index_image")
category_id = flask.request.form.get("category_id")
if not all([title, source, digest, content, index_image, category_id]):
return flask.jsonify(errno=RET.PARAMERR, errmsg='参数有误')
try:
category_id = int(category_id)
except Exception as e:
flask.current_app.logger.error(e)
return flask.jsonify(errno=RET.PARAMERR, errmsg='参数有误')
try:
index_image = index_image.read()
except Exception as e:
flask.current_app.logger.error(e)
return flask.jsonify(errno=RET.PARAMERR, errmsg='参数错误')
try:
key = storage(index_image)
except Exception as e:
flask.current_app.logger.error(e)
return flask.jsonify(errno=RET.THIRDERR, errmsg='上传图片失败')
news = News()
news.title = title
news.digest = digest
news.source = source
news.content = content
news.index_image_url = constants.QINIU_DOMIN_PREFIX + key
news.category_id = category_id
news.user_id = user.id
news.status = 1
try:
db.session.add(news)
db.session.commit()
except Exception as e:
db.session.rollback()
flask.current_app.logger.error(e)
return flask.jsonify(errno=RET.DBERR, errmsg='数据库错误')
return flask.jsonify(errno=RET.OK, errmsg='OK')
def news_release():
if request.method == "GET":
categories = []
try:
# 获取所有的分类数据
categories = Category.query.all()
except Exception as e:
current_app.logger.error(e)
# 定义列表保存分类数据
categories_dicts = []
for category in categories:
# 获取字典
cate_dict = category.to_dict()
# 拼接内容
categories_dicts.append(cate_dict)
# 移除`最新`分类
categories_dicts.pop(0)
# 返回内容
return render_template('news/user_news_release.html',
data={"categories": categories_dicts})
# POST 提交，执行发布新闻操作
# 1. 获取要提交的数据
title = request.form.get("title")
source = "个人发布"
digest = request.form.get("digest")
content = request.form.get("content")
index_image = request.files.get("index_image")
category_id = request.form.get("category_id")
print(title)
print(digest)
print(content)
print(index_image)
print(category_id)
# 1.1 判断数据是否有值
if not all([title, source, digest, content, index_image, category_id]):
return jsonify(errno=RET.PARAMERR, errmsg="参数有误")
# 1.2 尝试读取图片
try:
index_image = index_image.read()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数有误")
# # 2. 将标题图片上传到七牛
# try:
# key = storage(index_image)
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(errno=RET.THIRDERR, errmsg="上传图片错误")
# 3. 初始化新闻模型，并设置相关数据
news = News()
news.title = title
news.digest = digest
news.source = source
news.content = content
# news.index_image_url = constants.QINIU_DOMIN_PREFIX + key
news.category_id = category_id
news.user_id = g.user.id
# 1代表待审核状态
news.status = 1
# 4. 保存到数据库
try:
db.session.add(news)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg="保存数据失败")
# 5. 返回结果
return jsonify(errno=RET.OK, errmsg="发布成功，等待审核")
def news_release():
"""新闻发布的后端接口"""
# 获取用户对象
user = g.user
# GET请求：展示新闻发布页面
if request.method == 'GET':
# 查询分类数据
try:
categories = Category.query.all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询分类数据异常")
# 对象列表转字典列表
category_dict_list = []
for category in categories if categories else []:
category_dict_list.append(category.to_dict())
# 注意： 移除最新分类
category_dict_list.pop(0)
# 组织响应数据
data = {"categories": category_dict_list}
return render_template("profile/user_news_release.html", data=data)
# POST请求：发布新闻
"""
1.获取参数
1.1 title:新闻标题， category_id:新闻分类id，digest:新闻摘要，index_image:新闻主图片
content: 新闻内容，user:当前用户，source:新闻来源（默认值：个人发布）
2.校验参数
2.1 非空判断
3.逻辑处理
3.0 将新闻主图片上传到七牛云
3.1 创建新闻对象，并将其属性赋值
3.2 保存回数据库
4.返回值
"""
# 1.1获取参数
title = request.form.get("title")
category_id = request.form.get("category_id")
digest = request.form.get("digest")
content = request.form.get("content")
index_image = request.files.get("index_image")
source = "个人发布"
# 2.1 非空判断
if not all([title, category_id, digest, content, index_image]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不足")
#2.2 用户是否登录判断
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
try:
pic_data = index_image.read()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="图片数据不能为空")
# 3.0 将新闻主图片上传到七牛云
try:
pic_name = pic_storage(pic_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg="上传图片到七牛云失败")
# 3.1 创建新闻对象，并将其属性赋值（8个属性）
news = News()
news.title = title
news.category_id = category_id
news.digest = digest
news.content = content
news.index_image_url = constants.QINIU_DOMIN_PREFIX + pic_name
news.source = source
news.user_id = user.id
# 设置新闻发布后的状态为:审核中
news.status = 1
# 3.2 保存回数据库
try:
db.session.add(news)
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="发布新闻成功")
def news_release():
"""
发布新闻
get
1.显示前段信息
:return:
"""
if request.method == 'GET':
categories = []
try:
categories = Category.query.all()
except Exception as e:
current_app.logger.error(e)
category_dict_li = []
for category in categories:
category_dict_li.append(category.to_dict())
category_dict_li.pop(0)
data = {
'categories': category_dict_li
}
return render_template('news/user_news_release.html', data=data)
# 获取参数
title = request.form.get('title')
category_id = request.form.get('category_id')
digest = request.form.get('digest')
index_image = request.files.get('index_image')
content = request.form.get('content')
# 校验参数
if not all([title, category_id, digest, index_image, content]):
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
try:
category_id = int(category_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
# 上传新闻图片
try:
index_image_content = index_image.read()
key = image_storage.storage(index_image_content)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg='新闻图片上传错误')
# 初始化新闻模型
news = News()
news.title = title
news.category_id = category_id
news.source = '个人发布'
news.content = content
news.user_id = g.user.id
news.digest = digest
news.index_image_url = constants.QINIU_DOMIN_PREFIX + key
# 标记当前新闻的状态
news.status = 1 # 审核状态
# 保存到数据库
try:
db.session.add(news)
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='新闻发布成功')
def user_news_release():
"""用户发布新闻"""
user = g.user
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
categories = 1
if request.method == "GET": # get请求，则直接显示页面
try:
categories = Category.query.filter(
Category.name != "最新").all() # 获取所有的分类数据
except Exception as e:
current_app.logger.error(e)
return render_template("news/user_news_release.html",
categories=categories)
# 如果不是get请求，则需要接受表单提交的新增新闻内容
# 1. 后端接收参数[ 标题、分类id、摘要、内容、上传图片 ]
data_dict = request.form
data_dict.get("")
title = data_dict.get("title") # 新闻标题
source = "刘小猛" # 新闻来源
digest = data_dict.get("digest") # 新闻摘要
content = data_dict.get("content") # 新闻内容
index_iamge = request.files.get("index_image") # 图片
category_id = data_dict.get("category_id")
# 2.校验数据
if not all([source, title, digest, content, index_iamge, category_id]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不全")
# 获取图片的内容，通过read()
try:
index_iamge = index_iamge.read()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数有误")
# 保存数据，图片上传到7牛云
try:
key = file_storage(index_iamge) # 上传到7牛云，获取图片的地址key
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg="上传图片出错")
news = News()
news.title = title
news.source = source
news.digest = digest
news.content = content
news.index_image_url = constants.QINIU_DOMIN_PREFIX + key
news.category_id = category_id
news.user_id = user.id
print(category_id)
# 1代表带审核状态
news.status = 1
# 响应数据
try:
db.session.add(news)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(err=RET.DBERR, errmsg="保存数据失败")
# 返回结果（因为是表单提交数据，所以直接可以后端指定要跳转的页面）
return redirect(url_for("user.user_news_list"))
def news_release():
if request.method == 'GET':
categories = []
try:
categories = Category.query.all()
except Exception as e:
current_app.logger.error(e)
category_dict_li = []
for category in categories:
category_dict_li.append(category.to_dict())
category_dict_li.pop(0)
return render_template('news/user_news_release.html',
data={'categories': category_dict_li})
title = request.form.get('title')
source = '个人发布'
digest = request.form.get('digest')
content = request.form.get('content')
index_image = request.files.get('index_image')
category_id = request.form.get('category_id')
if not all([title, source, digest, content, index_image, category_id]):
return jsonify(errno=RET.PARAMERR, errmsg='参数有误')
try:
category_id = int(category_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg='参数有误')
user = g.user
time = datetime.datetime.now()
file_name = 'index_image' + str(user.id) + str(time)
try:
index_image_data = index_image.read()
storage(index_image_data, file_name)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg='参数有误')
news = News()
news.title = title
news.digest = digest
news.source = source
news.content = content
news.index_image_url = constants.QINIU_DOMIN_PREFIX + file_name
news.category_id = category_id
news.user_id = user.id
news.status = 1
try:
db.session.add(news)
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')
def news_release():
user = g.user
if request.method == "GET":
categorys = Category.query.all()
# 定义列表保存分类数据
category_list = []
for category in categorys:
# 把分类数据添加到列表中
category_list.append(category.to_dict())
#移除最新分类,删除第0个元素
category_list.pop(0)
data = {"categories": category_list}
return render_template("news/user_news_release.html", data=data)
# POST 提交，执行发布新闻操作
#获取要提交的数据
# 新闻标题
title = request.form.get("title")
source = "个人发布"
# 新闻分类id
category_id = request.form.get("category_id")
# 新闻摘要
digest = request.form.get("digest")
#索引图片
index_image = request.files.get("index_image").read()
#新闻内容
content = request.form.get("content")
# 判断数据是否有值
if not all([title, source, category_id, digest, index_image, content]):
return jsonify(errno=RET.PARAMERR, errmsg="参数有误")
#将标题图片上传到七牛
try:
key = storage(index_image)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg="上传图片失败")
#初始化新闻模型,并设置相关数据
news = News()
news.title = title
news.digest = digest
news.source = source
news.content = content
news.index_image_url = constants.QINIU_DOMIN_PREFIX + key
news.category_id = category_id
news.user_id = g.user.id
# 审核状态,0:代审核 1:审核通过 -1:审核不通过
news.status = 1
# 保存到数据库
try:
db.session.add(news)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.sessioh.rollback()
return jsonify(errno=RET.DBERR, errmsg="保存数据失败")
# 返回结果
return jsonify(errno=RET.OK, errmsg="发布成功,待审核")
def news_release():
"""新闻发布"""
# 1.获取登录用户信息
user = g.user
if not user:
return redirect(url_for('index.index'))
# 2. GET请求逻辑：渲染发布新闻的界面
if request.method == 'GET':
# 2.1 渲染新闻的分类数据
categories = []
try:
categories = Category.query.all()
except Exception as e:
current_app.logger.error(e)
# "最新"分类不是用户发布新闻时绑定的。
categories.pop(0)
context = {
'categories':categories
}
return render_template('news/user_news_release.html',context=context)
# 3. POST请求逻辑：实现新闻发布的业务逻辑
if request.method == 'POST':
# 3.1 接受参数
title = request.form.get("title")
source = "个人发布"
digest = request.form.get("digest")
content = request.form.get("content")
index_image = request.files.get("index_image")
category_id = request.form.get("category_id")
# 3.2 校验参数
if not all([title,source,digest,content,index_image,category_id]):
return jsonify(errno=response_code.RET.PARAMERR, errmsg='缺少参数')
# 3.3 读取用户上传的新闻图片
try:
index_image_data = index_image.read()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=response_code.RET.PARAMERR, errmsg='读取新闻图片失败')
# 3.4 将用户上传的新闻图片转存到七牛
try:
key = upload_file(index_image_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=response_code.RET.THIRDERR, errmsg='上传新闻图片失败')
# 3.5 创建News新闻模型对象，并赋值和同步到数据库
news = News()
news.title = title
news.digest = digest
news.source = source
news.content = content
# 纯粹是迫不得已：因为我们的是新闻类的网站，里面大部分的数据否是靠爬虫爬的，爬虫会将新闻的图片的全路径url爬下来
# 那么我们就需要存储新闻图片的全路径url http://ip:port/path
news.index_image_url = constants.QINIU_DOMIN_PREFIX + key
news.category_id = category_id
news.user_id = user.id
# 1代表待审核状态
news.status = 1
try:
db.session.add(news)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=response_code.RET.DBERR, errmsg='保存新闻数据失败')
# 3.6 响应新闻发布的结果
return jsonify(errno=response_code.RET.OK, errmsg='发布新闻成功')
def news_release():
"""
新闻发布
如果是get请求，加载新闻分类数据,需要移除'最新'分类
1、如果是post请求，获取参数，title，category_id,digest,index_image,content
2、检查参数的完整性
3、转换分类id的数据类型
4、读取图片数据
5、调用七牛云，上传图片
6、保存新闻数据，构造模型类News对象
user_id/source/status
7、返回结果
:return:
"""
user = g.user
if request.method == 'GET':
# 查询新闻分类
try:
categories = Category.query.all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询新闻分类数据失败')
# 判断查询结果
if not categories:
return jsonify(errno=RET.NODATA, errmsg='无新闻分类数据')
# 定义容器存储查询结果
category_list = []
for category in categories:
category_list.append(category.to_dict())
# 移除最新分类
category_list.pop(0)
data = {'categories': category_list}
return render_template('news/user_news_release.html', data=data)
# 获取参数
title = request.form.get('title')
digest = request.form.get('digest')
category_id = request.form.get('category_id')
index_image = request.files.get('index_image')
content = request.form.get('content')
# 检查参数的完整性
if not all([title, digest, category_id, index_image, content]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不完整')
# 转换数据类型
try:
category_id = int(category_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg='参数类型错误')
# 读取图片数据
try:
image_data = index_image.read()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg='参数格式错误')
# 调用七牛云上传图片
try:
image_name = storage(image_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg='上传图片失败')
# 构造模型类对象，准备存储新闻数据
news = News()
news.category_id = category_id
news.user_id = user.id
news.title = title
news.source = '个人发布'
news.digest = digest
# 新闻图片对于新闻来说是个整体，存储的是绝对路径。
news.index_image_url = constants.QINIU_DOMIN_PREFIX + image_name
news.status = 1
news.content = content
# 提交数据到mysql中
try:
db.session.add(news)
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')
def news_release():
"""发布新闻接口"""
# GET请求：查询新闻分类数据，展示发布新闻的模板
if request.method == "GET":
# 1.查询新闻分类数据
try:
categories = Category.query.all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询用户对象异常")
# 2.对象列表转字典列表
category_dict_list = []
for category in categories if categories else []:
category_dict_list.append(category.to_dict())
# 3.移除`最新`分类
category_dict_list.pop(0)
data = {"categories": category_dict_list}
return render_template("user/user_news_release.html", data=data)
# POST请求：发布新闻
# 1.1 title: 新闻标题，category_id: 分类id， digest：新闻摘要
# index_image:新闻主图片，content:新闻内容， user：当前登录用户 source:个人发布
title = request.form.get("title")
category_id = request.form.get("cid")
digest = request.form.get("digest")
content = request.form.get("content")
# 新闻主图片
index_image = request.files.get("index_image")
user = g.user
source = "个人发布"
# 2.1 非空判断
if not all([title, category_id, digest, index_image, content]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不足")
# 2.2 category_id强制数据类型转换
try:
category_id = int(category_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数类型错误")
try:
image_data = index_image.read()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg="读取图片数据异常")
if not image_data:
return jsonify(errno=RET.NODATA, errmsg="图片数据不能为空")
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
# 3.0 将主图片上传到七牛云平台
try:
image_name = pic_store(image_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg="上传到七牛云异常")
# 3.1 创建新闻对象，并给各个属性赋值
news = News()
# 新闻标题
news.title = title
# 新闻分类id
news.category_id = category_id
# 新闻摘要
news.digest = digest
# 新闻内容
news.content = content
# 新闻主图片完整url
news.index_image_url = constants.QINIU_DOMAIN + image_name
# 新闻来源
news.source = source
# 那个用户发布的新闻
news.user_id = user.id
# 默认发布的新闻未审核中：1
news.status = 1
# 3.2 保存回数据库
try:
db.session.add(news)
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="发布新闻成功")
def news_release():
# 新闻发布
if request.method == "GET":
categories = []
try:
categories = Category.query.all()
except Exception as e:
current_app.logger.error(e)
# 定义列表保存分类数据
categories_dict = []
for category in categories:
cate_dict = category.to_dict()
categories_dict.append(cate_dict)
# 移除`最新`分类
categories_dict.pop(0)
return render_template("news/user_news_release.html", data={"categories": categories_dict})
# 获取参数
title = request.form.get("title")
source = "个人发布"
category_id = request.form.get("category_id")
digest = request.form.get("digest")
index_image = request.files.get("index_image")
content = request.form.get("content")
if not all([title, source, category_id, digest, index_image, content]):
return jsonify(errno=RET.PARAMERR, errmsg="参数有误")
try:
avatar_file = index_image.read()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="读取文件出错")
try:
url = storage(avatar_file)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg="上传图片错误")
news = News()
news.source = source
news.title = title
news.digest = digest
news.content = content
news.index_image_url = constants.QINIU_DOMIN_PREFIX + url
news.category_id = int(category_id)
news.user_id = int(g.user.id)
# 1代表待审核状态
news.status = 1
# 保存到数据库
try:
db.session.add(news)
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="发布成功，等待审核")
def news_release():
if request.method == "GET":
# 加载新闻分类数据
categories = []
try:
categories = Category.query.all()
except Exception as e:
current_app.logger.error(e)
category_dict_li = []
for category in categories:
category_dict_li.append(category.to_dict())
# 移除最新的分类
category_dict_li.pop(0)
return render_template('news/user_news_release.html', data={"categories": category_dict_li})
# 1. 获取要提交的数据
# 标题
title = request.form.get("title")
# 新闻来源
source = "个人发布"
# 摘要
digest = request.form.get("digest")
# 新闻内容
content = request.form.get("content")
# 索引图片
index_image = request.files.get("index_image")
# 分类id
category_id = request.form.get("category_id")
# 校验参数
# 2.1 判断数据是否有值
if not all([title, source, digest, content, index_image, category_id]):
return jsonify(errno=RET.PARAMERR, errmsg="参数有误")
# 2.2
try:
category_id = int(category_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数有误")
# 3.取到图片，将图片上传到七牛云
try:
index_image_data = index_image.read()
# 上传到七牛云
key = storage(index_image_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数有误")
news = News()
news.title = title
news.digest = digest
news.source = source
news.content = content
news.index_image_url = constants.QINIU_DOMIN_PREFIX + key
news.category_id = category_id
news.user_id = g.user.id
# 1代表待审核状态
news.status = 1
try:
db.session.add(news)
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")
def news_release():
"""展示新闻发布页面，及功能实现接口"""
if request.method == "GET":
# 去数据库查询新闻的分类，返回给前端处理
try:
categories = Category.query.all()
except Exception as e:
current_app.logger.error(e)
# 转换为字典列表
category_dict_list = []
for category in categories if categories else []:
category_dict_list.append(category.to_dict())
# 因为第一个分类不是真正的分类信息，所以要删除
category_dict_list.pop(0)
# 组织数据
data = {"categories": category_dict_list}
return render_template("news/user_news_release.html", data=data)
# 1. 获取参数
params_dict = request.form
title = params_dict.get("title")
category_id = params_dict.get("category_id")
digest = params_dict.get("digest")
index_image = request.files.get("index_image")
content = params_dict.get("content")
source = "个人发布"
user = g.user
# 2. 校验参数
# 2.1 非空判断
if not all([title, category_id, digest, index_image, content]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不足")
# 2.2 用户登录判断
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
# 3. 逻辑处理
# 3.1 获取图片数据
image_data = index_image.read()
# 3.2 上传图片
try:
image_name = qiniu_image_store(image_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg="上传图片到七牛云失败")
# 3.3 创建新闻模型
news = News()
news.title = title
news.category_id = category_id
news.digest = digest
news.index_image_url = constants.QINIU_DOMIN_PREFIX + image_name
news.content = content
news.source = source
news.user_id = user.id
# 标记为审核状态
news.status = 1
# 3.4 保存到数据库
try:
db.session.add(news)
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="新闻发布成功")
