def ExactQuery(tablename, field, param,type='one'):
'''
:param tablename: 需要精确查询的model
:param field: 查询条件（model的字段）
:param param: 查询条件的value
:param type: 查询类型（查询单条type为'one',查询多条为'more'）
:return: 返回json信息，包含status，message，data
'''
if hasattr(tablename, '__tablename__') and hasattr(tablename, field):
if isinstance(param, str) and len(param) > 0:
if type == 'one':
try:
one_data = db_session.query(tablename).filter_by(field=param).first()
if one_data:
return json.dumps({'status': 'OK', 'message': '数据查询成功！', 'data':one_data}, cls=AlchemyEncoder, ensure_ascii=False)
else:
return json.dumps({'status': 'OK', 'message': '未查询到相关数据！'}, cls=AlchemyEncoder, ensure_ascii=False)
except Exception as e:
logger.error(e)
insertSyslog("error", "%s数据更新报错：" % tablename + str(e), current_user.Name)
if type == 'more':
try:
more_data = db_session.query(tablename).filter_by(field=param).all()
if more_data:
return json.dumps({'status': 'OK', 'message': '数据查询成功！', 'data':more_data}, cls=AlchemyEncoder, ensure_ascii=False)
else:
return json.dumps({'status': 'OK', 'message': '未查询到相关数据！'}, cls=AlchemyEncoder, ensure_ascii=False)
except Exception as e:
logger.error(e)
insertSyslog("error", "%s数据更新报错：" % tablename + str(e), current_user.Name)
else:
return json.dumps({'status': 'error', 'message': '系统错误，请联系系统管理员解决...'}, cls=AlchemyEncoder, ensure_ascii=False)
return json.dumps({'status': 'error', 'message': '数据查询失败，请输入正确的关键字...'}, cls=AlchemyEncoder, ensure_ascii=False)
else:
return json.dumps({'status': 'error', 'message': '系统错误，请联系系统管理员解决...'}, cls=AlchemyEncoder, ensure_ascii=False)
def repairs():
"""
添加设备维修任务
:return:
"""
if request.method == 'GET':
data = db_session.query(Repair).all()
return json.dumps({
'code': '10001',
'message': '操作成功',
'data': data
},
cls=AlchemyEncoder,
ensure_ascii=False)
if request.method == 'POST':
json_data = request.values
data = Repair(EquipmentCode=json_data.get('EquipmentCode'),
No=get_no(json_data.get('ApplyTime')),
Worker=current_user.Name,
ApplyTime=json_data.get('ApplyTime'),
FaultExpound=json_data.get('FaultExpound'))
equipment = db_session.query(Equipment).filter_by(
EquipmentCode=json_data.get('EquipmentCode')).first()
equipment.Status = '待接单'
db_session.add_all([data, equipment])
db_session.commit()
db_session.close()
return json.dumps({
'code': '10000',
'message': '操作成功'
},
cls=AlchemyEncoder,
ensure_ascii=False)
def ElectronicBatchRecord():
if request.method == 'GET':
data = request.values
BatchNum = data.get('BatchID')
title = data.get('title')
user = db_session.query(User.Name).all()
operters = db_session.query(
User.id, User.Name).filter(User.RoleName == "操作人").all()
operatorlist = []
if operters != None:
for i in operters:
id = i[0]
name = i[1]
op = {'ID': id, 'text': name}
operatorlist.append(op)
checkers = db_session.query(
User.id, User.Name).filter(User.RoleName == "检查人").all()
checklist = []
if checkers != None:
for i in checkers:
id = i[0]
name = i[1]
ch = {'ID': id, 'text': name}
checklist.append(ch)
if title == "提取":
PUIDLineName = db_session.query(BatchInfo.PUIDLineName).filter(
BatchInfo.BatchNum == BatchNum).first()
title = PUIDLineName[0] + data.get('title')
return render_template(
'./ProductionManagement/electronicBatchRecord.html',
title=title,
BatchNum=BatchNum,
operatorlist=operatorlist,
checklist=checklist)
def BatchInfoDetailSearch():
if request.method == 'GET':
data = request.values
try:
jsonstr = json.dumps(data.to_dict())
if len(jsonstr) > 10:
pages = int(data.get("offset"))
rowsnumber = int(data.get("limit"))
inipage = pages * rowsnumber + 0
endpage = pages * rowsnumber + rowsnumber
BatchNum = data.get('BatchNum')
total = db_session.query(BatchInfoDetail).filter(
BatchInfoDetail.BatchNum == BatchNum).count()
oclass = db_session.query(BatchInfoDetail).filter(
BatchInfoDetail.BatchNum ==
BatchNum).all()[inipage:endpage]
jsonoclass = json.dumps(oclass,
cls=AlchemyEncoder,
ensure_ascii=False)
return '{"total"' + ":" + str(
total) + ',"rows"' + ":\n" + jsonoclass + "}"
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "设备建模查询报错Error：" + str(e), current_user.Name)
def menuToUser():
if request.method == 'GET':
data = request.values # 返回请求中的参数和form
try:
# 获取菜单和用户并存入数据库
role_id = data['role_id'] # 获取角色ID
if role_id is None:
return
menus = db_session.query(Menu).join(Role_Menu, isouter=True).filter_by(Role_ID=id).all()
if menus:
db_session.delete(menus)
db_session.commit()
menu_id = data['menu_id'] # 获取菜单ID
if menu_id is None:
return
menu_id = re.findall(r'\d+\.?\d*', menu_id)
for r in menu_id:
role = db_session.query(Role).filter_by(ID=role_id).first()
menu = db_session.query(Menu).filter_by(ID=r).first()
# 将菜单ID和角色ID存入User_Role
menu.roles.append(role)
db_session.add(menu)
db_session.commit()
# 存入数据库后跳转到权限分配页面
return redirect(url_for("roleright"))
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "权限分配下为角色添加权限Error：" + str(e), current_user.Name)
return json.dumps([{"status": "Error:" + str(e)}], cls=AlchemyEncoder, ensure_ascii=False)
def allrolesFind():
if request.method == 'GET':
data = request.values
try:
json_str = json.dumps(data.to_dict())
if len(json_str) > 10:
pages = int(data.get("offset")) # 页数
rowsnumber = int(data.get("limit")) # 行数
inipage = pages * rowsnumber + 0 # 起始页
endpage = pages * rowsnumber + rowsnumber # 截止页
total = db_session.query(func.count(Role.ID)).scalar()
roles = db_session.query(Role).all()[inipage:endpage]
# ORM模型转换json格式
jsonroles = json.dumps(roles,
cls=AlchemyEncoder,
ensure_ascii=False)
jsonroles = '{"total"' + ":" + str(
total) + ',"rows"' + ":\n" + jsonroles + "}"
return jsonroles
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "查询角色列表报错Error：" + str(e), current_user.Name)
return json.dumps([{
"status": "Error：" + string(e)
}],
cls=AlchemyEncoder,
ensure_ascii=False)
def SelectMenus():
if request.method == 'GET':
data = request.values
try:
MenuType = data.get("MenuType")
Name = current_user.Name
if Name == "系统管理员":
oclass = db_session.query(ModulMenus).all()
return json.dumps(oclass, cls=AlchemyEncoder, ensure_ascii=False)
periss = db_session.query(Permission).filter(Permission.Name == current_user.Name, Permission.MenuType == MenuType).all()
flag = 'OK'
dic = []
for i in periss:
oclass = db_session.query(ModulMenus).filter(
ModulMenus.ResourceMenuName.like("%" + i.MenuName + "%")).first()
dic.append(oclass)
# if MenuType == "资源级":
# oclass = db_session.query(ResourceMenus).filter(ResourceMenus.ModulMenuName.like("%"+i.MenuName+"%")).first()
# dic.append(oclass)
# else:
# oclass = db_session.query(ModulMenus).filter(
# ModulMenus.ResourceMenuName.like("%" + i.MenuName + "%")).first()
# dic.append(oclass)
return json.dumps(dic, cls=AlchemyEncoder, ensure_ascii=False)
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "菜单权限查询报错Error：" + str(e), current_user.Name)
return json.dumps([{"status": "Error:" + str(e)}], cls=AlchemyEncoder, ensure_ascii=False)
def select(table, page, rows, fieid, param):
'''
:param tablename: 查询表
:param pages: 页数
:param rowsnumber: 一页多少行
:param fieid: 查询字段
:param param: 查询条件
:return:
'''
try:
inipage = (page - 1) * rows + 0
endpage = (page - 1) * rows + rows
if (param == "" or param == None):
total = db_session.query(table).count()
oclass = db_session.query(table).all()[inipage:endpage]
else:
# sql = "select * from "+tableName+" t where t."+fieid+" like "+"'%"+param+"%'"
# oclass = db_session.execute(sql).fetchall()
# total = len(oclass)
# db_session.close()
print(fieid)
print(param)
print(table)
# obj.__tablename__ = table
total = db_session.query(table).filter_by(fieid==param).count()
oclass = db_session.query(table).filter_by(fieid=param).all()[inipage:endpage]
jsonoclass = json.dumps(oclass, cls=AlchemyEncoder, ensure_ascii=False)
jsonoclass = '{"total"' + ":" + str(total) + ',"rows"' + ":\n" + jsonoclass + "}"
return jsonoclass
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "查询报错Error：" + str(e), current_user.Name)
def userselect(data): #table, page, rows, fieid, param
'''
:param tablename: 查询表
:param pages: 页数
:param rowsnumber: 一页多少行
:param fieid: 查询字段
:param param: 查询条件
:return:用户查询
'''
try:
pages = int(data.get("offset"))
rowsnumber = int(data.get("limit"))
param = data.get("field")
tableName = data.get("tableName")
paramvalue = data.get("fieldvalue")
if (paramvalue == "" or paramvalue == None):
oclass = db_session.query(User).filter(
User.WorkNumber == paramvalue).all()
total = db_session.query(User).filter(
User.WorkNumber == paramvalue).count()
jsonoclass = '{"total"' + ":" + str(
total) + ',"rows"' + ":\n" + oclass + "}"
return jsonoclass
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "用户查询报错Error：" + str(e), current_user.Name)
def PermissionsMenus():
if request.method == 'GET':
data = request.values
try:
MenuName = data.get("MenuName")
MenuType = data.get("MenuType")
if MenuName == None:
MenuNames = db_session.query(Permission.MenuName).filter(Permission.WorkNumber == current_user.WorkNumber, Permission.MenuType == MenuType).all()
else:
ParentNode = db_session.query(ModulMenus.ID).filter(ModulMenus.ModulMenuName == MenuName).first()
pmenus = db_session.query(ModulMenus.ModulMenuName).filter(ModulMenus.ParentNode == ParentNode,ModulMenus.MenuType == MenuType).all()
cmenus = db_session.query(Permission.MenuName).filter(Permission.WorkNumber == current_user.WorkNumber).all()
MenuNames = list(set(pmenus).intersection(set(cmenus)))
dir = []
for mn in MenuNames:
meu = db_session.query(ModulMenus).filter(ModulMenus.ModulMenuName == mn).first()
dir.append(meu)
if dir:
dir = sorted(dir, key=lambda aa: aa.ID)
return json.dumps(dir, cls=AlchemyEncoder, ensure_ascii=False)
except Exception as e:
db_session.rollback()
print(e)
logger.error(e)
insertSyslog("error", "添加用户报错Error：" + str(e), current_user.Name)
return json.dumps([{"status": "Error:" + str(e)}], cls=AlchemyEncoder, ensure_ascii=False)
def saverolepermission():
'''
角色添加权限
:return:
'''
if request.method == 'POST':
data = request.values
try:
roleID = data.get("roleID")
permissionIDs = data.get("permissionIDs")
if permissionIDs:
permissionIDs = eval(permissionIDs)
roleclass = db_session.query(Role).filter(Role.ID == int(roleID)).first()
sql = "delete from RolePermission where RoleID = " + roleID
db_session.execute(sql)
db_session.commit()
for pid in permissionIDs:
permissioncalss = db_session.query(Permission).filter(Permission.ID == int(pid)).first()
rpclas = db_session.query(RolePermission).filter(RolePermission.RoleID == roleclass.ID, RolePermission.PermissionID == permissioncalss.ID).first()
if not rpclas:
rp = RolePermission()
rp.RoleID = roleclass.ID
rp.RoleName = roleclass.RoleName
rp.PermissionID = permissioncalss.ID
rp.PermissionName = permissioncalss.PermissionName
db_session.add(rp)
db_session.commit()
return json.dumps("OK", cls=AlchemyEncoder, ensure_ascii=False)
except Exception as e:
db_session.rollback()
print(e)
logger.error(e)
insertSyslog("error", "角色添加权限Error：" + str(e), current_user.Name)
def UpdateUser():
if request.method == 'POST':
data = request.values
str = request.get_json()
try:
json_str = json.dumps(data.to_dict())
if len(json_str) > 10:
id = int(data['ID'])
user = db_session.query(User).filter_by(id=id).first()
user.Name = data['Name']
user.WorkNumber = data['WorkNumber']
ocal = db_session.query(User).filter(User.WorkNumber == user.WorkNumber).first()
if ocal != None:
if ocal.id != id:
return "工号重复，请重新修改！"
user.Password = user.password(data['Password'])
user.OrganizationName = data['OrganizationName']
user.RoleName = data['RoleName']
db_session.commit()
return 'OK'
except Exception as e:
db_session.rollback()
print(e)
logger.error(e)
insertSyslog("error", "更新用户报错Error：" + str(e), current_user.Name)
return json.dumps([{"status": "Error:" + str(e)}], cls=AlchemyEncoder, ensure_ascii=False)
def selectrolebyuser():
'''
根据用户查询角色
:return:
'''
if request.method == 'GET':
data = request.values
try:
dir = {}
UserID = data.get("UserID")
pids = db_session.query(RoleUser).filter(
RoleUser.UserID == int(UserID)).all()
perids_list = []
for pid in pids:
perids_list.append(pid.RoleID)
if len(perids_list) > 0:
existingRows = db_session.query(Role).filter(
Role.ID.in_(perids_list)).all()
dir["existingRows"] = existingRows
else:
dir["existingRows"] = []
notHaveRows = db_session.query(Role).filter().all()
dir["notHaveRows"] = notHaveRows
return json.dumps(dir, cls=AlchemyEncoder, ensure_ascii=False)
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "根据用户查询角色Error：" + str(e), current_user.Name)
def BrandFlagSearch():
if request.method == 'GET':
data = request.values
try:
jsonstr = json.dumps(data.to_dict())
if len(jsonstr) > 10:
pages = int(data.get("offset"))
rowsnumber = int(data.get("limit"))
inipage = pages * rowsnumber + 0
endpage = pages * rowsnumber + rowsnumber
BrandName = data.get('BrandName')
if BrandName == None or BrandName == "":
total = db_session.query(BrandFlag).order_by(
("ID")).count()
oclass = db_session.query(BrandFlag).order_by(
("ID")).all()[inipage:endpage]
else:
total = db_session.query(BrandFlag).filter(
BrandFlag.BrandName.like(BrandName)).order_by(
("ID")).count()
oclass = db_session.query(BrandFlag).filter(
BrandFlag.BrandName.like(BrandName)).order_by(
("ID")).all()[inipage:endpage]
jsonoclass = json.dumps(oclass,
cls=AlchemyEncoder,
ensure_ascii=False)
return '{"total"' + ":" + str(
total) + ',"rows"' + ":\n" + jsonoclass + "}"
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "品名维护表Error：" + str(e), current_user.Name)
def organizationTU():
if request.method == 'GET':
data = request.values
try:
dic = []
facs = db_session.query(Factory).all()
for fa in facs:
deps = db_session.query(DepartmentManager).filter(
DepartmentManager.DepartLoad == fa.FactoryName).all()
for dep in deps:
die = []
die.append(fa.FactoryName)
die.append(dep.DepartName)
dic.append(die)
ros = db_session.query(Role).filter(
Role.ParentNode == dep.DepartName).all()
for ro in ros:
dif = []
dif.append(dep.DepartName)
dif.append(ro.RoleName)
dic.append(dif)
return json.dumps(dic, cls=AlchemyEncoder, ensure_ascii=False)
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "组织架构图报错Error：" + str(e), current_user.Name)
return json.dumps([{
"status": "Error:" + str(e)
}],
cls=AlchemyEncoder,
ensure_ascii=False)
def searchEqpID(BrandName, BatchID, PID, name):
EQPIDs = db_session.query(Equipment.ID).filter(
Equipment.PUID == PID, Equipment.EQPName.like("%" + name + "%")).all()
EQPS = db_session.query(ElectronicBatchTwo.EQPID).distinct().filter(
ElectronicBatchTwo.PDUnitRouteID == PID,
ElectronicBatchTwo.BrandName == BrandName,
ElectronicBatchTwo.BatchID == BatchID).all()
tmp = [val for val in EQPIDs if val in EQPS]
return tmp
def delete_role():
rid = request.headers.get('rid')
role = db_session.query(Role).filter(Role.ID == rid).first()
user_query = db_session.query(RoleUser).filter(
RoleUser.RoleName == role.RoleName).all()
for item in user_query:
db_session.delete(item)
db_session.delete(role)
db_session.commit()
return json.dumps({'code': 10004, 'msg': '删除成功'})
def BatchSearch():
if request.method == 'GET':
data = request.values
try:
json_str = json.dumps(data.to_dict())
if len(json_str) > 2:
BatchNum = data.get("BatchNum")
Name = data.get("Name")
dic = {}
oclass = db_session.query(BatchInfo).filter(
BatchInfo.BatchNum == BatchNum).first()
if Name == "提取":
if oclass.PUIDLineName == "篮式":
PUID = "1"
elif oclass.PUIDLineName == "搅拌":
PUID = "3"
eqps = db_session.query(
ElectronicBatchTwo.EQPID).distinct().filter(
ElectronicBatchTwo.BatchID == BatchNum,
ElectronicBatchTwo.PDUnitRouteID == PUID).order_by(
("EQPID")).all()
j = 1
for i in eqps:
EQPName = db_session.query(Equipment.EQPName).filter(
Equipment.ID == i[0]).first()
btss = db_session.query(BatchType).filter(
BatchType.Descrip.like("%" + oclass.PUIDLineName +
"%")).all()
for bt in btss:
type = bt.Type
if type == "_Batch_LS_Action01" or type == "_Batch_JB_Action01":
dic[type + "_" + str(j)] = EQPName[0]
else:
ret = queryvalue(BatchNum, int(i[0]),
bt.Descrip)
dic[type + "_" + str(j) + "_1"] = ret[0]
dic[type + "_" + str(j) + "_2"] = ret[1]
j = j + 1
dic["BatchNum"] = oclass.BatchNum
dic["MedicinalType"] = oclass.MedicinalType
dic["BrandName"] = oclass.BrandName
return json.dumps(dic,
cls=AlchemyEncoder,
ensure_ascii=False)
else:
return ""
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "电子批记录查询报错Error：" + str(e),
current_user.Name)
return json.dumps("电子批记录查询",
cls=AlchemyEncoder,
ensure_ascii=False)
def tags():
"""树形tag点"""
factory = db_session.query(AreaMaintain).first()
sql = "select ChildrenTag from tags"
parent_tags = db_session.execute(sql).fetchall()
tags_list = set(str(item[0]) for item in parent_tags)
children = []
for item in tags_list:
# 通过一级节点获取所有对应节点下的值
children2 = []
children1 = {"label": item, "children": children2}
query_data = db_session.query(Tags).filter_by(ChildrenTag=item).all()
parent_tag2 = set(item.ParentTag for item in query_data)
for result in parent_tag2:
# children4 = []
# 通过一级节点获取所有对应的二级节点
if result:
# 二级节点不为空
children3 = []
rank2_data = {"label": result, "children": children3}
# children4.append(rank2_data)
last_data = db_session.query(Tags).filter_by(
ParentTag=result).all()
parent_tag_sql = 'select '
for data in last_data:
# 循环获取最后节点的数据
rank3_data = {
"id": data.TagCode,
"label": data.TagName,
"ParentTagCode": "1"
}
children3.append(rank3_data)
children2.append(rank2_data)
# rank3 = {"label": result.ParentTag, "children": [{"id": result.TagCode, "label": result.TagName}]}
else:
for data in query_data:
rank2_data = {
"id": data.TagCode,
"label": data.TagName,
"ParentTagCode": "1"
}
children2.append(rank2_data)
children.append(children1)
tree = [{"label": factory.AreaName, "children": children}]
return json.dumps({
'code': '20001',
'message': '成功',
'data': tree
},
cls=AlchemyEncoder,
ensure_ascii=False)
def repair_tasks(p):
"""
更新维修任务表的状态
:param p: 更改工单状态
:return:
"""
if p == 'jiedan':
json_data = request.values
data = db_session.query(Repair).filter_by(
No=json_data.get('No')).first()
data.Status = '维修中'
data.ReceiveWorker = current_user.Name
data.ReceiveTime = json_data.get('Time')
equipment = db_session.query(Equipment).filter_by(
EquipmentCode=json_data.get('EquipmentCode')).first()
equipment.Status = '维修中'
db_session.add_all([data, equipment])
db_session.commit()
db_session.close()
return json.dumps({
'code': '10001',
'message': '操作成功'
},
cls=AlchemyEncoder,
ensure_ascii=False)
if p == 'over':
json_data = request.values
data = db_session.query(Repair).filter_by(
No=json_data.get('No')).first()
task_data = RepairTask(EquipmentCode=data.EquipmentCode,
No=data.No,
Status='维修完成',
Worker=data.Worker,
ReceiveWorker=data.ReceiveWorker,
Content=json_data.get('Content'),
ApplyTime=data.ApplyTime,
ReceiveTime=data.ReceiveTime,
EndTime=json_data.get('EndTime'))
equipment = db_session.query(Equipment).filter_by(
EquipmentCode=json_data.get('EquipmentCode')).first()
equipment.Status = '运行中'
db_session.add_all([task_data, equipment])
db_session.delete(data)
db_session.commit()
db_session.close()
return json.dumps({
'code': '10001',
'message': '操作成功'
},
cls=AlchemyEncoder,
ensure_ascii=False)
def userList():
# 获取用户列表
if request.method == 'GET':
data = request.values # 返回请求中的参数和form
# 默认返回所有用户
ID = data['ID']
if ID == '':
try:
json_str = json.dumps(data.to_dict())
if len(json_str) > 10:
pages = int(data.get("offset")) # 页数
rowsnumber = int(data.get("limit")) # 行数
inipage = pages * rowsnumber + 0 # 起始页
endpage = pages * rowsnumber + rowsnumber # 截止页
total = db_session.query(User).count()
users_data = db_session.query(User)[inipage:endpage]
# ORM模型转换json格式
jsonusers = json.dumps(users_data, cls=AlchemyEncoder, ensure_ascii=False)
jsonusers = '{"total"' + ":" + str(total) + ',"rows"' + ":\n" + jsonusers + "}"
return jsonusers.encode("utf8")
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "查询权限分配下的用户列表报错Error：" + str(e), current_user.Name)
return json.dumps([{"status": "Error:" + str(e)}], cls=AlchemyEncoder, ensure_ascii=False)
if ID != '':
data = request.values # 返回请求中的参数和form
try:
json_str = json.dumps(data.to_dict())
if len(json_str) > 10:
pages = int(data['page']) # 页数
rowsnumber = int(data['rows']) # 行数
inipage = (pages - 1) * rowsnumber + 0 # 起始页
endpage = (pages - 1) * rowsnumber + rowsnumber # 截止页
# 通过角色ID获取当前角色对应的用户
role_id = data['ID']
role_name= db_session.query(Role.RoleName).filter_by(ID=role_id).first()
if role_name is None: # 判断当前角色是否存在
return
total = db_session.query(User).filter_by(RoleName=role_name).count()
users_data = db_session.query(User).filter_by(RoleName=role_name).all()[
inipage:endpage]
# ORM模型转换json格式
jsonusers = json.dumps(users_data, cls=AlchemyEncoder, ensure_ascii=False)
jsonusers = '{"total"' + ":" + str(total) + ',"rows"' + ":\n" + jsonusers + "}"
return jsonusers
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "通过点击角色查询用户报错Error：" + str(e), current_user.Name)
return json.dumps([{"status": "Error:" + str(e)}], cls=AlchemyEncoder, ensure_ascii=False)
def update_role():
rid = request.json.get('rid')
code = request.json.get('role_code')
role_name = request.json.get('role_name')
rdes = request.json.get('role_description')
role = db_session.query(Role).filter(Role.ID == rid).first()
user_query = db_session.query(RoleUser).filter(
RoleUser.RoleName == role.RoleName).all()
for item in user_query:
item.RoleName = role_name
role.RoleCode = code
role.RoleName = role_name
role.Description = rdes
db_session.commit()
return json.dumps({'code': 10005, 'msg': '更新成功'})
def userloginauthentication():
'''
用户登陆认证
:return:
'''
try:
if request.method == 'POST':
data = request.values
WorkNumber = data.get('WorkNumber')
password = data.get('password')
# 验证账户与密码
user = db_session.query(User).filter_by(WorkNumber=WorkNumber).first()
resp = make_response()
if user and (user.confirm_password(password) or user.Password == password):
login_user(user) # login_user(user)调用user_loader()把用户设置到db_session中
user.session_id = str(time.time())
user.LastLoginTime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
db_session.commit()
return 'OK'
else:
return '用户名密码错误'
except Exception as e:
print(e)
db_session.rollback()
logger.error(e)
return json.dumps([{"status": "Error:" + str(e)}], cls=AlchemyEncoder, ensure_ascii=False)
def addUser():
if request.method == 'POST':
data = request.values
str = request.get_json()
try:
json_str = json.dumps(data.to_dict())
if len(json_str) > 10:
user = User()
user.WorkNumber=data['WorkNumber']
ocal = db_session.query(User).filter(User.WorkNumber == user.WorkNumber).first()
if ocal != None:
return "工号重复，请重新录入！"
user.Name=data['Name']
user.Password=user.password(data['Password'])
# print(user.Password)
user.Status="1" # 登录状态先设置一个默认值1：已登录，0：未登录
user.Creater=current_user.Name
user.CreateTime=datetime.datetime.now()
user.LastLoginTime=datetime.datetime.now()
user.IsLock='false' # data['IsLock'],
user.OrganizationName=data['OrganizationName']
user.RoleName=data['RoleName']
db_session.add(user)
db_session.commit()
return 'OK'
except Exception as e:
db_session.rollback()
print(e)
logger.error(e)
insertSyslog("error", "添加用户报错Error：" + str(e), current_user.Name)
return json.dumps([{"status": "Error:" + str(e)}], cls=AlchemyEncoder, ensure_ascii=False)
def PermissionsSave():
if request.method == 'POST':
data = request.values
try:
datastr = json.loads(data.get("data"))
#删除之前的权限
perss = db_session.query(Permission).filter(Permission.WorkNumber == datastr[0].get("WorkNumber")).all()
for pe in perss:
db_session.delete(pe)
db_session.commit()
for i in datastr:
per = Permission()
per.MenuName = i.get("MenuName")
per.MenuType = i.get("MenuType")
per.MenuCode = i.get("MenuCode")
per.Name = i.get("Name")
per.WorkNumber = i.get("WorkNumber")
db_session.add(per)
db_session.commit()
return 'OK'
except Exception as e:
db_session.rollback()
print(e)
logger.error(e)
insertSyslog("error", "添加用户报错Error：" + str(e), current_user.Name)
return json.dumps([{"status": "Error:" + str(e)}], cls=AlchemyEncoder, ensure_ascii=False)
def FuzzyQuery(tablename, params):
'''
:param tablename: 要进行查询的model
:param params: 一个字典，字典中的key为model的字段，value为进行查询的关键字
:return: 返回json信息，包含status，message，data
'''
if hasattr(tablename, '__tablename__'):
if isinstance(params, dict) and len(params) > 0:
for key in params.keys():
if hasattr(tablename, key):
try:
data = db_session.query(tablename).filter_by(key = params[key]).all()
if data:
return json.dumps({'status': 'OK', 'message': '数据更新成功！', 'data':data}, cls=AlchemyEncoder, ensure_ascii=False)
else:
return json.dumps({'status': 'OK', 'message': '未查询到相关的数据！'}, cls=AlchemyEncoder, ensure_ascii=False)
except Exception as e:
logger.error(e)
insertSyslog("error", "%s数据更新报错："%tablename + str(e), current_user.Name)
return json.dumps({'status':'error', 'message': '数据查询失败，请输入正确的关键字...'}, cls=AlchemyEncoder, ensure_ascii=False)
else:
return json.dumps({'status': 'error', 'message': '系统错误，请联系系统管理员解决...'}, cls=AlchemyEncoder, ensure_ascii=False)
else:
return json.dumps({'status': 'error', 'message': '系统错误，请联系系统管理员解决...'}, cls=AlchemyEncoder, ensure_ascii=False)
def menulist():
if request.method == 'GET':
role_data = request.values
if 'id' not in role_data.keys():
try:
data = getMenuList(role_menus=[],id=0)
jsondata = json.dumps(data, cls=AlchemyEncoder, ensure_ascii=False)
return jsondata.encode("utf8")
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "加载菜单列表Error：" + str(e), current_user.Name)
return json.dumps([{"status": "Error:" + str(e)}], cls=AlchemyEncoder, ensure_ascii=False)
id = role_data['id']
try:
role_menus = db_session.query(Menu.ModuleName).join(Role_Menu, isouter=True).filter_by(Role_ID=id).all()
r_menus = []
for menu in role_menus:
r_menus.append(menu[0])
menus_data = getMenuList(r_menus, id=0)
jsondata = json.dumps(menus_data, cls=AlchemyEncoder, ensure_ascii=False)
return jsondata.encode("utf8")
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "加载菜单列表Error：" + str(e), current_user.Name)
return json.dumps([{"status": "Error:" + str(e)}], cls=AlchemyEncoder, ensure_ascii=False)
def queryvalue(BatchNum, EQPID, type):
SampleValues = db_session.query(ElectronicBatchTwo.SampleValue).filter(
ElectronicBatchTwo.BatchID == BatchNum,
ElectronicBatchTwo.EQPID == EQPID,
ElectronicBatchTwo.Type == type).order_by(("SampleDate")).all()
dir = []
if len(SampleValues) == 1:
SampleValue1 = SampleValues[0][0]
if len(SampleValue1) > 18:
dir.append(strch(SampleValue1))
else:
dir.append(SampleValue1)
dir.append("")
elif len(SampleValues) == 2:
SampleValue1 = SampleValues[0][0]
if SampleValue1 == None or SampleValue1 == "":
dir.append("")
else:
if len(SampleValue1) > 18:
dir.append(strch(SampleValue1))
else:
dir.append(SampleValue1)
SampleValue2 = SampleValues[1][0]
if SampleValue1 == None or SampleValue1 == "":
dir.append("")
else:
if len(SampleValue2) > 18:
dir.append(strch(SampleValue2))
else:
dir.append(SampleValue2)
elif SampleValues == None or len(SampleValues) < 1 or len(
SampleValues) > 2:
dir.append("")
dir.append("")
return dir
def allrolesSearch():
if request.method == 'POST':
data = request.values
try:
json_str = json.dumps(data.to_dict())
if len(json_str) > 2:
strconditon = "%" + data['condition'] + "%"
roles = db_session.query(Role).filter(
Role.RoleName.like(strconditon)).all()
total = Counter(roles)
jsonroles = json.dumps(roles,
cls=AlchemyEncoder,
ensure_ascii=False)
jsonroles = '{"total"' + ":" + str(
total.__len__()) + ',"rows"' + ":\n" + jsonroles + "}"
return jsonroles
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "擦护心角色列表报错Error：" + str(e),
current_user.Name)
return json.dumps([{
"status": "Error：" + string(e)
}],
cls=AlchemyEncoder,
ensure_ascii=False)
def delete(tablename, delete_data):
'''
:param tablename: 要进行删除信息的model
:param recv_data: 要进行更新的数据，数据类型为list，list中的每个元素为需要删除的每条记录的ID
:return: 返回json信息，包含status，message
'''
if hasattr(tablename, '__tablename__'):
try:
jsonstr = json.dumps(delete_data.to_dict())
if len(jsonstr) > 10:
jsonnumber = re.findall(r"\d+\.?\d*", jsonstr)
for key in jsonnumber:
id = int(key)
try:
oclass = db_session.query(tablename).filter_by(ID=id).first()
db_session.delete(oclass)
db_session.commit()
except Exception as ee:
db_session.rollback()
insertSyslog("error", "删除户ID为"+str(id)+"报错Error：" + str(ee), current_user.Name)
return json.dumps("删除用户报错", cls=AlchemyEncoder,ensure_ascii=False)
return 'OK'
except Exception as e:
db_session.rollback()
logger.error(e)
insertSyslog("error", "%s数据删除报错："%tablename + str(e), current_user.Name)
return json.dumps('数据删除失败！')
