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 flask import request, jsonify, current_app from apps.manage import api_power
# from apps.manage import api_power from apps.models import *
# from apps.models import * from apps.util import login_required, verify_btoken
# from apps.util import login_required, verify_btoken from apps.utils.response_code import RET
# from apps.utils.response_code import RET
#
# # 获取角色列表
# # 新增角色 @api_power.route("/GetFixedRole", methods=["GET"])
# @api_power.route("/addRole", methods=["POST"]) @login_required
# @login_required def get_fixed_role():
# def add_role(): try:
# token = request.headers["token"] chart_obj_list = OrganizationChart.query.all()
# user = verify_btoken(token) data = [{
# user_role = user.role # 用户角色 "id": chart_obj.id,
# if user_role != 1: # "one_org": chart_obj.one_org,
# return jsonify(code=RET.ROLEERR, msg="暂无权限") # "two_department": chart_obj.two_department,
# req_dict = request.get_json() "three_role": chart_obj.three_role,
# role_name = req_dict.get("role_name") # 职位名称（角色） } for chart_obj in chart_obj_list]
# rolev = req_dict.get("rolev") # 权值 0层级123， 1调度，2审核，3删除，4审核/上报，5新增/编辑 ,300001" return jsonify(code=RET.OK, data=data, msg="查询成功！")
# info = req_dict.get("info") # 职位功能（角色）
# except Exception as e:
# # 校验参数完整性 current_app.logger.error(e)
# if not all([role_name, rolev, info]): return jsonify(code=RET.DBERR, msg="数据库查询错误")
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
#
# try: # 获取角色权限详情
# role = Role.query.filter_by(role_name=role_name).first() @api_power.route("/GetFixedRoleDetail", methods=["POST"])
# if role: @login_required
# return jsonify(code=RET.DATAEXIST, msg="角色名已存在") def get_fixed_role_detail():
# role = Role.query.filter_by(role=rolev).first() req_dic = request.get_json()
# if role: role_id = req_dic['role_id']
# return jsonify(code=RET.DATAEXIST, msg="权限配置已存在,角色：{}".format(role.role_name))
# try:
# role = Role(role_name=role_name, role=rolev, info=info) chart_obj = OrganizationChart.query.get(role_id)
# db.session.add(role) print(chart_obj)
# db.session.commit() data = {
# return jsonify(code=RET.OK, msg="添加成功") "three_role": chart_obj.three_role,
# except Exception as e: "page_permission_id": eval(chart_obj.page_permission_id),
# current_app.logger.error(e) "fun_permission_id": eval(chart_obj.fun_permission_id)}
# return jsonify(code=RET.DBERR, msg="数据库查询错误") 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("/roles", methods=["GET"])
# @login_required
# def roles(): # 新增/修改角色并且赋予权限
# try: @api_power.route("/AddEditRole", methods=["POST"])
# roles = Role.query.all() @login_required
# data = [{"id": role.id, def add_edit_role():
# "name": role.role_name, # token = request.headers["token"]
# "rolev": role.role, # user = verify_btoken(token)
# "info": role.info} for role in roles] # user_role = user.role # 用户角色
# # if user_role != 1:
# return jsonify(code=RET.OK, msg="查询成功", data=data) # return jsonify(code=RET.ROLEERR, msg="暂无权限，请联系管理员")
# except Exception as e:
# current_app.logger.error(e) req_dict = request.get_json()
# return jsonify(code=RET.DBERR, msg="数据库查询错误") 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")
# @api_power.route("/getRole", methods=["POST"]) fun_id_list = req_dict.get("fun_id_list")
# @login_required
# def roleinfo(): # 校验参数完整性
# req_dict = request.get_json() if not all([role_name, page_id_list, fun_id_list]):
# _id = req_dict.get("id") # 角色id return jsonify(code=RET.PARAMERR, msg="参数不完整, 权限勾选不能为空！")
# # 校验参数完整性
# if not all([_id]): try:
# return jsonify(code=RET.PARAMERR, msg="参数不完整") if flag == 1: # 新增
# try: role_obj = OrganizationChart.query.filter_by(three_role=role_name).first()
# role = Role.query.get(_id) if role_obj:
# data = {"id": role.id, return jsonify(code=RET.DATAEXIST, msg="角色名已存在！")
# "name": role.role_name, else:
# "rolev": role.role, role_obj = OrganizationChart(three_role=role_name, page_permission_id=str(page_id_list),
# "info": role.info} fun_permission_id=str(fun_id_list)
# )
# return jsonify(code=RET.OK, msg="查询成功", data=data) db.session.add(role_obj)
# except Exception as e: db.session.commit()
# current_app.logger.error(e) return jsonify(code=RET.OK, msg="添加成功")
# return jsonify(code=RET.DBERR, msg="数据库查询错误") elif flag == 2: # 编辑修改
# role_obj = OrganizationChart.query.get(role_id)
# # role_obj.one_org = org_name
# # 角色编辑 # role_obj.two_department = department_name
# @api_power.route("/updateRole", methods=["POST"]) role_obj.three_role = role_name
# @login_required role_obj.page_permission_id = str(page_id_list)
# def update_role(): role_obj.fun_permission_id = str(fun_id_list)
# token = request.headers["token"] db.session.commit()
# user = verify_btoken(token) return jsonify(code=RET.OK, msg="修改成功")
# user_role = user.role # 用户角色 else:
# if user_role != 1: return jsonify(code=RET.OK, msg="参数错误")
# return jsonify(code=RET.ROLEERR, msg="暂无权限") except Exception as e:
# current_app.logger.error(e)
# req_dict = request.get_json() db.session.rollback()
# _id = req_dict.get("id") # 角色id return jsonify(code=RET.DBERR, msg="数据库查询错误")
# role_name = req_dict.get("role_name") # 职位名称（角色）
# rolev = req_dict.get("rolev") # 权值 1调度，2审核，3删除，4审核/上报，5新增/编辑 "00001"
# info = req_dict.get("info") # 职位功能（角色） # 删除角色
# @api_power.route("/deleteRole", methods=["POST"])
# # 校验参数完整性 @login_required
# if not all([_id, role_name, rolev, info]): def delete_role():
# return jsonify(code=RET.PARAMERR, msg="参数不完整") # token = request.headers["token"]
# # user = verify_btoken(token)
# try: # user_role = user.role # 用户角色
# me = Role.query.get(_id) # if user_role != 1:
# if me.role_name != role_name: # return jsonify(code=RET.ROLEERR, msg="暂无权限，请联系管理员")
# role = Role.query.filter_by(role_name=role_name).first() req_dict = request.get_json()
# if role: _id = req_dict.get("id") # 角色id
# return jsonify(code=RET.DATAEXIST, msg="角色名已存在")
# if me.role != rolev: # 校验参数完整性
# role = Role.query.filter_by(role=rolev).first() if not all([_id]):
# if role: return jsonify(code=RET.PARAMERR, msg="参数不完整")
# return jsonify(code=RET.DATAEXIST, msg="权限配置已存在,角色：{}".format(role.role_name))
# me.role_name = role_name try:
# me.role = rolev user_obj = User.query.filter_by(org_id=_id).all()
# me.info = info if len(user_obj):
# db.session.commit() return jsonify(code=RET.DATAEXIST, msg="当前角色存在用户使用,请查证并清除后再操作")
# return jsonify(code=RET.OK, msg="添加成功") org_obj = OrganizationChart.query.get(_id)
# except Exception as e: db.session.delete(org_obj)
# current_app.logger.error(e) db.session.commit()
# return jsonify(code=RET.DBERR, msg="数据库查询错误") return jsonify(code=RET.OK, msg="删除成功")
# except Exception as e:
# current_app.logger.error(e)
# # 删除角色 db.session.rollback()
# @api_power.route("/deleteRole", methods=["POST"]) return jsonify(code=RET.DBERR, msg="删除出错！")
# @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="数据库操作错误")
apps/manage/view_org.py
# import time import time
# from datetime import datetime from datetime import datetime
#
# from flask import request, jsonify, current_app, g from flask import request, jsonify, current_app, g
# from apps.manage import api_power from apps.manage import api_power
# from apps.models import * from apps.models import *
# from apps.utils.response_code import RET from apps.utils.response_code import RET
# from apps.util import login_required, verify_token from apps.util import login_required, verify_token
#
#
# # 新增机构组织 # 获取首页机构列表
# @api_power.route("/AddOrg", methods=["POST"]) @api_power.route("/organization", methods=["POST"])
# @login_required @login_required
# def add_org(): def organization():
# ''' req_dict = request.get_json()
# 不得重名 page = req_dict.get("page")
# ''' perpage = req_dict.get("perpage")
# token = request.headers["token"] # 校验参数完整性
# user = verify_token(token) if not all([page, perpage]):
# user_id = user.id return jsonify(code=RET.PARAMERR, msg="参数不完整")
# user_name = User.query.get(id=user_id).name try:
# req_dict = request.get_json() goverment = Government.query.all()
# org_name = req_dict.get("name") # 机构名称 size = Government.query.count()
# # forg = req_dict.get("forg") # 上级机构 id df = [{"id": gover.id, # id
# charge = req_dict.get("charge") # 机构负责人 "name": gover.name, # 机构
# charge_phone = req_dict.get("charge_phone") # 负责人电话 "pnums": gover.pnums if gover.pnums else 0, # 人数
# # sublist = req_dict.get("sublist") # 统筹机构id list["1","2"...] "charge": gover.charge if gover.charge else "-", # 负责人
# "charge_phone": gover.charge_phone if gover.charge_phone else "-", # 负责人电话
# # 校验参数完整性 "cate": 1} for gover in goverment]
# if not all([org_name]): data = {"df": df, "size": size}
# return jsonify(code=RET.PARAMERR, msg="参数不完整") return jsonify(code=RET.OK, msg="查找成功", data=data)
# try: except Exception as e:
# gover = GovOrganization.query.filter_by(name=org_name).first() current_app.logger.error(e)
# if gover: # 机构名相同，提示其错误 return jsonify(code=RET.DBERR, msg="数据库查询错误", data=[])
# return jsonify(code=RET.DBERR, msg="机构名重复")
#
# goverment = GovOrganization(name=org_name) # 创建机构 # 新增机构组织
# if charge: @api_power.route("/AddOrg", methods=["POST"])
# goverment.charge = charge @login_required
# if charge_phone: def add_org():
# goverment.charge_phone = charge_phone '''
# if user_name: 不得重名
# goverment.add_person = user_name '''
# add_time = datetime.now() # token = request.headers["token"]
# goverment.add_time = add_time # user = verify_token(token)
# db.session.add(goverment) # 添加到数据库 # user_id = user.id
# # user_name = User.query.get(id=user_id).name
# # if forg: # 如果有上级机构，就让上级机构统筹新增机构 req_dict = request.get_json()
# # fgover = Government.query.get(forg) org_name = req_dict.get("name") # 机构名称
# # fgover.followed.append(goverment) pnums = req_dict.get("pnums") # 人数
# # for ctr in sublist: # 如果有统筹机构，就让新增机构统筹 charge = req_dict.get("charge") # 机构负责人
# # sgover = Government.query.get(ctr) charge_phone = req_dict.get("charge_phone") # 负责人电话
# # goverment.followed.append(sgover)
# db.session.commit() # 提交数据库 # 校验参数完整性
# return jsonify(code=RET.OK, msg="添加成功") if not all([org_name]):
# except Exception as e: return jsonify(code=RET.PARAMERR, msg="参数不完整")
# # 操作失败，回滚数据库 try:
# db.session.rollback() gover = Government.query.filter_by(name=org_name).first()
# current_app.logger.error(e) if gover: # 机构名相同，提示其错误
# return jsonify(code=RET.DBERR, msg="数据库操作错误") return jsonify(code=RET.DBERR, msg="机构名重复")
#
# goverment = Government(name=org_name) # 创建机构
# # 查询添加过的机构信息 if charge:
# @api_power.route("/GetOrg", methods=["GET"]) goverment.charge = charge
# @login_required if charge_phone:
# def get_org(): goverment.charge_phone = charge_phone
# try: if pnums:
# org = GovOrganization.query.all() goverment.pnums = pnums
# data = [{"id": i.id, "name": i.name, "pnums": i.pnums, # if user_name:
# "charge": i.charge, "charge_phone": i.charge_phone, # goverment.add_person = user_name
# "add_person": i.add_person, "add_time": i.add_time, # add_time = datetime.now()
# "edit_person": i.edit_person, "edit_time": i.edit_time} # goverment.add_time = add_time
# for i in org] db.session.add(goverment) # 添加到数据库
# return jsonify(code=RET.OK, msg="查询成功", data=data) db.session.commit() # 提交数据库
# except Exception as e: return jsonify(code=RET.OK, msg="添加成功")
# current_app.logger.error(e) except Exception as e:
# return jsonify(code=RET.DBERR, msg="数据库查询错误") # 操作失败，回滚数据库
# db.session.rollback()
# current_app.logger.error(e)
# # 新增下级部门(ok) return jsonify(code=RET.DBERR, msg="数据库操作错误")
# @api_power.route("/AddSubDepartment", methods=["POST"])
# @login_required
# def add_sub_department(): # 新增部门或组
# token = request.headers["token"] @api_power.route("/addSub", methods=["POST"])
# user = verify_token(token) @login_required
# user_id = user.id def add_sub():
# user_name = User.query.get(id=user_id).name req_dict = request.get_json()
# req_dict = request.get_json() _id = req_dict.get("id") # 当前机构或者部门id
# id = req_dict.get("id") # 当前机构或者部门id cate = req_dict.get("cate") # 分类标识，1机构，2部门
# # cate = req_dict.get("cate") # 分类标识，1机构，2部门 name = req_dict.get("name") # 部门或组名称
# name = req_dict.get("name") # 部门或组名称 pnums = req_dict.get("pnums") # 人数
# # pnums = req_dict.get("pnums") # 人数 charge = req_dict.get("charge") # 机构负责人
# charge = req_dict.get("charge") # 机构负责人 charge_phone = req_dict.get("charge_phone") # 负责人电话
# charge_phone = req_dict.get("charge_phone") # 负责人电话
# # 校验参数完整性
# # 校验参数完整性 if not all([_id, name]):
# # if not all([_id, cate, name]): return jsonify(code=RET.PARAMERR, msg="参数不完整")
# # return jsonify(code=RET.PARAMERR, msg="参数不完整")
# if not all([id, name]): try:
# return jsonify(code=RET.PARAMERR, msg="参数不完整") if cate == 1: # 增加部门
# sec = Section.query.filter_by(name=name, goverment_id=_id).first()
# try: if sec: # 一个机构下部门名不能重复
# # if cate == 1: # 增加部门 return jsonify(code=RET.DATAERR, msg="部门名重复")
# sec = GovDepartment.query.filter_by(name=name, goverment_org_id=id).first() goverment = Government.query.get(_id)
# if sec: # 一个机构下部门名不能重复 section = Section(name=name, goverment_id=_id)
# return jsonify(code=RET.DATAERR, msg="部门名重复") if pnums:
# gov_organization = GovOrganization.query.get(id) section.pnums = pnums
# gov_department = GovDepartment(name=name, goverment_org_id=id) if charge:
# # if pnums: section.charge = charge
# # gov_department.pnums = pnums if charge_phone:
# if charge: section.charge_phone = charge_phone
# gov_department.charge = charge db.session.add(section) # 添加部门
# if charge_phone: goverment.sections.append(section) # 外键关系添加
# gov_department.charge_phone = charge_phone db.session.commit() # 数据库提交
# if user_name: if cate == 2: # 增加组
# gov_department.add_person = user_name gro = Group.query.filter_by(name=name, section_id=_id).first()
# add_time = datetime.now() if gro: # 一个部门下组名不能重复
# gov_department.add_time = add_time return jsonify(code=RET.DATAERR, msg="组名重复")
# db.session.add(gov_department) # 添加部门 section = Section.query.get(_id)
# gov_organization.government_departments.append(gov_department) # 外键关系添加 group = Group(name=name, section_id=_id)
# db.session.commit() # 数据库提交 if pnums:
# # if cate == 2: # 增加组 group.pnums = pnums
# # gro = Group.query.filter_by(name=name, gov_department_id=_id).first() if charge:
# # if gro: # 一个部门下组名不能重复 group.charge = charge
# # return jsonify(code=RET.DATAERR, msg="组名重复") if charge_phone:
# # gov_department = Section.query.get(_id) group.charge_phone = charge_phone
# # group = Group(name=name, section_id=_id) db.session.add(group) # 添加组
# # if pnums: section.groups.append(group) # 添加关系
# # group.pnums = pnums db.session.commit() # 提交
# # if charge: # if cate == 3:
# # group.charge = charge # return jsonify(code=RET.OK, msg="暂无下级机构，请勿继续添加")
# # if charge_phone: return jsonify(code=RET.OK, msg="添加成功")
# # group.charge_phone = charge_phone except Exception as e:
# # db.session.add(group) # 添加组 # 操作失败，数据回滚
# # section.groups.append(group) # 添加关系 db.session.rollback()
# # db.session.commit() # 提交 current_app.logger.error(e)
# # if cate == 3: return jsonify(code=RET.DBERR, msg="数据库操作错误")
# # return jsonify(code=RET.OK, msg="暂无下级机构，请勿继续添加")
# return jsonify(code=RET.OK, msg="添加成功")
# except Exception as e: # 获取部门和组
# # 操作失败，数据回滚 @api_power.route("/sectionGroup", methods=["POST"])
# db.session.rollback() @login_required
# current_app.logger.error(e) def section_group():
# return jsonify(code=RET.DBERR, msg="数据库操作错误") req_dict = request.get_json()
# _id = req_dict.get("id") # 当前机构或者部门的id
# cate = req_dict.get("cate") # 分类标识，1机构，2部门
#
# # 校验参数完整性
# # 获取上级或下级统筹机构 (ok) if not all([_id, cate]):
# @api_power.route("/uadOrg", methods=["GET"]) return jsonify(code=RET.PARAMERR, msg="参数不完整")
# @login_required
# def uad_org(): try:
# try: if cate == 1: # 查询当前机构下的部门
# gover = Government.query.all() goverment = Government.query.get(_id)
# data = [{"label": i.name, "value": i.id} for i in gover] sections = goverment.sections # 查询当前机构下的部门list
# return jsonify(code=RET.OK, msg="查询成功", data=data) data = [{"id": sec.id,
# except Exception as e: "name": sec.name,
# current_app.logger.error(e) "pnums": sec.pnums if sec.pnums else 0,
# return jsonify(code=RET.DBERR, msg="数据库查询错误") "charge": sec.charge if sec.charge else "-",
# "charge_phone": sec.charge_phone if sec.charge_phone else "-",
# "cate": 2} for sec in sections]
# # 获取上级机构后的统筹机构 (ok) return jsonify(code=RET.OK, msg="查找成功", data=data)
# @api_power.route("/downOrg", methods=["POST"]) if cate == 2: # 查询当前部门下的组
# @login_required section = Section.query.get(_id)
# def down_org(): groups = section.groups # 查询当前部门下的组list
# req_dict = request.get_json() data = [{"id": group.id,
# _id = req_dict.get("id") # 机构名称 "name": group.name,
# try: "pnums": group.pnums if group.pnums else 0,
# if _id: "charge": group.charge if group.charge else "-",
# gover = Government.query.all() "charge_phone": group.charge_phone if group.charge_phone else "-",
# data = [{"label": i.name, "value": i.id} for i in gover if i.id != _id] "cate": 3} for group in groups]
# return jsonify(code=RET.OK, msg="查询成功", data=data) return jsonify(code=RET.OK, msg="查找成功", data=data)
# else: return jsonify(code=RET.OK, msg="暂无下级信息", data=[])
# gover = Government.query.all() except Exception as e:
# data = [{"label": i.name, "value": i.id} for i in gover] current_app.logger.error(e)
# return jsonify(code=RET.OK, msg="查询成功", data=data) return jsonify(code=RET.DBERR, msg="数据库查询错误", data=[])
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库查询错误") # 编辑机构，部门或者组详情
# @api_power.route("/editDetail", methods=["POST"])
# @login_required
# # 组织架构管理,获取机构单位数据（ok） def edit_detail():
# @api_power.route("/organization", methods=["POST"]) req_dict = request.get_json()
# @login_required _id = req_dict.get("id") # 部门id
# def organization(): cate = req_dict.get("cate") # 1机构，2部门，3组
# req_dict = request.get_json() name = req_dict.get("name") # 1机构，2部门，3组 的名称
# page = req_dict.get("page") charge = req_dict.get("charge") # 局内领导
# perpage = req_dict.get("perpage") charge_phone = req_dict.get("charge_phone") # 联系方式
# # 校验参数完整性 pnums = str(req_dict.get("pnums")) # 人数
# if not all([page, perpage]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整") # 校验参数完整性
# try: # # if not all([_id, name, charge, charge_phone, pnums, secnums]):
# # goverment = Government.query.paginate(page, perpage).items # return jsonify(code=RET.PARAMERR, msg="参数不完整")
# goverment = Government.query.all()
# size = Government.query.count() try:
# df = [{"id": gover.id, if cate == 1: # 机构
# "name": gover.name, gover = Government.query.filter_by(name=name).filter(Government.id != _id).first()
# "pnums": gover.pnums if gover.pnums else 0, if gover:
# "charge": gover.charge if gover.charge else "-", return jsonify(code=RET.DBERR, msg="机构名不可重复")
# "charge_phone": gover.charge_phone if gover.charge_phone else "-", gover = Government.query.get(_id)
# "cate": 1} for gover in goverment] gover.name = name
# data = {"df": df, "size": size} gover.charge = charge
# return jsonify(code=RET.OK, msg="查找成功", data=data) gover.charge_phone = charge_phone
# except Exception as e: gover.pnums = pnums
# current_app.logger.error(e) db.session.commit()
# return jsonify(code=RET.DBERR, msg="数据库查询错误", data=[]) return jsonify(code=RET.OK, msg="修改成功")
# if cate == 2: # 部门
# section = Section.query.get(_id) # 当前部门
# # 组织架构获取部门和组（Ok） gover_id = section.goverment_id # 当前部门的机构id
# @api_power.route("/sectionGroup", methods=["POST"]) sec = Section.query.filter_by(name=name, goverment_id=gover_id).filter(Section.id != _id).first()
# @login_required if sec: # 当前机构下此部门名已存在
# def section_group(): return jsonify(code=RET.DBERR, msg="部门名不可重复")
# req_dict = request.get_json() section.name = name
# _id = req_dict.get("id") # 当前机构或者部门的id section.charge = charge
# cate = req_dict.get("cate") # 分类标识，1机构，2部门 section.charge_phone = charge_phone
# section.pnums = pnums
# # 校验参数完整性 db.session.commit()
# if not all([_id, cate]): return jsonify(code=RET.OK, msg="修改成功")
# return jsonify(code=RET.PARAMERR, msg="参数不完整") if cate == 3: # 组
# group = Group.query.get(_id) # 当前组
# try: sec_id = group.section_id # 当前组的部门id
# if cate == 1: # 查询当前机构下的部门 gro = Group.query.filter_by(name=name, section_id=sec_id).filter(Group.id != _id).first()
# goverment = Government.query.get(_id) if gro: # 当前部门下此组名已存在
# sections = goverment.sections # 查询当前机构下的部门list return jsonify(code=RET.DBERR, msg="组名不可重复")
# data = [{"id": sec.id, group.name = name
# "name": sec.name, group.charge = charge
# "pnums": sec.pnums if sec.pnums else 0, group.charge_phone = charge_phone
# "charge": sec.charge if sec.charge else "-", # group.function = func
# "charge_phone": sec.charge_phone if sec.charge_phone else "-", group.pnums = pnums
# "cate": 2} for sec in sections] # group.secnums = secnums
# return jsonify(code=RET.OK, msg="查找成功", data=data) db.session.commit()
# if cate == 2: # 查询当前部门下的组 return jsonify(code=RET.OK, msg="修改成功")
# section = Section.query.get(_id) return jsonify(code=RET.DATAERR, msg="cate参数错误")
# groups = section.groups # 查询当前部门下的组list except Exception as e:
# data = [{"id": group.id, # 操作失败，回滚数据库
# "name": group.name, db.session.rollback()
# "pnums": group.pnums if group.pnums else 0, current_app.logger.error(e)
# "charge": group.charge if group.charge else "-", return jsonify(code=RET.DBERR, msg="数据库操作错误")
# "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=[]) @api_power.route("/deleteOrg", methods=["POST"])
# except Exception as e: @login_required
# current_app.logger.error(e) def deleteorg():
# return jsonify(code=RET.DBERR, msg="数据库查询错误", data=[]) req_dict = request.get_json()
# _id = req_dict.get("id") # 待删除的，部门、机构、组、id
# cate = req_dict.get("cate") # 待删除数据的类别 1政府，2部门，3组
# # 删除组织机构或者部门和组(需要先删除人员)--------OK
# @api_power.route("/deleteOrg", methods=["POST"]) # 校验参数完整性
# @login_required if not all([_id, cate]):
# def deleteorg(): return jsonify(code=RET.PARAMERR, msg="参数不完整")
# req_dict = request.get_json()
# _id = req_dict.get("id") # 待删除的，部门、机构、组、id try:
# cate = req_dict.get("cate") # 待删除数据的类别 1政府，2部门，3组 if cate == 1: # 删除机构
# gover = Government.query.get(_id) # 当前机构对象
# # 校验参数完整性 section = gover.sections # 当前机构下的部门对象列表
# if not all([_id, cate]): if len(section) > 0: # 有部门就需要先删除部门
# return jsonify(code=RET.PARAMERR, msg="参数不完整") return jsonify(code=RET.REQERR, msg="当前机构有部门存在，请清除后再操作")
# unums = User.query.filter_by(belong_organization=gover.name, status=1).count() # 当前机构下通过审核人员
# try: if unums > 0: # 当前部门有人，先到机构详情，进行人员的删除
# if cate == 1: # 删除机构 return jsonify(code=RET.REQERR, msg="当前机构有人员存在，请清除后再操作")
# gover = Government.query.get(_id) # 当前机构对象 db.session.delete(gover) # 无人无部门，删除
# section = gover.sections # 当前机构下的部门对象列表 db.session.commit() # 提交
# if len(section) > 0: # 有部门就需要先删除部门 return jsonify(code=RET.OK, msg="删除成功")
# return jsonify(code=RET.REQERR, msg="当前机构有部门存在，请清除后再操作") if cate == 2: # 删除部门
# unums = User.query.filter_by(unit=gover.name, status=1).count() # 当前机构下通过审核人员 section = Section.query.get(_id)
# if unums > 0: # 当前部门有人，先到机构详情，进行人员的删除 gover = section.goverment # 部门所属的机构
# return jsonify(code=RET.REQERR, msg="当前机构有人员存在，请清除后再操作") group = section.groups # 当前部门的组对象list
# db.session.delete(gover) # 无人无部门，删除 if len(group) > 0: # 如果有组先删除组
# db.session.commit() # 提交 return jsonify(code=RET.REQERR, msg="当前部门有组存在，请清除后再操作")
# return jsonify(code=RET.OK, msg="删除成功") unums = User.query.filter_by(belong_organization=gover.name,
# if cate == 2: # 删除部门 belong_department=section.name,
# section = Section.query.get(_id) status=1).count() # # 已经通过审核的人数
# gover = section.goverment # 部门所属的机构 if unums > 0: # 当前部门有人，先到部门详情，进行部门人员的删除
# group = section.groups # 当前部门的组对象list return jsonify(code=RET.REQERR, msg="当前部门有人员存在，请清除后再操作")
# if len(group) > 0: # 如果有组先删除组 gover.sections.remove(section) # 当前部门没有人，没有组，删除部门之前需要先删除与之相关的机构关系
# return jsonify(code=RET.REQERR, msg="当前部门有组存在，请清除后再操作") db.session.delete(section) # 删除
# unums = User.query.filter_by(unit=gover.name, section=section.name, status=1).count() # # 已经通过审核的人数 db.session.commit() # 提交
# if unums > 0: # 当前部门有人，先到部门详情，进行部门人员的删除 return jsonify(code=RET.OK, msg="删除成功")
# return jsonify(code=RET.REQERR, msg="当前部门有人员存在，请清除后再操作") if cate == 3: # 删除组
# gover.sections.remove(section) # 当前部门没有人，没有组，删除部门之前需要先删除与之相关的机构关系 group = Group.query.get(_id) # 当前组信息
# db.session.delete(section) # 删除 section = group.section # 组属于的部门，单个对象
# db.session.commit() # 提交 gover = section.goverment # 部门属于的机构，单个对象
# return jsonify(code=RET.OK, msg="删除成功") unums = User.query.filter_by(belong_organization=gover.name,
# if cate == 3: # 删除组 belong_department=section.name,
# group = Group.query.get(_id) # 当前组信息 group=group.name,
# section = group.section # 组属于的部门，单个对象 status=1).count() # 已经通过审核的人数
# gover = section.goverment # 部门属于的机构，单个对象 if unums > 0: # 当前组有人，先到组详情，进行组员的删除
# unums = User.query.filter_by(unit=gover.name, section=section.name, group=group.name, return jsonify(code=RET.REQERR, msg="当前组有人员存在，请清除后再操作")
# status=1).count() # 已经通过审核的人数 section.groups.remove(group) # 当前组没有人，删除组之前需要先删除与之相关的部门关系
# if unums > 0: # 当前组有人，先到组详情，进行组员的删除 db.session.delete(group) # 删除
# return jsonify(code=RET.REQERR, msg="当前组有人员存在，请清除后再操作") db.session.commit() # 提交
# section.groups.remove(group) # 当前组没有人，删除组之前需要先删除与之相关的部门关系 return jsonify(code=RET.OK, msg="删除成功")
# db.session.delete(group) # 删除 else:
# db.session.commit() # 提交 return jsonify(code=RET.DATAERR, msg="参数错误")
# return jsonify(code=RET.OK, msg="删除成功") except Exception as e:
# else: # 操作失败，回滚数据库
# return jsonify(code=RET.DATAERR, msg="参数错误") db.session.rollback()
# except Exception as e: current_app.logger.error(e)
# # 操作失败，回滚数据库 return jsonify(code=RET.DBERR, msg="数据库操作失败")
# 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="数据库操作失败")
apps/manage/view_user.py
...@@ -6,13 +6,62 @@ from apps.models import * ...@@ -6,13 +6,62 @@ from apps.models import *
from apps.utils.response_code import RET from apps.utils.response_code import RET
from apps.util import login_required 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"]) @api_power.route("/userListOfInside", methods=["POST"])
# @login_required @login_required
def user_list_inside(): def user_list_inside():
req_dict = request.get_json() req_dict = request.get_json()
page = req_dict.get("page") page = req_dict.get("page")
...@@ -20,8 +69,8 @@ def user_list_inside(): ...@@ -20,8 +69,8 @@ def user_list_inside():
key = req_dict.get("key") # 查询条件 key = req_dict.get("key") # 查询条件
status = req_dict.get("status") # 1通过，2在审，3驳回 status = req_dict.get("status") # 1通过，2在审，3驳回
unit = req_dict.get("unit") # 所在机构id one_org = req_dict.get("one_org")
section = req_dict.get("section") # 所在部门id two_department = req_dict.get("two_department")
# 校验参数完整性 # 校验参数完整性
if not all([page, perpage]): if not all([page, perpage]):
...@@ -29,31 +78,30 @@ def user_list_inside(): ...@@ -29,31 +78,30 @@ def user_list_inside():
try: try:
user = User.query.filter_by(flag=2) user = User.query.filter_by(flag=2)
if key: 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)))) user = user.filter(or_(User.real_name.like("%{}%".format(key)), User.name.like("%{}%".format(key))))
if status: if status:
user = user.filter_by(status=status) user = user.filter_by(status=status)
if unit: if one_org:
unit_name = Government.query.get(unit).name org_obj = OrganizationChart.query.filter_by(one_org=one_org).first()
user = user.filter_by(unit=unit_name) if org_obj:
if section: org_id = org_obj.id
sec_name = Section.query.get(section).name user = user.filter_by(org_id=org_id)
user = user.filter_by(section=sec_name) 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() size = user.count()
result = user.paginate(page, perpage).items result = user.paginate(page, perpage).items
df = [{"id": i.id, df = [{"id": i.id,
"real_name": i.real_name if i.real_name else "-", "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 "-", "position": i.position if i.position else "-",
"unit": i.belong_organization if i.belong_organization else "-", "unit": i.belong_organization if i.belong_organization else "-",
"section": i.belong_department if i.belong_department else "-", "section": i.belong_department if i.belong_department else "-",
# "role": "部门负责人" if i.role_id == 1 else "role": i.org.three_role if i.org.three_role else "-",
# "局领导" if i.role_id == 2 else "mobile": i.mobile if i.mobile else "-",
# "办事员工" if i.role_id == 3 else "-", "status": "通过" if i.status == 1 else "在审" if i.status == 2 else "驳回"} for i in result]
"role": i.role
} for i in result]
data = {"df": df, "size": size} data = {"df": df, "size": size}
return jsonify(code=RET.OK, msg="查询成功", data=data) return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e: except Exception as e:
...@@ -61,7 +109,7 @@ def user_list_inside(): ...@@ -61,7 +109,7 @@ def user_list_inside():
return jsonify(code=RET.DBERR, msg="数据库查询错误") return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 局内用户---用户信息展示 # 局内用户信息
@api_power.route("/userInsideInfo", methods=["POST"]) @api_power.route("/userInsideInfo", methods=["POST"])
@login_required @login_required
def user_inside_info(): def user_inside_info():
...@@ -70,53 +118,26 @@ def user_inside_info(): ...@@ -70,53 +118,26 @@ def user_inside_info():
try: try:
i = User.query.get(_id) 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, data = {"id": i.id,
"real_name": i.real_name if i.real_name else "-", "real_name": i.real_name if i.real_name else "-",
"position": i.position if i.position else "-", "position": i.position if i.position else "-",
# "role_id": i.role_id, "unit": i.belong_organization if i.belong_organization else "-",
# "role": "部门负责人" if i.role_id == 1 else "section": i.belong_department if i.belong_department else "-",
# "局领导" if i.role_id == 2 else "role": i.org.three_role if i.org.three_role else "-",
# "办事员工" if i.role_id == 3 else "-", # 角色 "mobile": i.mobile if i.mobile else "-",
"role": i.role, # "status": "通过" if i.status == 1 else "在审" if i.status == 2 else "驳回"
"unit": i.belong_organization, # 机构
"section": i.belong_department, # 部门
"mobile": i.mobile if i.mobile else "-"
} }
return jsonify(code=RET.OK, msg="查询成功", data=data) return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e: except Exception as e:
current_app.logger.error(e) current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误") 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"]) @api_power.route("/updateUser", methods=["POST"])
@login_required @login_required
def update_user(): def update_user():
...@@ -124,30 +145,28 @@ def update_user(): ...@@ -124,30 +145,28 @@ def update_user():
_id = req_dict.get("id") # 当亲用户id _id = req_dict.get("id") # 当亲用户id
real_name = req_dict.get("real_name") # 真名 real_name = req_dict.get("real_name") # 真名
position = req_dict.get("position") # 职务 position = req_dict.get("position") # 职务
unit = req_dict.get("unit") # 机构 one_org = req_dict.get("one_org") # 机构
section = req_dict.get("section") # 部门 two_department = req_dict.get("two_department") # 部门
# role_id = req_dict.get("role_id") # 角色id 必选 three_role = req_dict.get("three_role") # 角色
role = req_dict.get("role") # 角色 超级管理员/管理员/开发人员/工作人员
mobile = req_dict.get("mobile") mobile = req_dict.get("mobile")
password = req_dict.get("password") password = req_dict.get("password")
password1 = req_dict.get("password1") password1 = req_dict.get("password1")
# 校验参数完整性 # # 校验参数完整性
if not all([_id, real_name, position, role, mobile]): # if not all([_id, real_name, three_role, mobile]):
return jsonify(code=RET.PARAMERR, msg="请选择必填项") # return jsonify(code=RET.PARAMERR, msg="姓名、角色、手机号必填！")
try: 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) user = User.query.get(_id)
if position: user.org_id = org_obj.id
user.position = position user.position = position
if unit: user.belong_organization = one_org
user.unit = Government.query.get(unit).name user.two_department = two_department
if section:
user.section = Section.query.get(section).name
if mobile:
user.mobile = mobile user.mobile = mobile
if real_name:
user.real_name = real_name user.real_name = real_name
if password and not password1: if password and not password1:
return jsonify(code=RET.PARAMERR, msg="请填写确认密码！") return jsonify(code=RET.PARAMERR, msg="请填写确认密码！")
...@@ -157,8 +176,6 @@ def update_user(): ...@@ -157,8 +176,6 @@ def update_user():
if password != password1: if password != password1:
return jsonify(code=RET.PARAMERR, msg="密码和确认密码不一致！") return jsonify(code=RET.PARAMERR, msg="密码和确认密码不一致！")
user.password = password user.password = password
# role_obj.users.append(user)
db.session.commit() db.session.commit()
return jsonify(code=RET.OK, msg="修改成功") return jsonify(code=RET.OK, msg="修改成功")
except Exception as e: except Exception as e:
...@@ -166,63 +183,52 @@ def update_user(): ...@@ -166,63 +183,52 @@ def update_user():
return jsonify(code=RET.DBERR, msg="数据库查询错误") return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 局内用户新增 # 账号状态编辑（通过，在审，驳回）
@api_power.route("/addUser", methods=["POST"]) @api_power.route("/updateAccount", methods=["POST"])
# @login_required @login_required
def add_user(): def update_account():
req_dict = request.get_json() req_dict = request.get_json()
_id = req_dict.get("id")
real_name = req_dict.get("real_name") # 真实姓名 status = req_dict.get("status") # 1通过，2在审，3驳回
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") # 确认密码
# 校验参数完整性 # 校验参数完整性
if not all([real_name, position, unit, mobile, password]): if not all([_id, status]):
return jsonify(code=RET.PARAMERR, msg="参数不完整") 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: try:
user = User.query.filter_by(mobile=mobile).first() user = User.query.get(_id)
if user: # if not user.role and status == 1: # 没有角色，想通过
return jsonify(code=RET.DATAEXIST, msg="手机号已存在") # 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: except Exception as e:
current_app.logger.error(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: try:
role = Role.query.get(level) for i in id_list:
govername = Government.query.get(unit) # 获取机构name user = User.query.get(i)
user = User(real_name=real_name, mobile=mobile, unit=govername.name, position=position, db.session.delete(user)
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)
db.session.commit() db.session.commit()
return jsonify(code=RET.OK, msg="添加成功") return jsonify(code=RET.OK, msg="删除成功")
except Exception as e: except Exception as e:
db.session.rollback()
current_app.logger.error(e) 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(): ...@@ -235,7 +241,6 @@ def user_list_external():
req_dict = request.get_json() req_dict = request.get_json()
page = req_dict.get("page") page = req_dict.get("page")
perpage = req_dict.get("perpage") perpage = req_dict.get("perpage")
# key = req_dict.get("key") # 查询条件
# 校验参数完整性 # 校验参数完整性
if not all([page, perpage]): if not all([page, perpage]):
...@@ -248,6 +253,7 @@ def user_list_external(): ...@@ -248,6 +253,7 @@ def user_list_external():
"real_name": i.real_name if i.real_name else "-", "real_name": i.real_name if i.real_name else "-",
"mobile": i.mobile if i.mobile else "-", "mobile": i.mobile if i.mobile else "-",
"create_time": str(i.create_time) if i.create_time else "-", "create_time": str(i.create_time) if i.create_time else "-",
"status": i.status # 0禁止，1启动
} for i in result] } for i in result]
data = {"df": df, "size": size} data = {"df": df, "size": size}
return jsonify(code=RET.OK, msg="查询成功", data=data) return jsonify(code=RET.OK, msg="查询成功", data=data)
...@@ -281,35 +287,6 @@ def update_status(): ...@@ -281,35 +287,6 @@ def update_status():
current_app.logger.error(e) current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库操作错误") return jsonify(code=RET.DBERR, msg="数据库操作错误")
# # 局内用户筛选条件 # # 局内用户筛选条件
# @api_power.route("/manage/fields", methods=["GET"]) # @api_power.route("/manage/fields", methods=["GET"])
# def manage_field(): # def manage_field():
......
apps/models.py
...@@ -920,7 +920,6 @@ class User(BaseModel, db.Model): ...@@ -920,7 +920,6 @@ class User(BaseModel, db.Model):
# 基本信息 # 基本信息
id = db.Column(db.Integer, primary_key=True, autoincrement=True, comment='用户编号') id = db.Column(db.Integer, primary_key=True, autoincrement=True, comment='用户编号')
name = db.Column(db.String(32), unique=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='加密的密码') password_hash = db.Column(db.String(128), comment='加密的密码')
real_name = db.Column(db.String(32), comment='姓名') real_name = db.Column(db.String(32), comment='姓名')
mobile = db.Column(db.String(11), unique=True, comment='手机号') mobile = db.Column(db.String(11), unique=True, comment='手机号')
...@@ -938,6 +937,10 @@ class User(BaseModel, db.Model): ...@@ -938,6 +937,10 @@ class User(BaseModel, db.Model):
# 角色(职级配置) # 角色(职级配置)
# role_id = db.Column(db.Integer, db.ForeignKey("role.id"), comment='角色id') # role_id = db.Column(db.Integer, db.ForeignKey("role.id"), comment='角色id')
# role = db.relationship("Role", backref=db.backref("users")) # 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')) industry = db.relationship("Industry", secondary="user_industry", backref=db.backref('bindustry'))
# 用户关注太原企业 # 用户关注太原企业
...@@ -1089,18 +1092,30 @@ class Section(db.Model): ...@@ -1089,18 +1092,30 @@ class Section(db.Model):
# 政府组（政府1-N部门1-N组） # 政府组（政府1-N部门1-N组）
# class Group(db.Model): class Group(db.Model):
# __tablename__ = "group" __tablename__ = "group"
# # 基本信息 # 基本信息
# id = db.Column(db.Integer, primary_key=True, autoincrement=True) id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# pnums = db.Column(db.Integer) # 人数 pnums = db.Column(db.Integer) # 人数
# charge = db.Column(db.String(255)) # 组负责人 charge = db.Column(db.String(255)) # 组负责人
# charge_phone = db.Column(db.String(255)) # 负责人电话 charge_phone = db.Column(db.String(255)) # 负责人电话
# function = db.Column(db.Text) # 部门职能 function = db.Column(db.Text) # 部门职能
# name = db.Column(db.String(255), nullable=False) # 政府机构部门下组的名称 name = db.Column(db.String(255), nullable=False) # 政府机构部门下组的名称
# # sid = db.Column(db.Integer) # 部门id # sid = db.Column(db.Integer) # 部门id
# section_id = db.Column(db.Integer, db.ForeignKey("section.id")) section_id = db.Column(db.Integer, db.ForeignKey("section.id"))
# section = db.relationship('Section', backref=db.backref('groups')) # 部门1-N组 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