def pic_info():
if request.method == "GET":
# 1.如果是GET，直接渲染页面
return render_template("news/user_pic_info.html",
user=g.user.to_dict())
#2.1获取参数
avatar = request.files.get("avatar")
# 2.2校验参数
if not avatar:
return jsonify(errno=RET.PARAMERR, errmsg="参数不全")
# 2.3调用工具类方法，上传图片
try:
image_name = image_storage(avatar.read())
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg="七牛云上传失败")
# 2.4判断图片是否上传成功
if not image_name:
return jsonify(errno=RET.NODATA, errmsg="图片上传失败")
# 2.5修改用户图片
g.user.avatar_url = image_name
# 2.6返回响应，携带图片地址
data = {"avatar_url": constants.QINIU_DOMIN_PREFIX + image_name}
return jsonify(errno=RET.OK, errmsg="上传成功", data=data)
def pic_info():
# 1.第一次进来,是get请求,直接渲染页面
if request.method == "GET":
return render_template('news/user_pic_info.html',
data={"user_info": g.user.to_dict()})
# 2.获取参数
file_avatar = request.files.get("avatar")
# 3.校验参数
if not file_avatar:
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# 4.上传图片
try:
# 读取图片内容
image_data = file_avatar.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.设置图像到的头像中
g.user.avatar_url = image_name
# 6.返回响应
data = {"avatar_url": constants.QINIU_DOMIN_PREFIX + image_name}
return jsonify(errno=RET.OK, errmsg="上传成功", data=data)
def pic_info():
# 1.如果第一次进入,get请求,直接渲染页面
if request.method == "GET":
return render_template('news/user_pic_info.html',
user_info=g.user.to_dict())
# 2.获取参数
file = request.files.get("avatar")
# 3.校验参数
if not file:
return jsonify(errno=RET.NODATA, errmsg="图片不能为空")
# 4.上传图片
try:
# 读取图片为二进制
image_data = file.read()
# 调用方法上传
image_name = image_storage(image_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg="七牛云上传失败")
# 5.判断图片是否上传成功
if not image_name:
return jsonify(errno=RET.DATAERR, errmsg="上传失败")
# 6.设置图像给用户
g.user.avatar_url = image_name
# 7.返回响应
data = {"avatar_url": constants.QINIU_DOMIN_PREFIX + image_name}
return jsonify(errno=RET.OK, errmsg="上传成功", data=data)
def pic_info():
"""
1.获取参数
2.校验参数
3.调用工具类方法,上传图片
4.判断图片是否上传成功
5.修改用户图片
6.返回响应,携带图片地址
:return:
"""
if request.method == "GET":
return render_template("news/user_pic_info.html",
user=g.user.to_dict())
# 1.获取参数
avatar = request.files.get("avatar")
# 2.校验参数
if not avatar:
return jsonify(errno=RET.DBERR, errmsg="参数不全")
# 3.调用工具类方法,上传图片
try:
image_name = image_storage(avatar.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.修改用户图片
g.user.avatar_url = image_name
# 6.返回响应,携带图片地址
data = {"avatar_url": constants.QINIU_DOMIN_PREFIX + image_name}
return jsonify(errno=RET.OK, errmsg="上传成功", data=data)
def pic_info():
# 1.判断请求方式，如果是get请求
if request.method == 'GET':
# 2.携带用户数据，渲染页面
return render_template('news/user_pic_info.html',
user_info=g.user.to_dict())
# 3.如果是post请求
# 4.获取参数
avatar = request.files.get('avatar')
# 5.为空校验
if not avatar:
return jsonify(errno=RET.PARAMERR, errmsg='图片不能为空')
# 6.上传图像，判断图片是否上传成功
try:
image_name = image_storage(avatar.read())
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='图片上传失败')
# 7.将图片设置到用户对象
g.user.avatar_url = image_name
# 8.返回响应
data = {'avatar_url': constants.QINIU_DOMIN_PREFIX + image_name}
return jsonify(errno=RET.OK, errmsg='上传成功', data=data)
def news_release():
# 1.判断请求方式，如果是GET
if request.method == 'GET':
# 2.查询所有分类数据
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())
# 2.1 携带分类数据渲染页面
return render_template('news/user_news_release.html',
categories=categories)
# 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='参数不全')
# 5.上传图片，判断是否上传成功
try:
# 读取图片为二进制数据，上传
image_name = image_storage(index_image.read())
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='图片上传失败')
# 6.创建新闻对象，设置属性
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 # 表示审核中
# 7.保存数据
try:
db.session.add(news)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='新闻发布失败')
# 8.返回响应
return jsonify(errno=RET.OK, errmsg='发布成功')
def pic_info():
"""
思路分析:
1.第一次进来GEt请求,直接返回页面,携带用户数据
2.获取参数
3.校验参数
4.上传头像
5.判断头像是否上传成功
6.设置用户头像属性
7.返回响应携带头像
:return:
"""
# 1.第一次进来GEt请求,直接返回页面,携带用户数据
if request.method == 'GET':
data = {
"user_info":g.user.to_dict() if g.user else ""
}
return render_template('news/user_pic_info.html',data=data)
# 2.获取参数
avatar = request.files.get('avatar')
# 3.校验参数
if not avatar:
return jsonify(errno=RET.PARAMERR,errmsg="图像不能为空")
# 4.上传头像
try:
image_name = image_storage(avatar.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.设置用户头像属性
g.user.avatar_url = image_name;
# 7.返回响应携带头像
data = {
"avatar_url":constants.QINIU_DOMIN_PREFIX + image_name
}
return jsonify(errno=RET.OK,errmsg="上传成功",data=data)
def user_pic_info():
"""
思路分析:
2.如果是第一次进来,是GET请求,携带用户数据,渲染页面
3.如果是第二次进入,是POST请求,获取参数头像
4.校验头像
5.上传头像
6.判断头像是否有上传成功
7.设置头像到用户对象
8.返回响应,携带最新上传图像
"""
# 2.如果是第一次进来,是GET请求,携带用户数据,渲染页面
if request.method == "GET":
return render_template('news/user_pic_info.html',
user=g.user.to_dict())
# 3.如果是第二次进入,是POST请求,获取参数头像
avatar = request.files.get("avatar")
# 4.校验头像
if not avatar:
return jsonify(errno=RET.NODATA, errmsg="未选择图片")
# 5.上传头像
try:
#读取图片
image_data = avatar.read()
#上传图片
image_name = image_storage(image_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg="七牛云上传异常")
# 6.判断头像是否有上传成功
if not image_name:
return jsonify(errno=RET.DATAERR, errmsg="上传失败")
# 7.设置头像到用户对象
g.user.avatar_url = image_name
# 8.返回响应,携带最新上传图像
data = {"avatar_url": constants.QINIU_DOMIN_PREFIX + image_name}
return jsonify(errno=RET.OK, errmsg="上传成功", data=data)
def pic_info():
"""
1.判断请求方式
2,获取参数
3.校验参数,为空校验
4.上传图片,判断是否上传成功
5.设置图片到用户对象
6.返回响应,携带图片
:return:
"""
# 1.判断请求方式
if request.method == "GET":
return render_template("news/user_pic_info.html",user=g.user.to_dict())
# 2,获取参数
avatar = request.files.get("avatar")
# 3.校验参数,为空校验
if not avatar:
return jsonify(errno=RET.PARAMERR,errmsg="参数不全")
# 4.上传图片,判断是否上传成功
try:
image_name = image_storage(avatar.read())
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR,errmsg="七牛云上传异常")
if not image_name: return jsonify(errno=RET.DATAERR,errmsg="上传失败")
# 5.设置图片到用户对象
try:
g.user.avatar_url = image_name
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR,errmsg="修改图片失败")
# 6.返回响应,携带图片
data = {
"avatar_url":constants.QINIU_DOMIN_PREFIX + image_name
}
return jsonify(errno=RET.OK,errmsg="上传成功",data=data)
def pic_info():
"""
1.判断请求方式，如果是GET，渲染页面，携带用户数据
2.如果是POST请求，获取参数
3.校验参数，为空校验
4.上传图片
5.判断是否上传成功
6.设置图片到用户对象
7.返回响应，携带图片
:return:
"""
# 1.判断请求方式，如果是GET,渲染界面，携带用户数据
if request.method == "GET":
return render_template("news/user_pic_info.html",
user=g.user.to_dict())
# 2.如果是POST请求，获取参数
avatar = request.files.get("avatar")
# 3.校验参数，为空校验
if not avatar:
return jsonify(errno=RET.PARAMERR, errmsg="参数不全")
# 4.上传图片
try:
image_name = image_storage(avatar.read())
except Exception as e:
# current_app.logger(e)
return jsonify(errno=RET.THIRDERR, errmsg="七牛云异常")
# 5.判断是否上传成功
if not image_name:
return jsonify(errno=RET.NODATA, errmsg="上传失败")
# 6.设置图片到用户对象
g.user.avatar_url = image_name
# 7.返回响应，携带图片
data = {"avatar": constants.QINIU_DOMIN_PREFIX + image_name}
return jsonify(errno=RET.OK, errmsg="上传成功", data=data)
def pic_info():
"""
- 1.判断请求方式,如果是GET,渲染页面,携带用户数据
- 2.如果是POST请求,获取参数
- 3.校验参数,为空校验
- 4.上传图片
- 5.判断是否上传成功
- 6.设置图片到用户对象
- 7.返回响应,携带图片
:return:
"""
# - 1.判断请求方式,如果是GET,渲染页面,携带用户数据
if request.method == "GET":
return render_template("news/user_pic_info.html",
user=g.user.to_dict())
# - 2.如果是POST请求,获取参数
avatar = request.files.get("avatar")
# - 3.校验参数,为空校验
if not avatar:
return jsonify(errno=RET.PARAMERR, errmsg="参数不全")
# - 4.上传图片
try:
image_name = image_storage(avatar.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.设置图片到用户对象
g.user.avatar_url = image_name
# - 7.返回响应,携带图片
data = {"avatar_url": constants.QINIU_DOMIN_PREFIX + image_name}
return jsonify(errno=RET.OK, errmsg="上传成功", data=data)
def news_edit_detail():
"""
- 1.判断请求方式,如何是GET
- 1.1 获取参数
- 1.2 校验参数
- 1.3 取出新闻对象,判断新闻对象是否存在
- 1.4 携带新闻数据,渲染页面
- 2.获取参数
- 3.校验参数,为空校验
- 4.根据新闻编号,获取新闻对象
- 5.上传图片
- 6.判断图片是否上传成功
- 7.设置编辑信息,到新闻对象
- 8.返回响应
:return:
"""
# - 1.判断请求方式,如何是GET
if request.method == "GET":
# - 1.1 获取参数
news_id = request.args.get("news_id")
# - 1.2 校验参数
if not news_id: return jsonify(errno=RET.PARAMERR, errmsg="参数不全")
# - 1.3 取出新闻对象,判断新闻对象是否存在
try:
news = News.query.get(news_id)
categories = Category.query.all()
categories.pop(0) #弹出最新
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取新闻或分类失败")
if not news: return jsonify(errno=RET.NODATA, errmsg="新闻不存在")
#分类列表,转成字典列表
category_list = []
for category in categories:
category_list.append(category.to_dict())
# - 1.4 携带新闻数据,渲染页面
return render_template("admin/news_edit_detail.html",
news=news.to_dict(),
categories=category_list)
# - 2.获取参数
# 如果不知道请求的方式，可以通过Debug模式下的Watches工具栏，输入request查看
news_id = request.form.get("news_id")
title = request.form.get("title")
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.校验参数,为空校验
if not all([news_id, title, digest, content, index_image, category_id]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不全")
# 4.根据新闻编号,获取新闻对象
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取新闻失败")
if not news: return jsonify(errno=RET.NODATA, errmsg="新闻不存在")
# - 5.上传图片
try:
image_name = image_storage(index_image.read())
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg="七牛云异常")
#6.判断图片是否上传成功
if not image_name: return jsonify(errno=RET.NODATA, errmsg="图片上传失败")
#7.设置编辑信息,到新闻对象
news.title = title
news.digest = digest
news.content = content
news.index_image_url = constants.QINIU_DOMIN_PREFIX + image_name
news.category_id = category_id
#8.返回响应
return jsonify(errno=RET.OK, errmsg="编辑成功")
def news_edit_detail():
"""
1.判断请求方式,如果GET,渲染页面
校验参数
根据新闻编号获取新闻对象,并判断是否存在
查询所有分类信息
携带新闻数据,渲染页面
2.如果是POST请求,获取参数
3.校验参数,为空校验
4.判断新闻是否存在
5.上传图片
6.判断图片是否上传成功
7.设置属性到新闻对象
8.返回响应
:return:
"""
# 1.判断请求方式,如果GET,渲染页面
if request.method == "GET":
# 获取参数,新闻编号
news_id = request.args.get("news_id")
# 校验参数
if not news_id:
return jsonify(errno=RET.DBERR, errmsg="参数不全")
# 根据新闻编号获取新闻对象,并判断是否存在
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()
categories.pop(0)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取分类失败")
# 携带新闻数据,渲染页面
return render_template("admin/news_edit_detail.html", news=news.to_dict(), categories=categories)
# 2.如果是POST请求,获取参数
news_id = request.form.get("news_id")
title = request.form.get("title")
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.校验参数,为空校验
if not all([news_id, title, digest, content, index_image, category_id]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不全")
# 4.根据编号查询新闻对象,判断新闻是否存在
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取新闻失败")
if not news:
return jsonify(errno=RET.NODATA, errmsg="新闻不存在")
# 5.上传图片
try:
image_name = image_storage(index_image.read())
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="七牛云异常")
# 6.判断图片是否上传成功
if not image_name:
return jsonify(errno=RET.DBERR, errmsg="图片上传失败")
# 7.设置属性到新闻对象
news.title = title
news.digest = digest
news.content = content
news.index_image_url = constants.QINIU_DOMIN_PREFIX + image_name
# 8.返回响应
return jsonify(errno=RET.OK, errmsg="编辑成功")
def news_release():
"""
1.判断请求方式是否是GET
2.如果是GET，携带参数渲染页面
3.获取post请求参数
4.校验参数
5.上传图片
6.判断图片是否上传成功
7.创建新闻对象，设置新闻属性
8.保存新闻到数据库中
9.返回响应
: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="参数不全")
# 5.上传图片
try:
image_name = image_storage(index_image.read())
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg="七牛云上传失败")
# 6.判断图片是否上传成功
if not image_name:
return jsonify(errno=RET.NODATA, errmsg="图片上传失败")
# 7.创建新闻对象，设置新闻属性
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 #审核中
# 8.保存新闻到数据库中
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="新闻发布失败")
# 9.返回响应
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_edit_detail():
"""
思路分析:
1.第一次进来是GEt请求
2.获取参数
3.校验参数
4.查询新闻新闻对象,判断新闻是否存在
5.查询所有分类信息,转成字典数据
6.携带,新闻数据,分类数据,渲染页面
如果第二次提交进来,POST请求
1.获取参数
2.校验参数
3.查询新闻新闻对象,判断新闻是否存在
4.上传图片
5.重写设置属性到新闻对象
6.返回响应
:return:
"""
# 1.第一次进来是GEt请求
if request.method == "GET":
# 2.获取参数
news_id = request.args.get('news_id')
# 3.校验参数
if not news_id: return jsonify(errno=RET.PARAMERR,errmsg="参数不全")
# 4.查询新闻新闻对象,判断新闻是否存在
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR,errmsg="新闻查询失败")
if not news: return jsonify(errno=RET.NODATA,errmsg="新闻不存在")
# 5.查询所有分类信息,转成字典数据
try:
categories = Category.query.all()
categories.pop(0)#弹出最新信息
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())
# 6.携带,新闻数据,分类数据,渲染页面
return render_template('admin/news_edit_detail.html',news=news.to_dict(),category_list=category_list)
# 如果第二次提交进来,POST请求
# 1.获取参数,POST(news_id,title,digest,content,index_image,category_id)
news_id = request.form.get('news_id')
title = request.form.get('title')
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([news_id,title,digest,content,index_image,category_id]):
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.上传图片
try:
image_name = image_storage(index_image.read())
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg="七牛云上传异常")
#4.1判断图片是否上传成功
if not image_name: return jsonify(errno=RET.NODATA, errmsg="上传图片失败")
# 5.重写设置属性到新闻对象
news.title = title
news.digest = digest
news.content = content
news.index_image_url = constants.QINIU_DOMIN_PREFIX + image_name
news.category_id = category_id
# 6.返回响应
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_edit_detail():
# 1.判断请求方式，如果是GET
if request.method == 'GET':
# 2.获取新闻编号
news_id = request.args.get('news_id')
# 3.通过新闻编号查询新闻对象，并判断新闻对象是否存在
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return render_template('admin/news_review_detail.html',
errmsg='获取新闻失败')
if not news:
return render_template('admin/news_review_detail.html',
errmsg='新闻不存在')
# 3.1 获取分类数据
try:
categories = Category.query.all()
except Exception as e:
current_app.logger.error(e)
return render_template('admin/news_review_detail.html',
errmsg='分类获取失败')
# 3.2将分类对象列表，转成字典数据
category_list = []
for category in categories:
category_list.append(category.to_dict())
# 4.携带新闻数据和分类数据，渲染页面
return render_template('admin/news_edit_detail.html',
news=news.to_dict(),
category_list=category_list)
# 5.如果是POST请求，获取参数
news_id = request.form.get('news_id')
title = request.form.get('title')
digest = request.form.get('digest')
content = request.form.get('content')
index_image = request.files.get('index_image')
category_id = request.form.get('category_id')
# 6.为空校验
if not all([news_id, title, digest, content, index_image, category_id]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不全')
# 7.根据新闻编号读取新闻对象
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='新闻不存在')
# 8.上传图片
try:
image_name = image_storage(index_image.read())
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='图片上传失败')
# 9.设置新闻对象属性
news.title = title
news.digest = digest
news.content = content
news.index_image_url = constants.QINIU_DOMIN_PREFIX + image_name
news.category_id = category_id
# 10.返回响应
return jsonify(errno=RET.OK, errmsg='编辑成功')
def news_edit_detail():
"""
1.第一次进入是GEt请求,携带新闻数据渲染页面
2.第二次进入是POST请求,获取参数
3.校验参数,为空校验,操作类型校验
4.通过新闻编号获取新闻对象
5.判断新闻对象是否存在
6.根据操作类型,修改新闻状态
7.返回响应
:return:
"""
# 1.第一次进入是GEt请求,携带新闻数据渲染页面
if request.method == "GET":
# 1.1获取新闻编号
news_id = request.args.get("news_id")
# 1.2获取新闻对象
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取新闻失败")
# 1.3判断新闻是否存在
if not news:
return jsonify(errno=RET.NODATA, errmsg="新闻不存在")
#1.4 查询分类信息
try:
categories = Category.query.all()
categories.pop(0) #弹出最新
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())
# 1.5携带新闻数据渲染页面
return render_template('admin/news_edit_detail.html',
news=news.to_dict(),
categories=category_list)
# 2.第二次进入是POST请求,获取参数
news_id = request.form.get("news_id")
title = request.form.get("title")
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.校验参数,为空校验,操作类型校验
if not all([news_id, title, digest, content, index_image, category_id]):
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.上传图片
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.修改新闻对象数据
try:
news.title = title
news.digest = digest
news.content = content
news.index_image_url = constants.QINIU_DOMIN_PREFIX + image_name
news.category_id = category_id
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="操作失败")
# 返回响应
return jsonify(errno=RET.OK, errmsg="操作成功")
def news_release():
"""
思路分析
1.如果第一次进入,get请求,直接渲染页面
2.获取参数
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.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)
# 2.获取参数
title = request.form.get("title")
category_id = request.form.get("category_id")
digest = request.form.get("digest")
file_name = request.files.get("index_image")
content = request.form.get("content")
# 3.校验参数
if not all([title, category_id, digest, file_name, content]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不全")
# 4.图片上传
try:
# 读取图片为二进制流
image_data = file_name.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
news.status = 1 # 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_edit_detail():
"""
- 1.判断请求方式
- 2.如果是get,根据新闻编号获取新闻对象,判断是否存在
- 3.携带新闻数据,渲染页面
- 4.获取参数
- 5.校验操作,为空校验,操作类型校验
- 6.根据新闻编号查询新闻对象,判断是否存在
- 7.根据操作类型,改变新闻的状态
- 8.返回响应
:return:
"""
# - 1.判断请求方式
if request.method == "GET":
# - 2.如果是get,根据新闻编号获取新闻对象,判断是否存在
news_id = request.args.get("news_id")
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return render_template("admin/news_review_detail.html",
errmsg="获取新闻失败")
if not news:
return render_template("admin/news_review_detail.html",
errmsg="新闻不存在")
#2.1查询所有分类
try:
categories = Category.query.all()
except Exception as e:
current_app.logger.error(e)
return render_template("admin/news_review_detail.html",
errmsg="获取分类失败")
# - 3.携带新闻数据,渲染页面
return render_template("admin/news_edit_detail.html",
news=news.to_dict(),
categories=categories)
# - 4.获取参数,news_id,title,digest,content,index_image,category_id
news_id = request.form.get("news_id")
title = request.form.get("title")
digest = request.form.get("digest")
content = request.form.get("content")
index_image = request.files.get("index_image")
category_id = request.form.get("category_id")
# - 5.校验操作,为空校验,操作类型校验
if not all([news_id, title, digest, content, index_image, category_id]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不全")
# - 6.根据新闻编号查询新闻对象,判断是否存在
try:
news = News.query.get(news_id)
except Exception as e:
current_app.logger.error(e)
return render_template("admin/news_review_detail.html",
errmsg="获取新闻失败")
if not news:
return render_template("admin/news_review_detail.html", errmsg="新闻不存在")
# - 7.上传图片,判断图片是否上传成功
try:
image_name = image_storage(index_image.read())
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="图片上传失败")
#8.修改新闻对象属性
try:
news.title = title
news.digest = digest
news.content = content
news.index_image_url = constants.QINIU_DOMIN_PREFIX + image_name
news.category_id = category_id
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="编辑失败")
#9.返回响应
return jsonify(errno=RET.OK, errmsg="编辑成功")
def news_release():
"""
- 0.判断是否是GET请求,携带分类数据展示
- 1.如果是POST,获取参数
- 2.校验参数,为空校验
- 3.上传新闻图片
- 4.判断图片是否上传成功
- 5.创建新闻对象,设置新闻属性
- 6.保存到数据库
- 7.返回响应
:return:
"""
# - 0.判断是否是GET请求,携带分类数据展示
if request.method == "GET":
try:
categories = Category.query.all()
categories.pop(0) # 弹出最新
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, index_image, 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 news_release():
"""
1.判断是否是GET请求
2.获取参数
3.校验参数
4.上传图像
5.创建新闻对象,设置属性
6.保存新闻到数据库
7.返回响应
:return:
"""
# 1.判断是否是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)
# 2.获取参数
title = request.form.get("title")
category_id = request.form.get("category_id")
index_image = request.files.get("index_image")
digest = request.form.get("digest")
content = request.form.get("content")
# 3.校验参数
if not all([title,category_id,index_image,digest,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="七牛云异常")
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.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 #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="发布成功")
