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 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 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 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 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 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 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 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 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 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 batchmodelexport():
'''批记录模板导入'''
if request.method == 'POST':
try:
file = request.files['file']
file_path = os.path.join(
os.path.realpath(r"system_backend\SystemManagement\files"),
file.filename)
if allowe_file(file_path) == True:
file.save(file_path)
return json.dumps({"code": "200", "message": "上传成功！"})
else:
return json.dumps({"code": "200", "message": "请上传.doc或.docx！"})
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "批记录模板导入报错Error：" + str(e),
current_user.Name)
return json.dumps({"code": "500", "message": "后端报错"})
def PlanManagerRealse():
'''计划下发'''
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:
oclass = db_session.query(PlanManager).filter(
PlanManager.ID == ID).first()
oclass.PlanStatus = PlanStatus
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": "生产确认成功！！"})
elif PlanStatus == "撤回":
ID = data.get("ID")
oclassplan = db_session.query(PlanManager).filter_by(
ID=ID).first()
oclassplan.PlanStatus = Global.PlanStatus.Recall.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 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 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 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 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 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 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)
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 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)
