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 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 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 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 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 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 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 ModifyModel(self, AFilename, ATableName):
currentPath = os.path.abspath('.')
model_path = PATH(currentPath + r'\\' + AFilename)
i = 0
tmp = ""
try:
if not os.path.exists(model_path):
print("不存在！")
else:
# print("存在!!")
with open(AFilename, 'r', encoding='UTF-8') as f:
lines = f.readlines()
i = 0
strTbStart = "#" + ATableName + "_START"
strTbEnd = "#" + ATableName + "_END"
strExecStart = "# 生成表单的执行语句_START"
strExecEnd = "# 生成表单的执行语句_END"
isExist = "FLASE"
for line in lines:
iposstart = line.find(strTbStart)
iposend = line.find(strTbEnd)
istart = line.find(strExecStart)
iend = line.find(strExecEnd)
if iposstart >= 0:
isExist = "TRUE"
i = 1
continue
elif iposend >= 0:
i = 0
continue
elif istart >= 0:
i = 1
continue
elif iend >= 0:
i = 0
continue
elif i == 1:
continue
tmp += line
if tmp is "":
tmp += self.makeDevNotes()
tmp += self.makeImportNotes()
tmp += self.makeDBNotes()
tmp += self.makeBaseModel()
tmp += self.makeEndImplement()
if isExist == "TRUE":
ATableNameNew = ATableName + datetime.datetime.now(
).strftime('%Y-%m-%d %H:%M:%S')
sql = "EXEC sp_rename '" + ATableName + "', '" + ATableNameNew + "'"
db_session.execute(sql)
db_session.commit()
f = open(AFilename, 'w', encoding='utf-8')
f.write(tmp)
f.close()
return tmp
except Exception as e:
print(e)
os.remove("make_model_test.txt")
db_session.rollback()
logger.error(e)
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 addscheduledates():
'''
添加工作日休息日
:return:
'''
if request.method == 'GET':
data = request.values
try:
month = data['month']
count = db_session.query(scheduledate).filter(
scheduledate.WorkDate.like("%" + month + "%")).count()
if count < 20:
mou = month.split("-")
monthRange = calendar.monthrange(int(mou[0]), int(mou[1]))
re = timeChange(mou[0], str(int(mou[1])), monthRange[1])
lis = [
'星期一',
'星期二',
'星期三',
'星期四',
'星期五',
'星期六',
'星期日',
]
dic = dict(enumerate(lis))
for i in re:
ymr = i.split("-")
w = datetime.date(int(ymr[0]), int(ymr[1]), int(ymr[2]))
xq = dic[w.weekday()]
if xq == "星期六" or xq == "星期日":
# dc = db_session.query(scheduleDateType).filter(scheduleDateType.DateTypeName == "周末").first()
DateType = "周末"
color = "#FA7D00"
else:
DateType = "工作日"
color = "#00CAFA"
sc = scheduledate()
sc.WorkDate = i
sc.DateType = DateType
sc.comment = xq
sc.color = color
db_session.add(sc)
db_session.commit()
db_session.close_all()
return 'OK'
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 selectpaichanrule():
'''
查询排产规则
:return:
'''
if request.method == 'GET':
data = request.values
try:
data_list = json.loads(data.get('selectPlanList'))
redata_list = []
for i in data_list:
dir = {}
flag = 0
proclass = db_session.query(ProductRule).filter(
ProductRule.BrandCode == i.get("BrandCode")).first()
for j in redata_list:
if j.get("BrandCode") == i.get("BrandCode"):
flag = 1
j["BatchNum"] = math.ceil(
(float(i.get("PlanQuantity")) +
float(j.get("PlanQuantityTotal"))) /
float(proclass.BatchWeight))
j["PlanQuantityTotal"] = float(
i.get("PlanQuantity")) + float(
j.get("PlanQuantityTotal"))
j["orderNum"] = int(j.get("orderNum")) + 1
j["PlanNum"] = i.get("PlanNum") + "," + j.get(
"PlanNum")
if flag == 0:
dir["BatchNum"] = math.ceil(
float(i.get("PlanQuantity")) /
float(proclass.BatchWeight))
dir["PlanQuantityTotal"] = i.get("PlanQuantity")
dir["BatchWeight"] = proclass.BatchWeight
dir["BrandName"] = i.get("BrandName")
dir["BrandCode"] = i.get("BrandCode")
dir["PlanNum"] = i.get("PlanNum")
dir["unit"] = proclass.Unit
dir["orderNum"] = 1
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 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 WMS_SendReturnMaterialInfo():
'''发送退料信息到WMS'''
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)
dic = []
for key in jsonnumber:
id = int(key)
oclass = db_session.query(BatchMaterialInfo).filter(
BatchMaterialInfo.ID == id).first()
dic.append({
"BatchMaterialInfoID": oclass.ID,
"BrandCode": oclass.BrandCode,
"BrandName": oclass.BrandName,
"BatchID": oclass.BatchID,
"FlagCode": oclass.BucketNum,
"Weight": oclass.BucketWeight,
"Unit": oclass.Unit,
"Flag": oclass.Flag
})
oclass.SendFlag = "投料系统已接收退料"
oclass.OperationDate = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
url = Global.WMSurl + "api/WbeApi/RecvTransInfon"
dir = {}
dir["zyplan_list"] = dic
dir = json.dumps(dir)
resp = requests.post(url, json=dir, headers=headers)
responjson = json.loads(resp.content)
responjson = eval(responjson)
if responjson.get("code") != "0":
db_session.rollback()
return json.dumps({
"code":
"500",
"message":
"调用WMS_SendReturnMaterialInfo接口报错！" +
responjson.get("msg")
})
insertSyslog("调用退料信息发送接口", "发送退料信息到投料系统", current_user.Name)
return json.dumps({"code": "200", "message": "OK"})
except Exception as e:
db_session.rollback()
print("调用WMS_SendPlan接口报错！")
insertSyslog("error", "调用WMS_SendPlan接口报错Error" + str(e),
current_user.Name)
return json.dumps("调用WMS_SendPlan接口报错！")
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 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({
"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 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)
def batchmodelinsert():
'''批记录模板名称路径储存'''
if request.method == 'POST':
data = request.values
try:
BrandName = data.get("BrandName")
PUCode = data.get("PUCode")
BrandCode = data.get("BrandCode")
PUIDName = data.get("PUIDName")
FileName = data.get("FileName")
Parameter = data.get("Parameter")
#删除之前存的
oclass = db_session.query(BatchModel).filter(
BatchModel.PUCode == PUCode).all()
for oc in oclass:
db_session.delete(oc)
os.remove(oc.FilePath)
db_session.commit()
#新添加的
bm = BatchModel()
bm.BrandName = BrandName
bm.PUCode = PUCode
bm.BrandCode = BrandCode
bm.PUIDName = PUIDName
bm.FileName = FileName
bm.FilePath = os.path.join(
os.path.realpath(r"system_backend\SystemManagement\files"),
FileName)
bm.UserName = current_user.Name
bm.Parameter = Parameter
db_session.add(bm)
db_session.commit()
return json.dumps({"code": "200", "message": "上传成功！"})
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 taskSaveEqpCheckReview():
'''
任务审核复核（选择设备）
:return:
'''
if request.method == 'POST':
data = request.values
try:
ZYPlanStatus = data.get("ZYPlanStatus")
ocalss = db_session.query(ZYPlan).filter(
ZYPlan.ID == data.get("ID")).first()
# datalist = json.loads(data.get("datalist"))
# iTaskSeq = 0
# for i in datalist:
# ocalss = db_session.query(ZYTask).filter(ZYTask.ID == i.get("ID")).first()
# ocalss.EQPCode = i.get("EQPCode")
# ocalss.EQPName = i.get("EQPName")
# db_session.commit()
ocalss.ZYPlanStatus = ZYPlanStatus
db_session.commit()
insertAuditTrace(
"任务审核复核（选择设备）", "批次号是：" + ocalss.BatchID + "的" +
ocalss.BrandName + "在" + ocalss.PUName + "段的" +
datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') +
"进行计划审核操作", "PlanManager", current_user.Name, "")
return json.dumps({
"code": "200",
"message": "任务选择设备成功！",
"data": "OK"
})
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 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 batchequimentselect():
'''
查询批次下对应的设备
:return:
'''
if request.method == 'GET':
data = request.values
try:
BatchID = data.get('BatchID')
BrandCode = data.get('BrandCode')
oclass = db_session.query(PlanManager).filter(
PlanManager.BatchID == BatchID,
PlanManager.BrandCode == BrandCode).first()
dir = {}
if oclass:
pres = db_session.query(ProductUnit).filter(
ProductUnit.BrandCode == oclass.BrandCode).all()
dir_list = []
for pre in pres:
dir_list_i = {}
dir_list_i["PUName"] = pre.PUName
dir_list_i["PUCode"] = pre.PUCode
dir_list_i["Seq"] = pre.Seq
puoclass = db_session.query(ProcessUnit).filter(
ProcessUnit.PUCode == pre.PUCode).first()
dir_list_i["RelateTaskCount"] = puoclass.RelateTaskCount
eqList = []
eqps = db_session.query(ProductEquipment).filter(
ProductEquipment.PUCode == pre.PUCode).all()
for eqp in eqps:
eqp_dir = {}
eqp_dir["EQPCode"] = eqp.EQPCode
eqp_dir["EQPName"] = eqp.EQPName
eqp_dir["EQPStatus"] = eqp.EQPStatus
runeqp = db_session.query(
EquipmentBatchRunTime).filter(
EquipmentBatchRunTime.EQPCode == eqp.EQPCode,
EquipmentBatchRunTime.BrandCode ==
oclass.BrandCode, EquipmentBatchRunTime.BatchID
== oclass.BatchID, EquipmentBatchRunTime.PUCode
== pre.PUCode).first()
eqp_dir["isSelected"] = False
if runeqp: #如果被选中过True，没被选中就是False
eqp_dir["isSelected"] = True
eqp_dir["StartTime"] = runeqp.StartTime[0:10]
eqp_dir["EndTime"] = runeqp.EndTime[0:10]
eqp_dir["StartBC"] = runeqp.StartBC
eqp_dir["EndBC"] = runeqp.EndBC
else:
eqp_dir["StartTime"] = ""
eqp_dir["EndTime"] = ""
eqp_dir["StartBC"] = ""
eqp_dir["EndBC"] = ""
eqList.append(eqp_dir)
dir_list_i["eqList"] = eqList
dir_list.append(dir_list_i)
dir["processList"] = dir_list
return json.dumps({"code": "200", "message": "查询成功！", "data": dir})
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 BatchMaterialInfoselect():
'''物料明细查询'''
if request.method == 'GET':
data = request.values
try:
BrandCode = data.get("BrandCode")
BatchID = data.get("BatchID")
SendFlag = data.get("SendFlag")
pages = data.get("offset")
rowsnumber = data.get("limit")
inipage = int(pages) * int(rowsnumber) + 0 # 起始页
endpage = int(pages) * int(rowsnumber) + int(rowsnumber) # 截止页
if SendFlag == "" or SendFlag == None:
count = db_session.query(BatchMaterialInfo).filter(
BatchMaterialInfo.BrandCode == BrandCode,
BatchMaterialInfo.BatchID == BatchID).count()
oclass = db_session.query(BatchMaterialInfo).filter(
BatchMaterialInfo.BrandCode == BrandCode,
BatchMaterialInfo.BatchID ==
BatchID).all()[inipage:endpage]
else:
count = db_session.query(BatchMaterialInfo).filter(
BatchMaterialInfo.BrandCode == BrandCode,
BatchMaterialInfo.SendFlag == SendFlag,
BatchMaterialInfo.BatchID == BatchID).count()
oclass = db_session.query(BatchMaterialInfo).filter(
BatchMaterialInfo.BrandCode == BrandCode,
BatchMaterialInfo.SendFlag == SendFlag,
BatchMaterialInfo.BatchID ==
BatchID).all()[inipage:endpage]
dir_list = []
for oc in oclass:
dir = {}
dir["ID"] = oc.ID
dir["BatchID"] = oc.BatchID
dir["BrandCode"] = oc.BrandCode
dir["BrandName"] = oc.BrandName
dir["FeedingSeq"] = oc.FeedingSeq
dir["BucketNum"] = oc.BucketNum
dir["BucketWeight"] = oc.BucketWeight
dir["Flag"] = oc.Flag
dir["Unit"] = oc.Unit
dir["Description"] = oc.Description
dir["SendFlag"] = oc.SendFlag
dir_list.append(dir)
return json.dumps(
{
"code": "200",
"message": "请求成功",
"data": {
"total": count,
"rows": dir_list
}
},
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({"code": "500", "message": "后端报错"})
def makeZYPlanZYTask(id):
try:
ocalss = db_session.query(PlanManager).filter(
PlanManager.ID == id).first()
if ocalss:
if ocalss.PlanStatus == Global.PlanStatus.PreRUN.value:
proclass = db_session.query(ProductUnit).filter(
ProductUnit.BrandCode == ocalss.BrandCode).order_by(
"Seq").all()
for i in proclass:
pu = db_session.query(ProcessUnit).filter(
ProcessUnit.PUCode == i.PUCode).first()
zyplan = ZYPlan()
zyplan.PlanDate = ocalss.PlanBeginTime
zyplan.PlanNo = ocalss.SchedulePlanCode
zyplan.BatchID = ocalss.BatchID
zyplan.PlanSeq = i.Seq
zyplan.PUCode = i.PUCode
zyplan.PUName = i.PUName
zyplan.PlanType = Global.PLANTYPE.SCHEDULE.value
zyplan.BrandCode = ocalss.BrandCode
zyplan.BrandName = ocalss.BrandName
zyplan.ERPOrderNo = ""
zyplan.PlanQuantity = ocalss.PlanQuantity
zyplan.Unit = ocalss.Unit
zyplan.EnterTime = ""
zyplan.PlanBeginTime = ""
zyplan.ZYPlanStatus = Global.ZYPlanStatus.Produced.value
zyplan.LockStatus = Global.TASKLOCKSTATUS.UNLOCK.value
zyplan.INFStatus = Global.TASKSTATUS.NEW.value
zyplan.WMSStatus = Global.TASKSTATUS.NEW.value
db_session.add(zyplan)
db_session.commit()
# ebps = db_session.query(EquipmentBatchRunTime).filter(EquipmentBatchRunTime.BrandCode == ocalss.BrandCode,
# EquipmentBatchRunTime.BatchID == ocalss.BatchID, EquipmentBatchRunTime.PUCode == i.PUCode).all()
# iTaskSeq = 0
# for j in ebps:
# iTaskSeq = iTaskSeq + 1
# bReturn, strTaskNo = getTaskNo()
# if bReturn == False:
# return False
# zytask = ZYTask()
# zytask.PlanDate = j.StartTime
# zytask.TaskID = strTaskNo
# zytask.BatchID = ocalss.BatchID
# zytask.PlanSeq = iTaskSeq
# if i.PUName == "备料":#备料段为满足前端展示需要，虚拟了一个设备出来，所以下发要排除
# zytask.PUCode = ""
# zytask.PUName = ""
# else:
# zytask.PUCode = i.PUCode
# zytask.PUName = i.PUName
# zytask.PlanType = Global.PLANTYPE.SCHEDULE.value
# zytask.BrandCode = ocalss.BrandCode
# zytask.BrandName = ocalss.BrandName
# zytask.PlanQuantity = ocalss.PlanQuantity
# zytask.Unit = ocalss.Unit
# zytask.EnterTime = ""
# zytask.EQPCode = j.EQPCode
# zytask.EQPName = j.EQPName
# zytask.StartBC = j.StartBC
# zytask.EndBC = j.EndBC
# zytask.PlanStartTime = j.StartTime
# zytask.PlanEndTime = j.EndTime
# zytask.TaskStatus = ""
# zytask.LockStatus = Global.TASKLOCKSTATUS.UNLOCK.value
# db_session.add(zytask)
except Exception as ee:
db_session.rollback()
print(ee)
logger.error(ee)
insertSyslog("error", "下发计划生成ZY计划、任务报错Error" + str(ee),
current_user.Name)
return 'NO'
def WMS_SendPlan():
'''发送投料任务和桶对应提取罐信息到投料系统'''
if request.method == 'POST':
data = request.values
try:
jsonstr = json.dumps(data.to_dict())
if len(jsonstr) > 10:
dic = []
PlanID = data.get("PlanID")
pmoc = db_session.query(PlanManager).filter(
PlanManager.ID == PlanID).first()
zypl = db_session.query(ZYPlan).filter(
ZYPlan.BatchID == pmoc.BatchID,
ZYPlan.BrandCode == pmoc.BrandCode,
ZYPlan.PUName.like("%提%")).first()
if zypl == None:
zypl = db_session.query(ZYPlan).filter(
ZYPlan.BatchID == pmoc.BatchID,
ZYPlan.BrandCode == pmoc.BrandCode,
ZYPlan.PUName.like("%渗%")).first()
dic.append({
"PlanNo": zypl.ID,
"BrandCode": pmoc.BrandCode,
"BrandName": pmoc.BrandName,
"BatchID": pmoc.BatchID,
"Weight": pmoc.PlanQuantity,
"Unit": pmoc.Unit
})
url = Global.WMSurl + "api/WbeApi/RecvTransInfon"
dir = {}
dir["zyplan_list"] = dic
dir = json.dumps(dir)
resp = requests.post(url, json=dir, headers=headers)
responjson = json.loads(resp.content)
responjson = eval(responjson)
if responjson.get("code") != "0":
db_session.rollback()
return json.dumps({
"code":
"500",
"message":
"调用WMS_SendPlan接口报错！" + responjson.get("msg")
})
oclass = db_session.query(BatchMaterialInfo).filter(
BatchMaterialInfo.BrandCode == pmoc.BrandCode,
BatchMaterialInfo.BatchID == pmoc.BatchID).all()
dic = []
for oc in oclass:
dic.append({
"PlanNo": zypl.ID,
"BatchMaterialInfoID": oc.ID,
"BrandCode": pmoc.BrandCode,
"BrandName": pmoc.BrandName,
"BatchID": oc.BatchID,
"FlagCode": oc.BucketNum,
"Weight": oc.BucketWeight,
"Unit": oc.Unit,
"Flag": oc.Flag,
"FeedingSeq": oc.FeedingSeq,
"EQPCode": oc.EQPCode,
"EQPName": oc.EQPName,
"TYPE": "投料"
})
if len(dic) > 0:
url = Global.WMSurl + "api/WbeApi/RecvContanerInfon"
dir = {}
dir["batchmaterial_list"] = dic
dir = json.dumps(dir)
resp = requests.post(url, json=dir, headers=headers)
responjson = json.loads(resp.content)
responjson = eval(responjson)
if responjson.get("code") != "0":
return json.dumps({
"code":
"500",
"message":
"调用WMS_SendPlan接口报错！" + responjson.get("msg")
})
for oc in oclass:
oc.SendFlag = "投料系统已接收"
oc.OperationDate = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
db_session.commit()
# pmoc.PlanStatus = Global.PlanStatus.FSMWMSed.value
# db_session.commit()
insertSyslog(
"调用投料计划发送接口", "发送品名：" + pmoc.BrandName + " 批次：" +
pmoc.BatchID + "的投料计划到投料系统", current_user.Name)
return json.dumps({"code": "200", "message": "OK"})
except Exception as e:
db_session.rollback()
print("调用WMS_SendPlan接口报错！")
insertSyslog("error", "调用WMS_SendPlan接口报错Error" + str(e),
current_user.Name)
return json.dumps("调用WMS_SendPlan接口报错！")
def WMS_SendMatils():
'''备料明细发送投料系统接口'''
if request.method == 'POST':
data = request.values
try:
jsonstr = json.dumps(data.to_dict())
if len(jsonstr) > 10:
jsonnumber = re.findall(r"\d+\.?\d*", data.get("sendData"))
PlanID = data.get("PlanID")
pmoc = db_session.query(PlanManager).filter(
PlanManager.ID == PlanID).first()
dic = []
for key in jsonnumber:
id = int(key)
oclass = db_session.query(BatchMaterialInfo).filter(
BatchMaterialInfo.ID == id).first()
zypla = db_session.query(ZYPlan).filter(
ZYPlan.BatchID == oclass.BatchID,
ZYPlan.BrandCode == oclass.BrandCode,
ZYPlan.PUName.like("%提%")).first()
if zypla == None:
zypla = db_session.query(ZYPlan).filter(
ZYPlan.BatchID == oclass.BatchID,
ZYPlan.BrandCode == oclass.BrandCode,
ZYPlan.PUName.like("%渗%")).first()
dic.append({
"PlanNo": zypla.ID,
"BatchMaterialInfoID": oclass.ID,
"BrandCode": pmoc.BrandCode,
"BrandName": pmoc.BrandName,
"BatchID": oclass.BatchID,
"FlagCode": oclass.BucketNum,
"Weight": oclass.BucketWeight,
"Unit": oclass.Unit,
"Flag": oclass.Flag,
"FeedingSeq": oclass.FeedingSeq,
"EQPCode": oclass.EQPCode,
"EQPName": oclass.EQPName,
"TYPE": "备料"
})
if len(dic) > 0:
url = Global.WMSurl + "api/WbeApi/RecvContanerInfon"
dir = {}
dir["batchmaterial_list"] = dic
dir = json.dumps(dir)
resp = requests.post(url, json=dir, headers=headers)
responjson = json.loads(resp.content)
responjson = eval(responjson)
if responjson.get("code") != "0":
return json.dumps({
"code":
"500",
"message":
"调用WMS_SendPlan接口报错！" + responjson.get("msg")
})
for key in jsonnumber:
oclass = db_session.query(BatchMaterialInfo).filter(
BatchMaterialInfo.ID == key).first()
oclass.SendFlag = "投料系统已接收"
oclass.OperationDate = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
# zypla.TaskStatus = "已发送"
db_session.commit()
pmoc.PlanStatus = data.get("PlanStatus")
db_session.commit()
insertSyslog(
"投料物料明细发送接口", "发送品名：" + pmoc.BrandName + " 批次：" +
pmoc.BatchID + "的备料明细到投料系统", current_user.Name)
return json.dumps({"code": "200", "message": "OK"})
except Exception as e:
db_session.rollback()
print("调用WMS_SendPlan接口报错！")
insertSyslog("error", "调用WMS_SendPlan接口报错Error" + str(e),
current_user.Name)
return json.dumps("调用WMS_SendPlan接口报错！")
def taskSaveEqpCheck():
'''
设备审核（选择设备）
:return:
'''
if request.method == 'POST':
data = request.values
try:
ocalss = db_session.query(ZYPlan).filter(
ZYPlan.ID == data.get("ID")).first()
zytasks = db_session.query(ZYTask).filter(
ZYTask.BatchID == ocalss.BatchID,
ZYTask.BrandCode == ocalss.BrandCode,
ZYTask.PUCode == ocalss.PUCode).all()
for zy in zytasks:
db_session.delete(zy)
db_session.commit()
iTaskSeq = 0
if "提取" in ocalss.PUName:
bms = db_session.query(BatchMaterialInfo).filter(
BatchMaterialInfo.BatchID == ocalss.BatchID,
BatchMaterialInfo.BrandCode == ocalss.BrandCode).all()
for bm in bms:
iTaskSeq = iTaskSeq + 1
bReturn, strTaskNo = getTaskNo()
if bReturn == False:
return False
zytask = ZYTask()
zytask.PlanDate = datetime.datetime.now().strftime(
"%Y-%m-%d")
zytask.TaskID = strTaskNo
zytask.BatchID = ocalss.BatchID
zytask.PlanSeq = iTaskSeq
zytask.PUCode = ocalss.PUCode
zytask.PUName = ocalss.PUName
zytask.PlanType = Global.PLANTYPE.SCHEDULE.value
zytask.BrandCode = ocalss.BrandCode
zytask.BrandName = ocalss.BrandName
zytask.PlanQuantity = ocalss.PlanQuantity
zytask.Unit = ocalss.Unit
zytask.EnterTime = ""
zytask.EQPCode = bm.EQPCode
zytask.EQPName = bm.EQPName
zytask.PlanStartTime = ""
zytask.PlanEndTime = ""
zytask.TaskStatus = Global.TASKSTATUS.NEW.value
zytask.LockStatus = Global.TASKLOCKSTATUS.UNLOCK.value
db_session.add(zytask)
db_session.commit()
ocalss.ZYPlanStatus = Global.ZYPlanStatus.Produncting.value
db_session.commit()
else:
if data.get("EqpList") != None and data.get("EqpList") != "":
EqpList = json.loads(data.get("EqpList"))
for j in EqpList:
iTaskSeq = iTaskSeq + 1
bReturn, strTaskNo = getTaskNo()
if bReturn == False:
return False
zytask = ZYTask()
zytask.PlanDate = datetime.datetime.now().strftime(
"%Y-%m-%d")
zytask.TaskID = strTaskNo
zytask.BatchID = ocalss.BatchID
zytask.PlanSeq = iTaskSeq
zytask.PUCode = ocalss.PUCode
zytask.PUName = ocalss.PUName
zytask.PlanType = Global.PLANTYPE.SCHEDULE.value
zytask.BrandCode = ocalss.BrandCode
zytask.BrandName = ocalss.BrandName
zytask.PlanQuantity = ocalss.PlanQuantity
zytask.Unit = ocalss.Unit
zytask.EnterTime = ""
zytask.EQPCode = j.get("EQPCode")
zytask.EQPName = j.get("EQPName")
zytask.PlanStartTime = ""
zytask.PlanEndTime = ""
zytask.TaskStatus = Global.TASKSTATUS.NEW.value
zytask.LockStatus = Global.TASKLOCKSTATUS.UNLOCK.value
db_session.add(zytask)
db_session.commit()
insertAuditTrace(
"设备审核（选择设备）", "品名：" + ocalss.BrandName + " 批次：" +
ocalss.BatchID + "设备审核（选择设备）", "PlanManager",
current_user.Name, "")
return json.dumps({
"code": "200",
"message": "任务选择设备成功！",
"data": "OK"
})
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 makePlan():
if request.method == 'POST':
data = request.values # 返回请求中的参数和form
try:
json_str = json.dumps(data.to_dict())
if len(json_str) > 10:
BatchID = data.get("BatchID")
# PlanEndTime = data.get("PlanEndTime")
BrandCode = data.get("BrandCode")
# PlanBeginTime = data.get("PlanBeginTime")
#批次号判重
pcBatchID = db_session.query(PlanManager.BatchID).filter(
PlanManager.BatchID == BatchID,
PlanManager.BrandCode == BrandCode).first()
if pcBatchID:
return json.dumps({"code": "201", "message": "批次号重复！"})
pm = PlanManager()
pm.SchedulePlanCode = str(datetime.datetime.now().strftime(
"%Y-%m-%d %H:%M:%S"))[0:10]
pm.BatchID = BatchID
pr = db_session.query(ProductRule).filter(
ProductRule.BrandCode == BrandCode).first()
pm.PlanQuantity = pr.BatchWeight
pm.Unit = pr.Unit
pm.PlanNum = data.get("PlanNum")
pm.BrandCode = BrandCode
pm.BrandName = pr.BrandName
pm.PlanStatus = Global.PlanStatus.Confirm.value
# pm.PlanBeginTime = data.get("PlanBeginTime")
# pm.PlanEndTime = data.get("PlanEndTime")
pm.BrandType = pr.BrandType
pm.EqpCodes = data.get("EqpCodes")
db_session.add(pm)
sp = SchedulePlan()
sp.SchedulePlanCode = str(datetime.datetime.now().strftime(
"%Y-%m-%d %H:%M:%S"))[0:10]
sp.Description = Global.SCHEDULETYPE.DAY.value
sp.dEndTime = datetime.datetime.strptime(
str(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
[0:10], '%Y-%m-%d') + timedelta(days=1)
sp.PlanBeginTime = ""
sp.PlanEndTime = ""
Type = Global.SCHEDULETYPE.DAY.value
db_session.add(sp)
db_session.commit()
return json.dumps({"code": "200", "message": "添加成功！"})
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:
ID = data.get("ID")
BatchID = data.get("BatchID")
# PlanQuantity = data.get("PlanQuantity")
# PlanBeginTime = data.get("PlanBeginTime")
# PlanEndTime = data.get("PlanEndTime")
# Unit = data.get("Unit")
ocalss = db_session.query(PlanManager).filter(
PlanManager.ID == ID).first()
if ocalss:
pl = db_session.query(PlanManager).filter(
PlanManager.BatchID == BatchID,
PlanManager.BrandCode == ocalss.BrandCode).first()
if not pl:
ocalss.BatchID = BatchID
# ocalss.PlanQuantity = PlanQuantity
# ocalss.PlanBeginTime = PlanBeginTime
# ocalss.PlanEndTime = PlanEndTime
# ocalss.Unit = Unit
ocalss.PlanStatus = Global.PlanStatus.Confirm.value
db_session.commit()
return json.dumps({"code": "200", "message": "修改成功！"})
else:
return json.dumps({"code": "201", "message": "批次号重复！"})
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 planschedul():
'''
计划排产
:return:
'''
if request.method == 'POST':
data = request.values
try:
data_list = json.loads(data.get('selectPlanList'))
for i in data_list:
dir = {}
proclass = db_session.query(ProductRule).filter(
ProductRule.BrandCode == i.get("BrandCode")).first()
for BatchNo in range(0, int(i.get("BatchNum"))):
pm = PlanManager()
pm.PlanNum = i.get("PlanNum")
pm.SchedulePlanCode = str(datetime.datetime.now().strftime(
"%Y-%m-%d %H:%M:%S"))[0:10]
# nowtime = datetime.datetime.now().strftime("%Y-%m %M:%S").replace(":","").replace("-","").replace(" ","")
pm.BatchID = ""
pm.Seq = BatchNo
pm.PlanQuantity = proclass.BatchWeight
pm.Unit = proclass.Unit
pm.BrandCode = i.get("BrandCode")
pm.BrandName = i.get("BrandName")
# #计算计划开始时间结束时间
# pu = db_session.query(ProductUnit).filter(ProductUnit.BrandCode == oclass.BrandCode, ProductUnit.PUName.like("%提%")).first()
# proc = db_session.query(ProcessUnit).filter(ProcessUnit.PUCode == pu.PUCode).first()
# beg = int(proclass.BatchTimeLength)*BatchNo
# end = beg + int(proclass.BatchTimeLength)
# PlanBeginTime = (datetime.datetime.strptime(StartTime, "%Y-%m-%d %H:%M:%S") + datetime.timedelta(hours=beg)).strftime("%Y-%m-%d %H:%M:%S")
# PlanEndTime = (datetime.datetime.strptime(StartTime,
# "%Y-%m-%d %H:%M:%S") + datetime.timedelta(
# hours=end)).strftime("%Y-%m-%d %H:%M:%S")
# pm.PlanBeginTime = PlanBeginTime
# pm.PlanEndTime = PlanEndTime
pm.BrandType = proclass.BrandType
pm.PlanStatus = Global.PlanStatus.Confirm.value
db_session.add(pm)
db_session.commit()
PlanNums = i.get("PlanNum").split(",")
for pn in PlanNums:
oc = db_session.query(product_plan).filter(
product_plan.PlanNum == pn).first()
if oc:
oc.PlanStatus = "已分批"
db_session.commit()
insertAuditTrace(
"订单排产",
"订单号是：" + oc.PlanNum + "的" + oc.BrandName + "在" +
datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') +
"进行订单排产操作", "PlanManager", current_user.Name, "")
return json.dumps({
"code": "200",
"message": "排产成功！",
"data": "OK"
})
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 addEquipmentBatchRunTime():
'''
生产配置添加设备
:return:
'''
if request.method == 'POST':
data = request.values
try:
ID = data.get('ID')
processList = json.loads(data.get('processList'))
oclass = db_session.query(PlanManager).filter(
PlanManager.ID == ID).first()
#清空之前保存的数据
delete_list = db_session.query(EquipmentBatchRunTime).filter(
EquipmentBatchRunTime.BrandCode == oclass.BrandCode,
EquipmentBatchRunTime.BatchID == oclass.BatchID).all()
for i in delete_list:
db_session.delete(i)
db_session.commit()
dir = {}
if oclass:
for pl in processList:
PUName = pl.get("PUName")
PUCode = pl.get("PUCode")
eqList = pl.get('eqList')
for el in eqList:
isSelected = el.get("isSelected")
if isSelected == True: #选中过的设备
ert = EquipmentBatchRunTime()
ert.BatchID = oclass.BatchID
ert.BrandCode = oclass.BrandCode
ert.BrandName = oclass.BrandName
ert.EQPCode = el.get("EQPCode")
ert.EQPName = el.get("EQPName")
ert.PUCode = PUCode
ert.PUName = PUName
ert.StartBC = el.get("StartBC")
ert.EndBC = el.get("EndBC")
sft = db_session.query(Shifts).filter(
Shifts.ShiftsName == ert.StartBC).first()
ert.StartTime = str(
el.get("StartTime")) + " " + sft.BeginTime
eft = db_session.query(Shifts).filter(
Shifts.ShiftsName == ert.EndBC).first()
if eft.ShiftsName == "中" or eft.ShiftsName == "晚":
endt = (datetime.datetime.strptime(
el.get("EndTime"), "%Y-%m-%d") +
datetime.timedelta(hours=24)
).strftime("%Y-%m-%d")
else:
endt = el.get("EndTime")
ert.EndTime = str(endt) + " " + eft.EndTime
db_session.add(ert)
oclass.PlanStatus = Global.PlanStatus.WaitRealse.value
db_session.commit()
insertAuditTrace(
"生产配置添加设备",
"批次号是：" + oclass.BatchID + "的" + oclass.BrandName + "在" +
datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') +
"进行生产配置添加设备操作", "PlanManager", current_user.Name, "")
return json.dumps({
"code": "200",
"message": "保存成功！",
"data": "OK"
})
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 selectplanmanager():
'''
查询排产好的计划
:return:
'''
if request.method == 'GET':
data = request.values
try:
PlanNums = json.loads(data.get('PlanNums'))
tableName = "PlanManager"
pages = data.get("offset")
pages = int(data.get("offset")) + 1
rowsnumber = int(data.get("limit"))
newTable = Table(tableName,
metadata,
autoload=True,
autoload_with=engine)
columns = ""
for column in newTable.columns:
if columns == "":
columns = "[" + str(column).split(".")[1] + "]"
else:
columns = columns + ",[" + str(column).split(".")[1] + "]"
params = ""
for key in PlanNums:
if params == "":
params = "PlanNum like '%" + key + "%'"
else:
params = params + " OR PlanNum like '%" + key + "%'"
sql = "select top " + str(
rowsnumber) + " " + columns + " from [LIMS].[dbo].[" + tableName + "] where (" + params + \
") AND ID not in (select top " + str(
(
pages - 1) * rowsnumber) + " ID FROM [LIMS].[dbo].[" + tableName + "] where " + params +" ORDER BY ID DESC) ORDER BY ID DESC"
sqlcount = "select count(ID) from [LIMS].[dbo].[" + tableName + "] where " + params
re = db_session.execute(sql).fetchall()
recount = db_session.execute(sqlcount).fetchall()
dict_list = []
for i in re:
dir = {}
column_list = columns.split(",")
for col in column_list:
dir[col[1:-1]] = i[col[1:-1]]
dict_list.append(dir)
return json.dumps({
"code": "200",
"message": "查询成功！",
"data": {
"total": recount[0][0],
"rows": dict_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)
