def selectUserShiftsGroup():
'''
根据用户查班组
:return:
'''
if request.method == 'GET':
data = request.values
try:
dir = {}
userID = data.get("userID")
pids = db_session.query(UserShiftsGroup).filter(
UserShiftsGroup.UserID == int(userID)).all()
perids_list = []
for pid in pids:
perids_list.append(pid.ShiftsGroupID)
if len(perids_list) > 0:
existingRows = db_session.query(ShiftsGroup).filter(
ShiftsGroup.ID.in_(perids_list)).all()
dir["existingRows"] = existingRows
else:
dir["existingRows"] = []
notHaveRows = db_session.query(ShiftsGroup).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 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 selectTiQuEquipment():
'''
查询提取设备
:return:
'''
if request.method == 'GET':
data = request.values
try:
ID = data.get("ID")
oclass = db_session.query(PlanManager).filter(
PlanManager.ID == ID).first()
eqps = db_session.query(EquipmentBatchRunTime).filter(
EquipmentBatchRunTime.BatchID == oclass.BatchID,
EquipmentBatchRunTime.BrandCode == oclass.BrandCode,
EquipmentBatchRunTime.PUName.like("%提%")).all()
redata_list = []
for eq in eqps:
dir = {}
dir["EQPCode"] = eq.EQPCode
dir["EQPName"] = eq.EQPName
redata_list.append(dir)
return json.dumps({
"code": "200",
"message": "查询成功！",
"data": redata_list
})
except Exception as e:
db_session.rollback()
print(e)
logger.error(e)
insertSyslog("error", "查询提取设备报错Error：" + str(e), current_user.Name)
return json.dumps("查询提取设备报错",
cls=AlchemyEncoder,
ensure_ascii=False)
def SelectParentMenus():
if request.method == 'GET':
data = request.values
try:
pages = int(data.get("offset")) # 页数
rowsnumber = int(data.get("limit")) # 行数
inipage = pages * rowsnumber + 0 # 起始页
endpage = pages * rowsnumber + rowsnumber # 截止页
total = db_session.query(ModulMenus).filter(
ModulMenus.MenuType.in_(("系统级", "模块级"))).count()
oclass = db_session.query(ModulMenus).filter(
ModulMenus.MenuType.in_(("系统级", "模块级"))).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)
return json.dumps([{
"status": "Error:" + str(e)
}],
cls=AlchemyEncoder,
ensure_ascii=False)
def selectpermissionbyrole():
'''
根据角色查询权限
:return:
'''
if request.method == 'GET':
data = request.values
try:
dir = {}
roleID = data.get("roleID")
pids = db_session.query(RolePermission).filter(
RolePermission.RoleID == int(roleID)).all()
perids_list = []
for pid in pids:
perids_list.append(pid.PermissionID)
if len(perids_list) > 0:
existingRows = db_session.query(Permission).filter(
Permission.ID.in_(perids_list)).all()
dir["existingRows"] = existingRows
else:
dir["existingRows"] = []
notHaveRows = db_session.query(Permission).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 selectpermissionbyuser():
'''
根据用户查询权限
:return:
'''
if request.method == 'GET':
data = request.values
try:
userid = db_session.query(User.ID).filter(
User.WorkNumber == current_user.WorkNumber).first()[0]
rolecos = db_session.query(RoleUser).filter(
RoleUser.UserID == userid).all()
permission_list = []
for ro in rolecos:
rps = db_session.query(RolePermission).filter(
RolePermission.RoleID == ro.RoleID).all()
for rp in rps:
permission_list.append(rp.PermissionName)
return json.dumps({
"code": "200",
"message": "请求成功",
"data": {
"total": len(permission_list),
"rows": permission_list
}
})
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "根据用户查询权限Error：" + str(e), current_user.Name)
return {
"code": "500",
"message": "请求错误",
"data": "根据用户查询权限报错Error：" + str(e)
}
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 batchconflictequimentselect():
'''
查询选择时间段下对应的冲突设备的批次品名
:return:
'''
if request.method == 'GET':
data = request.values
try:
EQPCode = data.get('EQPCode')
DateTime = data.get('DateTime')
BCType = data.get('BCType')
PlanNum = data.get('PlanNum')
BatchID = data.get('BatchID')
BrandCode = data.get('BrandCode')
sft = db_session.query(Shifts).filter(
Shifts.ShiftsName == BCType).first()
if sft:
beginoclass = db_session.query(EquipmentBatchRunTime).filter(
EquipmentBatchRunTime.EQPCode == EQPCode,
EquipmentBatchRunTime.StartTime.between(
str(DateTime + " " + sft.BeginTime),
str(DateTime + " " + sft.EndTime))).all()
endoclass = db_session.query(EquipmentBatchRunTime).filter(
EquipmentBatchRunTime.EQPCode == EQPCode,
EquipmentBatchRunTime.EndTime.between(
str(DateTime + " " + sft.BeginTime),
str(DateTime + " " + sft.EndTime))).all()
dict_list = []
for i in beginoclass:
if i.BatchID == BatchID and i.BrandCode == BrandCode:
continue #跳出当前循环
dict_list.append(i)
for j in endoclass:
if j.BatchID == BatchID and j.BrandCode == BrandCode:
continue
if j not in dict_list:
dict_list.append(j)
return json.dumps(
{
"code": "200",
"message": "查询成功！",
"data": dict_list
},
cls=AlchemyEncoder,
ensure_ascii=False)
except Exception as e:
db_session.rollback()
logger.error(e)
insertSyslog("error", "查询选择时间段下对应的冲突设备的批次品名报错Error：" + str(e),
current_user.Name)
return json.dumps("查询选择时间段下对应的冲突设备的批次品名报错",
cls=AlchemyEncoder,
ensure_ascii=False)
def batchusemodelselect():
'''查询批记录使用模版'''
if request.method == 'GET':
data = request.values
try:
PUCode = data.get("PUCode")
BrandCode = data.get("BrandCode")
PUIDName = data.get("PUIDName")
BrandName = data.get("BrandName")
BatchID = data.get("BatchID")
oclass = db_session.query(BatchUseModel).filter(
BatchUseModel.BrandCode == BrandCode,
BatchUseModel.PUCode == PUCode,
BatchUseModel.BatchID == BatchID).first()
dir = {}
if not oclass: #初始化批记录模板
bum = BatchUseModel()
bum.BatchID = BatchID
bum.BrandCode = BrandCode
bum.BrandName = BrandName
bum.PUCode = PUCode
bum.PUIDName = PUIDName
oclass = db_session.query(BatchModel).filter(
BatchModel.BrandCode == BrandCode,
BatchModel.PUCode == PUCode).first()
bum.UseParameter = oclass.Parameter
db_session.add(bum)
db_session.commit()
oc = db_session.query(BatchUseModel).filter(
BatchUseModel.BrandCode == BrandCode,
BatchUseModel.PUCode == PUCode,
BatchUseModel.BatchID == BatchID).first()
dir["ID"] = oc.ID
dir["BrandCode"] = oc.FileName
dir["BrandName"] = oc.FileName
dir["PUIDName"] = oc.FileName
dir["PUCode"] = oc.PUCode
dir["UseParameter"] = oc.Parameter
else:
dir["ID"] = oclass.ID
dir["BrandCode"] = oclass.FileName
dir["BrandName"] = oclass.FileName
dir["PUIDName"] = oclass.FileName
dir["PUCode"] = oclass.PUCode
dir["UseParameter"] = oclass.UseParameter
return json.dumps({"code": "200", "message": dir})
except Exception as e:
db_session.rollback()
print(e)
logger.error(e)
insertSyslog("error", "查询批记录使用模版报错Error：" + str(e),
current_user.Name)
return json.dumps({"code": "500", "message": "后端报错"})
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 + "-" +
("0" + str(t) if t < 10 else str(t)),
plantCalendarScheduling.title == "休息")
if rest:
continue
if t == 1:
pcs = plantCalendarScheduling()
pcs.color = "#FFA500"
pcs.title = new_list
pcs.start = Month + "-" + ("0" +
str(t) if t < 10 else str(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 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 ManualDelete():
'''批记录模板删除'''
if request.method == 'POST':
data = request.values # 返回请求中的参数和form
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(BatchModel).filter(
BatchModel.ID == id).first()
if oclass:
db_session.delete(oclass)
os.remove(oclass.FilePath)
except Exception as ee:
db_session.rollback()
print(ee)
logger.error(ee)
return json.dumps({
"code": "500",
"message": "批记录模板删除报错"
})
db_session.commit()
return json.dumps({"code": "200", "message": "删除成功！"})
else:
return json.dumps({"code": "200", "message": "id为空！"})
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "路由：/ManualDelete，说明书删除Error：" + str(e),
current_user.Name)
return json.dumps({"code": "500", "message": "批记录模板删除报错"})
def batchmodelselect():
'''查询批记录模版'''
if request.method == 'GET':
data = request.values
try:
PUCode = data.get("PUCode")
# BrandCode = data.get("BrandCode")
oclass = db_session.query(BatchModel).filter(
BatchModel.PUCode == PUCode).all()
dir_list = []
for oc in oclass:
dir = {}
dir["ID"] = oc.ID
dir["FilePath"] = oc.FilePath
dir["FileName"] = oc.FileName
dir["BrandCode"] = oc.FileName
dir["BrandName"] = oc.FileName
dir["PUIDName"] = oc.FileName
dir["PUCode"] = oc.PUCode
dir["UserName"] = oc.UserName
dir["Parameter"] = oc.Parameter
dir_list.append(dir)
return json.dumps({"code": "200", "message": dir_list})
except Exception as e:
db_session.rollback()
print(e)
logger.error(e)
insertSyslog("error", "查询批记录模报错Error：" + str(e), current_user.Name)
return json.dumps({"code": "500", "message": "后端报错"})
def createZYPlanZYtask():
'''生产确认'''
if request.method == 'POST':
data = request.values # 返回请求中的参数和form
try:
jsonstr = json.dumps(data.to_dict())
if len(jsonstr) > 10:
PlanStatus = data.get("PlanStatus")
if PlanStatus == "待备料":
IDs = json.loads(data.get("IDs"))
for ID in IDs:
returnmsg = makeZYPlanZYTask(ID)
if (returnmsg == False):
return json.dumps({
"code": "500",
"message": "生产确认失败！"
})
oclassplan = db_session.query(PlanManager).filter_by(
ID=ID).first()
oclassplan.PlanStatus = Global.PlanStatus.PreMaterial.value
db_session.commit()
insertAuditTrace(
"生产确认计划", "批次号是：" + oclassplan.BatchID + "的" +
oclassplan.BrandName + "在" +
datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S') + "生产确认计划操作",
"PlanManager", current_user.Name, "")
return json.dumps({"code": "200", "message": "生产确认成功！！"})
else:
return json.dumps({"code": "200", "message": "批次计划状态不正确！"})
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "生产确认报错Error：" + str(e), current_user.Name)
return 'NO'
def checkPlanManagerSingle():
'''
单条审核计划
:return:
'''
if request.method == 'POST':
data = request.values # 返回请求中的参数和form
try:
PlanStatus = data.get("PlanStatus")
Description = data.get("Describtion")
ID = data.get("ID")
oclassplan = db_session.query(PlanManager).filter_by(ID=ID).first()
oclassplan.PlanStatus = PlanStatus
oclassplan.Description = Description
db_session.commit()
insertAuditTrace(
"审核计划",
"批次号是：" + oclassplan.BatchID + "的" + oclassplan.BrandName +
"在" + datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') +
"进行计划审核操作", "PlanManager", current_user.Name, "")
return json.dumps({"code": "200", "message": "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 makeModel(self, AModifyString, tableName):
try:
import os, configparser
BASE_DIR = os.path.dirname(
os.path.dirname(os.path.abspath(__file__)))
pythonFileName = os.path.join(BASE_DIR, r'common\core.py')
tpl = ''
# tpl += self.makeDevNotes()
# tpl += self.makeImportNotes()
# tpl += self.makeDBNotes()
# tpl += self.makeBaseModel()
tpl += self.makeORMFrontModel(tableName)
tpl += self.makeGeneralKeyModel("ID", "ID", "Integer", "True",
"True", "False", "")
ocs = db_session.query(FieldSet).filter(
FieldSet.TableName == tableName).all()
for i in ocs:
tpl += self.makeGeneralKeyModel(i.comment, i.FieldName, i.type,
i.primarykey, i.autoincrement,
i.nullable, i.length)
i.Status = "使用中"
db_session.commit()
tpl += '\n'
tpl += '#' + tableName + '_END:\n'
if len(tpl) > 10:
tpl += self.makeEndImplement()
notes = AModifyString + tpl
self.makeModelPythonFile(pythonFileName, notes)
except Exception as e:
os.remove("make_model_test.txt")
print(e)
logger.error(e)
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 json.dumps({"code": "200", "message": "OK"})
else:
return json.dumps({"code": "300", "message": "用户名密码错误"})
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 getMenuList(user_menus, id=0):
sz = []
try:
menus = db_session.query(ModulMenus).filter_by(ParentNode=id).all()
for obj in menus:
if obj.ParentNode == id:
sz.append({
"id": obj.ID,
"text": obj.ModulMenuName,
"ModulMenuName": obj.ModulMenuName,
"MenuType": obj.MenuType,
"ModulMenuCode": obj.ModulMenuCode,
"state": trueOrFalse(obj, user_menus),
"nodes": getMenuList(user_menus, obj.ID)
})
return sz
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 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 WMS_OrderStatus(self, name, json_data):
'''
投料明细状态便跟接口
'''
try:
dic = []
jso = json.loads(json_data)
for i in jso:
BatchMaterialInfoID = i.get("BatchMaterialInfoID")
EQPCode = i.get("EQPCode")
EQPName = i.get("EQPName")
status = i.get("status")
if BatchMaterialInfoID != None:
zy = db_session.query(BatchMaterialInfo).filter(
BatchMaterialInfo.ID == BatchMaterialInfoID).first()
if zy: #批次明细增加完成时间
if status == "End":
status = "投料系统已投料"
zy.ExcuteStatus = status
zy.FinishDate = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
db_session.commit()
else:
return json.dumps("没有此物料明细ID！")
else:
continue
return json.dumps("SUCCESS")
except Exception as e:
print("WMS调用WMS_OrderStatus接口报错！")
return json.dumps(e)
def WMS_ZYPlanStatus(self, name, json_data):
'''
投料段计划开始结束状态回传接口
'''
try:
dic = []
jso = json.loads(json_data)
for i in jso:
PlanNo = i.get("PlanNo")
BatchID = i.get("BatchID")
BrandCode = i.get("BrandCode")
status = i.get("status")
if PlanNo != None:
# oclas = db_session.query(PlanManager).filter(PlanManager.ID == PlanNo).first()
zy = db_session.query(ZYPlan).filter(
ZYPlan.ID == PlanNo).first()
if zy != None:
if status == "Start":
zy.ZYPlanStatus = common.Global.ZYPlanStatus.Feeding.value
zy.ActBeginTime = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
elif status == "End":
zy.ZYPlanStatus = common.Global.ZYPlanStatus.FeedingFinish.value
zy.ActEndTime = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
db_session.commit()
else:
continue
return json.dumps("SUCCESS")
except Exception as e:
print("WMS调用WMS_ZYPlanStatus接口报错！")
return json.dumps(e)
def WMS_TrayNumber(self, name, json_data):
'''
WMS托盘信息回传
'''
try:
dic = []
jso = json.loads(json_data)
for i in jso:
BatchNo = i.get("BatchNo")
TrayNum = i.get("TrayNum")
MID = i.get("MID")
PalletID = i.get("PalletID")
FormulaID = i.get("FormulaID")
MWeight = i.get("MWeight")
zy = db_session.query(WMSTrayNumber).filter(
WMSTrayNumber.BatchNo == BatchNo,
WMSTrayNumber.TrayNum == TrayNum,
WMSTrayNumber.MID == MID).first()
if zy == None:
tn = WMSTrayNumber()
tn.BatchNo = BatchNo
tn.TrayNum = TrayNum
tn.MID = MID
tn.PalletID = PalletID
tn.FormulaID = FormulaID
tn.MWeight = MWeight
tn.UpdateTime = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
db_session.commit()
else:
continue
return json.dumps("SUCCESS")
except Exception as e:
print("WMS调用WMS_TrayNumber接口报错！")
return json.dumps(e)
def getTaskNo():
bReturn = True
qry = db_session.query(func.max(TaskNoGenerator.TaskNoInt)).all()
intTaskNo = int(qry[0][0])
varTaskNo = str(intTaskNo + 1)
if len(varTaskNo) == 1:
varTaskNo = "00000" + varTaskNo
elif len(varTaskNo) == 2:
varTaskNo = "0000" + varTaskNo
if len(varTaskNo) == 3:
varTaskNo = "000" + varTaskNo
if len(varTaskNo) == 4:
varTaskNo = "00" + varTaskNo
if len(varTaskNo) == 5:
varTaskNo = "0" + varTaskNo
else:
varTaskNo = varTaskNo
try:
db_session.add(
TaskNoGenerator(TaskNoInt=intTaskNo + 1,
TaskNoVar=varTaskNo,
Description=""))
db_session.commit()
return bReturn, varTaskNo
except Exception as e:
bReturn = False
print(e)
logger.error(e)
return bReturn, varTaskNo
def addUpdateEletronicBatchDataStore(BrandCode, PUCode, BatchID, ke, val):
try:
oc = db_session.query(EletronicBatchDataStore).filter(
EletronicBatchDataStore.BrandID == BrandCode,
EletronicBatchDataStore.PUCode == PUCode,
EletronicBatchDataStore.BatchID == BatchID,
EletronicBatchDataStore.Content == ke).first()
if oc == None:
db_session.add(
EletronicBatchDataStore(BrandCode=BrandCode,
BatchID=BatchID,
PUCode=PUCode,
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 delete_department():
code = request.headers.get('department_code')
department = db_session.query(DepartmentManager).filter(
DepartmentManager.DepartCode == code).first()
role_query = db_session.query(Role).filter(
Role.ParentNode == department.DepartCode).all()
for item in role_query:
item.ParentNode = ''
db_session.commit()
user_query = db_session.query(User).filter(
User.OrganizationName == department.DepartName).all()
for item in user_query:
item.OrganizationName = ''
db_session.commit()
db_session.delete(department)
db_session.commit()
return json.dumps({'code': 10001, 'msg': '删除成功'})
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()
count = db_session.query(ModulMenus).count()
return {
"code": "200",
"message": "请求成功",
"data": {
"total": count,
"rows": oclass
}
}
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)
return {
"code": "200",
"message": "请求成功",
"data": {
"total": len(dic),
"rows": dic
}
}
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "菜单权限查询报错Error：" + str(e), current_user.Name)
return {
"code": "500",
"message": "请求错误",
"data": "菜单权限查询报错Error：" + str(e)
}
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 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({
"code": "200",
"message": "请求成功"
},
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 allUnitDataMutual():
if request.method == 'POST':
data = request.values
data = data.to_dict()
try:
for key in data.keys():
if key == "BrandCode":
continue
if key == "PUCode":
continue
if key == "BatchID":
continue
val = data.get(key)
addUpdateEletronicBatchDataStore(data.get("BrandCode"),
data.get("PUCode"),
data.get("BatchID"), key, val)
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)
if request.method == 'GET':
data = request.values
try:
dic = {}
json_str = json.dumps(data.to_dict())
if len(json_str) > 2:
PUCode = data['PUCode']
BatchID = data['BatchID']
BrandCode = data.get("BrandCode")
oclasss = db_session.query(EletronicBatchDataStore).filter(
EletronicBatchDataStore.BrandCode == BrandCode,
EletronicBatchDataStore.PUCode == PUCode,
EletronicBatchDataStore.BatchID == BatchID).all()
for oclass in oclasss:
dic[oclass.Content] = oclass.OperationpValue
return json.dumps(dic, 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({
"code": "200",
"message": "请求成功"
},
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)
