Skip to content

M
mancheng
Commit adcaf3a2 by dong
Options

fix20220308

parent 1d3f6d87
Showing with 1231 additions and 1152 deletions
apps/manage/view_org.py
import time
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 from apps.util import login_required, verify_token
# 获取上级或下级统筹机构 (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("/addOrg", methods=["POST"]) @api_power.route("/AddOrg", methods=["POST"])
@login_required @login_required
def add_org(): 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() req_dict = request.get_json()
name = req_dict.get("name") # 机构名称 org_name = req_dict.get("name") # 机构名称
forg = req_dict.get("forg") # 上级机构 id # forg = req_dict.get("forg") # 上级机构 id
charge = req_dict.get("charge") # 机构负责人 charge = req_dict.get("charge") # 机构负责人
charge_phone = req_dict.get("charge_phone") # 负责人电话 charge_phone = req_dict.get("charge_phone") # 负责人电话
sublist = req_dict.get("sublist") # 统筹机构id list["1","2"...] # sublist = req_dict.get("sublist") # 统筹机构id list["1","2"...]
# 校验参数完整性 # 校验参数完整性
if not all([name]): if not all([org_name]):
return jsonify(code=RET.PARAMERR, msg="参数不完整") return jsonify(code=RET.PARAMERR, msg="参数不完整")
try: try:
gover = Government.query.filter_by(name=name).first() gover = GovOrganization.query.filter_by(name=org_name).first()
if gover: # 机构名相同，提示其错误 if gover: # 机构名相同，提示其错误
return jsonify(code=RET.DBERR, msg="机构名重复") return jsonify(code=RET.DBERR, msg="机构名重复")
goverment = Government(name=name) # 创建机构 goverment = GovOrganization(name=org_name) # 创建机构
if charge: if charge:
goverment.charge = charge goverment.charge = charge
if charge_phone: if charge_phone:
goverment.charge_phone = 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) # 添加到数据库 db.session.add(goverment) # 添加到数据库
if forg: # 如果有上级机构，就让上级机构统筹新增机构 # if forg: # 如果有上级机构，就让上级机构统筹新增机构
fgover = Government.query.get(forg) # fgover = Government.query.get(forg)
fgover.followed.append(goverment) # fgover.followed.append(goverment)
for ctr in sublist: # 如果有统筹机构，就让新增机构统筹 # for ctr in sublist: # 如果有统筹机构，就让新增机构统筹
sgover = Government.query.get(ctr) # sgover = Government.query.get(ctr)
goverment.followed.append(sgover) # goverment.followed.append(sgover)
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:
...@@ -82,121 +60,82 @@ def add_org(): ...@@ -82,121 +60,82 @@ def add_org():
return jsonify(code=RET.DBERR, msg="数据库操作错误") return jsonify(code=RET.DBERR, msg="数据库操作错误")
# 组织架构管理,获取机构单位数据（ok） # 查询添加过的机构信息
@api_power.route("/organization", methods=["POST"]) @api_power.route("/GetOrg", methods=["GET"])
@login_required @login_required
def organization(): def get_org():
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: try:
# goverment = Government.query.paginate(page, perpage).items org = GovOrganization.query.all()
goverment = Government.query.all() data = [{"id": i.id, "name": i.name, "pnums": i.pnums,
size = Government.query.count() "charge": i.charge, "charge_phone": i.charge_phone,
df = [{"id": gover.id, "add_person": i.add_person, "add_time": i.add_time,
"name": gover.name, "edit_person": i.edit_person, "edit_time": i.edit_time}
"pnums": gover.pnums if gover.pnums else 0, for i in org]
"charge": gover.charge if gover.charge else "-", return jsonify(code=RET.OK, msg="查询成功", data=data)
"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: except Exception as e:
current_app.logger.error(e) current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误", data=[]) return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 新增下级部门(ok) # 新增下级部门(ok)
@api_power.route("/addSub", methods=["POST"]) @api_power.route("/AddSubDepartment", methods=["POST"])
@login_required @login_required
def add_sub(): 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() 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, cate, name]): # if not all([_id, cate, name]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
if not all([id, name]):
return jsonify(code=RET.PARAMERR, msg="参数不完整") return jsonify(code=RET.PARAMERR, msg="参数不完整")
try: try:
if cate == 1: # 增加部门 # if cate == 1: # 增加部门
sec = Section.query.filter_by(name=name, goverment_id=_id).first() sec = GovDepartment.query.filter_by(name=name, goverment_org_id=id).first()
if sec: # 一个机构下部门名不能重复 if sec: # 一个机构下部门名不能重复
return jsonify(code=RET.DATAERR, msg="部门名重复") return jsonify(code=RET.DATAERR, msg="部门名重复")
goverment = Government.query.get(_id) gov_organization = GovOrganization.query.get(id)
section = Section(name=name, goverment_id=_id) gov_department = GovDepartment(name=name, goverment_org_id=id)
if pnums: # if pnums:
section.pnums = pnums # gov_department.pnums = pnums
if charge: if charge:
section.charge = charge gov_department.charge = charge
if charge_phone: if charge_phone:
section.charge_phone = charge_phone gov_department.charge_phone = charge_phone
db.session.add(section) # 添加部门 if user_name:
goverment.sections.append(section) # 外键关系添加 gov_department.add_person = user_name
db.session.commit() # 数据库提交 add_time = datetime.now()
if cate == 2: # 增加组 gov_department.add_time = add_time
gro = Group.query.filter_by(name=name, section_id=_id).first() db.session.add(gov_department) # 添加部门
if gro: # 一个部门下组名不能重复 gov_organization.government_departments.append(gov_department) # 外键关系添加
return jsonify(code=RET.DATAERR, msg="组名重复") db.session.commit() # 数据库提交
section = Section.query.get(_id) # if cate == 2: # 增加组
group = Group(name=name, section_id=_id) # gro = Group.query.filter_by(name=name, gov_department_id=_id).first()
if pnums: # if gro: # 一个部门下组名不能重复
group.pnums = pnums # return jsonify(code=RET.DATAERR, msg="组名重复")
if charge: # gov_department = Section.query.get(_id)
group.charge = charge # group = Group(name=name, section_id=_id)
if charge_phone: # if pnums:
group.charge_phone = charge_phone # group.pnums = pnums
db.session.add(group) # 添加组 # if charge:
section.groups.append(group) # 添加关系 # group.charge = charge
db.session.commit() # 提交 # if charge_phone:
if cate == 3: # group.charge_phone = charge_phone
return jsonify(code=RET.OK, msg="暂无下级机构，请勿继续添加") # 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="添加成功") return jsonify(code=RET.OK, msg="添加成功")
except Exception as e: except Exception as e:
# 操作失败，数据回滚 # 操作失败，数据回滚
...@@ -205,521 +144,624 @@ def add_sub(): ...@@ -205,521 +144,624 @@ def add_sub():
return jsonify(code=RET.DBERR, msg="数据库操作错误") return jsonify(code=RET.DBERR, msg="数据库操作错误")
# 删除组织机构或者部门和组(需要先删除人员)--------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: # # 获取上级或下级统筹机构 (ok)
if cate == 1: # 机构 # @api_power.route("/uadOrg", methods=["GET"])
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 # @login_required
def list_Staff(): # def uad_org():
req_dict = request.get_json() # try:
_id = req_dict.get("id") # 当前机构id # gover = Government.query.all()
cate = req_dict.get("cate") # 1机构 2部门 3组 # data = [{"label": i.name, "value": i.id} for i in gover]
# return jsonify(code=RET.OK, msg="查询成功", data=data)
# 校验参数完整性 # except Exception as e:
if not all([_id]): # current_app.logger.error(e)
return jsonify(code=RET.PARAMERR, msg="参数不完整") # return jsonify(code=RET.DBERR, msg="数据库查询错误")
try: #
if cate == 1: # 政府 #
gover = Government.query.get(_id) # # 获取上级机构后的统筹机构 (ok)
if gover: # @api_power.route("/downOrg", methods=["POST"])
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 # @login_required
def add_staff(): # def down_org():
req_dict = request.get_json() # req_dict = request.get_json()
_id = req_dict.get("id") # 部门机构组id # _id = req_dict.get("id") # 机构名称
cate = req_dict.get("cate") # 1政府，2部门，3组 # try:
uid = req_dict.get("uid") # 员工id # if _id:
level = req_dict.get("level") # 职级(角色id) # gover = Government.query.all()
position = req_dict.get("position") # 职务,文本框随意填 # data = [{"label": i.name, "value": i.id} for i in gover if i.id != _id]
# return jsonify(code=RET.OK, msg="查询成功", data=data)
# 校验参数完整性 # else:
if not all([_id, level, position]): # gover = Government.query.all()
return jsonify(code=RET.PARAMERR, msg="参数不完整") # data = [{"label": i.name, "value": i.id} for i in gover]
try: # return jsonify(code=RET.OK, msg="查询成功", data=data)
user = User.query.get(uid) # except Exception as e:
if user: # current_app.logger.error(e)
if cate == 1: # 政府机构 # return jsonify(code=RET.DBERR, msg="数据库查询错误")
user.section = Government.query.get(_id).name #
# 删除原有角色 #
role = Role.query.get(user.role_id) # # 组织架构管理,获取机构单位数据（ok）
role.users.remove(user) # @api_power.route("/organization", methods=["POST"])
# 添加新角色 # @login_required
role = Role.query.get(level) # def organization():
role.users.append(user) # req_dict = request.get_json()
# page = req_dict.get("page")
user.position = position # perpage = req_dict.get("perpage")
db.session.commit() # # 校验参数完整性
return jsonify(code=RET.OK, msg="添加成功") # if not all([page, perpage]):
if cate == 2: # 部门调度 # return jsonify(code=RET.PARAMERR, msg="参数不完整")
user.section = Section.query.get(_id).name # try:
# 删除原有角色 # # goverment = Government.query.paginate(page, perpage).items
role = Role.query.get(user.role_id) # goverment = Government.query.all()
role.users.remove(user) # size = Government.query.count()
# 添加新角色 # df = [{"id": gover.id,
role = Role.query.get(level) # "name": gover.name,
role.users.append(user) # "pnums": gover.pnums if gover.pnums else 0,
# "charge": gover.charge if gover.charge else "-",
user.position = position # "charge_phone": gover.charge_phone if gover.charge_phone else "-",
db.session.commit() # "cate": 1} for gover in goverment]
return jsonify(code=RET.OK, msg="添加成功") # data = {"df": df, "size": size}
if cate == 3: # 组调度 # return jsonify(code=RET.OK, msg="查找成功", data=data)
user.group = Group.query.get(_id).name # except Exception as e:
# 删除原有角色 # current_app.logger.error(e)
role = Role.query.get(user.role_id) # return jsonify(code=RET.DBERR, msg="数据库查询错误", data=[])
role.users.remove(user) #
# 添加新角色 #
role = Role.query.get(level) # # 组织架构获取部门和组（Ok）
role.users.append(user) # @api_power.route("/sectionGroup", methods=["POST"])
# @login_required
user.position = position # def section_group():
db.session.commit() # req_dict = request.get_json()
return jsonify(code=RET.OK, msg="添加成功") # _id = req_dict.get("id") # 当前机构或者部门的id
# cate = req_dict.get("cate") # 分类标识，1机构，2部门
return jsonify(code=RET.DATAERR, msg="参数错误") #
else: # # 校验参数完整性
return jsonify(code=RET.DATAERR, msg="参数错误") # if not all([_id, cate]):
except Exception as e: # return jsonify(code=RET.PARAMERR, msg="参数不完整")
# 操作失败，回滚数据库 #
db.session.rollback() # try:
current_app.logger.error(e) # if cate == 1: # 查询当前机构下的部门
return jsonify(code=RET.DBERR, msg="数据库操作错误") # goverment = Government.query.get(_id)
# sections = goverment.sections # 查询当前机构下的部门list
# data = [{"id": sec.id,
# # 测试 # "name": sec.name,
# @api_power.route("/cs", methods=["get"]) # "pnums": sec.pnums if sec.pnums else 0,
# def ces(): # "charge": sec.charge if sec.charge else "-",
# gover = Government.query.get(18) # "charge_phone": sec.charge_phone if sec.charge_phone else "-",
# section = Section.query.get(37) # "cate": 2} for sec in sections]
# print(gover,section) # return jsonify(code=RET.OK, msg="查找成功", data=data)
# # section.goverment.remove(gover) # if cate == 2: # 查询当前部门下的组
# gover.sections.remove(section) # section = Section.query.get(_id)
# db.session.commit() # groups = section.groups # 查询当前部门下的组list
# return "ok" # 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 "-",
@api_power.route("/deleteStaffOrg", methods=["POST"]) # "cate": 3} for group in groups]
@login_required # return jsonify(code=RET.OK, msg="查找成功", data=data)
def delete_staff(): # return jsonify(code=RET.OK, msg="暂无下级信息", data=[])
req_dict = request.get_json() # except Exception as e:
uid = req_dict.get("uid") # 员工id # current_app.logger.error(e)
cate = req_dict.get("cate") # 1政府，2部门，3组 # return jsonify(code=RET.DBERR, msg="数据库查询错误", data=[])
_id = req_dict.get("id") # 机构部门组id #
# level = req_dict.get("level") # 职级 #
# position = req_dict.get("position") # 职务 # # 删除组织机构或者部门和组(需要先删除人员)--------OK
# @api_power.route("/deleteOrg", methods=["POST"])
# 校验参数完整性 # @login_required
if not all([uid, cate, _id]): # def deleteorg():
return jsonify(code=RET.PARAMERR, msg="参数不完整") # req_dict = request.get_json()
try: # _id = req_dict.get("id") # 待删除的，部门、机构、组、id
user = User.query.get(uid) # cate = req_dict.get("cate") # 待删除数据的类别 1政府，2部门，3组
if user: #
if cate == 1: # 政府机构 # # 校验参数完整性
role = Role.query.get(user.role_id) # if not all([_id, cate]):
role.users.remove(user) # return jsonify(code=RET.PARAMERR, msg="参数不完整")
user.unit = "" # 机构 #
user.position = "" # 职位 # try:
user.section = "" # 部门 # if cate == 1: # 删除机构
user.group = "" # 组 # gover = Government.query.get(_id) # 当前机构对象
user.level = "" # 级别 # section = gover.sections # 当前机构下的部门对象列表
user.leader = "" # 领导者 # if len(section) > 0: # 有部门就需要先删除部门
user.password = "" # 密码 # return jsonify(code=RET.REQERR, msg="当前机构有部门存在，请清除后再操作")
db.session.commit() # unums = User.query.filter_by(unit=gover.name, status=1).count() # 当前机构下通过审核人员
return jsonify(code=RET.OK, msg="删除成功") # if unums > 0: # 当前部门有人，先到机构详情，进行人员的删除
if cate == 2: # 部们 # return jsonify(code=RET.REQERR, msg="当前机构有人员存在，请清除后再操作")
role = Role.query.get(user.role_id) # db.session.delete(gover) # 无人无部门，删除
# user.role_id = "" # db.session.commit() # 提交
role.users.remove(user) # return jsonify(code=RET.OK, msg="删除成功")
user.position = "" # if cate == 2: # 删除部门
user.section = "" # section = Section.query.get(_id)
user.group = "" # gover = section.goverment # 部门所属的机构
user.level = "" # group = section.groups # 当前部门的组对象list
# user.role_id = "" # if len(group) > 0: # 如果有组先删除组
db.session.commit() # return jsonify(code=RET.REQERR, msg="当前部门有组存在，请清除后再操作")
return jsonify(code=RET.OK, msg="删除成功") # unums = User.query.filter_by(unit=gover.name, section=section.name, status=1).count() # # 已经通过审核的人数
if cate == 3: # 组调度 # if unums > 0: # 当前部门有人，先到部门详情，进行部门人员的删除
user.group = "" # return jsonify(code=RET.REQERR, msg="当前部门有人员存在，请清除后再操作")
db.session.commit() # gover.sections.remove(section) # 当前部门没有人，没有组，删除部门之前需要先删除与之相关的机构关系
return jsonify(code=RET.OK, msg="删除成功") # db.session.delete(section) # 删除
return jsonify(code=RET.DATAERR, msg="参数错误") # db.session.commit() # 提交
else: # return jsonify(code=RET.OK, msg="删除成功")
return jsonify(code=RET.DATAERR, msg="参数错误") # if cate == 3: # 删除组
except Exception as e: # group = Group.query.get(_id) # 当前组信息
# 操作失败，回滚数据库 # section = group.section # 组属于的部门，单个对象
db.session.rollback() # gover = section.goverment # 部门属于的机构，单个对象
current_app.logger.error(e) # unums = User.query.filter_by(unit=gover.name, section=section.name, group=group.name,
return jsonify(code=RET.DBERR, msg="数据库操作错误") # status=1).count() # 已经通过审核的人数
# if unums > 0: # 当前组有人，先到组详情，进行组员的删除
# return jsonify(code=RET.REQERR, msg="当前组有人员存在，请清除后再操作")
# 获取统筹机构列表 # section.groups.remove(group) # 当前组没有人，删除组之前需要先删除与之相关的部门关系
@api_power.route("/orgCtrl", methods=["POST"]) # db.session.delete(group) # 删除
@login_required # db.session.commit() # 提交
def org_ctrl(): # return jsonify(code=RET.OK, msg="删除成功")
req_dict = request.get_json() # else:
_id = req_dict.get("id") # 机构id # return jsonify(code=RET.DATAERR, msg="参数错误")
cate = req_dict.get("cate") # 1政府，2部门，3组 # except Exception as e:
# # 操作失败，回滚数据库
# 校验参数完整性 # db.session.rollback()
if not all([_id, cate]): # current_app.logger.error(e)
return jsonify(code=RET.PARAMERR, msg="参数不完整") # return jsonify(code=RET.DBERR, msg="数据库操作失败")
try: #
if cate == 1: # 政府机构详情 #
goverment = Government.query.get(_id) # ''''''
# 统筹机构列表 #
ctrl = goverment.followed #
bkpm = [{"id": j.id, # # 获取机构，部门或者组详情()
"name": j.name, # @api_power.route("/orgDetail", methods=["POST"])
"charge": j.charge if j.charge else "-", # @login_required
"phone": j.charge_phone if j.charge_phone else "-"} for j in ctrl] # def org_detail():
return jsonify(code=RET.OK, msg="查询成功", data=bkpm) # req_dict = request.get_json()
# _id = req_dict.get("id") # id
return jsonify(code=RET.OK, msg="参数错误") # cate = req_dict.get("cate") # 1机构，2部门，3组
except Exception as e: #
current_app.logger.error(e) # # 校验参数完整性
return jsonify(code=RET.DBERR, msg="数据库操作错误") # if not all([_id, cate]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
#
# 获取待新增统筹机构列表 # try:
@api_power.route("/getCtrl", methods=["POST"]) # if cate == 1: # 政府机构详情
@login_required # goverment = Government.query.get(_id)
def get_ctrl(): # # 政府信息
req_dict = request.get_json() # data = {"id": goverment.id,
_id = req_dict.get("id") # "name": goverment.name, # 机构名
# "charge": goverment.charge if goverment.charge else "-", # 主管
# 校验参数完整性 # "phone": goverment.charge_phone if goverment.charge_phone else "-", # 电话
if not all([_id]): # "pnums": goverment.pnums if goverment.pnums else 0, # 机构人数
return jsonify(code=RET.PARAMERR, msg="参数不完整") # "secnums": len(goverment.sections), # 部门数
try: # "func": goverment.function if goverment.function else "", # 政府职能
goverment = Government.query.get(_id) # "cate": cate}
folllowedids = {i.id for i in goverment.followed} # 已经被管制的 # return jsonify(code=RET.OK, msg="查询成功", data=data)
folllowedids.add(_id) # 添加自己 # if cate == 2: # 部门详情
all_ids = {i.id for i in Government.query.filter_by().all()} # 全部机构id # section = Section.query.get(_id)
options = list(all_ids - folllowedids) # 未被当前机构统筹的机构id列表 # # 政府信息
# data = {"id": section.id,
goverments = Government.query.filter(Government.id.in_(options)).all() # "name": section.name, # 机构名
data = [{"id": i.id, # "charge": section.charge if section.charge else "-", # 主管
"name": i.name} for i in goverments] # "phone": section.charge_phone if section.charge_phone else "-", # 电话
# "pnums": section.pnums if section.pnums else 0, # 机构人数
return jsonify(code=RET.OK, msg="查询成功", data=data) # "secnums": len(section.groups), # 组数
except Exception as e: # "func": section.function if section.function else "", # 部门职能
current_app.logger.error(e) # "cate": cate}
return jsonify(code=RET.DBERR, msg="添加失败") # return jsonify(code=RET.OK, msg="查询成功", data=data)
# if cate == 3: # 组详情
# group = Group.query.get(_id)
# 机构详情页添加统筹机构 # # 政府信息
@api_power.route("/addBeCtrl", methods=["POST"]) # data = {"id": group.id,
@login_required # "name": group.name, # 机构名
def add_bectrl(): # "charge": group.charge if group.charge else "-", # 主管
req_dict = request.get_json() # "phone": group.charge_phone if group.charge_phone else "-", # 电话
_id = req_dict.get("id") # "pnums": group.pnums if group.pnums else 0, # 机构人数
ids = req_dict.get("ids") # "secnums": "-",
# "func": group.function if group.function else "", # 部门职能
# 校验参数完整性 # "cate": cate}
if not all([_id, ids]): # return jsonify(code=RET.OK, msg="查询成功", data=data)
return jsonify(code=RET.PARAMERR, msg="参数不完整") #
try: # return jsonify(code=RET.OK, msg="参数错误")
goverment = Government.query.get(_id) # except Exception as e:
folllowedids = {i.id for i in goverment.followed} # current_app.logger.error(e)
ids = set(ids) # return jsonify(code=RET.DBERR, msg="数据库操作错误")
for id in (ids - folllowedids): #
gover = Government.query.get(id) #
goverment.followed.append(gover) # # 编辑机构，部门或者组详情
db.session.commit() # @api_power.route("/editDetail", methods=["POST"])
return jsonify(code=RET.OK, msg="添加成功") # @login_required
except Exception as e: # def edit_detail():
# 操作失败，回滚数据库 # req_dict = request.get_json()
db.session.rollback() # _id = req_dict.get("id") # 部门id
current_app.logger.error(e) # cate = req_dict.get("cate") # 1机构，2部门，3组
return jsonify(code=RET.DBERR, msg="添加失败") # 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") # 部门职能
@api_power.route("/deleteCtrl", methods=["POST"]) # pnums = str(req_dict.get("pnums")) # 人数
@login_required # secnums = str(req_dict.get("secnums")) # 部门组人数
def delete_bectrl(): #
req_dict = request.get_json() # # 校验参数完整性
_id = req_dict.get("id") # if not all([_id, name, charge, charge_phone, pnums, secnums]):
bectrl_id = req_dict.get("bectrl_id") # return jsonify(code=RET.PARAMERR, msg="参数不完整")
#
# 校验参数完整性 # try:
if not all([_id, bectrl_id]): # if cate == 1: # 机构
return jsonify(code=RET.PARAMERR, msg="参数不完整") # gover = Government.query.filter_by(name=name).filter(Government.id != _id).first()
try: # if gover:
goverment = Government.query.get(_id) # return jsonify(code=RET.DBERR, msg="机构名不可重复")
begoverment = Government.query.get(bectrl_id) # gover = Government.query.get(_id)
goverment.followed.remove(begoverment) # gover.name = name
db.session.commit() # gover.charge = charge
# gover.charge_phone = charge_phone
return jsonify(code=RET.OK, msg="删除成功") # gover.function = func
except Exception as e: # gover.pnums = pnums
# 操作失败，回滚数据库 # gover.secnums = secnums
db.session.rollback() # db.session.commit()
current_app.logger.error(e) # return jsonify(code=RET.OK, msg="修改成功")
return jsonify(code=RET.DBERR, 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/models.py
...@@ -993,6 +993,76 @@ class Role(BaseModel, db.Model): ...@@ -993,6 +993,76 @@ class Role(BaseModel, db.Model):
role = db.Column(db.String(10), unique=True, comment='权限值 000000 0位位职级123，后面为权限01') role = db.Column(db.String(10), unique=True, comment='权限值 000000 0位位职级123，后面为权限01')
info = db.Column(db.String(255), comment='权限说明') info = db.Column(db.String(255), comment='权限说明')
# 政府机构表（自关联多对多）
class GovOrganization(db.Model):
__tablename__ = "government_organization"
# 基本信息
id = db.Column(db.Integer, primary_key=True, autoincrement=True, doc='主键id', comment='主键id')
pnums = db.Column(db.Integer, doc='人数', comment='人数')
charge = db.Column(db.String(20), doc='机构负责人', comment='机构负责人')
charge_phone = db.Column(db.String(20), doc='负责人电话', comment='负责人电话')
function = db.Column(db.Text, doc='部门职能', comment='部门职能')
# name = db.Column(db.String(30), nullable=False, view_index=True, doc='新增时间', comment='新增时间')
name = db.Column(db.String(30), doc='新增时间', comment='新增时间')
add_person = db.Column(db.String(20), doc='新增人', comment='新增人')
add_time = db.Column(db.DateTime, doc='新增时间', comment='新增时间')
edit_person = db.Column(db.String(20), doc='编辑人', comment='编辑人')
edit_time = db.Column(db.DateTime, doc='编辑时间', comment='编辑时间')
# followed 我的下级，管制谁，followers 我的上级，谁管制我
# followed = db.relationship('Government', secondary=followers, primaryjoin=(followers.c.follower_id == id),
# secondaryjoin=(followers.c.followed_id == id),
# backref=db.backref('followers', lazy='dynamic'), lazy='dynamic')
# 政府部门（政府-部门 一对多）
class GovDepartment(db.Model):
__tablename__ = "government_department"
# 基本信息
id = db.Column(db.Integer, primary_key=True, autoincrement=True, doc='主键id', comment='主键id')
pnums = db.Column(db.Integer, doc='人数', comment='人数') # 人数
charge = db.Column(db.String(255), doc='部门负责人', comment='部门负责人') # 部门负责人
charge_phone = db.Column(db.String(255), doc='负责人电话', comment='负责人电话') # 负责人电话
function = db.Column(db.Text, doc='负责人电话', comment='负责人电话') # 部门职能
name = db.Column(db.String(255), nullable=False, doc='政府机构部门名称', comment='政府机构部门名称') # 政府机构部门名称
# gid = db.Column(db.Integer) # 政府id
goverment_org_id = db.Column(db.Integer, db.ForeignKey("government_organization.id"), doc='外键id，机构id', comment='外键id，机构id')
goverment = db.relationship('GovOrganization', backref=db.backref('government_departments')) # 政府1-N部门
# 项目列表 # 项目列表
# class Item(db.Model): # class Item(db.Model):
# __tablename_ = "item" # __tablename_ = "item"
...@@ -1071,38 +1141,9 @@ class Role(BaseModel, db.Model): ...@@ -1071,38 +1141,9 @@ class Role(BaseModel, db.Model):
# db.Column('follower_id', db.Integer, db.ForeignKey('government.id'), primary_key=True), # db.Column('follower_id', db.Integer, db.ForeignKey('government.id'), primary_key=True),
# db.Column('followed_id', db.Integer, db.ForeignKey('government.id'), primary_key=True) # db.Column('followed_id', db.Integer, db.ForeignKey('government.id'), primary_key=True)
# ) # )
#
#
# # 政府机构表（自关联多对多）
# class Government(db.Model):
# __tablename__ = "government"
# # 基本信息
# 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, view_index=True) # 政府机构单位名称
# # followed 我的下级，管制谁，followers 我的上级，谁管制我
# followed = db.relationship('Government', secondary=followers, primaryjoin=(followers.c.follower_id == id),
# secondaryjoin=(followers.c.followed_id == id),
# backref=db.backref('followers', lazy='dynamic'), lazy='dynamic')
#
#
# # 政府部门（政府-部门 一对多）
# class Section(db.Model):
# __tablename__ = "section"
# # 基本信息
# 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) # 政府机构部门名称
# # gid = db.Column(db.Integer) # 政府id
# goverment_id = db.Column(db.Integer, db.ForeignKey("government.id"))
# goverment = db.relationship('Government', backref=db.backref('sections')) # 政府1-N部门
#
# #
# # 政府组（政府1-N部门1-N组） # # 政府组（政府1-N部门1-N组）
# class Group(db.Model): # class Group(db.Model):
......
apps/util.py
...@@ -5,13 +5,13 @@ from itsdangerous import SignatureExpired, BadSignature ...@@ -5,13 +5,13 @@ from itsdangerous import SignatureExpired, BadSignature
from flask import request, jsonify, current_app from flask import request, jsonify, current_app
from config import Config from config import Config
# from apps.models import User, Bstage # from apps.models import User, Bstage
from apps.models import User
import functools import functools
# from flask_httpauth import HTTPBasicAuth # from flask_httpauth import HTTPBasicAuth
# #
# auth = HTTPBasicAuth # auth = HTTPBasicAuth
# from models import User
class RegexConverter(BaseConverter): class RegexConverter(BaseConverter):
......
apps/utils/send_phone_info.py
...@@ -106,4 +106,33 @@ def code_new(phone, c_num): ...@@ -106,4 +106,33 @@ def code_new(phone, c_num):
el = eval(str(response, encoding='utf-8')) el = eval(str(response, encoding='utf-8'))
return el return el
# print(send_code('15769202654', '9999'))
# 密码重置操作
def send_reset_password_code(phone, c_num):
client = AcsClient('LTAI4Fkgi7DUf6jCVW3KNGwT', 'ynr6TWWNOnpALn3YUICUaXwpp9w4er', 'cn-hangzhou')
request = CommonRequest()
request.set_accept_format('json')
request.set_domain('dysmsapi.aliyuncs.com')
request.set_method('POST')
request.set_protocol_type('https') # https | http
request.set_version('2017-05-25')
request.set_action_name('SendSms')
request.add_query_param('RegionId', "cn-hangzhou")
request.add_query_param('PhoneNumbers', phone)
# 签名
request.add_query_param('SignName', "中研认知产业链在线")
# 模板
request.add_query_param('TemplateCode', "SMS_186575190")
request.add_query_param('TemplateParam', "{\"code\":\"" + c_num + "\"}")
response = client.do_action(request)
el = eval(str(response, encoding='utf-8'))
return el
# 密码重置操作 SMS_168827629
# 手机号码绑定 SMS_186575190
# 手机号码注册平台 SMS_187755198
# 手机号码登录平台 SMS_187752221
apps/view_user/view.py
...@@ -12,11 +12,11 @@ from flask_mail import Mail, Message ...@@ -12,11 +12,11 @@ from flask_mail import Mail, Message
from flask import g, current_app, request, jsonify, session from flask import g, current_app, request, jsonify, session
from apps.view_user import api_user from apps.view_user import api_user
from apps import creat_app from apps import creat_app
from apps.utils.send_phone_info import send_code_new, send_code from apps.utils.send_phone_info import send_code_new, send_code, send_reset_password_code
from apps.utils.response_code import RET from apps.utils.response_code import RET
from apps import db, constants, redis_store from apps import db, constants, redis_store
from apps.models import * from apps.models import *
from apps.util import create_token from apps.util import create_token, verify_token, login_required
from werkzeug.security import generate_password_hash, check_password_hash from werkzeug.security import generate_password_hash, check_password_hash
from apps import qiniu_store from apps import qiniu_store
from apps.utils.vxconfig import WxConfig from apps.utils.vxconfig import WxConfig
...@@ -53,12 +53,13 @@ def send_phone_code(): ...@@ -53,12 +53,13 @@ def send_phone_code():
# 生成短信验证码 # 生成短信验证码
sms_code = "%06d" % random.randint(0, 999999) sms_code = "%06d" % random.randint(0, 999999)
data = '' data = ''
if sms_type == 1: if sms_type == 1: # 验证码登录
data = send_code_new(mobile, sms_code) data = send_code_new(mobile, sms_code)
if sms_type == 2: if sms_type == 2: # 手机号码绑定
data = send_code(mobile, sms_code) data = send_code(mobile, sms_code)
if sms_type == 3: # 密码重置验证码
# print(data) data = send_reset_password_code(mobile, sms_code)
print(data)
if data['Message'] == 'OK': if data['Message'] == 'OK':
# 保存真实的短信验证码 # 保存真实的短信验证码
try: try:
...@@ -70,6 +71,8 @@ def send_phone_code(): ...@@ -70,6 +71,8 @@ def send_phone_code():
return jsonify(code=RET.DBERR, msg="保存短信验证码异常") return jsonify(code=RET.DBERR, msg="保存短信验证码异常")
# 发送成功 # 发送成功
return jsonify(code=RET.OK, msg="发送成功") return jsonify(code=RET.OK, msg="发送成功")
if data['Message'] != 'OK':
return jsonify(code=RET.THIRDERR, msg="发送次数太多，已被限流，请稍后再试！")
else: else:
return jsonify(code=RET.THIRDERR, msg="发送失败") return jsonify(code=RET.THIRDERR, msg="发送失败")
...@@ -132,7 +135,7 @@ def login_bysms(): ...@@ -132,7 +135,7 @@ def login_bysms():
current_app.logger.error(e) current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库异常") return jsonify(code=RET.DBERR, msg="数据库异常")
# print(user.status==3) # print(user.status==3)
if user.status == 3: if user.status == 0:
return jsonify(code=RET.USERERR, msg="当前用户被禁止登录,请联系管理员") return jsonify(code=RET.USERERR, msg="当前用户被禁止登录,请联系管理员")
# 获取用户id，传入生成token的方法，并接收返回的token # 获取用户id，传入生成token的方法，并接收返回的token
...@@ -145,152 +148,6 @@ def login_bysms(): ...@@ -145,152 +148,6 @@ def login_bysms():
return jsonify(code=RET.OK, msg="登录成功", data={"token": token, "flag": user.flag}) return jsonify(code=RET.OK, msg="登录成功", data={"token": token, "flag": user.flag})
# 用户中心-账号设置-添加账号(注册)
@api_user.route("/Register", methods=["POST"])
def register():
"""
用户注册
:return:
"""
# 获取请求参数，转化字典
req_dict = request.get_json()
real_name = req_dict.get("real_name") # 姓名
mobile = req_dict.get('mobile') # 联系电话
belong_organization = req_dict.get("belong_organization") # 所属机构
# age = req_dict.get("age") # 年龄
# sex = req_dict.get("sex") # 性别
# sms_code = req_dict.get("sms_code") # 验证码
is_organization_manager = req_dict.get("is_organization_manager") # 是否是机构负责人
charge_organization = req_dict.get("charge_organization") # 是机构负责人的话，所负责的机构
belong_department = req_dict.get("belong_department") # 所属部门（政府）
is_department_manager = req_dict.get("is_department_manager") # 是否是部门负责人
# charge_department = req_dict.get("charge_department") # 是部门负责人的话，所负责的部门
position = req_dict.get("position") # 职务
name = req_dict.get("name") # 用户名
password = req_dict.get("password") # 密码
password_again = req_dict.get("password_again") # 密码2
# 校验参数完整性
if not all([real_name, mobile, name, belong_organization, is_organization_manager, belong_department,
is_department_manager,
position, password, password_again]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
# 校验手机号格式
if not re.match(r"1[23456789]\d{9}$", mobile):
return jsonify(code=RET.PARAMERR, msg="手机号格式错误")
# # 获取短信验证码
# try:
# real_sms_code = redis_store.get('sms_code_{}'.format(mobile)).decode()
# # real_sms_code = "123456"
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.NODATA, msg="短信验证码失效")
#
# # 判断短信验证码是否失效
# if not redis_store:
# return jsonify(code=RET.NODATA, msg="短信验证码失效")
# # 删除redis中的短信验证码，防止重复校验
# try:
# redis_store.delete("sms_code_{}".format(mobile))
# except Exception as e:
# current_app.logger.error(e)
#
# # 判断用户填写短信验证码是否一致
# if real_sms_code != sms_code:
# # if "123456" != sms_code:
# return jsonify(code=RET.DATAERR, 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="用户名格式错误")
# 校验密码
if password != password_again:
return jsonify(code=RET.DATAERR, msg="密码不一致")
# 增加密码校验策略，20211109
# 判断密码长度是否8位，数字、字母、特殊字符同时存在，能使用用户名、连续性字母、数字、特殊字符等易猜测口令。
if len(password) < 8:
return jsonify(code=RET.DATAERR, msg="密码长度最少为8位")
# 密码应设置为包含大小写字母、数字、特殊符号'!@#$%^&*()_+=-'
if not (re.search(r'\d+', password) and re.search(r'[a-z]+', password) and re.search(r'[A-Z]+',
password) and re.search(
r'[.!@#$%^&*()_+=-]+', password)):
return jsonify(code=RET.DATAERR, msg="密码应设置为包含大小写字母、数字、特殊符号'!@#$%^&*()_+=-'")
# 密码不能使用用户名
if password == name:
return jsonify(code=RET.DATAERR, msg="密码存在风险，不能与用户名相同！")
# 判断并添加用户信息
try:
ouser = User.query.filter_by(mobile=mobile).first()
print(ouser)
# if ouser and ouser.flag == 1 and ouser.status != 1: # 外部访客被禁止
# return jsonify(code=RET.DATAEXIST, msg="当前用户被禁止，请联系管理员")
# if ouser and ouser.flag == 2 and ouser.status == 2: # 注册暂时未通过
# return jsonify(code=RET.DATAEXIST, msg="手机号已注册,请耐心等待审核")
if ouser and ouser.flag == 2 and ouser.status == 1: # 内部用户再次注册
return jsonify(code=RET.DATAEXIST, msg="手机号已注册,请勿重复注册")
if ouser and ouser.flag == 1 and ouser.status == 1: # 外部访客注册
ouser.real_name = real_name # 姓名
ouser.mobile = mobile # 联系电话
ouser.belong_organization = belong_organization # 所属机构
ouser.is_organization_manager = is_organization_manager # 是否为机构负责人
ouser.charge_organization = charge_organization # 是机构负责人的话，所负责的机构
ouser.belong_department = belong_department # 所属部门
ouser.is_department_manager = is_department_manager # 是否为部门负责人
# ouser.charge_department = charge_department # 是部门负责人的话，所负责的部门
ouser.position = position # 职务
ouser.name = name # 用户名
ouser.flag = 2 # 外部访问为1，内部人员为2
# ouser.status = 1 #
ouser.password = password
else:
user = User(real_name=real_name,
mobile=mobile,
belong_organization=belong_organization,
is_organization_manager=is_organization_manager,
charge_organization=charge_organization,
belong_department=belong_department,
is_department_manager=is_department_manager,
# charge_department=charge_department,
position=position,
name=name,
flag=2, status=1, password=password)
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库异常")
# except IntegrityError as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="手机号已被使用，请勿重复注册")
return jsonify(code=RET.OK, msg="注册成功")
# 内部用户手机-密码登录 # 内部用户手机-密码登录
@api_user.route("/LoginByPwd", methods=["POST"]) @api_user.route("/LoginByPwd", methods=["POST"])
def login_bypwd(): def login_bypwd():
...@@ -499,137 +356,348 @@ def binding(): ...@@ -499,137 +356,348 @@ def binding():
token = create_token(user.id) token = create_token(user.id)
return jsonify(code=RET.OK, msg="绑定成功，登录成功", data={"token": token, "flag": user.flag}) return jsonify(code=RET.OK, msg="绑定成功，登录成功", data={"token": token, "flag": user.flag})
# # 异步邮箱发送信息
# def send_async_email(mail, app, msg): """
# with app.app_context(): 用户中心
# mail.send(msg) """
#
#
# # 给邮箱发验证码 # 用户中心-账号设置-添加账号(注册)
# @api_user.route("/send_email_code", methods=["POST"]) @api_user.route("/Register", methods=["POST"])
# def send_email_code(): def register():
# ''' """
# 向邮箱送验证码 用户注册
# :return: :return:
# ''' """
# # 获取请求参数，转化字典 # 获取请求参数，转化字典
# req_dict = request.get_json() req_dict = request.get_json()
# email = req_dict.get('email') # 邮箱号
# # 校验参数完整性 real_name = req_dict.get("real_name") # 姓名
# if not all([email]): mobile = req_dict.get('mobile') # 联系电话
# return jsonify(code=RET.PARAMERR, msg="参数不完整") belong_organization = req_dict.get("belong_organization") # 所属机构
# # age = req_dict.get("age") # 年龄
# # 校验邮箱格式 # sex = req_dict.get("sex") # 性别
# if not re.match("^.+\\@(\\[?)[a-zA-Z0-9\\-\\.]+\\.([a-zA-Z]{2,3}|[0-9]{1,3})(\\]?)$", email): # sms_code = req_dict.get("sms_code") # 验证码
# return jsonify(code=RET.PARAMERR, msg="邮箱格式错误") is_organization_manager = req_dict.get("is_organization_manager") # 是否是机构负责人
# charge_organization = req_dict.get("charge_organization") # 是机构负责人的话，所负责的机构
# # print(email)
# app = creat_app('product') belong_department = req_dict.get("belong_department") # 所属部门（政府）
# mail = Mail(app) is_department_manager = req_dict.get("is_department_manager") # 是否是部门负责人
# sms_code = "%06d" % random.randint(0, 999999) # charge_department = req_dict.get("charge_department") # 是部门负责人的话，所负责的部门
#
# msg = Message("中研认知产业链在线,欢迎您！", recipients=[email]) position = req_dict.get("position") # 职务
# msg.body = "【中研认知产业链在线】您的验证码为：{}，您正在进行邮箱绑定，如非本人操作，请忽略本邮件！".format(sms_code)
# thread = threading.Thread(target=send_async_email, args=(mail, app, msg)) name = req_dict.get("name") # 用户名
# thread.start() password = req_dict.get("password") # 密码
# try: password_again = req_dict.get("password_again") # 密码2
# redis_store.setex("ems_code_%s" % email, constants.SMS_CODE_REDIS_EXPIRES, sms_code)
# # 保存发送给这个邮箱的记录，防止用户在180s内再次出发发送短信的操作 # 校验参数完整性
# redis_store.setex("send_ems_code_%s" % email, constants.SEND_EMS_CODE_INTERVAL, 1) if not all([real_name, mobile, name, belong_organization, is_organization_manager, belong_department,
# except Exception as e: is_department_manager,
# current_app.logger.error(e) position, password, password_again]):
# return jsonify(code=RET.DBERR, msg="保存验证码异常") return jsonify(code=RET.PARAMERR, msg="参数不完整")
#
# return jsonify(code=RET.OK, msg="发送成功") # 校验手机号格式
# '''''' if not re.match(r"1[23456789]\d{9}$", mobile):
return jsonify(code=RET.PARAMERR, msg="手机号格式错误")
# # 注册页面选择选择单位(2020-11-4) # # 获取短信验证码
# @api_user.route('/orgs', methods=['GET']) # try:
# def zcorgs(): # real_sms_code = redis_store.get('sms_code_{}'.format(mobile)).decode()
# ''' # # real_sms_code = "123456"
# 太原市企业条件选择导航获取 # except Exception as e:
# :return: # current_app.logger.error(e)
# ''' # return jsonify(code=RET.NODATA, msg="短信验证码失效")
# try: #
# gover = Government.query.all() # # 判断短信验证码是否失效
# ty = Government.query.get(1) # if not redis_store:
# sections = ty.sections # return jsonify(code=RET.NODATA, msg="短信验证码失效")
# data = [{"label": i.name, "value": i.id} for i in gover]
# section = [{"label": i.name, "value": i.id} for i in sections] # # 删除redis中的短信验证码，防止重复校验
# orgs = {"data": data, "section": section} # try:
# return jsonify(code=RET.OK, msg="获取成功", orgs=orgs) # redis_store.delete("sms_code_{}".format(mobile))
# except Exception as e: # except Exception as e:
# current_app.logger.error(e) # current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库查询错误") #
# # # 判断用户填写短信验证码是否一致
# # if real_sms_code != sms_code:
# # # if "123456" != sms_code:
# # return jsonify(code=RET.DATAERR, 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="用户名格式错误")
# @api_user.route("/backLogin", methods=["POST"])
# def back_login(): # 校验密码
# ''' if password != password_again:
# 用户密码登录 return jsonify(code=RET.DATAERR, msg="密码不一致")
# :return:
# ''' # 增加密码校验策略，20211109
# # 参数获取与校验 # 判断密码长度是否8位，数字、字母、特殊字符同时存在，能使用用户名、连续性字母、数字、特殊字符等易猜测口令。
# req_dict = request.get_json() if len(password) < 8:
# # 解密 return jsonify(code=RET.DATAERR, msg="密码长度最少为8位")
# param = req_dict.get("param") # 揭秘参数 # 密码应设置为包含大小写字母、数字、特殊符号'!@#$%^&*()_+=-'
# req_dict = json.loads(decrypt(param)) if not (re.search(r'\d+', password) and re.search(r'[a-z]+', password) and re.search(r'[A-Z]+',
# name = req_dict.get('name') password) and re.search(
# password = req_dict.get('password') r'[.!@#$%^&*()_+=-]+', password)):
# # 校验参数完整性 return jsonify(code=RET.DATAERR, msg="密码应设置为包含大小写字母、数字、特殊符号'!@#$%^&*()_+=-'")
# if not all([name, password]): # 密码不能使用用户名
# return jsonify(code=RET.PARAMERR, msg="参数不完整") if password == name:
# return jsonify(code=RET.DATAERR, msg="密码存在风险，不能与用户名相同！")
# # 判断错误次数是否超过限制，如果超过则10分钟内禁止此IP登录
# user_ip = request.remote_addr # 判断并添加用户信息
# # print("IP地址：", user_ip) try:
# try: ouser = User.query.filter_by(mobile=mobile).first()
# access_nums = redis_store.get('access_nums_{}'.format(user_ip)) print(ouser)
# except Exception as e: # if ouser and ouser.flag == 1 and ouser.status != 1: # 外部访客被禁止
# current_app.logger.error(e) # return jsonify(code=RET.DATAEXIST, msg="当前用户被禁止，请联系管理员")
# else:
# if access_nums: # if ouser and ouser.flag == 2 and ouser.status == 2: # 注册暂时未通过
# if int(access_nums.decode()) >= constants.LOGIN_ERROR_TIMES: # return jsonify(code=RET.DATAEXIST, msg="手机号已注册,请耐心等待审核")
# return jsonify(code=RET.REQERR, msg="错误次数过多，请稍候重试")
# if ouser and ouser.flag == 2 and ouser.status == 1: # 内部用户再次注册
# # 验证账户与密码 return jsonify(code=RET.DATAEXIST, msg="手机号已注册,请勿重复注册")
# try:
# user = Bstage.query.filter_by(name=name).first() if ouser and ouser.flag == 1 and ouser.status == 1: # 外部访客注册
# except Exception as e: ouser.real_name = real_name # 姓名
# current_app.logger.error(e) ouser.mobile = mobile # 联系电话
# return jsonify(code=RET.DBERR, msg="获取用户信息失败") ouser.belong_organization = belong_organization # 所属机构
# ouser.is_organization_manager = is_organization_manager # 是否为机构负责人
# # 将用户名与密码验证放置在一处，若失败返回提示信息并记录次数 ouser.charge_organization = charge_organization # 是机构负责人的话，所负责的机构
# if (not user) or (not user.check_password(password)):
# # if (not user) or (password != "123"): ouser.belong_department = belong_department # 所属部门
# try: ouser.is_department_manager = is_department_manager # 是否为部门负责人
# redis_store.incr('access_nums_{}'.format(user_ip)) # ouser.charge_department = charge_department # 是部门负责人的话，所负责的部门
# redis_store.expire('access_nums_{}'.format(user_ip), constants.LOGIN_ERROR_FORBID_TIME)
# except Exception as e: ouser.position = position # 职务
# current_app.logger.error(e) ouser.name = name # 用户名
# return jsonify(code=RET.DBERR, msg="密码错误") ouser.flag = 2 # 外部访问为1，内部人员为2
# # ouser.status = 1 #
# # 若成功保存登录状态和管理员的角色id ouser.password = password
# token = create_token(user.id) else:
# user = User(real_name=real_name,
# time = datetime.now() mobile=mobile,
# current_app.logger.error( belong_organization=belong_organization,
# '++++++++++++++++++++++++++++登录日志>>>{}:{}通过后台登录成功了！+++++++++++++++++++++++=++'.format(time, name)) is_organization_manager=is_organization_manager,
# charge_organization=charge_organization,
# return jsonify(code=RET.OK, msg="登录成功", token=token, flag=3) belong_department=belong_department,
is_department_manager=is_department_manager,
# charge_department=charge_department,
position=position,
name=name,
flag=2, status=1, password=password)
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库异常")
# except IntegrityError as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="手机号已被使用，请勿重复注册")
return jsonify(code=RET.OK, msg="注册成功")
# 用户中心-个人中心初始数据展示
@api_user.route("/UserInfo", methods=["GET"])
@login_required
def detail():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
try:
user_info = User.query.get(user_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
data = {
"flag": user.flag,
"real_name": user_info.real_name, # 名字
"age": user_info.age, # 年龄
"sex": user_info.sex, # 性别
"mobile": user_info.mobile, # 手机号
"username": user_info.name, # 用户名
# "email": user_info.email, # 邮箱
"belong_organization": user_info.belong_organization if user_info.belong_organization else "-", # 机构
"belong_department": user_info.belong_department if user_info.belong_department else "-", # 部门
"position": user_info.position if user_info.position else "-", # 职务
# "level": user_info.level if user_info.level else "-", # 职级
# "unit": user_info.unit if user_info.unit else "-", # 所在机构
# "funct": user_info.function if user_info.function else "-", # 工作职能
# "name": user_info.name if user_info.name else "-", # 用户名
# "password": user_info.password if user_info.password else "-", # 密码
}
return jsonify(code=RET.OK, msg="查找成功", data=data)
# 用户中心-个人中心确认修改
@api_user.route("/FixUserInfo", methods=["POST"])
@login_required
def fix_user_info():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
req_dict = request.get_json()
real_name = req_dict.get("real_name")
age = req_dict.get("age")
sex = req_dict.get("sex")
name = req_dict.get("name")
position = req_dict.get("position")
try:
user_information = User.query.get(user_id)
# 姓名
if real_name:
user_information.real_name = real_name
# 年龄
if age:
user_information.age = age
# 性别 1 - 男 2 - 女
if sex:
user_information.sex = sex
# 职务
if position:
user_information.position = position
# 用户名
if name:
user = User.query.filter_by(name=name).filter(User.id != user_id).first()
if user:
return jsonify(code=RET.DATAEXIST, msg="用户名已经存在")
user_information.name = name
db.session.commit()
except Exception as e:
db.session.rollback() # 回滚数据库
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
return jsonify(code=RET.OK, msg="修改成功")
# 修改用户手机号
@api_user.route("/ChangePhone", methods=["POST"])
@login_required
def change_phone():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
try:
user_info = User.query.get(user_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
req_dict = request.get_json()
mobile = req_dict.get("mobile")
sms_code = req_dict.get("sms_code")
# 校验手机号格式
if not re.match(r'^1[3456789]\d{9}$', user_info.mobile):
return jsonify(code=RET.PARAMERR, msg="手机号格式错误")
if not redis_store.get('sms_code_{}'.format(user_info.mobile)):
return jsonify(code=RET.DATAERR, msg="请获取验证码")
# 获取短信验证码
try:
real_sms_code = redis_store.get('sms_code_{}'.format(user_info.mobile)).decode()
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="redis数据库异常")
# 判断短信验证码是否失效
if not redis_store:
return jsonify(code=RET.NODATA, msg="短信验证码失效")
# 删除redis中的短信验证码，防止重复校验
try:
redis_store.delete("sms_code_{}".format(user_info.mobile))
except Exception as e:
current_app.logger.error(e)
# 判断用户填写短信验证码是否一致
if real_sms_code != sms_code:
return jsonify(code=RET.DATAERR, msg="短信验证码错误")
try:
exist = User.query.filter_by(mobile=mobile).first()
if exist:
return jsonify(code=RET.DATAEXIST, msg="手机号已存在")
user.mobile = mobile
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_user.route("/ChangePassword", methods=["POST"])
@login_required
def change_password():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
# 原密码是否正确
req_dic = request.get_json()
password = req_dic.get("password")
new_password = req_dic.get("new_password")
again_password = req_dic.get("again_password")
try:
user_info = User.query.get(user_id)
if not check_password_hash(user_info.password_hash, password):
return jsonify(code=RET.DATAERR, msg="原始密码错误")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 密码长度
if len(new_password) < 6:
return jsonify(code=RET.DATAERR, msg="密码太短，不安全")
# 新密码不能与原始密码一致
if new_password == password:
return jsonify(code=RET.DATAERR, msg="新密码不能与原始密码一致")
# 两次密码是否一致
if new_password != again_password:
return jsonify(code=RET.PARAMERR, msg="两次密码不一致")
# 判断密码长度是否8位，数字、字母、特殊字符同时存在，能使用用户名、连续性字母、数字、特殊字符等易猜测口令。
if len(new_password) < 8:
return jsonify(code=RET.DATAERR, msg="密码长度最少为8位")
# 密码应设置为包含大小写字母、数字、特殊符号'!@#$%^&*()_+=-'
if not (re.search(r'\d+', new_password) and re.search(r'[a-z]+', new_password) and re.search(r'[A-Z]+',
new_password) and re.search(
r'.[!@#$%^&*()_+=-]+', new_password)):
return jsonify(code=RET.DATAERR, msg="密码应设置为包含大小写字母、数字、特殊符号'!@#$%^&*()_+=-'")
# 两个密码是否都存在
if not all([new_password, again_password, password]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
user_info = User.query.get(user_id)
# if not check_password_hash(user_info.password_hash, password):
# return jsonify(code=RET.DATAERR, msg="密码错误")
user_info.password = new_password
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/view_user/view_other.py
...@@ -51,108 +51,7 @@ def send_async_email(mail, app, msg): ...@@ -51,108 +51,7 @@ def send_async_email(mail, app, msg):
mail.send(msg) mail.send(msg)
@api_user.route("/phoneChange", methods=["POST"])
@login_required
def phone_change():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
try:
user_information = User.query.get(user_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
req_dict = request.get_json()
mobile = req_dict.get("mobile")
sms_code = req_dict.get("sms_code")
user_information.mobile = mobile
sms_code = sms_code
print(sms_code)
# 校验手机号格式
if not re.match(r'^1[3456789]\d{9}$', user_information.mobile):
return jsonify(code=RET.PARAMERR, msg="手机号格式错误")
if not redis_store.get('sms_code_{}'.format(user_information.mobile)):
return jsonify(code=RET.DATAERR, msg="请获取验证码")
# 获取短信验证码
try:
real_sms_code = redis_store.get('sms_code_{}'.format(user_information.mobile)).decode()
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="redis数据库异常")
# 判断短信验证码是否失效
if not redis_store:
return jsonify(code=RET.NODATA, msg="短信验证码失效")
# 删除redis中的短信验证码，防止重复校验
try:
redis_store.delete("sms_code_{}".format(user_information.mobile))
except Exception as e:
current_app.logger.error(e)
# 判断用户填写短信验证码是否一致
if real_sms_code != sms_code:
return jsonify(code=RET.DATAERR, msg="短信验证码错误")
try:
exist = User.query.filter_by(mobile=mobile).first()
if exist:
return jsonify(code=RET.DATAEXIST, msg="手机号已存在")
user.mobile = mobile
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_user.route("/changepassword", methods=["POST"])
@login_required
def change_password():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
# 原密码是否正确
req_dic = request.get_json()
password = req_dic.get("password")
re_pas = req_dic.get("repassword")
new_pas = req_dic.get("newpass")
# 密码长度
if len(new_pas) < 6:
return jsonify(code=RET.DATAERR, msg="密码太短，不安全")
# 两次密码是否一致
if new_pas != re_pas:
return jsonify(code=RET.PARAMERR, msg="两次密码不一致")
# 判断密码长度是否8位，数字、字母、特殊字符同时存在，能使用用户名、连续性字母、数字、特殊字符等易猜测口令。
if len(new_pas) < 8:
return jsonify(code=RET.DATAERR, msg="密码长度最少为8位")
# 密码应设置为包含大小写字母、数字、特殊符号'!@#$%^&*()_+=-'
if not (re.search(r'\d+', new_pas) and re.search(r'[a-z]+', new_pas) and re.search(r'[A-Z]+',
new_pas) and re.search(
r'[!@#$%^&*()_+=-]+', new_pas)):
return jsonify(code=RET.DATAERR, msg="密码应设置为包含大小写字母、数字、特殊符号'!@#$%^&*()_+=-'")
# 两个密码是否都存在
if not all([new_pas, re_pas, password]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
user_information = User.query.get(user_id)
if not check_password_hash(user_information.password_hash, password):
return jsonify(code=RET.DATAERR, msg="密码错误")
user_information.password = new_pas
db.session.commit()
return jsonify(code=RET.DBERR, msg="更改成功")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 给邮箱发验证码 # 给邮箱发验证码
...@@ -248,76 +147,76 @@ def change_email(): ...@@ -248,76 +147,76 @@ def change_email():
return jsonify(code=RET.DBERR, msg="数据库错误") return jsonify(code=RET.DBERR, msg="数据库错误")
@api_user.route("/detail", methods=["GET"]) # @api_user.route("/detail", methods=["GET"])
@login_required # @login_required
def detail(): # def detail():
token = request.headers["token"] # token = request.headers["token"]
user = verify_token(token) # user = verify_token(token)
user_id = user.id # user_id = user.id
try: # try:
user_information = User.query.get(user_id) # user_information = User.query.get(user_id)
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="数据库错误")
#
data = { # data = {
"flag": user.flag, # "flag": user.flag,
"real_name": user_information.real_name, # 名字 # "real_name": user_information.real_name, # 名字
"age": user_information.age, # 年龄 # "age": user_information.age, # 年龄
"sex": user_information.sex, # 性别 # "sex": user_information.sex, # 性别
"mobile": user_information.mobile, # 手机号 # "mobile": user_information.mobile, # 手机号
"username": user_information.name, # 用户名 # "username": user_information.name, # 用户名
"email": user_information.email, # 邮箱 # "email": user_information.email, # 邮箱
"section": user_information.section if user_information.section else "-", # 部门 # "section": user_information.section if user_information.section else "-", # 部门
"position": user_information.position if user_information.position else "-", # 职务 # "position": user_information.position if user_information.position else "-", # 职务
"level": user_information.level if user_information.level else "-", # 职级 # "level": user_information.level if user_information.level else "-", # 职级
"unit": user_information.unit if user_information.unit else "-", # 所在机构 # "unit": user_information.unit if user_information.unit else "-", # 所在机构
"funct": user_information.function if user_information.function else "-", # 工作职能 # "funct": user_information.function if user_information.function else "-", # 工作职能
} # }
return jsonify(code=RET.OK, msg="查找成功", data=data) # return jsonify(code=RET.OK, msg="查找成功", data=data)
@api_user.route("/personal", methods=["POST"]) # @api_user.route("/personal", methods=["POST"])
@login_required # @login_required
def personal(): # def personal():
token = request.headers["token"] # token = request.headers["token"]
user = verify_token(token) # user = verify_token(token)
user_id = user.id # user_id = user.id
#
req_dict = request.get_json() # req_dict = request.get_json()
real_name = req_dict.get("real_name") # real_name = req_dict.get("real_name")
age = req_dict.get("age") # age = req_dict.get("age")
sex = req_dict.get("sex") # sex = req_dict.get("sex")
name = req_dict.get("name") # name = req_dict.get("name")
#
try: # try:
user_information = User.query.get(user_id) # user_information = User.query.get(user_id)
#
# 姓名 # # 姓名
if real_name: # if real_name:
user_information.real_name = real_name # user_information.real_name = real_name
#
# 年龄 # # 年龄
if age: # if age:
user_information.age = age # user_information.age = age
#
# 性别 1 - 男 2 - 女 # # 性别 1 - 男 2 - 女
if sex: # if sex:
user_information.sex = sex # user_information.sex = sex
#
# 用户名 # # 用户名
if name: # if name:
user = User.query.filter_by(name=name).filter(User.id != user_id).first() # user = User.query.filter_by(name=name).filter(User.id != user_id).first()
if user: # if user:
return jsonify(code=RET.DATAEXIST, msg="用户名已经存在") # return jsonify(code=RET.DATAEXIST, msg="用户名已经存在")
user_information.name = name # user_information.name = name
db.session.commit() # db.session.commit()
except Exception as e: # except Exception as e:
db.session.rollback() # 回滚数据库 # 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="数据库错误")
#
return jsonify(code=RET.OK, msg="修改成功") # return jsonify(code=RET.OK, msg="修改成功")
# 企业的收藏加个下拉列表来判断来自哪个表--是全国企业还是山西企业。返回值里面要带有status还未添加 # 企业的收藏加个下拉列表来判断来自哪个表--是全国企业还是山西企业。返回值里面要带有status还未添加
......
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