def add_category():
# 1.获取参数
c_id = request.json.get("id")
c_name = request.json.get("name")
# 2.校验参数,为空校验
if not c_name:
return jsonify(errno=RET.PARAMERR, errmsg="参数不全")
# 3.根据编号判断是否增加
if c_id: # 编辑
# 通过编号查询分类对象
try:
category = Category.query.get(c_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="分类获取失败")
# 判断分类对象是否存在
if not category:
return jsonify(errno=RET.DATAERR, errmsg="分类不存在")
# 设置新的分类名字
category.name = c_name
else:
category = Category()
category.name = c_name
try:
db.session.add(category)
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_type():
if request.method == 'GET':
try:
category = Category.query.all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='数据库错误')
category_li = []
for cate in category:
category_li.append(cate.to_dict())
data = {'category_li': category_li}
return render_template('admin/news_type.html', data=data)
if request.method == 'POST':
"""
post category_id name
"""
category_id = request.json.get('id', None)
name = request.json.get('name')
if not name:
return jsonify(errno=RET.PARAMERR, errmsg='参数不全')
if category_id:
cate = Category.query.get(category_id)
cate.name = name
db.session.commit()
return jsonify(errno=RET.OK, errmsg='成功')
else:
cate = Category()
cate.name = name
db.session.add(cate)
db.session.commit()
return jsonify(errno=RET.OK, errmsg='OK')
def add_category():
"""修改或者添加分类"""
category_id = request.json.get("id")
category_name = request.json.get("name")
if not category_name:
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 判断是否有分类id
if category_id:
try:
category = Category.query.get(category_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询数据失败")
if not category:
return jsonify(errno=RET.NODATA, errmsg="未查询到分类信息")
category.name = category_name
else:
# 如果没有分类id，则是添加分类
category = Category()
category.name = category_name
db.session.add(category)
try:
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 add_category():
category_id = request.json.get("id")
category_name = request.json.get("name")
# 不允许添加或者修改的结果空值:
if not category_name:
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
if category_id:
try:
category = Category.query.get(category_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库查询错误")
category.name = category_name
else:
category = Category()
category.name = category_name
db.session.add(category)
try:
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 add_category():
'''修改或者添加分类'''
category_id = request.json.get('id')
category_name = request.json.get('name')
if not category_name:
return jsonify(errno=RET.PARAMERR, errmsg='缺少参数')
if category_id:
try:
category = Category.query.get(category_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询数据失败')
if not category:
return jsonify(errno=RET.NODATA, errmsg='未查询到分类数据')
category.name = category_name
else:
# 如果没有分类id,则是添加分类
category = Category()
category.name = category_name
db.session.add(category)
try:
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_type():
if request.method =="GET":
category = Category.query.all()
data = {
"category":category
}
return render_template("admin/news_type.html", data=data)
print("kkkkkkkkkkkk")
cid = request.json.get("id")
name = request.json.get("name")
if not name:
return jsonify(errno=RET.NODATA, errmsg ="数据不全")
if cid:
category_id = Category.query.get(cid)
category_id.name = name
try:
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno = RET.DBERR, errmsg = "数据库链接失败")
else:
add_category = Category()
add_category.name = name
db.session.add(add_category)
try:
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno = RET.DBERR, errmsg = "数据库链接失败")
return jsonify(errno=RET.OK, errmsg='')
def category_operate():
"""新闻分类的操作"""
category_id = request.json.get('id')
print(category_id)
category_name = request.json.get('name')
# 修改当前id对应的name
if category_id:
try:
category = Category.query.get(category_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库查询错误")
if not category:
return jsonify(errno=RET.NODATA, errmsg="没有这个分类")
category.name = category_name
return jsonify(errno=RET.OK, errmsg="修改成功")
# 新增分类
else:
if not category_name:
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
categories = Category.query.all()
for category in categories:
if category_name == category.name:
return jsonify(errno=RET.PARAMERR, errmsg="分类重复")
# 新建分类对象
category = Category()
category.name = category_name
try:
db.session.add(category)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=RET.OK, errmsg="新增成功")
def add_category():
category_id = request.json.get("id")
category_name = request.json.get("name")
# 根据有没有id 判断是新增分类还是修改分类， 数据库category_id 是自增长， 不需要前端传
if category_id:
try:
category = Category.query.get(category_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据查询失败")
if not category:
return jsonify(errno=RET.NODATA, errmsg="未查询到分类信息")
category.name = category_name
else:
category = Category()
category.name = category_name
try:
db.session.add(category)
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_type():
if request.method == "GET":
"""新闻分类管理"""
# 新闻分类的数据展示
# 获取所有的分类数据
categories = Category.query.all()
# 定义列表保存分类数据
categories_dicts = []
for category in categories:
# 获取字典
cate_dict = category.to_dict()
# 拼接内容
categories_dicts.append(cate_dict)
#categories_dicts.pop(0) #yuanshis
data = {"categories": categories_dicts}
# 返回内容
return render_template('admin/news_type.html', data=data)
# POST 修改或者添加分类
# 1.取参数
category_name = request.json.get("name")
cdd = request.json
print(cdd)
category_title = request.json.get("title")
category_dec = request.json.get("dec")
print(category_name, category_title, category_dec)
# 如果传入了category_id，代表是编辑已存在的分类
category_id = request.json.get("id")
if not category_name: #（原始）
return jsonify(errno=RET.PARAMERR, errmsg="参数错误") #（原始）
# 判断是否有分类id
if category_id:
try:
category = Category.query.get(category_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询数据失败")
if not category:
return jsonify(errno=RET.NODATA, errmsg="未查询到分类信息")
category.name = category_name
else:
# 如果没有分类id，则是添加分类
category = Category()
category.name = category_name
category.title = category_title
category.dec = category_dec
db.session.add(category)
try:
print('test')
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 add_category():
category_id = request.json.get("id")
category_name = request.json.get("name")
if not category_name:
return jsonify(errno = RET.NODATA,errmsg = "参数为空")
if category_id:
category = Category.query.get(category_id)
try:
category.name = category_name
except Exception as e:
current_app.logger.error(e)
return jsonify(errno = RET.DATAERR,errmsg ="操作异常")
else:
cate = Category()
cate.name = category_name
try:
db.session.add(cate)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno = RET.DATAERR,errmsg = "数据库操作失败")
return jsonify(errno= RET.OK ,errmsg = "返回成功")
def news_type():
"""
新闻分类的列表
:return:
"""
try:
if request.method == 'GET':
categories_obj = Category.query.all()
categories = [category.to_dict() for category in categories_obj]
return render_template('news_type.html', categories=categories)
else:
cate_info = request.json
cate_name = request.json.get('name')
if cate_info.get('id'):
cate_id = request.json.get('id')
category = Category.query.filter(
Category.id == cate_id).first()
category.name = cate_name
db.session.commit()
return jsonify(errno=RET.OK, errmsg='修改成功')
else:
new_category = Category()
new_category.name = cate_name
db.session.add(new_category)
db.session.commit()
return jsonify(errno=RET.OK, errmsg='添加成功')
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=error_map[RET.DBERR])
def add_category():
category_name = request.json.get('name')
category_id = request.json.get('id')
if category_id:
if not Category.query.filter(
Category.id.contains(category_id)).first():
return jsonify(errno=RET.PARAMERR, errmsg='id输入有误')
if not category_name:
return jsonify(errno=RET.PARAMERR, errmsg='请输入新类目')
if Category.query.filter(
Category.name.contains(category_name)).first():
return jsonify(errno=RET.PARAMERR, errmsg='新条目已经存在')
category = Category.query.filter(Category.id == category_id).first()
category.name = category_name
else:
category = Category()
category.name = category_name
db.session.add(category)
db.session.commit()
return jsonify(errno=RET.OK, errmsg='添加成功')
pass
def add_category():
# 分类编号，如果为空表示添加，如果非空表示修改
cid = request.json.get('id')
name = request.json.get('name')
if not all([name]):
return jsonify(errno=RET.NODATA, errmsg='请填写分类名称')
if Category.query.filter_by(name=name).count() > 0:
return jsonify(errno=RET.DATAEXIST, errmsg='此名称已经存在')
if cid:
# 修改
try:
category = Category.query.get(cid)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='数据库连接失败')
if category is None:
return jsonify(errno=RET.DATAERR, errmsg='分类编号无效')
category.name = name
else:
# 添加
category = Category()
category.name = name
db.session.add(category)
try:
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='保存失败')
return jsonify(errno=RET.OK, errmsg='')
def admin_news_type():
if request.method == "GET":
try:
cates = Category.query.filter(Category.id != 1).all()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询新闻分类错误")
categary_list = []
if cates:
for cate in cates:
categary_list.append(cate.to_dict())
data = {
"categary_list" : categary_list
}
return render_template("admin/news_type.html", data=data)
if request.method == "POST":
if not request.json:
return jsonify(errno=RET.PARAMERR, errmsg="不是json类型参数")
name = request.json.get("name", None)
id = request.json.get("id", None)
if not name:
return jsonify(errno=RET.PARAMERR, errmsg="没有分类名参数")
if id:
try:
id = int(id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="id参数类型不对")
try:
cate = Category.query.get(id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="没有查到分类id")
else:
cate = Category()
cate.name = name
try:
db.session.add(cate)
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_type():
"""管理新闻分类的视图"""
if request.method == "GET":
# 查询分类数据
categories = []
try:
categories = Category.query.all()
categories.pop(0)
except Exception as e:
current_app.logger.error(e)
abort(404)
category_dict_list = []
for category in categories:
category_dict_list.append(category.to_dict())
data = {"categories": category_dict_list}
return render_template("admin/news_type.html", data=data)
# 新增或编辑分类
# 1.取参数
category_name = request.json.get("category_name")
category_id = request.json.get("category_id")
# 2.校验参数
if not category_name:
return jsonify(errno=RET.PARAMERR, errmsg="参数有误")
if category_id:
# 修改新闻类型
try:
category_id = int(category_id)
except Exception as e:
current_app.logger.error()
return jsonify(errno=RET.PARAMERR, errmsg="参数有误")
try:
category = Category.query.get(category_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库查询错误")
if not category:
current_app.logger.error()
return jsonify(errno=RET.NODATA, errmsg="没有查询到相关数据")
category.name = category_name
try:
db.session.add(category)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库插入失败")
return jsonify(errno=RET.OK, errmsg="编辑分类成功")
else:
# 新增新闻分类
category = Category()
category.name = category_name
try:
db.session.add(category)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库插入失败")
return jsonify(errno=RET.OK, errmsg="添加分类成功")
def news_type():
"""新闻分页管理"""
# 渲染新闻分类界面
if request.method == 'GET':
# 查询新闻分类数据
categories = []
try:
categories = Category.query.all()
categories.pop(0)
except Exception as e:
current_app.logger.error(e)
abort(404)
context = {'categories': categories}
return render_template('admin/news_type.html', context=context)
# 修改和增加新闻分类
if request.method == 'POST':
# 1.接收参数
cname = request.json.get('name')
cid = request.json.get('id')
# 校验参数
if not cname:
return jsonify(errno=response_code.RET.PARAMERR, errmsg="缺少参数")
# 根据是否有cid判断是增加分类还是修改分类
if cid:
# 修改分类
try:
category = Category.query.get(cid)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=response_code.RET.DBERR,
errmsg="查询分类数据失败")
if not category:
return jsonify(errno=response_code.RET.NODATA, errmsg="分类不存在")
# 修改分类名字
category.name = cname
else:
# 增加分类
category = Category()
category.name = cname
db.session.add(category)
# 同步数据库
try:
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="OK")
def news_type():
# 查询分类
if request.method == "GET":
categories = None
try:
categories = Category.query.all()
except Exception as e:
current_app.logger.debug(e)
if not categories:
return jsonify(errno=RET.DATAERR, errmsg="参数查询错误")
data = {'category': categories}
return render_template('admin/news_type.html', data=data)
else:
c_id = request.json.get('id')
c_name = request.json.get('name', 0)
# if not c_name:
# return jsonify(errno=RET.DATAERR, errmsg="参数错误")
if c_id:
try:
c_id = int(c_id)
except Exception as e:
current_app.logger.debug(e)
return jsonify(errno=RET.DATAERR, errmsg="参数错误")
category = None
try:
# category = Category.query.get(c_id)
category = Category.query.filter(Category.id == c_id).first()
except Exception as e:
current_app.logger.debug(e)
return jsonify(errno=RET.DATAERR, errmsg="参数错误或者分类不存在")
if not category:
return jsonify(errno=RET.DATAERR, errmsg="查询错误")
try:
category.name = c_name
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.debug(e)
return jsonify(errno=RET.DATAERR, errmsg="内部错误")
return jsonify(errno=RET.OK, errmsg="修改成功")
if not c_name:
return jsonify(errno=RET.DATAERR, errmsg="分类名称不能为空")
try:
category = Category()
category.name = c_name
db.session.add(category)
except Exception as e:
current_app.logger.debug(e)
return jsonify(errno=RET.DATAERR, errmsg="内部错误")
return jsonify(errno=RET.OK, errmsg="保存成功")
def news_type():
if not g.user.is_admin:
return redirect('/')
if request.method == 'GET':
# 查询分类的数据
categories = []
try:
categories = Category.query.all()
except Exception as e:
current_app.logger.error(e)
categories_li = []
for category in categories:
# if category.id == 1:
# continue
categories_li.append(category.to_dict())
# 返回数据
data = {"categories": categories_li}
return render_template('admin/news_type.html', data=data)
# 获取post提交的参数
"""修改或者添加分类"""
cid = request.json.get("id")
cname = request.json.get("name")
if not cname:
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 判断是否有分类id
if cid:
try:
cid = int(cid)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
try:
category = Category.query.get(cid)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询数据失败")
if not category:
return jsonify(errno=RET.NODATA, errmsg="未查询到分类信息")
category.name = cname
else:
# 如果没有分类id，则是添加分类
category = Category()
category.name = cname
db.session.add(category)
return jsonify(errno=RET.OK, errmsg='OK')
def category_edit():
"""新增分类&编辑分类"""
"""
1.获取参数
1.1 cid:分类id， category_name:分类名称
2.校验参数
2.1 非空判断
3.逻辑处理
3.0 根据cid判断是否有值
cid有值：编辑分类，根据分类id查询对应分类对应，然后修改分类名称
cid没有值：创建分类对象，并赋值
3.1 将上述修改提交到数据库
4.返回值
"""
# 1.1 cid:分类id， category_name:分类名称
cid = request.json.get("cid")
category_name = request.json.get("category_name")
# 2.1 非空判断
if not category_name:
return jsonify(errno=RET.PARAMERR, errmsg="参数不足")
# 3.0 根据cid判断是否有值
if cid:
# cid有值：编辑分类，
# 根据分类id查询对应分类对象，然后修改分类名称
try:
category = Category.query.get(cid)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询分类对象异常")
# 修改分类名称
if category:
category.name = category_name
else:
# cid没有值：创建分类对象，并赋值
category_obj = Category()
category_obj.name = category_name
# 添加到数据库
db.session.add(category_obj)
# 3.1 将上述修改提交到数据库
try:
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_type():
'''新闻分类管理'''
# 渲染新闻分类界面
if request.method == "GET":
categories = []
try:
# 获取所有的分类数据
categories = Category.query.all()
categories.pop(0)
except Exception as e:
current_app.logger.error(e)
abort(404)
context = {'categories': categories}
# 返回内容
return render_template('admin/news_type.html', context=context)
# 修改和增加新闻分类
if request.method == 'POST':
# 接受参数
category_id = request.json.get("id")
category_name = request.json.get("name")
# 校验参数
if not category_name:
return jsonify(errno=response_code.RET.PARAMERR, errmsg="参数错误")
# 判断是否有分类id
if category_id:
try:
category = Category.query.get(category_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=response_code.RET.DBERR, errmsg="查询数据失败")
if not category:
return jsonify(errno=response_code.RET.NODATA,
errmsg="未查询到分类信息")
# 修改分类名字
category.name = category_name
else:
# 如果没有分类id，则是添加分类
category = Category()
category.name = category_name
db.session.add(category)
try:
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=response_code.RET.DBERR, errmsg="保存数据失败")
return jsonify(errno=response_code.RET.OK, errmsg="保存数据成功")
def news_type():
"""
新闻分类管理
:return:
"""
if request.method == "GET":
try:
categories = Category.query.all()
except Exception as e:
current_app.logger.error(e)
return render_template('admin/news_type.html', errmsg="查询数据错误")
category_dict_li = []
for category in categories:
# 取到分类的字典
cate_dict = category.to_dict()
category_dict_li.append(cate_dict)
# 移除最新的分类
category_dict_li.pop(0)
data = {"categories": category_dict_li}
return render_template('admin/news_type.html', data=data)
# 新增或者添加分类
# 1. 取参数
cname = request.json.get("name")
# 如果传了cid，代表是编辑已存在的分类
cid = request.json.get("id")
if not cname:
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
if cid:
# 有 分类 id 代表查询相关数据
try:
cid = int(cid)
category = Category.query.get(cid)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
if not category:
return jsonify(errno=RET.NODATA, errmsg="未查询到分类数据")
category.name = cname
else:
category = Category()
category.name = cname
db.session.add(category)
return jsonify(errno=RET.OK, errmsg="OK")
def add_category():
category_id = request.json.get("id")
name = request.json.get("name")
if category_id:
category = Category.query.get(category_id)
category.name = name
else:
category = Category()
category.name = name
db.session.add(category)
db.session.commit()
return jsonify(errno=RET.OK, errmsg="ok")
def get_news_category():
"""新闻分类管理页面"""
if request.method == "GET":
# 1.查询所有的分类数据并转成字典保存
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)
if not categories:
return render_template("admin/news_type.html", errmsg="未查询到此新闻数据")
categories_dict_li = []
for category in categories:
category = category.to_dict()
categories_dict_li.append(category)
data = {"categories": categories_dict_li}
# 3.响应渲染模板
return render_template("admin/news_type.html", data=data)
else:
# POST请求修改分类数据:格式json
# 1.取参：分类id/分类name
cid = request.json.get("id")
c_name = request.json.get("name")
# 2.校参：非空
if not c_name:
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 3.如果有cid就查询并修改
if cid:
try:
category = Category.query.get(cid)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询数据失败")
if not category:
return jsonify(errno=RET.NODATA, errmsg="未查询到分类信息")
# 赋值修改
category.name = c_name
else:
# 没有cid则是新增分类
category = Category()
category.name = c_name
# 新增模型需要add
db.session.add(category)
# 4.以上将会自动提交，进行响应
return jsonify(errno=RET.OK, errmsg="保存数据成功")
def news_type():
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())
category_list.pop(0)
data = {"category_list": category_list}
return render_template('admin/news_type.html', data=data)
category_id = request.json.get('id')
name = request.json.get('name')
print(category_id, name)
if not name:
return jsonify(errno=RET.NODATA, errmsg="请求数据为空")
if category_id:
try:
category = Category.query.get(category_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库查询失败")
category.name = name
try:
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="数据库查询失败")
else:
category = Category()
category.name = name
try:
db.session.add(category)
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 news_type():
if request.method == "GET":
# 查询新闻分类
try:
categories = Category.query.all()
except Exception as e:
current_app.logger.error(e)
return render_template("admin/news_type.html", errmsg="数据查询错误")
category_dict_list = []
for category in categories:
# 取到分类的字典
cate_dict = category.to_dict()
category_dict_list.append(cate_dict)
# 移除最新的分类
category_dict_list.pop(0)
data = {
"categories": category_dict_list
}
return render_template("admin/news_type.html", data=data)
# 添加分类
# 取参数
cname = request.json.get("name")
# 如果传了cid，代表是编辑已存在的分类
cid = request.json.get("id")
if not cname:
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
if cid:
# 有分类id代表查询相关的数据
try:
cid = int(cid)
category = Category.query.get(cid)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
if not category:
return jsonify(errno=RET.PARAMERR, errmsg="未查到分类数据")
category.name = cname
else:
category = Category()
category.name = cname
db.session.add(category)
return jsonify(errno=RET.OK, errmsg="ok")
def news_type():
"""
新闻分类
1、如果get请求，查询分类数据，遍历查询结果，移除'最新'的分类
2、返回模板admin/news_type.html,categories
3、如果post请求，获取参数，name,id(表示编辑已存在的分类)
4、校验name参数存在
5、如果id存在(即修改已有的分类)，转成int，根据分类id查询数据库，校验查询结果，category.name = name
6、实例化分类对象，保存分类名称，提交数据到数据库
7、返回结果
:return:
"""
if request.method == 'GET':
try:
categories = Category.query.all()
except Exception as e:
current_app.logger.error(e)
return render_template('admin/news_type.html',errmsg='查询数据错误')
categories_dict_list = []
for category in categories:
categories_dict_list.append(category.to_dict())
categories_dict_list.pop(0)
data = {
'categories':categories_dict_list
}
return render_template('admin/news_type.html',data=data)
cname = request.json.get('name')
cid = request.json.get('id')
if not cname:
return jsonify(errno=RET.PARAMERR,errmsg='参数错误')
if cid:
try:
cid = int(cid)
category = Category.query.get(cid)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR,errmsg='查询数据错误')
if not category:
return jsonify(errno=RET.NODATA,errmsg='未查询到分类数据')
category.name = cname
else:
category = Category()
category.name = cname
db.session.add(category)
try:
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')
def add_category():
"""
思路分析:
1.获取参数
2.校验,name即可,必有值
3.根据分类编号判断,是增加,还是编辑
4.返回响应
:return:
"""
# 1.获取参数
category_id = request.json.get('id')
category_name = request.json.get('name')
# 2.校验,name即可,必有值
if not category_name:
return jsonify(errno=RET.PARAMERR,errmsg="参数不全")
# 3.根据分类编号判断,是增加,还是编辑
if category_id: #编辑
#取出分类对象
try:
category = Category.query.get(category_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR,errmsg="查询分类失败")
#判断分类是否存在
if not category:
return jsonify(errno=RET.NODATA,errmsg="分类不存在")
#修改分类名称
category.name = category_name
else:#增加
#创建分类对象,设置属性
category = Category()
category.name = category_name
#提交到数据库
try:
db.session.add(category)
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_type():
if request.method == 'GET':
# 查询分类
try:
categories = Category.query.all()
except Exception as e:
current_app.logger.error(e)
return render_template('admin/news_type.html', errmsg="查询数据错误")
category_dict_list = []
for category in categories:
cate_dict = category.to_dict()
category_dict_list.append(cate_dict)
# 移除最新分类
category_dict_list.pop(0)
data = {'categories': category_dict_list}
return render_template('admin/news_type.html', data=data)
cname = request.json.get('name')
# 如果传了cid，代表是编辑
cid = request.json.get('id')
if not cname:
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
if cid:
try:
cid = int(cid)
category = Category.query.get(cid)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
if not category:
return jsonify(errno=RET.NODATA, errmsg="未查询到分类数据")
category.name = cname
else:
category = Category()
category.name = cname
db.session.add(category)
try:
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_type():
"""
新闻分类编辑
:return:
"""
# 分类显示
if request.method == 'GET':
categories = Category.query.filter(Category.id != 1)
category_li = []
for category in categories:
category_li.append(category.to_dict())
data = {'category_li': category_li}
return render_template('admin/news_type.html', data=data)
# 修改内容
category_id = request.json.get('id')
category_name = request.json.get('name')
if not category_name:
return jsonify(errno=RET.PARAMERR, errmsg="参数错误")
# 编辑or新增分类
if category_id:
try:
category = Category.query.get(category_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询数据失败")
if not category:
return jsonify(errno=RET.NODATA, errmsg="未查询到分类信息")
category.name = category_name
else:
new_category = Category()
new_category.name = category_name
try:
db.session.add(new_category)
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 add_category():
"""编辑/新增分类"""
"""
1.获取参数
1.1 id：分类id(非必传), name:分类名称
2.校验参数
2.1 非空判断
3.逻辑处理
3.0 id存在表示需要编辑分类，根据id查询出对应分类对象，再编辑分类对象的名称
3.1 id不存在表示新增分类，创建分类对象，给其name属性赋值即可
3.3 保存回数据库
4.返回值
"""
# 1.1 id：分类id(非必传), name:分类名称
id = request.json.get("id")
name = request.json.get("name")
# 2.1 非空判断
if not name:
return jsonify(errno=RET.PARAMERR, errmsg="参数不足")
# 3.0 id存在表示需要编辑分类，根据id查询出对应分类对象，再编辑分类对象的名称
if id:
try:
category = Category.query.get(id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询分类对象异常")
if not category:
return jsonify(errno=RET.NODATA, errmsg="分类不存在")
else:
# 分类存在，进行编辑
category.name = name
# 3.1 id不存在表示新增分类，创建分类对象，给其name属性赋值即可
else:
category = Category()
category.name = name
db.session.add(category)
# 3.3 保存回数据库
try:
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")
