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 addUpdateEletronicBatchDataStore(PUID, BatchID, ke, val):
try:
oc = db_session.query(EletronicBatchDataStore).filter(
EletronicBatchDataStore.PUID == PUID,
EletronicBatchDataStore.BatchID == BatchID,
EletronicBatchDataStore.Content == ke).first()
if oc == None:
db_session.add(
EletronicBatchDataStore(BatchID=BatchID,
PUID=PUID,
Content=ke,
OperationpValue=val,
Operator=current_user.Name))
else:
oc.Content = ke
oc.OperationpValue = val
oc.Operator = current_user.Name
db_session.commit()
except Exception as e:
db_session.rollback()
print(e)
logger.error(e)
insertSyslog("error", "保存更新EletronicBatchDataStore报错：" + str(e),
current_user.Name)
return json.dumps("保存更新EletronicBatchDataStore报错",
cls=AlchemyEncoder,
ensure_ascii=False)
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 read_Excel(file_dir):
# 打开文件
workbook = xlrd.open_workbook(file_dir)
if workbook:
# 获取所有sheet
# print(workbook.sheet_names())# [u'sheet1', u'sheet2']
# sheet1_name = workbook.sheet_names()[0]
# 根据sheet索引或者名称获取sheet内容
# sheet1 = workbook.sheet_by_index(0)
sheet1 = workbook.sheet_by_name('Sheet1')
# sheet的名称，行数，列数
print(sheet1.name, sheet1.nrows, sheet1.ncols)
if sheet1:
if sheet1.nrows <= 0:
return
for row in range(1, sheet1.nrows):
row_value = sheet1.row_values(row)
if row_value[0] is None or row_value[0] == '':
continue
db_session.add(
QualityControlTree(Name=row_value[0],
Note=row_value[1],
ParentNode=int(row_value[2]),
BatchTag=row_value[3],
Brand=row_value[4],
EquipmentCode=row_value[5]))
db_session.commit()
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 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 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 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 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('数据删除失败！')
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 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 add_role():
rcode = request.json.get('role_code')
did = request.json.get('did')
rname = request.json.get('role_name')
rdes = request.json.get('role_description')
department = db_session.query(DepartmentManager).filter(
DepartmentManager.ID == int(did)).first()
role = Role(RoleCode=rcode,
RoleName=rname,
Description=rdes,
ParentNode=department.DepartCode)
db_session.add(role)
db_session.commit()
return json.dumps({'code': 10003, 'msg': '新增成功', 'data': {'rid': role.ID}})
def OperatorCheckSaveUpdate():
'''操作人检查人确认'''
if request.method == 'GET':
data = request.values
try:
ConfirmFlow = data.get("ConfirmFlow")
BatchNum = data.get("BatchNum")
Confirmer = data.get("Confirmer")
key = data.get("key")
oclass = db_session.query(FlowConfirm).filter(
FlowConfirm.BatchNum == BatchNum,
FlowConfirm.key == key).first()
if oclass == None or oclass == "":
db_session.add(
FlowConfirm(BatchNum=BatchNum,
ConfirmFlow=ConfirmFlow,
Confirmer=Confirmer,
ConfirmTime=datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S'),
key=key))
db_session.add(
AuditTrace(Operation=ConfirmFlow,
DeitalMSG="用户：" + Confirmer + " 节点：" +
ConfirmFlow + "确认",
ReviseDate=datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S'),
User=current_user.Name))
else:
oclass.Confirmer = Confirmer
oclass.UpdateTime = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
db_session.add(
AuditTrace(Operation=ConfirmFlow + "修改",
DeitalMSG="用户：" + Confirmer + " 节点：" +
ConfirmFlow + "修改",
ReviseDate=datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S'),
User=current_user.Name))
db_session.commit()
return 'OK'
except Exception as e:
db_session.rollback()
print(e)
logger.error(e)
insertSyslog("error", "/OperatorCheckSaveUpdate报错：" + str(e),
current_user.Name)
return json.dumps("保存更新EletronicBatchDataStore报错",
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 add_department():
did = request.json.get('department_code')
dname = request.json.get('department_name')
fname = request.json.get('factory_name')
depart = DepartmentManager(DepartCode=did,
DepartName=dname,
DepartLoad=fname)
db_session.add(depart)
db_session.commit()
return json.dumps({
'code': 10000,
'msg': '新增成功',
'data': {
'Did': depart.ID
}
})
def updaterole():
'''
修改角色
:return:
'''
try:
if request.method == 'POST':
data = request.values
ID = data.get("ID")
oclass = db_session.query(Role).filter(Role.ID == ID).first()
oclass.RoleName = "角色名字1"
db_session.commit()
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 insertSyslog(operationType, operationContent, userName):
try:
if operationType == None: operationType = ""
if operationContent == None:
operationContent = ""
else:
operationContent = str(operationContent)
if userName == None: userName = ""
ComputerName = socket.gethostname()
db_session.add(
SysLog(OperationType=operationType, OperationContent=operationContent,OperationDate=datetime.datetime.now(), UserName=userName,
ComputerName=ComputerName, IP=socket.gethostbyname(ComputerName)))
db_session.commit()
except Exception as e:
db_session.rollback()
print(e)
logger.error(e)
def addrole():
'''
添加角色
:return:
'''
try:
if request.method == 'POST':
role = Role()
role.RoleName = "角色名字"
role.Description = ""
role.RoleCode = "角色编码"
db_session.add(role)
db_session.commit()
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 update_department():
did = request.json.get('did')
code = request.json.get('department_code')
department_name = request.json.get('department_name')
department = db_session.query(DepartmentManager).filter(
DepartmentManager.ID == int(did)).first()
role_query = db_session.query(Role).filter(
Role.ParentNode == department.DepartCode).all()
for item in role_query:
item.ParentNode = code
department.DepartCode = code
department.DepartName = department_name
db_session.commit()
user_query = db_session.query(User).filter(
User.OrganizationName == department.DepartName).all()
for user in user_query:
user.OrganizationName = department_name
db_session.commit()
return json.dumps({'code': 10002, 'msg': '更新成功'})
def keep_plans():
"""保养计划"""
try:
json_data = request.get_json()
# equipments = ['XXF-2', 'XXF-1', 'PYF-1']
equipments = json_data.get('EquipmentCode')
if len(equipments) == 1:
equipment_code = equipments[0]
else:
equipment_code = ' '.join(equipments)
work_time = add_date(json_data.get('WeekTime'),
json_data.get('StartTime'))
work_type = json_data.get('Type')
week_time = '单次' if work_type == '单次' else json_data.get('WeekTime')
data = KeepPlan(EquipmentCode=equipment_code,
No=get_no(json_data.get('ApplyTime')),
Worker=current_user.Name,
ApplyTime=json_data.get('ApplyTime'),
Type=json_data.get('Type'),
StartTime=json_data.get('StartTime'),
Describe=json_data.get('Describe'),
WorkTime=work_time,
WeekTime=week_time)
db_session.add(data)
db_session.commit()
db_session.close()
return json.dumps({
'code': '10001',
'message': '操作成功'
},
cls=AlchemyEncoder,
ensure_ascii=False)
except Exception as e:
logger.error(e)
insertSyslog("error", "保养计划表添加错误：" + str(e), current_user.Name)
return json.dumps({
'code': '20002',
'message': str(e)
},
cls=AlchemyEncoder,
ensure_ascii=False)
def paiban():
if request.method == 'GET':
data = request.values
try:
dir = {}
StartClass = data.get("StartClass")
Month = data.get("Month")
sfs = db_session.query(ShiftsClass).filter().order_by(("ShiftsClassNum")).all()
sum = None
new_list = ""
for sf in sfs:
if sf.ShiftsClassName == StartClass:
sum = None if sf.ShiftsClassNum is None else float(sf.ShiftsClassNum)
if sum:
for i in sfs:
if (0 if sf.ShiftsClassNum is None else float(sf.ShiftsClassNum)) >= sum:
if i == 1:
new_list = i.ShiftsClassName
else:
new_list = new_list + "," + i.ShiftsClassName
for i in sfs:
if (0 if sf.ShiftsClassNum is None else float(sf.ShiftsClassNum)) < sum:
new_list = new_list + "," + i.ShiftsClassName
re_date = getMonthFirstDayAndLastDay(Month[0:4], int(Month[5:7]))
for t in range(1, int(re_date[1][8:10])):
rest = db_session.query(plantCalendarScheduling).filter(plantCalendarScheduling.start == Month + "-" + addzero(t),
plantCalendarScheduling.title == "休息")
if rest:
continue
if t == 1:
pcs = plantCalendarScheduling()
pcs.color = "#FFA500"
pcs.title = new_list
pcs.start = Month + "-" + addzero(t)
pcs.end = ""
db_session.commit()
return json.dumps(dir, cls=AlchemyEncoder, ensure_ascii=False)
except Exception as e:
print(e)
insertSyslog("error", "日历排班报错Error：" + str(e), current_user.Name)
return json.dumps([{"status": "Error：" + str(e)}], cls=AlchemyEncoder, ensure_ascii=False)
def getTreeChildrenMap(id, ParentCode, tableName, Name, Code):
sz = []
try:
db_session.commit()
newTable = Table(tableName, metadata, autoload=True, autoload_with=engine)
orgs = db_session.query(newTable).filter(newTable.columns._data[ParentCode] == int(id)).all()
dir = []
for i in orgs:
a = 0
divi = {}
for j in newTable.columns._data:
divi[str(j)] = str(i[a])
a = a + 1
dir.append(divi)
for obj in dir:
if int(obj.get(ParentCode)) == int(id):
sz.append(
{"label": obj.get(Name), "value": obj.get(Code), "children": getTreeChildrenMap(obj.get("ID"), ParentCode, tableName, Name, Code)})
return sz
except Exception as e:
print(e)
return json.dumps([{"status": "Error：" + str(e)}], cls=AlchemyEncoder, ensure_ascii=False)
def saveuserusershiftsgroup():
'''
用户添加班组
:return:
'''
if request.method == 'POST':
data = request.values
try:
userID = data.get("userID")
shiftsgroupIDs = data.get("shiftsgroupIDs")
if shiftsgroupIDs:
shiftsgroupIDs = eval(shiftsgroupIDs)
userclass = db_session.query(User).filter(
User.ID == int(userID)).first()
sql = "delete from usershiftsgroup where UserID = " + userID
db_session.execute(sql)
db_session.commit()
for pid in shiftsgroupIDs:
shiftsgroupcalss = db_session.query(ShiftsGroup).filter(
ShiftsGroup.ID == int(pid)).first()
rpclas = db_session.query(UserShiftsGroup).filter(
UserShiftsGroup.UserID == userclass.ID,
UserShiftsGroup.ShiftsGroupID ==
shiftsgroupcalss.ID).first()
if not rpclas:
rp = UserShiftsGroup()
rp.UserID = userclass.ID
rp.Name = userclass.Name
rp.ShiftsGroupID = shiftsgroupcalss.ID
rp.ShiftsGroupName = shiftsgroupcalss.ShiftsGroupName
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 BatchUpdate():
if request.method == 'POST':
try:
data = request.values
BatchID = data.get("BatchID")
EQPName = data.get("EQPName")
SampleValue = data.get("SampleValue")
EQPID = db_session.query(
Equipment.ID).filter(Equipment.EQPName == EQPName).first()[0]
Type = data.get("Type")
JZNum = data.get("JZNum")
Type = Type[0:-4]
Type = db_session.query(
BatchType.Descrip).filter(BatchType.Type == Type).first()[0]
if JZNum == "二煎":
oclass = db_session.query(ElectronicBatchTwo).filter(
ElectronicBatchTwo.BatchID == BatchID,
ElectronicBatchTwo.Type == Type,
ElectronicBatchTwo.EQPID == EQPID).order_by(
desc("SampleDate")).first()
else:
oclass = db_session.query(ElectronicBatchTwo).filter(
ElectronicBatchTwo.BatchID == BatchID,
ElectronicBatchTwo.Type == Type,
ElectronicBatchTwo.EQPID == EQPID).order_by(
("SampleDate")).first()
oclass.SampleValue = SampleValue
db_session.commit()
return 'OK'
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 login():
try:
if request.method == 'GET':
return render_template('./main/login.html')
if request.method == 'POST':
data = request.values
WorkNumber = data.get('WorkNumber')
password = data.get('password')
# 验证账户与密码
if WorkNumber:
user = db_session.query(User).filter_by(WorkNumber=WorkNumber).first()
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())
db_session.commit()
# roles = db_session.query(User.RoleName).filter_by(WorkNumber=WorkNumber).all()
# menus = []
# for role in roles:
# for index in role:
# role_id = db_session.query(Role.ID).filter_by(RoleName=index).first()
# menu = db_session.query(Menu.ModuleCode).join(Role_Menu, isouter=True).filter_by(Role_ID=role_id).all()
# for li in menu:
# menus.append(li[0])
# session['menus'] = menus
# user.Status = "1"
# db_session.commit()
use = db_session.query(User).filter_by(WorkNumber=WorkNumber).first()
# return redirect('/')
return render_template('./main/heatmap.html')
# 认证失败返回登录页面
error = '用户名或密码错误'
return render_template('./main/login.html', error=error)
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 saveroleuser():
'''
用户添加角色
:return:
'''
if request.method == 'POST':
data = request.values
try:
UserID = data.get("UserID")
RoleIDs = data.get("RoleIDs")
if RoleIDs:
RoleIDs = eval(RoleIDs)
userclass = db_session.query(User).filter(
User.ID == int(UserID)).first()
sql = "delete from RoleUser where UserID = " + UserID
db_session.execute(sql)
db_session.commit()
for pid in RoleIDs:
rolecalss = db_session.query(Role).filter(
Role.ID == int(pid)).first()
rpclas = db_session.query(RoleUser).filter(
RoleUser.UserID == userclass.ID,
RoleUser.RoleID == rolecalss.ID).first()
if not rpclas:
rp = RoleUser()
rp.UserID = userclass.ID
rp.UserName = userclass.Name
rp.RoleID = rolecalss.ID
rp.RoleName = rolecalss.RoleName
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 deleteUser():
if request.method == 'POST':
data = request.values
try:
jsonstr = json.dumps(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(User).filter_by(id=id).first()
db_session.delete(oclass)
db_session.commit()
except Exception as ee:
db_session.rollback()
print(ee)
insertSyslog("error", "删除户ID为"+string(id)+"报错Error：" + string(ee), current_user.Name)
return json.dumps("删除用户报错", cls=AlchemyEncoder,ensure_ascii=False)
return 'OK'
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(tablename, new_data):
'''
:param tablename:要进行更新的model
:param new_data: 要进行更新的数据，数据类型为dict，key为model的字段属性，value为要更新的值
:return: 返回json信息，包含status，message
'''
if hasattr(tablename, '__tablename__'):
if isinstance(new_data, dict) and len(new_data) > 0:
try:
oclass = db_session.query(tablename).filter(tablename.ID==new_data['ID']).first()
if oclass:
for key in new_data:
if hasattr(oclass, key) and key != 'ID':
setattr(oclass, key, new_data[key])
db_session.add(oclass)
db_session.commit()
return 'OK'
else:
return json.dumps('当前记录不存在！', cls=AlchemyEncoder, ensure_ascii=False)
except Exception as e:
db_session.rollback()
logger.error(e)
insertSyslog("error", "%s数据更新报错："%tablename + str(e), current_user.Name)
return json.dumps('数据更新失败！', cls=AlchemyEncoder, ensure_ascii=False)
def insert(tablename, data):
'''
:param tablename: 要进行插入数据的model
:param insert_dict: 要进行插入的数据，数据类型为dict，key为model的字段属性，value为要插入的值
:return: 返回json信息，包含status，message
'''
if hasattr(tablename, '__tablename__'):
oclass = tablename()
if isinstance(data, dict) and len(data) > 0:
try:
# if "ID" in data.keys():
# popdata = data.pop("ID")
for key in data:
if key != "ID":
setattr(oclass, key, data[key])
db_session.add(oclass)
db_session.commit()
return 'OK'
except Exception as e:
print(e)
db_session.rollback()
logger.error(e)
insertSyslog("error", "%s数据添加报错："%tablename + str(e), current_user.Name)
return json.dumps('数据添加失败！')
