Skip to content

M
mancheng
Commit ba3bb3b7 by dong
Options

fix20230104

parent d7ac019a
Showing with 578 additions and 1120 deletions
apps/manage/view_auth.py
# import re
# from flask import request, jsonify, current_app
# from apps.manage import api_power
# from apps.models import *
# from apps.util import login_required, verify_btoken
# from apps.utils.response_code import RET
#
#
# # 新增角色
# @api_power.route("/addRole", methods=["POST"])
# @login_required
# def add_role():
# token = request.headers["token"]
# user = verify_btoken(token)
# user_role = user.role # 用户角色
# if user_role != 1:
# return jsonify(code=RET.ROLEERR, msg="暂无权限")
# req_dict = request.get_json()
# role_name = req_dict.get("role_name") # 职位名称（角色）
# rolev = req_dict.get("rolev") # 权值 0层级123， 1调度，2审核，3删除，4审核/上报，5新增/编辑 ,300001"
# info = req_dict.get("info") # 职位功能（角色）
#
# # 校验参数完整性
# if not all([role_name, rolev, info]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
#
# try:
# role = Role.query.filter_by(role_name=role_name).first()
# if role:
# return jsonify(code=RET.DATAEXIST, msg="角色名已存在")
# role = Role.query.filter_by(role=rolev).first()
# if role:
# return jsonify(code=RET.DATAEXIST, msg="权限配置已存在,角色：{}".format(role.role_name))
#
# role = Role(role_name=role_name, role=rolev, info=info)
# db.session.add(role)
# db.session.commit()
# return jsonify(code=RET.OK, msg="添加成功")
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库查询错误")
#
#
# # 获取角色列表
# @api_power.route("/roles", methods=["GET"])
# @login_required
# def roles():
# try:
# roles = Role.query.all()
# data = [{"id": role.id,
# "name": role.role_name,
# "rolev": role.role,
# "info": role.info} for role in roles]
#
# return jsonify(code=RET.OK, msg="查询成功", data=data)
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库查询错误")
#
#
# # 获取角色信息
# @api_power.route("/getRole", methods=["POST"])
# @login_required
# def roleinfo():
# req_dict = request.get_json()
# _id = req_dict.get("id") # 角色id
# # 校验参数完整性
# if not all([_id]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
# try:
# role = Role.query.get(_id)
# data = {"id": role.id,
# "name": role.role_name,
# "rolev": role.role,
# "info": role.info}
#
# return jsonify(code=RET.OK, msg="查询成功", data=data)
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库查询错误")
#
#
# # 角色编辑
# @api_power.route("/updateRole", methods=["POST"])
# @login_required
# def update_role():
# token = request.headers["token"]
# user = verify_btoken(token)
# user_role = user.role # 用户角色
# if user_role != 1:
# return jsonify(code=RET.ROLEERR, msg="暂无权限")
#
# req_dict = request.get_json()
# _id = req_dict.get("id") # 角色id
# role_name = req_dict.get("role_name") # 职位名称（角色）
# rolev = req_dict.get("rolev") # 权值 1调度，2审核，3删除，4审核/上报，5新增/编辑 "00001"
# info = req_dict.get("info") # 职位功能（角色）
#
# # 校验参数完整性
# if not all([_id, role_name, rolev, info]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
#
# try:
# me = Role.query.get(_id)
# if me.role_name != role_name:
# role = Role.query.filter_by(role_name=role_name).first()
# if role:
# return jsonify(code=RET.DATAEXIST, msg="角色名已存在")
# if me.role != rolev:
# role = Role.query.filter_by(role=rolev).first()
# if role:
# return jsonify(code=RET.DATAEXIST, msg="权限配置已存在,角色：{}".format(role.role_name))
# me.role_name = role_name
# me.role = rolev
# me.info = info
# db.session.commit()
# return jsonify(code=RET.OK, msg="添加成功")
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库查询错误")
#
#
# # 删除角色
# @api_power.route("/deleteRole", methods=["POST"])
# @login_required
# def delete_role():
# token = request.headers["token"]
# user = verify_btoken(token)
# user_role = user.role # 用户角色
# if user_role != 1:
# return jsonify(code=RET.ROLEERR, msg="暂无权限")
#
# req_dict = request.get_json()
# _id = req_dict.get("id") # 角色id
#
# # 校验参数完整性
# if not all([_id]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
#
# try:
# me = Role.query.get(_id)
# if len(me.users) != 0:
# return jsonify(code=RET.DATAEXIST, msg="当前角色存在用户使用,请查证并清除后再操作")
# db.session.delete(me)
# db.session.commit()
# return jsonify(code=RET.OK, msg="删除成功")
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库查询错误")
#
#
# # 新添管理员账号
# @api_power.route("/addManager", methods=["POST"])
# @login_required
# def add_manager():
# token = request.headers["token"]
# user = verify_btoken(token)
# user_role = user.role # 用户角色
# if user_role != 1:
# return jsonify(code=RET.ROLEERR, msg="暂无权限")
# req_dict = request.get_json()
# account = req_dict.get("account") # 账户
# password = req_dict.get("password") # 密码
# role = req_dict.get("role") # 角色 1超级管理员，2系统运维员
#
# # 校验参数完整性
# if not all([account, password, role]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
#
# # 用户名唯一(字母开头，长度4-15)
# try:
# patten = "^[a-zA-Z][\w]*[\w]*$"
# if re.match(patten, account) and re.match(patten, account).string == account:
# user = Bstage.query.filter_by(name=account).first()
# if user:
# return jsonify(code=RET.DATAEXIST, msg="用户名已存在")
# else:
# return jsonify(code=RET.DATAERR, msg="用户名格式错误1")
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="用户名格式错误2")
#
# try:
# me = Bstage(name=account, role=role)
# me.password = password
# db.session.add(me)
# db.session.commit()
# return jsonify(code=RET.OK, msg="添加成功")
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库操作错误")
from flask import request, jsonify, current_app
from apps.manage import api_power
from apps.models import *
from apps.util import login_required, verify_btoken
from apps.utils.response_code import RET
# 获取角色列表
@api_power.route("/GetFixedRole", methods=["GET"])
@login_required
def get_fixed_role():
try:
chart_obj_list = OrganizationChart.query.all()
data = [{
"id": chart_obj.id,
# "one_org": chart_obj.one_org,
# "two_department": chart_obj.two_department,
"three_role": chart_obj.three_role,
} for chart_obj in chart_obj_list]
return jsonify(code=RET.OK, data=data, msg="查询成功！")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 获取角色权限详情
@api_power.route("/GetFixedRoleDetail", methods=["POST"])
@login_required
def get_fixed_role_detail():
req_dic = request.get_json()
role_id = req_dic['role_id']
try:
chart_obj = OrganizationChart.query.get(role_id)
print(chart_obj)
data = {
"three_role": chart_obj.three_role,
"page_permission_id": eval(chart_obj.page_permission_id),
"fun_permission_id": eval(chart_obj.fun_permission_id)}
return jsonify(code=RET.OK, data=data, msg="查询成功！")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 新增/修改角色并且赋予权限
@api_power.route("/AddEditRole", methods=["POST"])
@login_required
def add_edit_role():
# token = request.headers["token"]
# user = verify_btoken(token)
# user_role = user.role # 用户角色
# if user_role != 1:
# return jsonify(code=RET.ROLEERR, msg="暂无权限，请联系管理员")
req_dict = request.get_json()
flag = req_dict.get("flag") # 1为新增，2为修改编辑
role_id = req_dict.get("role_id") # 为修改编辑时填写，新增不填
role_name = req_dict.get("role_name") # 职位名称（角色）
page_id_list = req_dict.get("page_id_list")
fun_id_list = req_dict.get("fun_id_list")
# 校验参数完整性
if not all([role_name, page_id_list, fun_id_list]):
return jsonify(code=RET.PARAMERR, msg="参数不完整, 权限勾选不能为空！")
try:
if flag == 1: # 新增
role_obj = OrganizationChart.query.filter_by(three_role=role_name).first()
if role_obj:
return jsonify(code=RET.DATAEXIST, msg="角色名已存在！")
else:
role_obj = OrganizationChart(three_role=role_name, page_permission_id=str(page_id_list),
fun_permission_id=str(fun_id_list)
)
db.session.add(role_obj)
db.session.commit()
return jsonify(code=RET.OK, msg="添加成功")
elif flag == 2: # 编辑修改
role_obj = OrganizationChart.query.get(role_id)
# role_obj.one_org = org_name
# role_obj.two_department = department_name
role_obj.three_role = role_name
role_obj.page_permission_id = str(page_id_list)
role_obj.fun_permission_id = str(fun_id_list)
db.session.commit()
return jsonify(code=RET.OK, msg="修改成功")
else:
return jsonify(code=RET.OK, msg="参数错误")
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 删除角色
@api_power.route("/deleteRole", methods=["POST"])
@login_required
def delete_role():
# token = request.headers["token"]
# user = verify_btoken(token)
# user_role = user.role # 用户角色
# if user_role != 1:
# return jsonify(code=RET.ROLEERR, msg="暂无权限，请联系管理员")
req_dict = request.get_json()
_id = req_dict.get("id") # 角色id
# 校验参数完整性
if not all([_id]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
user_obj = User.query.filter_by(org_id=_id).all()
if len(user_obj):
return jsonify(code=RET.DATAEXIST, msg="当前角色存在用户使用,请查证并清除后再操作")
org_obj = OrganizationChart.query.get(_id)
db.session.delete(org_obj)
db.session.commit()
return jsonify(code=RET.OK, msg="删除成功")
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(code=RET.DBERR, msg="删除出错！")
apps/manage/view_org.py
# import time
# from datetime import datetime
#
# from flask import request, jsonify, current_app, g
# from apps.manage import api_power
# from apps.models import *
# from apps.utils.response_code import RET
# from apps.util import login_required, verify_token
#
#
# # 新增机构组织
# @api_power.route("/AddOrg", methods=["POST"])
# @login_required
# def add_org():
# '''
# 不得重名
# '''
# token = request.headers["token"]
# user = verify_token(token)
# user_id = user.id
# user_name = User.query.get(id=user_id).name
# req_dict = request.get_json()
# org_name = req_dict.get("name") # 机构名称
# # forg = req_dict.get("forg") # 上级机构 id
# charge = req_dict.get("charge") # 机构负责人
# charge_phone = req_dict.get("charge_phone") # 负责人电话
# # sublist = req_dict.get("sublist") # 统筹机构id list["1","2"...]
#
# # 校验参数完整性
# if not all([org_name]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
# try:
# gover = GovOrganization.query.filter_by(name=org_name).first()
# if gover: # 机构名相同，提示其错误
# return jsonify(code=RET.DBERR, msg="机构名重复")
#
# goverment = GovOrganization(name=org_name) # 创建机构
# if charge:
# goverment.charge = charge
# if charge_phone:
# goverment.charge_phone = charge_phone
# if user_name:
# goverment.add_person = user_name
# add_time = datetime.now()
# goverment.add_time = add_time
# db.session.add(goverment) # 添加到数据库
#
# # if forg: # 如果有上级机构，就让上级机构统筹新增机构
# # fgover = Government.query.get(forg)
# # fgover.followed.append(goverment)
# # for ctr in sublist: # 如果有统筹机构，就让新增机构统筹
# # sgover = Government.query.get(ctr)
# # goverment.followed.append(sgover)
# db.session.commit() # 提交数据库
# return jsonify(code=RET.OK, msg="添加成功")
# except Exception as e:
# # 操作失败，回滚数据库
# db.session.rollback()
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库操作错误")
#
#
# # 查询添加过的机构信息
# @api_power.route("/GetOrg", methods=["GET"])
# @login_required
# def get_org():
# try:
# org = GovOrganization.query.all()
# data = [{"id": i.id, "name": i.name, "pnums": i.pnums,
# "charge": i.charge, "charge_phone": i.charge_phone,
# "add_person": i.add_person, "add_time": i.add_time,
# "edit_person": i.edit_person, "edit_time": i.edit_time}
# for i in org]
# return jsonify(code=RET.OK, msg="查询成功", data=data)
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库查询错误")
#
#
# # 新增下级部门(ok)
# @api_power.route("/AddSubDepartment", methods=["POST"])
# @login_required
# def add_sub_department():
# token = request.headers["token"]
# user = verify_token(token)
# user_id = user.id
# user_name = User.query.get(id=user_id).name
# req_dict = request.get_json()
# id = req_dict.get("id") # 当前机构或者部门id
# # cate = req_dict.get("cate") # 分类标识，1机构，2部门
# name = req_dict.get("name") # 部门或组名称
# # pnums = req_dict.get("pnums") # 人数
# charge = req_dict.get("charge") # 机构负责人
# charge_phone = req_dict.get("charge_phone") # 负责人电话
#
# # 校验参数完整性
# # if not all([_id, cate, name]):
# # return jsonify(code=RET.PARAMERR, msg="参数不完整")
# if not all([id, name]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
#
# try:
# # if cate == 1: # 增加部门
# sec = GovDepartment.query.filter_by(name=name, goverment_org_id=id).first()
# if sec: # 一个机构下部门名不能重复
# return jsonify(code=RET.DATAERR, msg="部门名重复")
# gov_organization = GovOrganization.query.get(id)
# gov_department = GovDepartment(name=name, goverment_org_id=id)
# # if pnums:
# # gov_department.pnums = pnums
# if charge:
# gov_department.charge = charge
# if charge_phone:
# gov_department.charge_phone = charge_phone
# if user_name:
# gov_department.add_person = user_name
# add_time = datetime.now()
# gov_department.add_time = add_time
# db.session.add(gov_department) # 添加部门
# gov_organization.government_departments.append(gov_department) # 外键关系添加
# db.session.commit() # 数据库提交
# # if cate == 2: # 增加组
# # gro = Group.query.filter_by(name=name, gov_department_id=_id).first()
# # if gro: # 一个部门下组名不能重复
# # return jsonify(code=RET.DATAERR, msg="组名重复")
# # gov_department = Section.query.get(_id)
# # group = Group(name=name, section_id=_id)
# # if pnums:
# # group.pnums = pnums
# # if charge:
# # group.charge = charge
# # if charge_phone:
# # group.charge_phone = charge_phone
# # db.session.add(group) # 添加组
# # section.groups.append(group) # 添加关系
# # db.session.commit() # 提交
# # if cate == 3:
# # return jsonify(code=RET.OK, msg="暂无下级机构，请勿继续添加")
# return jsonify(code=RET.OK, msg="添加成功")
# except Exception as e:
# # 操作失败，数据回滚
# db.session.rollback()
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库操作错误")
#
#
#
#
# # 获取上级或下级统筹机构 (ok)
# @api_power.route("/uadOrg", methods=["GET"])
# @login_required
# def uad_org():
# try:
# gover = Government.query.all()
# data = [{"label": i.name, "value": i.id} for i in gover]
# return jsonify(code=RET.OK, msg="查询成功", data=data)
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库查询错误")
#
#
# # 获取上级机构后的统筹机构 (ok)
# @api_power.route("/downOrg", methods=["POST"])
# @login_required
# def down_org():
# req_dict = request.get_json()
# _id = req_dict.get("id") # 机构名称
# try:
# if _id:
# gover = Government.query.all()
# data = [{"label": i.name, "value": i.id} for i in gover if i.id != _id]
# return jsonify(code=RET.OK, msg="查询成功", data=data)
# else:
# gover = Government.query.all()
# data = [{"label": i.name, "value": i.id} for i in gover]
# return jsonify(code=RET.OK, msg="查询成功", data=data)
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库查询错误")
#
#
# # 组织架构管理,获取机构单位数据（ok）
# @api_power.route("/organization", methods=["POST"])
# @login_required
# def organization():
# req_dict = request.get_json()
# page = req_dict.get("page")
# perpage = req_dict.get("perpage")
# # 校验参数完整性
# if not all([page, perpage]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
# try:
# # goverment = Government.query.paginate(page, perpage).items
# goverment = Government.query.all()
# size = Government.query.count()
# df = [{"id": gover.id,
# "name": gover.name,
# "pnums": gover.pnums if gover.pnums else 0,
# "charge": gover.charge if gover.charge else "-",
# "charge_phone": gover.charge_phone if gover.charge_phone else "-",
# "cate": 1} for gover in goverment]
# data = {"df": df, "size": size}
# return jsonify(code=RET.OK, msg="查找成功", data=data)
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库查询错误", data=[])
#
#
# # 组织架构获取部门和组（Ok）
# @api_power.route("/sectionGroup", methods=["POST"])
# @login_required
# def section_group():
# req_dict = request.get_json()
# _id = req_dict.get("id") # 当前机构或者部门的id
# cate = req_dict.get("cate") # 分类标识，1机构，2部门
#
# # 校验参数完整性
# if not all([_id, cate]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
#
# try:
# if cate == 1: # 查询当前机构下的部门
# goverment = Government.query.get(_id)
# sections = goverment.sections # 查询当前机构下的部门list
# data = [{"id": sec.id,
# "name": sec.name,
# "pnums": sec.pnums if sec.pnums else 0,
# "charge": sec.charge if sec.charge else "-",
# "charge_phone": sec.charge_phone if sec.charge_phone else "-",
# "cate": 2} for sec in sections]
# return jsonify(code=RET.OK, msg="查找成功", data=data)
# if cate == 2: # 查询当前部门下的组
# section = Section.query.get(_id)
# groups = section.groups # 查询当前部门下的组list
# data = [{"id": group.id,
# "name": group.name,
# "pnums": group.pnums if group.pnums else 0,
# "charge": group.charge if group.charge else "-",
# "charge_phone": group.charge_phone if group.charge_phone else "-",
# "cate": 3} for group in groups]
# return jsonify(code=RET.OK, msg="查找成功", data=data)
# return jsonify(code=RET.OK, msg="暂无下级信息", data=[])
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库查询错误", data=[])
#
#
# # 删除组织机构或者部门和组(需要先删除人员)--------OK
# @api_power.route("/deleteOrg", methods=["POST"])
# @login_required
# def deleteorg():
# req_dict = request.get_json()
# _id = req_dict.get("id") # 待删除的，部门、机构、组、id
# cate = req_dict.get("cate") # 待删除数据的类别 1政府，2部门，3组
#
# # 校验参数完整性
# if not all([_id, cate]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
#
# try:
# if cate == 1: # 删除机构
# gover = Government.query.get(_id) # 当前机构对象
# section = gover.sections # 当前机构下的部门对象列表
# if len(section) > 0: # 有部门就需要先删除部门
# return jsonify(code=RET.REQERR, msg="当前机构有部门存在，请清除后再操作")
# unums = User.query.filter_by(unit=gover.name, status=1).count() # 当前机构下通过审核人员
# if unums > 0: # 当前部门有人，先到机构详情，进行人员的删除
# return jsonify(code=RET.REQERR, msg="当前机构有人员存在，请清除后再操作")
# db.session.delete(gover) # 无人无部门，删除
# db.session.commit() # 提交
# return jsonify(code=RET.OK, msg="删除成功")
# if cate == 2: # 删除部门
# section = Section.query.get(_id)
# gover = section.goverment # 部门所属的机构
# group = section.groups # 当前部门的组对象list
# if len(group) > 0: # 如果有组先删除组
# return jsonify(code=RET.REQERR, msg="当前部门有组存在，请清除后再操作")
# unums = User.query.filter_by(unit=gover.name, section=section.name, status=1).count() # # 已经通过审核的人数
# if unums > 0: # 当前部门有人，先到部门详情，进行部门人员的删除
# return jsonify(code=RET.REQERR, msg="当前部门有人员存在，请清除后再操作")
# gover.sections.remove(section) # 当前部门没有人，没有组，删除部门之前需要先删除与之相关的机构关系
# db.session.delete(section) # 删除
# db.session.commit() # 提交
# return jsonify(code=RET.OK, msg="删除成功")
# if cate == 3: # 删除组
# group = Group.query.get(_id) # 当前组信息
# section = group.section # 组属于的部门，单个对象
# gover = section.goverment # 部门属于的机构，单个对象
# unums = User.query.filter_by(unit=gover.name, section=section.name, group=group.name,
# status=1).count() # 已经通过审核的人数
# if unums > 0: # 当前组有人，先到组详情，进行组员的删除
# return jsonify(code=RET.REQERR, msg="当前组有人员存在，请清除后再操作")
# section.groups.remove(group) # 当前组没有人，删除组之前需要先删除与之相关的部门关系
# db.session.delete(group) # 删除
# db.session.commit() # 提交
# return jsonify(code=RET.OK, msg="删除成功")
# else:
# return jsonify(code=RET.DATAERR, msg="参数错误")
# except Exception as e:
# # 操作失败，回滚数据库
# db.session.rollback()
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库操作失败")
#
#
# ''''''
#
#
# # 获取机构，部门或者组详情()
# @api_power.route("/orgDetail", methods=["POST"])
# @login_required
# def org_detail():
# req_dict = request.get_json()
# _id = req_dict.get("id") # id
# cate = req_dict.get("cate") # 1机构，2部门，3组
#
# # 校验参数完整性
# if not all([_id, cate]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
#
# try:
# if cate == 1: # 政府机构详情
# goverment = Government.query.get(_id)
# # 政府信息
# data = {"id": goverment.id,
# "name": goverment.name, # 机构名
# "charge": goverment.charge if goverment.charge else "-", # 主管
# "phone": goverment.charge_phone if goverment.charge_phone else "-", # 电话
# "pnums": goverment.pnums if goverment.pnums else 0, # 机构人数
# "secnums": len(goverment.sections), # 部门数
# "func": goverment.function if goverment.function else "", # 政府职能
# "cate": cate}
# return jsonify(code=RET.OK, msg="查询成功", data=data)
# if cate == 2: # 部门详情
# section = Section.query.get(_id)
# # 政府信息
# data = {"id": section.id,
# "name": section.name, # 机构名
# "charge": section.charge if section.charge else "-", # 主管
# "phone": section.charge_phone if section.charge_phone else "-", # 电话
# "pnums": section.pnums if section.pnums else 0, # 机构人数
# "secnums": len(section.groups), # 组数
# "func": section.function if section.function else "", # 部门职能
# "cate": cate}
# return jsonify(code=RET.OK, msg="查询成功", data=data)
# if cate == 3: # 组详情
# group = Group.query.get(_id)
# # 政府信息
# data = {"id": group.id,
# "name": group.name, # 机构名
# "charge": group.charge if group.charge else "-", # 主管
# "phone": group.charge_phone if group.charge_phone else "-", # 电话
# "pnums": group.pnums if group.pnums else 0, # 机构人数
# "secnums": "-",
# "func": group.function if group.function else "", # 部门职能
# "cate": cate}
# return jsonify(code=RET.OK, msg="查询成功", data=data)
#
# return jsonify(code=RET.OK, msg="参数错误")
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库操作错误")
#
#
# # 编辑机构，部门或者组详情
# @api_power.route("/editDetail", methods=["POST"])
# @login_required
# def edit_detail():
# req_dict = request.get_json()
# _id = req_dict.get("id") # 部门id
# cate = req_dict.get("cate") # 1机构，2部门，3组
# name = req_dict.get("name") # 1机构，2部门，3组 的名称
# charge = req_dict.get("charge") # 局内领导
# charge_phone = req_dict.get("charge_phone") # 联系方式
# func = req_dict.get("func") # 部门职能
# pnums = str(req_dict.get("pnums")) # 人数
# secnums = str(req_dict.get("secnums")) # 部门组人数
#
# # 校验参数完整性
# if not all([_id, name, charge, charge_phone, pnums, secnums]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
#
# try:
# if cate == 1: # 机构
# gover = Government.query.filter_by(name=name).filter(Government.id != _id).first()
# if gover:
# return jsonify(code=RET.DBERR, msg="机构名不可重复")
# gover = Government.query.get(_id)
# gover.name = name
# gover.charge = charge
# gover.charge_phone = charge_phone
# gover.function = func
# gover.pnums = pnums
# gover.secnums = secnums
# db.session.commit()
# return jsonify(code=RET.OK, msg="修改成功")
# if cate == 2: # 部门
# section = Section.query.get(_id) # 当前部门
# gover_id = section.goverment_id # 当前部门的机构id
# sec = Section.query.filter_by(name=name, goverment_id=gover_id).filter(Section.id != _id).first()
# if sec: # 当前机构下此部门名已存在
# return jsonify(code=RET.DBERR, msg="部门名不可重复")
# section.name = name
# section.charge = charge
# section.charge_phone = charge_phone
# section.function = func
# section.pnums = pnums
# section.secnums = secnums
# db.session.commit()
# return jsonify(code=RET.OK, msg="修改成功")
# if cate == 3: # 组
# group = Group.query.get(_id) # 当前组
# sec_id = group.section_id # 当前组的部门id
# gro = Group.query.filter_by(name=name, section_id=sec_id).filter(Group.id != _id).first()
# if gro: # 当前部门下此组名已存在
# return jsonify(code=RET.DBERR, msg="组名不可重复")
# group.name = name
# group.charge = charge
# group.charge_phone = charge_phone
# group.function = func
# group.pnums = pnums
# group.secnums = secnums
# db.session.commit()
# return jsonify(code=RET.OK, msg="修改成功")
# return jsonify(code=RET.DATAERR, msg="cate参数错误")
# except Exception as e:
# # 操作失败，回滚数据库
# db.session.rollback()
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库操作错误")
#
#
# # 获取机构，部门或者组的人员
# @api_power.route("/orgStaff", methods=["POST"])
# @login_required
# def org_staff():
# req_dict = request.get_json()
# _id = req_dict.get("id") # 部门id
# cate = req_dict.get("cate") # 1机构，2部门，3组
#
# # 校验参数完整性
# if not all([_id, cate]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
#
# try:
# if cate == 1: # 政府机构详情
# goverment = Government.query.get(_id)
# # 人员列表
# staff = User.query.filter_by(status=1, unit=goverment.name).filter(
# User.role_id.isnot(None)).all() # 通过审核的员工列表
# staff = [{"id": i.id,
# "name": i.real_name,
# "position": i.position,
# "section": i.section} for i in staff]
# return jsonify(code=RET.OK, msg="查询成功", data=staff)
# if cate == 2: # 部门详情
# section = Section.query.get(_id)
# # 人员列表
# staff = User.query.filter_by(status=1, unit=section.goverment.name, section=section.name).filter(
# User.role_id.isnot(None)).all() # 通过审核的员工列表
# staff = [{"id": i.id,
# "name": i.real_name,
# "position": i.position,
# "section": i.section} for i in staff]
# return jsonify(code=RET.OK, msg="查询成功", data=staff)
# if cate == 3: # 组详情
# group = Group.query.get(_id)
# # 人员列表
# staff = User.query.filter_by(status=1, unit=group.section.goverment.name, section=group.section.name,
# group=group.name).filter(User.role_id.isnot(None)).all() # 通过审核的员工列表
# staff = [{"id": i.id,
# "name": i.real_name,
# "position": i.position,
# "section": i.section} for i in staff]
# return jsonify(code=RET.OK, msg="查询成功", data=staff)
# else:
# return jsonify(code=RET.OK, msg="参数错误")
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库操作错误")
#
#
# # 机构部门或这组的待新增人员列表-------------------?
# @api_power.route("/listOfStaff", methods=["POST"])
# # @login_required
# def list_Staff():
# req_dict = request.get_json()
# _id = req_dict.get("id") # 当前机构id
# cate = req_dict.get("cate") # 1机构 2部门 3组
#
# # 校验参数完整性
# if not all([_id]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
# try:
# if cate == 1: # 政府
# gover = Government.query.get(_id)
# if gover:
# name = gover.name
# user = User.query.filter_by(unit=name).filter(User.role_id.isnot(None)).all()
# data = [{"id": i.id,
# "real_name": i.real_name if i.real_name else i.id} for i in user]
# return jsonify(code=RET.OK, msg="查询成功", data=data)
# else:
# return jsonify(code=RET.DATAERR, msg="参数错误")
# if cate == 2: # 部门
# section = Section.query.get(_id)
# if section:
# gover = section.goverment
# user = User.query.filter_by(unit=gover.name).filter(User.role_id.isnot(None)).all()
# data = [{"id": i.id,
# "real_name": i.real_name if i.real_name else i.id} for i in user]
# return jsonify(code=RET.OK, msg="查询成功", data=data)
# else:
# return jsonify(code=RET.DATAERR, msg="参数错误")
# if cate == 3: # 组
# group = Group.query.get(_id)
# if group:
# section = group.section
# gover = section.goverment
# user = User.query.filter_by(unit=gover.name).filter(User.role_id.isnot(None)).all()
# data = [{"id": i.id,
# "real_name": i.real_name if i.real_name else i.id} for i in user]
# return jsonify(code=RET.OK, msg="查询成功", data=data)
# else:
# return jsonify(code=RET.DATAERR, msg="参数错误")
# return jsonify(code=RET.DATAERR, msg="参数错误")
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库查询错误")
#
#
# # 机构部门或这组的人员 新增（人员部门调度）
# @api_power.route("/addStaffOrg", methods=["POST"])
# # @login_required
# def add_staff():
# req_dict = request.get_json()
# _id = req_dict.get("id") # 部门机构组id
# cate = req_dict.get("cate") # 1政府，2部门，3组
# uid = req_dict.get("uid") # 员工id
# level = req_dict.get("level") # 职级(角色id)
# position = req_dict.get("position") # 职务,文本框随意填
#
# # 校验参数完整性
# if not all([_id, level, position]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
# try:
# user = User.query.get(uid)
# if user:
# if cate == 1: # 政府机构
# user.section = Government.query.get(_id).name
# # 删除原有角色
# role = Role.query.get(user.role_id)
# role.users.remove(user)
# # 添加新角色
# role = Role.query.get(level)
# role.users.append(user)
#
# user.position = position
# db.session.commit()
# return jsonify(code=RET.OK, msg="添加成功")
# if cate == 2: # 部门调度
# user.section = Section.query.get(_id).name
# # 删除原有角色
# role = Role.query.get(user.role_id)
# role.users.remove(user)
# # 添加新角色
# role = Role.query.get(level)
# role.users.append(user)
#
# user.position = position
# db.session.commit()
# return jsonify(code=RET.OK, msg="添加成功")
# if cate == 3: # 组调度
# user.group = Group.query.get(_id).name
# # 删除原有角色
# role = Role.query.get(user.role_id)
# role.users.remove(user)
# # 添加新角色
# role = Role.query.get(level)
# role.users.append(user)
#
# user.position = position
# db.session.commit()
# return jsonify(code=RET.OK, msg="添加成功")
#
# return jsonify(code=RET.DATAERR, msg="参数错误")
# else:
# return jsonify(code=RET.DATAERR, msg="参数错误")
# except Exception as e:
# # 操作失败，回滚数据库
# db.session.rollback()
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库操作错误")
#
#
# # # 测试
# # @api_power.route("/cs", methods=["get"])
# # def ces():
# # gover = Government.query.get(18)
# # section = Section.query.get(37)
# # print(gover,section)
# # # section.goverment.remove(gover)
# # gover.sections.remove(section)
# # db.session.commit()
# # return "ok"
# ''''''
#
#
# # 机构部门或这组的人员 删除（人员失去组，机构项目）
# @api_power.route("/deleteStaffOrg", methods=["POST"])
# @login_required
# def delete_staff():
# req_dict = request.get_json()
# uid = req_dict.get("uid") # 员工id
# cate = req_dict.get("cate") # 1政府，2部门，3组
# _id = req_dict.get("id") # 机构部门组id
# # level = req_dict.get("level") # 职级
# # position = req_dict.get("position") # 职务
#
# # 校验参数完整性
# if not all([uid, cate, _id]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
# try:
# user = User.query.get(uid)
# if user:
# if cate == 1: # 政府机构
# role = Role.query.get(user.role_id)
# role.users.remove(user)
# user.unit = "" # 机构
# user.position = "" # 职位
# user.section = "" # 部门
# user.group = "" # 组
# user.level = "" # 级别
# user.leader = "" # 领导者
# user.password = "" # 密码
# db.session.commit()
# return jsonify(code=RET.OK, msg="删除成功")
# if cate == 2: # 部们
# role = Role.query.get(user.role_id)
# # user.role_id = ""
# role.users.remove(user)
# user.position = ""
# user.section = ""
# user.group = ""
# user.level = ""
# # user.role_id = ""
# db.session.commit()
# return jsonify(code=RET.OK, msg="删除成功")
# if cate == 3: # 组调度
# user.group = ""
# db.session.commit()
# return jsonify(code=RET.OK, msg="删除成功")
# return jsonify(code=RET.DATAERR, msg="参数错误")
# else:
# return jsonify(code=RET.DATAERR, msg="参数错误")
# except Exception as e:
# # 操作失败，回滚数据库
# db.session.rollback()
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库操作错误")
#
#
# # 获取统筹机构列表
# @api_power.route("/orgCtrl", methods=["POST"])
# @login_required
# def org_ctrl():
# req_dict = request.get_json()
# _id = req_dict.get("id") # 机构id
# cate = req_dict.get("cate") # 1政府，2部门，3组
#
# # 校验参数完整性
# if not all([_id, cate]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
# try:
# if cate == 1: # 政府机构详情
# goverment = Government.query.get(_id)
# # 统筹机构列表
# ctrl = goverment.followed
# bkpm = [{"id": j.id,
# "name": j.name,
# "charge": j.charge if j.charge else "-",
# "phone": j.charge_phone if j.charge_phone else "-"} for j in ctrl]
# return jsonify(code=RET.OK, msg="查询成功", data=bkpm)
#
# return jsonify(code=RET.OK, msg="参数错误")
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库操作错误")
#
#
# # 获取待新增统筹机构列表
# @api_power.route("/getCtrl", methods=["POST"])
# @login_required
# def get_ctrl():
# req_dict = request.get_json()
# _id = req_dict.get("id")
#
# # 校验参数完整性
# if not all([_id]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
# try:
# goverment = Government.query.get(_id)
# folllowedids = {i.id for i in goverment.followed} # 已经被管制的
# folllowedids.add(_id) # 添加自己
# all_ids = {i.id for i in Government.query.filter_by().all()} # 全部机构id
# options = list(all_ids - folllowedids) # 未被当前机构统筹的机构id列表
#
# goverments = Government.query.filter(Government.id.in_(options)).all()
# data = [{"id": i.id,
# "name": i.name} for i in goverments]
#
# return jsonify(code=RET.OK, msg="查询成功", data=data)
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="添加失败")
#
#
# # 机构详情页添加统筹机构
# @api_power.route("/addBeCtrl", methods=["POST"])
# @login_required
# def add_bectrl():
# req_dict = request.get_json()
# _id = req_dict.get("id")
# ids = req_dict.get("ids")
#
# # 校验参数完整性
# if not all([_id, ids]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
# try:
# goverment = Government.query.get(_id)
# folllowedids = {i.id for i in goverment.followed}
# ids = set(ids)
# for id in (ids - folllowedids):
# gover = Government.query.get(id)
# goverment.followed.append(gover)
# db.session.commit()
# return jsonify(code=RET.OK, msg="添加成功")
# except Exception as e:
# # 操作失败，回滚数据库
# db.session.rollback()
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="添加失败")
#
#
# # 机构详情页删除统筹机构
# @api_power.route("/deleteCtrl", methods=["POST"])
# @login_required
# def delete_bectrl():
# req_dict = request.get_json()
# _id = req_dict.get("id")
# bectrl_id = req_dict.get("bectrl_id")
#
# # 校验参数完整性
# if not all([_id, bectrl_id]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
# try:
# goverment = Government.query.get(_id)
# begoverment = Government.query.get(bectrl_id)
# goverment.followed.remove(begoverment)
# db.session.commit()
#
# return jsonify(code=RET.OK, msg="删除成功")
# except Exception as e:
# # 操作失败，回滚数据库
# db.session.rollback()
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库操作失败")
import time
from datetime import datetime
from flask import request, jsonify, current_app, g
from apps.manage import api_power
from apps.models import *
from apps.utils.response_code import RET
from apps.util import login_required, verify_token
# 获取首页机构列表
@api_power.route("/organization", methods=["POST"])
@login_required
def organization():
req_dict = request.get_json()
page = req_dict.get("page")
perpage = req_dict.get("perpage")
# 校验参数完整性
if not all([page, perpage]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
goverment = Government.query.all()
size = Government.query.count()
df = [{"id": gover.id, # id
"name": gover.name, # 机构
"pnums": gover.pnums if gover.pnums else 0, # 人数
"charge": gover.charge if gover.charge else "-", # 负责人
"charge_phone": gover.charge_phone if gover.charge_phone else "-", # 负责人电话
"cate": 1} for gover in goverment]
data = {"df": df, "size": size}
return jsonify(code=RET.OK, msg="查找成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误", data=[])
# 新增机构组织
@api_power.route("/AddOrg", methods=["POST"])
@login_required
def add_org():
'''
不得重名
'''
# token = request.headers["token"]
# user = verify_token(token)
# user_id = user.id
# user_name = User.query.get(id=user_id).name
req_dict = request.get_json()
org_name = req_dict.get("name") # 机构名称
pnums = req_dict.get("pnums") # 人数
charge = req_dict.get("charge") # 机构负责人
charge_phone = req_dict.get("charge_phone") # 负责人电话
# 校验参数完整性
if not all([org_name]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
gover = Government.query.filter_by(name=org_name).first()
if gover: # 机构名相同，提示其错误
return jsonify(code=RET.DBERR, msg="机构名重复")
goverment = Government(name=org_name) # 创建机构
if charge:
goverment.charge = charge
if charge_phone:
goverment.charge_phone = charge_phone
if pnums:
goverment.pnums = pnums
# if user_name:
# goverment.add_person = user_name
# add_time = datetime.now()
# goverment.add_time = add_time
db.session.add(goverment) # 添加到数据库
db.session.commit() # 提交数据库
return jsonify(code=RET.OK, msg="添加成功")
except Exception as e:
# 操作失败，回滚数据库
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库操作错误")
# 新增部门或组
@api_power.route("/addSub", methods=["POST"])
@login_required
def add_sub():
req_dict = request.get_json()
_id = req_dict.get("id") # 当前机构或者部门id
cate = req_dict.get("cate") # 分类标识，1机构，2部门
name = req_dict.get("name") # 部门或组名称
pnums = req_dict.get("pnums") # 人数
charge = req_dict.get("charge") # 机构负责人
charge_phone = req_dict.get("charge_phone") # 负责人电话
# 校验参数完整性
if not all([_id, name]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if cate == 1: # 增加部门
sec = Section.query.filter_by(name=name, goverment_id=_id).first()
if sec: # 一个机构下部门名不能重复
return jsonify(code=RET.DATAERR, msg="部门名重复")
goverment = Government.query.get(_id)
section = Section(name=name, goverment_id=_id)
if pnums:
section.pnums = pnums
if charge:
section.charge = charge
if charge_phone:
section.charge_phone = charge_phone
db.session.add(section) # 添加部门
goverment.sections.append(section) # 外键关系添加
db.session.commit() # 数据库提交
if cate == 2: # 增加组
gro = Group.query.filter_by(name=name, section_id=_id).first()
if gro: # 一个部门下组名不能重复
return jsonify(code=RET.DATAERR, msg="组名重复")
section = Section.query.get(_id)
group = Group(name=name, section_id=_id)
if pnums:
group.pnums = pnums
if charge:
group.charge = charge
if charge_phone:
group.charge_phone = charge_phone
db.session.add(group) # 添加组
section.groups.append(group) # 添加关系
db.session.commit() # 提交
# if cate == 3:
# return jsonify(code=RET.OK, msg="暂无下级机构，请勿继续添加")
return jsonify(code=RET.OK, msg="添加成功")
except Exception as e:
# 操作失败，数据回滚
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库操作错误")
# 获取部门和组
@api_power.route("/sectionGroup", methods=["POST"])
@login_required
def section_group():
req_dict = request.get_json()
_id = req_dict.get("id") # 当前机构或者部门的id
cate = req_dict.get("cate") # 分类标识，1机构，2部门
# 校验参数完整性
if not all([_id, cate]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if cate == 1: # 查询当前机构下的部门
goverment = Government.query.get(_id)
sections = goverment.sections # 查询当前机构下的部门list
data = [{"id": sec.id,
"name": sec.name,
"pnums": sec.pnums if sec.pnums else 0,
"charge": sec.charge if sec.charge else "-",
"charge_phone": sec.charge_phone if sec.charge_phone else "-",
"cate": 2} for sec in sections]
return jsonify(code=RET.OK, msg="查找成功", data=data)
if cate == 2: # 查询当前部门下的组
section = Section.query.get(_id)
groups = section.groups # 查询当前部门下的组list
data = [{"id": group.id,
"name": group.name,
"pnums": group.pnums if group.pnums else 0,
"charge": group.charge if group.charge else "-",
"charge_phone": group.charge_phone if group.charge_phone else "-",
"cate": 3} for group in groups]
return jsonify(code=RET.OK, msg="查找成功", data=data)
return jsonify(code=RET.OK, msg="暂无下级信息", data=[])
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误", data=[])
# 编辑机构，部门或者组详情
@api_power.route("/editDetail", methods=["POST"])
@login_required
def edit_detail():
req_dict = request.get_json()
_id = req_dict.get("id") # 部门id
cate = req_dict.get("cate") # 1机构，2部门，3组
name = req_dict.get("name") # 1机构，2部门，3组 的名称
charge = req_dict.get("charge") # 局内领导
charge_phone = req_dict.get("charge_phone") # 联系方式
pnums = str(req_dict.get("pnums")) # 人数
# 校验参数完整性
# # if not all([_id, name, charge, charge_phone, pnums, secnums]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if cate == 1: # 机构
gover = Government.query.filter_by(name=name).filter(Government.id != _id).first()
if gover:
return jsonify(code=RET.DBERR, msg="机构名不可重复")
gover = Government.query.get(_id)
gover.name = name
gover.charge = charge
gover.charge_phone = charge_phone
gover.pnums = pnums
db.session.commit()
return jsonify(code=RET.OK, msg="修改成功")
if cate == 2: # 部门
section = Section.query.get(_id) # 当前部门
gover_id = section.goverment_id # 当前部门的机构id
sec = Section.query.filter_by(name=name, goverment_id=gover_id).filter(Section.id != _id).first()
if sec: # 当前机构下此部门名已存在
return jsonify(code=RET.DBERR, msg="部门名不可重复")
section.name = name
section.charge = charge
section.charge_phone = charge_phone
section.pnums = pnums
db.session.commit()
return jsonify(code=RET.OK, msg="修改成功")
if cate == 3: # 组
group = Group.query.get(_id) # 当前组
sec_id = group.section_id # 当前组的部门id
gro = Group.query.filter_by(name=name, section_id=sec_id).filter(Group.id != _id).first()
if gro: # 当前部门下此组名已存在
return jsonify(code=RET.DBERR, msg="组名不可重复")
group.name = name
group.charge = charge
group.charge_phone = charge_phone
# group.function = func
group.pnums = pnums
# group.secnums = secnums
db.session.commit()
return jsonify(code=RET.OK, msg="修改成功")
return jsonify(code=RET.DATAERR, msg="cate参数错误")
except Exception as e:
# 操作失败，回滚数据库
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库操作错误")
# 删除组织机构或者部门和组(需要先删除人员)
@api_power.route("/deleteOrg", methods=["POST"])
@login_required
def deleteorg():
req_dict = request.get_json()
_id = req_dict.get("id") # 待删除的，部门、机构、组、id
cate = req_dict.get("cate") # 待删除数据的类别 1政府，2部门，3组
# 校验参数完整性
if not all([_id, cate]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if cate == 1: # 删除机构
gover = Government.query.get(_id) # 当前机构对象
section = gover.sections # 当前机构下的部门对象列表
if len(section) > 0: # 有部门就需要先删除部门
return jsonify(code=RET.REQERR, msg="当前机构有部门存在，请清除后再操作")
unums = User.query.filter_by(belong_organization=gover.name, status=1).count() # 当前机构下通过审核人员
if unums > 0: # 当前部门有人，先到机构详情，进行人员的删除
return jsonify(code=RET.REQERR, msg="当前机构有人员存在，请清除后再操作")
db.session.delete(gover) # 无人无部门，删除
db.session.commit() # 提交
return jsonify(code=RET.OK, msg="删除成功")
if cate == 2: # 删除部门
section = Section.query.get(_id)
gover = section.goverment # 部门所属的机构
group = section.groups # 当前部门的组对象list
if len(group) > 0: # 如果有组先删除组
return jsonify(code=RET.REQERR, msg="当前部门有组存在，请清除后再操作")
unums = User.query.filter_by(belong_organization=gover.name,
belong_department=section.name,
status=1).count() # # 已经通过审核的人数
if unums > 0: # 当前部门有人，先到部门详情，进行部门人员的删除
return jsonify(code=RET.REQERR, msg="当前部门有人员存在，请清除后再操作")
gover.sections.remove(section) # 当前部门没有人，没有组，删除部门之前需要先删除与之相关的机构关系
db.session.delete(section) # 删除
db.session.commit() # 提交
return jsonify(code=RET.OK, msg="删除成功")
if cate == 3: # 删除组
group = Group.query.get(_id) # 当前组信息
section = group.section # 组属于的部门，单个对象
gover = section.goverment # 部门属于的机构，单个对象
unums = User.query.filter_by(belong_organization=gover.name,
belong_department=section.name,
group=group.name,
status=1).count() # 已经通过审核的人数
if unums > 0: # 当前组有人，先到组详情，进行组员的删除
return jsonify(code=RET.REQERR, msg="当前组有人员存在，请清除后再操作")
section.groups.remove(group) # 当前组没有人，删除组之前需要先删除与之相关的部门关系
db.session.delete(group) # 删除
db.session.commit() # 提交
return jsonify(code=RET.OK, msg="删除成功")
else:
return jsonify(code=RET.DATAERR, msg="参数错误")
except Exception as e:
# 操作失败，回滚数据库
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库操作失败")
apps/manage/view_user.py
......@@ -6,13 +6,62 @@ from apps.models import *
from apps.utils.response_code import RET
from apps.util import login_required
"""局内用户"""
# 局内用户账号列表
# 局内用户新增
@api_power.route("/AddUser", methods=["POST"])
@login_required
def add_user():
req_dict = request.get_json()
real_name = req_dict.get("real_name") # 真实姓名
position = req_dict.get("position") # 职务
one_org = req_dict.get("one_org") # 机构
two_department = req_dict.get("two_department") # 部门
three_role = req_dict.get("three_role") # 角色
mobile = req_dict.get("mobile")
password = req_dict.get("password")
password1 = req_dict.get("password1")
# 校验参数完整性
if not all([real_name, position, one_org,
three_role, mobile, password, password1]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
# 判断手机号
try:
user = User.query.filter_by(mobile=mobile).first()
if user:
return jsonify(code=RET.DATAEXIST, msg="手机号已存在")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="手机号已存在")
try:
if not any([password, password1]):
return jsonify(code=RET.PARAMERR, msg="密码和确认密码都不能为空！")
if password != password1:
return jsonify(code=RET.PARAMERR, msg="两次输入的密码不一致，请确认！")
user = User(real_name=real_name, mobile=mobile, belong_organization=one_org, position=position,
flag=2, status=2, belong_department=two_department)
user.password = password
org_obj = OrganizationChart.query.filter(
# OrganizationChart.one_org == one_org,
OrganizationChart.three_role == three_role).first()
user.org_id = org_obj.id
db.session.add(user)
db.session.commit()
return jsonify(code=RET.OK, msg="添加成功")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 局内用户列表
@api_power.route("/userListOfInside", methods=["POST"])
# @login_required
@login_required
def user_list_inside():
req_dict = request.get_json()
page = req_dict.get("page")
......@@ -20,8 +69,8 @@ def user_list_inside():
key = req_dict.get("key") # 查询条件
status = req_dict.get("status") # 1通过，2在审，3驳回
unit = req_dict.get("unit") # 所在机构id
section = req_dict.get("section") # 所在部门id
one_org = req_dict.get("one_org")
two_department = req_dict.get("two_department")
# 校验参数完整性
if not all([page, perpage]):
......@@ -29,31 +78,30 @@ def user_list_inside():
try:
user = User.query.filter_by(flag=2)
if key:
# user = user.filter(User.real_name.like("%{}%".format(key)))
user = user.filter(or_(User.real_name.like("%{}%".format(key)), User.name.like("%{}%".format(key))))
if status:
user = user.filter_by(status=status)
if unit:
unit_name = Government.query.get(unit).name
user = user.filter_by(unit=unit_name)
if section:
sec_name = Section.query.get(section).name
user = user.filter_by(section=sec_name)
if one_org:
org_obj = OrganizationChart.query.filter_by(one_org=one_org).first()
if org_obj:
org_id = org_obj.id
user = user.filter_by(org_id=org_id)
if two_department:
org_obj = OrganizationChart.query.filter_by(two_department=two_department).first()
if org_obj:
org_id = org_obj.id
user = user.filter_by(org_id=org_id)
size = user.count()
result = user.paginate(page, perpage).items
df = [{"id": i.id,
"real_name": i.real_name if i.real_name else "-",
"mobile": i.mobile if i.mobile else "-",
"status": "通过" if i.status == 1 else "在审" if i.status == 2 else "驳回",
"position": i.position if i.position else "-",
"unit": i.belong_organization if i.belong_organization else "-",
"section": i.belong_department if i.belong_department else "-",
# "role": "部门负责人" if i.role_id == 1 else
# "局领导" if i.role_id == 2 else
# "办事员工" if i.role_id == 3 else "-",
"role": i.role
} for i in result]
"role": i.org.three_role if i.org.three_role else "-",
"mobile": i.mobile if i.mobile else "-",
"status": "通过" if i.status == 1 else "在审" if i.status == 2 else "驳回"} for i in result]
data = {"df": df, "size": size}
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
......@@ -61,7 +109,7 @@ def user_list_inside():
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 局内用户---用户信息展示
# 局内用户信息
@api_power.route("/userInsideInfo", methods=["POST"])
@login_required
def user_inside_info():
......@@ -70,53 +118,26 @@ def user_inside_info():
try:
i = User.query.get(_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="用户信息查询失败")
try:
data = {"id": i.id,
"real_name": i.real_name if i.real_name else "-",
"position": i.position if i.position else "-",
# "role_id": i.role_id,
# "role": "部门负责人" if i.role_id == 1 else
# "局领导" if i.role_id == 2 else
# "办事员工" if i.role_id == 3 else "-", # 角色
"role": i.role,
"unit": i.belong_organization, # 机构
"section": i.belong_department, # 部门
"mobile": i.mobile if i.mobile else "-"
"unit": i.belong_organization if i.belong_organization else "-",
"section": i.belong_department if i.belong_department else "-",
"role": i.org.three_role if i.org.three_role else "-",
"mobile": i.mobile if i.mobile else "-",
# "status": "通过" if i.status == 1 else "在审" if i.status == 2 else "驳回"
}
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 局内用户---用户账号状态编辑（通过，在审，驳回）
@api_power.route("/updateAccount", methods=["POST"])
@login_required
def update_account():
req_dict = request.get_json()
_id = req_dict.get("id")
status = req_dict.get("status") # 1通过，2在审，3驳回
# 校验参数完整性
if not all([_id, status]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
user = User.query.get(_id)
if not user.role and status == 1: # 没有角色，想通过
return jsonify(code=RET.DATAERR, msg="请先在编辑，为用户添加职级角色")
user.status = status
db.session.commit()
dict_zh = {1: "通过", 2: "在审", 3: "驳回"}
data = dict_zh[status]
return jsonify(code=RET.OK, msg="修改成功", info=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 局内用户---用户账号详情信息编辑
# 编辑用户账号详情信息
@api_power.route("/updateUser", methods=["POST"])
@login_required
def update_user():
......@@ -124,30 +145,28 @@ def update_user():
_id = req_dict.get("id") # 当亲用户id
real_name = req_dict.get("real_name") # 真名
position = req_dict.get("position") # 职务
unit = req_dict.get("unit") # 机构
section = req_dict.get("section") # 部门
# role_id = req_dict.get("role_id") # 角色id 必选
role = req_dict.get("role") # 角色 超级管理员/管理员/开发人员/工作人员
one_org = req_dict.get("one_org") # 机构
two_department = req_dict.get("two_department") # 部门
three_role = req_dict.get("three_role") # 角色
mobile = req_dict.get("mobile")
password = req_dict.get("password")
password1 = req_dict.get("password1")
# 校验参数完整性
if not all([_id, real_name, position, role, mobile]):
return jsonify(code=RET.PARAMERR, msg="请选择必填项")
# # 校验参数完整性
# if not all([_id, real_name, three_role, mobile]):
# return jsonify(code=RET.PARAMERR, msg="姓名、角色、手机号必填！")
try:
# role_obj = Role.query.get(role_id)
org_obj = OrganizationChart.query.filter_by(
three_role=three_role).first()
if not org_obj:
return jsonify(code=RET.NODATA, msg="选择的角色不存在！")
user = User.query.get(_id)
if position:
user.org_id = org_obj.id
user.position = position
if unit:
user.unit = Government.query.get(unit).name
if section:
user.section = Section.query.get(section).name
if mobile:
user.belong_organization = one_org
user.two_department = two_department
user.mobile = mobile
if real_name:
user.real_name = real_name
if password and not password1:
return jsonify(code=RET.PARAMERR, msg="请填写确认密码！")
......@@ -157,8 +176,6 @@ def update_user():
if password != password1:
return jsonify(code=RET.PARAMERR, msg="密码和确认密码不一致！")
user.password = password
# role_obj.users.append(user)
db.session.commit()
return jsonify(code=RET.OK, msg="修改成功")
except Exception as e:
......@@ -166,63 +183,52 @@ def update_user():
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 局内用户新增
@api_power.route("/addUser", methods=["POST"])
# @login_required
def add_user():
# 账号状态编辑（通过，在审，驳回）
@api_power.route("/updateAccount", methods=["POST"])
@login_required
def update_account():
req_dict = request.get_json()
real_name = req_dict.get("real_name") # 真实姓名
position = req_dict.get("position") # 职务
unit = req_dict.get("unit") # 机构id
section = req_dict.get("section") # 部门id
level = req_dict.get("level") # 角色
mobile = req_dict.get("mobile") # 手机号
password = req_dict.get("password") # 密码
password1 = req_dict.get("password1") # 确认密码
_id = req_dict.get("id")
status = req_dict.get("status") # 1通过，2在审，3驳回
# 校验参数完整性
if not all([real_name, position, unit, mobile, password]):
if not all([_id, status]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
# 用户名唯一(字母开头，长度4-15)
# try:
# patten = "^[a-zA-Z][\w]*[\w]*$"
# if re.match(patten, name) and re.match(patten, name).string == name:
# user = User.query.filter_by(name=name).first()
# if user:
# return jsonify(code=RET.DATAEXIST, msg="用户名已存在")
# else:
# return jsonify(code=RET.DATAERR, msg="用户名格式错误,请填入以字母开头的数字和字母组合")
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="用户名格式错误")
# 判断手机号
try:
user = User.query.filter_by(mobile=mobile).first()
if user:
return jsonify(code=RET.DATAEXIST, msg="手机号已存在")
user = User.query.get(_id)
# if not user.role and status == 1: # 没有角色，想通过
# return jsonify(code=RET.DATAERR, msg="请先在编辑，为用户添加职级角色")
user.status = status
db.session.commit()
dict_zh = {1: "通过", 2: "在审", 3: "驳回"}
data = dict_zh[status]
return jsonify(code=RET.OK, msg="修改成功", info=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="手机号已存在")
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 删除用户(批量删除，单个删除)
@api_power.route("/deleteUser", methods=["POST"])
@login_required
def delete_user():
req_dict = request.get_json()
id_list = req_dict.get("id_list") # list[1,2,3]
# 校验参数完整性
if not all([id_list]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
role = Role.query.get(level)
govername = Government.query.get(unit) # 获取机构name
user = User(real_name=real_name, mobile=mobile, unit=govername.name, position=position,
flag=2, status=1, level=role.role_name)
user.password = password
if section: # 部门id
secname = Section.query.get(section).name # 获取部门名
user.section = secname
db.session.add(user)
role.users.append(user)
for i in id_list:
user = User.query.get(i)
db.session.delete(user)
db.session.commit()
return jsonify(code=RET.OK, msg="添加成功")
return jsonify(code=RET.OK, msg="删除成功")
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
return jsonify(code=RET.DBERR, msg="删除失败")
"""外部访客"""
......@@ -235,7 +241,6 @@ def user_list_external():
req_dict = request.get_json()
page = req_dict.get("page")
perpage = req_dict.get("perpage")
# key = req_dict.get("key") # 查询条件
# 校验参数完整性
if not all([page, perpage]):
......@@ -248,6 +253,7 @@ def user_list_external():
"real_name": i.real_name if i.real_name else "-",
"mobile": i.mobile if i.mobile else "-",
"create_time": str(i.create_time) if i.create_time else "-",
"status": i.status # 0禁止，1启动
} for i in result]
data = {"df": df, "size": size}
return jsonify(code=RET.OK, msg="查询成功", data=data)
......@@ -281,35 +287,6 @@ def update_status():
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库操作错误")
# # 局内用户筛选条件
# @api_power.route("/manage/fields", methods=["GET"])
# def manage_field():
......
apps/models.py
......@@ -920,7 +920,6 @@ class User(BaseModel, db.Model):
# 基本信息
id = db.Column(db.Integer, primary_key=True, autoincrement=True, comment='用户编号')
name = db.Column(db.String(32), unique=True, comment='用户名')
role_id = db.Column(db.Integer, comment='角色id ')
password_hash = db.Column(db.String(128), comment='加密的密码')
real_name = db.Column(db.String(32), comment='姓名')
mobile = db.Column(db.String(11), unique=True, comment='手机号')
......@@ -938,6 +937,10 @@ class User(BaseModel, db.Model):
# 角色(职级配置)
# role_id = db.Column(db.Integer, db.ForeignKey("role.id"), comment='角色id')
# role = db.relationship("Role", backref=db.backref("users"))
org_id = db.Column(db.Integer, db.ForeignKey("organization_chart.id"))
org = db.relationship("OrganizationChart", backref=db.backref("users"))
# 用户关注行业（图谱）
industry = db.relationship("Industry", secondary="user_industry", backref=db.backref('bindustry'))
# 用户关注太原企业
......@@ -1089,18 +1092,30 @@ class Section(db.Model):
# 政府组（政府1-N部门1-N组）
# class Group(db.Model):
# __tablename__ = "group"
# # 基本信息
# id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# pnums = db.Column(db.Integer) # 人数
# charge = db.Column(db.String(255)) # 组负责人
# charge_phone = db.Column(db.String(255)) # 负责人电话
# function = db.Column(db.Text) # 部门职能
# name = db.Column(db.String(255), nullable=False) # 政府机构部门下组的名称
# # sid = db.Column(db.Integer) # 部门id
# section_id = db.Column(db.Integer, db.ForeignKey("section.id"))
# section = db.relationship('Section', backref=db.backref('groups')) # 部门1-N组
class Group(db.Model):
__tablename__ = "group"
# 基本信息
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
pnums = db.Column(db.Integer) # 人数
charge = db.Column(db.String(255)) # 组负责人
charge_phone = db.Column(db.String(255)) # 负责人电话
function = db.Column(db.Text) # 部门职能
name = db.Column(db.String(255), nullable=False) # 政府机构部门下组的名称
# sid = db.Column(db.Integer) # 部门id
section_id = db.Column(db.Integer, db.ForeignKey("section.id"))
section = db.relationship('Section', backref=db.backref('groups')) # 部门1-N组
# 组织结构
class OrganizationChart(db.Model):
__tablename__ = "organization_chart"
__table_args__ = ({'comment': '后台管理系统---组织结构表'}) # 添加表注释
id = db.Column(db.Integer, primary_key=True, autoincrement=True, comment='主键id')
one_org = db.Column(db.String(30), comment='一级组织机构')
two_department = db.Column(db.String(30), comment='二级部门')
three_role = db.Column(db.String(30), comment='三级角色')
page_permission_id = db.Column(db.String(255), comment='页面权限id列表')
fun_permission_id = db.Column(db.String(255), comment='功能权限id列表')
"""招商资源管理"""
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment