Skip to content

M
mancheng
Commit adcaf3a2 by dong
Options

fix20220308

parent 1d3f6d87
Showing with 1225 additions and 1146 deletions
apps/manage/view_org.py
import time
from datetime import datetime
from flask import request, jsonify, current_app, g
from apps.manage import api_power
from apps.models import *
from apps.utils.response_code import RET
from apps.util import login_required
# 获取上级或下级统筹机构 (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="数据库查询错误")
from apps.util import login_required, verify_token
# 获取上级机构后的统筹机构 (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
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()
name = req_dict.get("name") # 机构名称
forg = req_dict.get("forg") # 上级机构 id
org_name = req_dict.get("name") # 机构名称
# forg = req_dict.get("forg") # 上级机构 id
charge = req_dict.get("charge") # 机构负责人
charge_phone = req_dict.get("charge_phone") # 负责人电话
sublist = req_dict.get("sublist") # 统筹机构id list["1","2"...]
# sublist = req_dict.get("sublist") # 统筹机构id list["1","2"...]
# 校验参数完整性
if not all([name]):
if not all([org_name]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
gover = Government.query.filter_by(name=name).first()
gover = GovOrganization.query.filter_by(name=org_name).first()
if gover: # 机构名相同，提示其错误
return jsonify(code=RET.DBERR, msg="机构名重复")
goverment = Government(name=name) # 创建机构
goverment = GovOrganization(name=org_name) # 创建机构
if charge:
goverment.charge = charge
if charge_phone:
goverment.charge_phone = charge_phone
if user_name:
goverment.add_person = user_name
add_time = datetime.now()
goverment.add_time = add_time
db.session.add(goverment) # 添加到数据库
if forg: # 如果有上级机构，就让上级机构统筹新增机构
fgover = Government.query.get(forg)
fgover.followed.append(goverment)
for ctr in sublist: # 如果有统筹机构，就让新增机构统筹
sgover = Government.query.get(ctr)
goverment.followed.append(sgover)
# if forg: # 如果有上级机构，就让上级机构统筹新增机构
# fgover = Government.query.get(forg)
# fgover.followed.append(goverment)
# for ctr in sublist: # 如果有统筹机构，就让新增机构统筹
# sgover = Government.query.get(ctr)
# goverment.followed.append(sgover)
db.session.commit() # 提交数据库
return jsonify(code=RET.OK, msg="添加成功")
except Exception as e:
......@@ -82,121 +60,82 @@ def add_org():
return jsonify(code=RET.DBERR, msg="数据库操作错误")
# 组织架构管理,获取机构单位数据（ok）
@api_power.route("/organization", methods=["POST"])
# 查询添加过的机构信息
@api_power.route("/GetOrg", methods=["GET"])
@login_required
def organization():
req_dict = request.get_json()
page = req_dict.get("page")
perpage = req_dict.get("perpage")
# 校验参数完整性
if not all([page, perpage]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
def get_org():
try:
# goverment = Government.query.paginate(page, perpage).items
goverment = Government.query.all()
size = Government.query.count()
df = [{"id": gover.id,
"name": gover.name,
"pnums": gover.pnums if gover.pnums else 0,
"charge": gover.charge if gover.charge else "-",
"charge_phone": gover.charge_phone if gover.charge_phone else "-",
"cate": 1} for gover in goverment]
data = {"df": df, "size": size}
return jsonify(code=RET.OK, msg="查找成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误", data=[])
# 组织架构获取部门和组（Ok）
@api_power.route("/sectionGroup", methods=["POST"])
@login_required
def section_group():
req_dict = request.get_json()
_id = req_dict.get("id") # 当前机构或者部门的id
cate = req_dict.get("cate") # 分类标识，1机构，2部门
# 校验参数完整性
if not all([_id, cate]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if cate == 1: # 查询当前机构下的部门
goverment = Government.query.get(_id)
sections = goverment.sections # 查询当前机构下的部门list
data = [{"id": sec.id,
"name": sec.name,
"pnums": sec.pnums if sec.pnums else 0,
"charge": sec.charge if sec.charge else "-",
"charge_phone": sec.charge_phone if sec.charge_phone else "-",
"cate": 2} for sec in sections]
return jsonify(code=RET.OK, msg="查找成功", data=data)
if cate == 2: # 查询当前部门下的组
section = Section.query.get(_id)
groups = section.groups # 查询当前部门下的组list
data = [{"id": group.id,
"name": group.name,
"pnums": group.pnums if group.pnums else 0,
"charge": group.charge if group.charge else "-",
"charge_phone": group.charge_phone if group.charge_phone else "-",
"cate": 3} for group in groups]
return jsonify(code=RET.OK, msg="查找成功", data=data)
return jsonify(code=RET.OK, msg="暂无下级信息", data=[])
org = GovOrganization.query.all()
data = [{"id": i.id, "name": i.name, "pnums": i.pnums,
"charge": i.charge, "charge_phone": i.charge_phone,
"add_person": i.add_person, "add_time": i.add_time,
"edit_person": i.edit_person, "edit_time": i.edit_time}
for i in org]
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误", data=[])
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 新增下级部门(ok)
@api_power.route("/addSub", methods=["POST"])
@api_power.route("/AddSubDepartment", methods=["POST"])
@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()
_id = req_dict.get("id") # 当前机构或者部门id
cate = req_dict.get("cate") # 分类标识，1机构，2部门
id = req_dict.get("id") # 当前机构或者部门id
# cate = req_dict.get("cate") # 分类标识，1机构，2部门
name = req_dict.get("name") # 部门或组名称
pnums = req_dict.get("pnums") # 机构负责人
# pnums = req_dict.get("pnums") # 人数
charge = req_dict.get("charge") # 机构负责人
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="参数不完整")
try:
if cate == 1: # 增加部门
sec = Section.query.filter_by(name=name, goverment_id=_id).first()
# if cate == 1: # 增加部门
sec = GovDepartment.query.filter_by(name=name, goverment_org_id=id).first()
if sec: # 一个机构下部门名不能重复
return jsonify(code=RET.DATAERR, msg="部门名重复")
goverment = Government.query.get(_id)
section = Section(name=name, goverment_id=_id)
if pnums:
section.pnums = pnums
gov_organization = GovOrganization.query.get(id)
gov_department = GovDepartment(name=name, goverment_org_id=id)
# if pnums:
# gov_department.pnums = pnums
if charge:
section.charge = charge
gov_department.charge = charge
if charge_phone:
section.charge_phone = charge_phone
db.session.add(section) # 添加部门
goverment.sections.append(section) # 外键关系添加
gov_department.charge_phone = charge_phone
if user_name:
gov_department.add_person = user_name
add_time = datetime.now()
gov_department.add_time = add_time
db.session.add(gov_department) # 添加部门
gov_organization.government_departments.append(gov_department) # 外键关系添加
db.session.commit() # 数据库提交
if cate == 2: # 增加组
gro = Group.query.filter_by(name=name, section_id=_id).first()
if gro: # 一个部门下组名不能重复
return jsonify(code=RET.DATAERR, msg="组名重复")
section = Section.query.get(_id)
group = Group(name=name, section_id=_id)
if pnums:
group.pnums = pnums
if charge:
group.charge = charge
if charge_phone:
group.charge_phone = charge_phone
db.session.add(group) # 添加组
section.groups.append(group) # 添加关系
db.session.commit() # 提交
if cate == 3:
return jsonify(code=RET.OK, msg="暂无下级机构，请勿继续添加")
# if cate == 2: # 增加组
# gro = Group.query.filter_by(name=name, gov_department_id=_id).first()
# if gro: # 一个部门下组名不能重复
# return jsonify(code=RET.DATAERR, msg="组名重复")
# gov_department = Section.query.get(_id)
# group = Group(name=name, section_id=_id)
# if pnums:
# group.pnums = pnums
# if charge:
# group.charge = charge
# if charge_phone:
# group.charge_phone = charge_phone
# db.session.add(group) # 添加组
# section.groups.append(group) # 添加关系
# db.session.commit() # 提交
# if cate == 3:
# return jsonify(code=RET.OK, msg="暂无下级机构，请勿继续添加")
return jsonify(code=RET.OK, msg="添加成功")
except Exception as e:
# 操作失败，数据回滚
......@@ -205,521 +144,624 @@ def add_sub():
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:
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"])
# # 获取上级或下级统筹机构 (ok)
# @api_power.route("/uadOrg", methods=["GET"])
# @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"])
# 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 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)
# def down_org():
# req_dict = request.get_json()
# _id = req_dict.get("id") # 机构名称
# try:
# if _id:
# gover = Government.query.all()
# data = [{"label": i.name, "value": i.id} for i in gover if i.id != _id]
# return jsonify(code=RET.OK, msg="查询成功", data=data)
# else:
# gover = Government.query.all()
# data = [{"label": i.name, "value": i.id} for i in gover]
# return jsonify(code=RET.OK, msg="查询成功", data=data)
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库查询错误")
#
#
# # 组织架构管理,获取机构单位数据（ok）
# @api_power.route("/organization", methods=["POST"])
# @login_required
# def organization():
# req_dict = request.get_json()
# page = req_dict.get("page")
# perpage = req_dict.get("perpage")
# # 校验参数完整性
# if not all([page, perpage]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
# try:
# # goverment = Government.query.paginate(page, perpage).items
# goverment = Government.query.all()
# size = Government.query.count()
# df = [{"id": gover.id,
# "name": gover.name,
# "pnums": gover.pnums if gover.pnums else 0,
# "charge": gover.charge if gover.charge else "-",
# "charge_phone": gover.charge_phone if gover.charge_phone else "-",
# "cate": 1} for gover in goverment]
# data = {"df": df, "size": size}
# return jsonify(code=RET.OK, msg="查找成功", data=data)
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库查询错误", data=[])
#
#
# # 组织架构获取部门和组（Ok）
# @api_power.route("/sectionGroup", methods=["POST"])
# @login_required
# def section_group():
# req_dict = request.get_json()
# _id = req_dict.get("id") # 当前机构或者部门的id
# cate = req_dict.get("cate") # 分类标识，1机构，2部门
#
# # 校验参数完整性
# if not all([_id, cate]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
#
# try:
# if cate == 1: # 查询当前机构下的部门
# goverment = Government.query.get(_id)
# sections = goverment.sections # 查询当前机构下的部门list
# data = [{"id": sec.id,
# "name": sec.name,
# "pnums": sec.pnums if sec.pnums else 0,
# "charge": sec.charge if sec.charge else "-",
# "charge_phone": sec.charge_phone if sec.charge_phone else "-",
# "cate": 2} for sec in sections]
# return jsonify(code=RET.OK, msg="查找成功", data=data)
# if cate == 2: # 查询当前部门下的组
# section = Section.query.get(_id)
# groups = section.groups # 查询当前部门下的组list
# data = [{"id": group.id,
# "name": group.name,
# "pnums": group.pnums if group.pnums else 0,
# "charge": group.charge if group.charge else "-",
# "charge_phone": group.charge_phone if group.charge_phone else "-",
# "cate": 3} for group in groups]
# return jsonify(code=RET.OK, msg="查找成功", data=data)
# return jsonify(code=RET.OK, msg="暂无下级信息", data=[])
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库查询错误", data=[])
#
#
# # 删除组织机构或者部门和组(需要先删除人员)--------OK
# @api_power.route("/deleteOrg", methods=["POST"])
# @login_required
# def deleteorg():
# req_dict = request.get_json()
# _id = req_dict.get("id") # 待删除的，部门、机构、组、id
# cate = req_dict.get("cate") # 待删除数据的类别 1政府，2部门，3组
#
# # 校验参数完整性
# if not all([_id, cate]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
#
# try:
# if cate == 1: # 删除机构
# gover = Government.query.get(_id) # 当前机构对象
# section = gover.sections # 当前机构下的部门对象列表
# if len(section) > 0: # 有部门就需要先删除部门
# return jsonify(code=RET.REQERR, msg="当前机构有部门存在，请清除后再操作")
# unums = User.query.filter_by(unit=gover.name, status=1).count() # 当前机构下通过审核人员
# if unums > 0: # 当前部门有人，先到机构详情，进行人员的删除
# return jsonify(code=RET.REQERR, msg="当前机构有人员存在，请清除后再操作")
# db.session.delete(gover) # 无人无部门，删除
# db.session.commit() # 提交
# return jsonify(code=RET.OK, msg="删除成功")
# if cate == 2: # 删除部门
# section = Section.query.get(_id)
# gover = section.goverment # 部门所属的机构
# group = section.groups # 当前部门的组对象list
# if len(group) > 0: # 如果有组先删除组
# return jsonify(code=RET.REQERR, msg="当前部门有组存在，请清除后再操作")
# unums = User.query.filter_by(unit=gover.name, section=section.name, status=1).count() # # 已经通过审核的人数
# if unums > 0: # 当前部门有人，先到部门详情，进行部门人员的删除
# return jsonify(code=RET.REQERR, msg="当前部门有人员存在，请清除后再操作")
# gover.sections.remove(section) # 当前部门没有人，没有组，删除部门之前需要先删除与之相关的机构关系
# db.session.delete(section) # 删除
# db.session.commit() # 提交
# return jsonify(code=RET.OK, msg="删除成功")
# if cate == 3: # 删除组
# group = Group.query.get(_id) # 当前组信息
# section = group.section # 组属于的部门，单个对象
# gover = section.goverment # 部门属于的机构，单个对象
# unums = User.query.filter_by(unit=gover.name, section=section.name, group=group.name,
# status=1).count() # 已经通过审核的人数
# if unums > 0: # 当前组有人，先到组详情，进行组员的删除
# return jsonify(code=RET.REQERR, msg="当前组有人员存在，请清除后再操作")
# section.groups.remove(group) # 当前组没有人，删除组之前需要先删除与之相关的部门关系
# db.session.delete(group) # 删除
# db.session.commit() # 提交
# return jsonify(code=RET.OK, msg="删除成功")
# else:
# return jsonify(code=RET.DATAERR, msg="参数错误")
# except Exception as e:
# # 操作失败，回滚数据库
# db.session.rollback()
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库操作失败")
#
#
# ''''''
#
#
# # 获取机构，部门或者组详情()
# @api_power.route("/orgDetail", methods=["POST"])
# @login_required
# def org_detail():
# req_dict = request.get_json()
# _id = req_dict.get("id") # id
# cate = req_dict.get("cate") # 1机构，2部门，3组
#
# # 校验参数完整性
# if not all([_id, cate]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
#
# try:
# if cate == 1: # 政府机构详情
# goverment = Government.query.get(_id)
# # 政府信息
# data = {"id": goverment.id,
# "name": goverment.name, # 机构名
# "charge": goverment.charge if goverment.charge else "-", # 主管
# "phone": goverment.charge_phone if goverment.charge_phone else "-", # 电话
# "pnums": goverment.pnums if goverment.pnums else 0, # 机构人数
# "secnums": len(goverment.sections), # 部门数
# "func": goverment.function if goverment.function else "", # 政府职能
# "cate": cate}
# return jsonify(code=RET.OK, msg="查询成功", data=data)
# if cate == 2: # 部门详情
# section = Section.query.get(_id)
# # 政府信息
# data = {"id": section.id,
# "name": section.name, # 机构名
# "charge": section.charge if section.charge else "-", # 主管
# "phone": section.charge_phone if section.charge_phone else "-", # 电话
# "pnums": section.pnums if section.pnums else 0, # 机构人数
# "secnums": len(section.groups), # 组数
# "func": section.function if section.function else "", # 部门职能
# "cate": cate}
# return jsonify(code=RET.OK, msg="查询成功", data=data)
# if cate == 3: # 组详情
# group = Group.query.get(_id)
# # 政府信息
# data = {"id": group.id,
# "name": group.name, # 机构名
# "charge": group.charge if group.charge else "-", # 主管
# "phone": group.charge_phone if group.charge_phone else "-", # 电话
# "pnums": group.pnums if group.pnums else 0, # 机构人数
# "secnums": "-",
# "func": group.function if group.function else "", # 部门职能
# "cate": cate}
# return jsonify(code=RET.OK, msg="查询成功", data=data)
#
# return jsonify(code=RET.OK, msg="参数错误")
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库操作错误")
#
#
# # 编辑机构，部门或者组详情
# @api_power.route("/editDetail", methods=["POST"])
# @login_required
# def edit_detail():
# req_dict = request.get_json()
# _id = req_dict.get("id") # 部门id
# cate = req_dict.get("cate") # 1机构，2部门，3组
# name = req_dict.get("name") # 1机构，2部门，3组 的名称
# charge = req_dict.get("charge") # 局内领导
# charge_phone = req_dict.get("charge_phone") # 联系方式
# func = req_dict.get("func") # 部门职能
# pnums = str(req_dict.get("pnums")) # 人数
# secnums = str(req_dict.get("secnums")) # 部门组人数
#
# # 校验参数完整性
# if not all([_id, name, charge, charge_phone, pnums, secnums]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
#
# try:
# if cate == 1: # 机构
# gover = Government.query.filter_by(name=name).filter(Government.id != _id).first()
# if gover:
# return jsonify(code=RET.DBERR, msg="机构名不可重复")
# gover = Government.query.get(_id)
# gover.name = name
# gover.charge = charge
# gover.charge_phone = charge_phone
# gover.function = func
# gover.pnums = pnums
# gover.secnums = secnums
# db.session.commit()
# return "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="数据库操作失败")
# 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/models.py
......@@ -993,6 +993,76 @@ class Role(BaseModel, db.Model):
role = db.Column(db.String(10), unique=True, comment='权限值 000000 0位位职级123，后面为权限01')
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):
# __tablename_ = "item"
......@@ -1071,38 +1141,9 @@ class Role(BaseModel, db.Model):
# 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)
# )
#
#
# # 政府机构表（自关联多对多）
# 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组）
# class Group(db.Model):
......
apps/util.py
......@@ -5,13 +5,13 @@ from itsdangerous import SignatureExpired, BadSignature
from flask import request, jsonify, current_app
from config import Config
# from apps.models import User, Bstage
from apps.models import User
import functools
# from flask_httpauth import HTTPBasicAuth
#
# auth = HTTPBasicAuth
# from models import User
class RegexConverter(BaseConverter):
......
apps/utils/send_phone_info.py
......@@ -106,4 +106,33 @@ def code_new(phone, c_num):
el = eval(str(response, encoding='utf-8'))
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
from flask import g, current_app, request, jsonify, session
from apps.view_user import api_user
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 import db, constants, redis_store
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 apps import qiniu_store
from apps.utils.vxconfig import WxConfig
......@@ -53,12 +53,13 @@ def send_phone_code():
# 生成短信验证码
sms_code = "%06d" % random.randint(0, 999999)
data = ''
if sms_type == 1:
if sms_type == 1: # 验证码登录
data = send_code_new(mobile, sms_code)
if sms_type == 2:
if sms_type == 2: # 手机号码绑定
data = send_code(mobile, sms_code)
# print(data)
if sms_type == 3: # 密码重置验证码
data = send_reset_password_code(mobile, sms_code)
print(data)
if data['Message'] == 'OK':
# 保存真实的短信验证码
try:
......@@ -70,6 +71,8 @@ def send_phone_code():
return jsonify(code=RET.DBERR, msg="保存短信验证码异常")
# 发送成功
return jsonify(code=RET.OK, msg="发送成功")
if data['Message'] != 'OK':
return jsonify(code=RET.THIRDERR, msg="发送次数太多，已被限流，请稍后再试！")
else:
return jsonify(code=RET.THIRDERR, msg="发送失败")
......@@ -132,7 +135,7 @@ def login_bysms():
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库异常")
# print(user.status==3)
if user.status == 3:
if user.status == 0:
return jsonify(code=RET.USERERR, msg="当前用户被禁止登录,请联系管理员")
# 获取用户id，传入生成token的方法，并接收返回的token
......@@ -145,152 +148,6 @@ def login_bysms():
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"])
def login_bypwd():
......@@ -499,137 +356,348 @@ def binding():
token = create_token(user.id)
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"])
# def send_email_code():
# '''
# 向邮箱送验证码
# :return:
# '''
# # 获取请求参数，转化字典
# req_dict = request.get_json()
# email = req_dict.get('email') # 邮箱号
# # 校验参数完整性
# if not all([email]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
#
# # 校验邮箱格式
# if not re.match("^.+\\@(\\[?)[a-zA-Z0-9\\-\\.]+\\.([a-zA-Z]{2,3}|[0-9]{1,3})(\\]?)$", email):
# return jsonify(code=RET.PARAMERR, msg="邮箱格式错误")
#
# # print(email)
# app = creat_app('product')
# mail = Mail(app)
# sms_code = "%06d" % random.randint(0, 999999)
#
# msg = Message("中研认知产业链在线,欢迎您！", recipients=[email])
# msg.body = "【中研认知产业链在线】您的验证码为：{}，您正在进行邮箱绑定，如非本人操作，请忽略本邮件！".format(sms_code)
# thread = threading.Thread(target=send_async_email, args=(mail, app, msg))
# thread.start()
# try:
# 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)
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="保存验证码异常")
#
# return jsonify(code=RET.OK, msg="发送成功")
# ''''''
# # 注册页面选择选择单位(2020-11-4)
# @api_user.route('/orgs', methods=['GET'])
# def zcorgs():
# '''
# 太原市企业条件选择导航获取
# :return:
# '''
# try:
# gover = Government.query.all()
# ty = Government.query.get(1)
# sections = ty.sections
# data = [{"label": i.name, "value": i.id} for i in gover]
# section = [{"label": i.name, "value": i.id} for i in sections]
# orgs = {"data": data, "section": section}
# return jsonify(code=RET.OK, msg="获取成功", orgs=orgs)
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库查询错误")
#
#
#
#
#
#
#
# ''''''
#
#
#
#
#
#
# # 后台用户账号密码
# @api_user.route("/backLogin", methods=["POST"])
# def back_login():
# '''
# 用户密码登录
# :return:
# '''
# # 参数获取与校验
# req_dict = request.get_json()
# # 解密
# param = req_dict.get("param") # 揭秘参数
# req_dict = json.loads(decrypt(param))
# name = req_dict.get('name')
# password = req_dict.get('password')
# # 校验参数完整性
# if not all([name, password]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
#
# # 判断错误次数是否超过限制，如果超过则10分钟内禁止此IP登录
# user_ip = request.remote_addr
# # print("IP地址：", user_ip)
# try:
# access_nums = redis_store.get('access_nums_{}'.format(user_ip))
# except Exception as e:
# current_app.logger.error(e)
# else:
# if access_nums:
# if int(access_nums.decode()) >= constants.LOGIN_ERROR_TIMES:
# return jsonify(code=RET.REQERR, msg="错误次数过多，请稍候重试")
#
# # 验证账户与密码
# try:
# user = Bstage.query.filter_by(name=name).first()
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="获取用户信息失败")
#
# # 将用户名与密码验证放置在一处，若失败返回提示信息并记录次数
# if (not user) or (not user.check_password(password)):
# # if (not user) or (password != "123"):
# try:
# redis_store.incr('access_nums_{}'.format(user_ip))
# redis_store.expire('access_nums_{}'.format(user_ip), constants.LOGIN_ERROR_FORBID_TIME)
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="密码错误")
#
# # 若成功保存登录状态和管理员的角色id
# token = create_token(user.id)
#
# time = datetime.now()
# current_app.logger.error(
# '++++++++++++++++++++++++++++登录日志>>>{}:{}通过后台登录成功了！+++++++++++++++++++++++=++'.format(time, name))
#
# return jsonify(code=RET.OK, msg="登录成功", token=token, flag=3)
"""
用户中心
"""
# 用户中心-账号设置-添加账号(注册)
@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("/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):
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():
return jsonify(code=RET.DBERR, msg="数据库错误")
@api_user.route("/detail", methods=["GET"])
@login_required
def detail():
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="数据库错误")
data = {
"flag": user.flag,
"real_name": user_information.real_name, # 名字
"age": user_information.age, # 年龄
"sex": user_information.sex, # 性别
"mobile": user_information.mobile, # 手机号
"username": user_information.name, # 用户名
"email": user_information.email, # 邮箱
"section": user_information.section if user_information.section else "-", # 部门
"position": user_information.position if user_information.position else "-", # 职务
"level": user_information.level if user_information.level else "-", # 职级
"unit": user_information.unit if user_information.unit else "-", # 所在机构
"funct": user_information.function if user_information.function else "-", # 工作职能
}
return jsonify(code=RET.OK, msg="查找成功", data=data)
@api_user.route("/personal", methods=["POST"])
@login_required
def personal():
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")
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 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("/detail", methods=["GET"])
# @login_required
# def detail():
# 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="数据库错误")
#
# data = {
# "flag": user.flag,
# "real_name": user_information.real_name, # 名字
# "age": user_information.age, # 年龄
# "sex": user_information.sex, # 性别
# "mobile": user_information.mobile, # 手机号
# "username": user_information.name, # 用户名
# "email": user_information.email, # 邮箱
# "section": user_information.section if user_information.section else "-", # 部门
# "position": user_information.position if user_information.position else "-", # 职务
# "level": user_information.level if user_information.level else "-", # 职级
# "unit": user_information.unit if user_information.unit else "-", # 所在机构
# "funct": user_information.function if user_information.function else "-", # 工作职能
# }
# return jsonify(code=RET.OK, msg="查找成功", data=data)
# @api_user.route("/personal", methods=["POST"])
# @login_required
# def personal():
# 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")
#
# 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 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="修改成功")
# 企业的收藏加个下拉列表来判断来自哪个表--是全国企业还是山西企业。返回值里面要带有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