def SapBrandUnitInfoUpdate():
if request.method == 'POST':
data = request.values
try:
json_str = json.dumps(data.to_dict())
if len(json_str) > 10:
ID = data.get('ID')
if ID:
oclass = db_session.query(SapBrandUnitInfo).filter(
SapBrandUnitInfo.ID == ID).first()
oclass.BUDAT = data.get("BUDAT")
oclass.ActStartTime = data.get("ActStartTime")
oclass.ActFinishTime = data.get("ActFinishTime")
oclass.NUM1 = data.get("NUM1")
oclass.QTY = data.get("QTY")
oclass.QDATE = data.get("QDATE")
oclass.HSDAT = data.get("HSDAT")
oclass.AGRND = data.get("AGRND")
oclass.SCRAP = data.get("SCRAP")
oclass.PRQTY = data.get("PRQTY")
oclass.FCONF = data.get("FCONF")
db_session.commit()
return json.dumps('OK')
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "SAP流程订单工序信息更新报错Error：" + str(e),
current_user.Name)
return json.dumps("SAP流程订单工序信息更新报错Error",
cls=Model.BSFramwork.AlchemyEncoder,
ensure_ascii=False)
def InstrumentationReminderTimeSelect():
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 # 截止页
oclass = db_session.query(Instrumentation).all()
nowTime = datetime.datetime.now().strftime('%Y-%m-%d')
dic = []
for oc in oclass:
if oc != None:
# aa = (datetime.datetime.now() - datetime.datetime.strptime(oc.CreateTime[0:10],"%Y-%m-%d")).days
# bb = aa/int(oc.NumberVerification)
# cc = int(oc.VerificationCycle) - int(oc.ReminderTime)
if (datetime.datetime.now() - datetime.datetime.strptime(
oc.CreateTime[0:10], "%Y-%m-%d")).days / int(
oc.NumberVerification) >= (
int(oc.VerificationCycle) -
int(oc.ReminderTime)):
dic.append(oc)
jsonoclass = json.dumps(dic,
cls=AlchemyEncoder,
ensure_ascii=False)
return '{"total"' + ":" + str(
len(dic)) + ',"rows"' + ":\n" + jsonoclass + "}"
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "仪器仪表查询报错Error：" + str(e), current_user.Name)
return json.dumps("仪器仪表查询报错",
cls=Model.BSFramwork.AlchemyEncoder,
ensure_ascii=False)
def SapMatailInfoSearch():
if request.method == 'GET':
data = request.values
try:
json_str = json.dumps(data.to_dict())
if len(json_str) > 10:
pages = int(data['page'])
rowsnumber = int(data['rows'])
inipage = (pages - 1) * rowsnumber + 0
endpage = (pages - 1) * rowsnumber + rowsnumber
AUFNR = data.get('AUFNR')
if not AUFNR:
total = db_session.query(SapMatailInfo).filter().count()
oclass = db_session.query(
SapMatailInfo).filter().all()[inipage:endpage]
else:
total = db_session.query(SapMatailInfo).filter(
SapMatailInfo.AUFNR == AUFNR).count()
oclass = db_session.query(SapMatailInfo).filter(
SapMatailInfo.AUFNR == AUFNR).all()[inipage:endpage]
jsonoclass = json.dumps(oclass,
cls=AlchemyEncoder,
ensure_ascii=False)
jsonoclass = '{"total"' + ":" + str(
total) + ',"rows"' + ":\n" + jsonoclass + "}"
return jsonoclass
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "工艺质量确认流程表查询报错Error：" + str(e),
current_user.Name)
return json.dumps("工艺质量确认流程表查询报错",
cls=Model.BSFramwork.AlchemyEncoder,
ensure_ascii=False)
def change_status():
"""修改机组频率"""
try:
json_data = request.json.get('params')
equipment_code = json_data.get('EquipmentCode')
hz = json_data.get('HZ')
ctrl = ScheduleCTRLWORD('TY')
if equipment_code in ['LD1', 'LQ1']:
ctrl.Write_LS1_Params(equipment_code, hz)
elif equipment_code in ['LD2', 'LQ2']:
ctrl.Write_LS2_Params(equipment_code, hz)
insertSyslog("频率修改操作", f"将{equipment_code}设备的频率修改为{hz}",
current_user.Name)
return json.dumps({
'code': '20001',
'message': '操作成功'
},
cls=AlchemyEncoder,
ensure_ascii=False)
except Exception as e:
logger.error(e)
insertSyslog("error", "频率修改错误：" + str(e), current_user.Name)
return json.dumps({
'code': '20002',
'message': str(e)
},
cls=AlchemyEncoder,
ensure_ascii=False)
def InstrumentationHandleChecked():
if request.method == 'POST':
data = request.values
try:
json_str = json.dumps(data.to_dict())
if len(json_str) > 10:
ID = data.get("ID")
HandleStatus = data.get("HandleStatus")
ReviewStatus = data.get("ReviewStatus")
if ID is not "":
cla = db_session.query(Instrumentation).filter_by(
ID=ID).first()
if cla:
if HandleStatus:
cla.Handler = current_user.Name
cla.HandleStatus = HandleStatus
if ReviewStatus:
cla.Reviewer = current_user.Name
cla.ReviewStatus = ReviewStatus
db_session.commit()
return 'OK'
except Exception as e:
print(e)
logger.error(e)
insertSyslog(
"error",
"/equipment_model/InstrumentationHandleChecked仪器仪表复核审核报错Error："
+ str(e), current_user.Name)
return json.dumps(
"/equipment_model/InstrumentationHandleChecked仪器仪表复核审核报错",
cls=Model.BSFramwork.AlchemyEncoder,
ensure_ascii=False)
def plantSchedulingAddBatch():
'''
计划排产增加批次
:return:
'''
if request.method == 'POST':
data = request.values
try:
PRName = data['title']
code = db_session.query(ERPproductcode_prname.product_code).filter(
ERPproductcode_prname.PRName == PRName).first()[0]
plan_id = db_session.query(product_plan.plan_id).filter(
product_plan.product_code == code).order_by(
desc("plan_id")).first()
if plan_id != None:
plan_id = plan_id[0]
else:
return "请先同步ERP计划！"
date = data['start']
#添加排产数据
sch = db_session.query(Scheduling).filter(
Scheduling.PRName == PRName).order_by(
desc("SchedulingNum")).first()
if sch == None:
return "请先进行排产！"
count = db_session.query(Scheduling).filter(
Scheduling.SchedulingTime == sch.SchedulingTime).count()
SchedulingTime = sch.SchedulingTime
if int(sch.BatchNumS) == count or sch.BatchNumS == "1":
spls = str(sch.SchedulingTime)[8:10]
spls = str(int(spls) + 1)
SchedulingTime = str(sch.SchedulingTime)[0:8] + spls
ishas = db_session.query(plantCalendarScheduling).filter(
plantCalendarScheduling.start == SchedulingTime).first()
while ishas != None:
i = 1
spls = str(int(spls) + i)
SchedulingTime = str(sch.SchedulingTime)[0:8] + spls
ishas = db_session.query(plantCalendarScheduling).filter(
plantCalendarScheduling.start ==
SchedulingTime).first()
i = i + 1
sc = Scheduling()
sc.PRName = sch.PRName
sc.SchedulingStatus = SchedulingStatus.Unlock.value
sc.SchedulingTime = SchedulingTime
sc.BatchNumS = sch.BatchNumS
sc.SchedulingNum = str(int(sch.SchedulingNum) + 1)
sc.create_time = datetime.datetime.now().strftime(
"%Y-%m-%d %H:%M:%S")
db_session.add(sc)
db_session.commit()
return 'OK'
except Exception as e:
logger.error(e)
insertSyslog("error", "计划排产增加批次报错Error：" + str(e),
current_user.Name)
return json.dumps("计划排产增加批次报错",
cls=AlchemyEncoder,
ensure_ascii=False)
def plantCalendarSchedulingSelect():
'''
工厂日历
:return:
'''
if request.method == 'GET':
data = request.values
try:
re = []
oclass = db_session.query(Scheduling).all()
for oc in oclass:
dir = {}
dir['ID'] = oc.ID
dir['start'] = oc.SchedulingTime
dir['title'] = oc.PRName + ": 第" + oc.SchedulingNum[6:] + "批"
dir['color'] = "#9FDABF"
re.append(dir)
ocl = db_session.query(plantCalendarScheduling).all()
for o in ocl:
dic = {}
dic['ID'] = str(o.ID)
dic['start'] = str(o.start)
dic['title'] = o.title.split(":")[0]
dic['color'] = o.color
re.append(dic)
return json.dumps(re, cls=AlchemyEncoder, ensure_ascii=False)
except Exception as e:
logger.error(e)
insertSyslog("error", "工厂日历查询报错Error：" + str(e), current_user.Name)
return json.dumps("工厂日历查询报错",
cls=AlchemyEncoder,
ensure_ascii=False)
def makecoolselectbytime():
'''
根据时间段查询制冷分析值
:return:
'''
if request.method == 'GET':
data = request.values
try:
db_session.commit()
TagCode = data.get("TagCode")
begin = data.get("begin")
end = data.get("end")
tag_str = "SUM(" + TagCode + ") AS " + TagCode
sql = "SELECT " + tag_str + " FROM datahistory WHERE SampleTime BETWEEN '" + begin + "' AND '" + end + "'"
re = db_session.execute(sql).fetchall()
count = 0
for i in re:
count = round(float(0 if i[TagCode] == None else i[TagCode]),
2)
return json.dumps(count, cls=AlchemyEncoder, ensure_ascii=False)
except Exception as e:
logger.error(e)
insertSyslog("error", "根据时间段查询制冷分析值报错Error：" + str(e),
current_user.Name)
return json.dumps("根据时间段查询制冷分析值报错",
cls=AlchemyEncoder,
ensure_ascii=False)
def energyselectbytime():
'''
根据时间段查询能耗值
:return:
'''
if request.method == 'GET':
data = request.values
try:
db_session.commit()
begin = data.get("begin")
end = data.get("end")
tag_str = "SUM(`MB2TCP3.A_ACR_12.Ep_total_q`) AS A_ACR_10,SUM(`MB2TCP3.A_ACR_20.Ep_total_q`) AS A_ACR_13"
sql = "SELECT " + tag_str + ",CollectionDate AS CollectionDate,CollectionHour AS CollectionHour FROM incrementelectrictable WHERE CollectionDate BETWEEN '" \
+ begin + "' AND '" + end + "'"
re = db_session.execute(sql).fetchall()
count = 0
for i in re:
count = round(
float(0 if i["A_ACR_10"] == None else i["A_ACR_10"]) +
float(0 if i["A_ACR_13"] == None else i["A_ACR_13"]), 2)
return json.dumps(count, cls=AlchemyEncoder, ensure_ascii=False)
except Exception as e:
logger.error(e)
insertSyslog("error", "根据时间段查询能耗值报错Error：" + str(e),
current_user.Name)
return json.dumps("根据时间段查询能耗值报错",
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 a():
if request.method == 'GET':
data = request.values
try:
jsonstr = json.dumps(data.to_dict())
if len(jsonstr) > 10:
return select("Equipment", "0", "5", data)
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "/BatchInfoSearch查询报错Error：" + str(e),
current_user.Name)
def selectEquipmentEfficiencyTree():
'''查询设备效率分析树形结构'''
if request.method == 'GET':
try:
return json.dumps(getEquipmentEfficiencyTreeChildrenMap(id=0),
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 keep_record(p):
"""
查看保养记录
:param p: 设备号
:return: 该设备的所有保养记录记录
"""
try:
# 当前页码
page = int(request.values.get('offset'))
# 每页多少条
per_page = int(request.values.get('limit'))
query_data = db_session.query(KeepRecord).order_by(
KeepRecord.ApplyTime.desc()).all()
# data_list = [item for item in query_data]
result = []
for data in query_data:
if p in data.EquipmentCode:
result.append(data)
result_data = result[(page - 1) * per_page:page * per_page]
return json.dumps(
{
'code': '10001',
'message': '操作成功',
'data': {
'rows': result_data,
'total': len(result)
}
},
cls=AlchemyEncoder,
ensure_ascii=False)
# total = db_session.query(KeepRecord).filter_by(EquipmentCode=p).count()
# data = db_session.query(KeepRecord).filter(KeepRecord.EquipmentCode == p).order_by(
# KeepRecord.ApplyTime.desc()).limit(per_page).offset((page - 1) * per_page)
# return json.dumps({'code': '10001', 'message': '操作成功', 'data': {'rows': data.all(), 'total': total}},
# cls=AlchemyEncoder, ensure_ascii=False)
except Exception as e:
logger.error(e)
insertSyslog("error", "保养记录查询错误：" + str(e), current_user.Name)
return json.dumps({
'code': '20002',
'message': str(e)
},
cls=AlchemyEncoder,
ensure_ascii=False)
def SAP_MailInfos():
'''SAP物料主数据同步接口'''
if request.method == 'GET':
data = request.values
try:
dic = {}
data_ma = {
"RID": str(uuid.uuid4()),
"WERKS": "1100",
"MTART": data.get("Mtart"),
"SDATE": data.get("StartTime"),
"EDATE": data.get("EndTime"),
"SYSID": "WX_MES",
"OPDAT": datetime.datetime.now().strftime('%Y%m%d'),
"OPTME": datetime.datetime.now().strftime('%H%M%S')
}
dic["CATEGORY"] = ""
dic["TYPE"] = ""
dic["OPERATION"] = ""
dic["DESCRIPTION"] = ""
dic["DATA"] = data_ma
data_json = json.dumps(dic, cls=AlchemyEncoder, ensure_ascii=False)
# headers = {'Content-Type': 'application/soap+xml; charset="UTF-8"'}
t = HttpAuthenticated(username='******', password='******')
client = Client(Model.Global.SAPcsurl, transport=t)
result = client.service.Z_PP_MES_INTF(data_json, 'PP1005', 'MES')
if result:
re = json.loads(result).get("RETURN").get("MSG_LIST")
for i in re:
mat = i.get("DATA")
if mat:
e = product_infoERP()
e.product_code = mat.get("ITEM_CODE")
e.product_name = mat.get("ITEM_NAME")
e.product_type = mat.get("ITEM_TYPE")
e.product_unit = mat.get("ITEM_UNIT")
db_session.commit()
return json.dumps('OK')
except Exception as e:
print(e)
insertSyslog()
return json.dumps("调用SAP物料主数据同步接口接口报错！")
def run():
try:
while True:
data_dict = {}
redis_conn = redis.Redis(connection_pool=pool)
#trays = constant.TrayNumber
eqps = constant.EQPNameS
for key in eqps:
value = redis_conn.hget(constant.REDIS_TABLENAME,
eqps.get(key)).decode('utf-8')
tagvalue = db_session.query(TrayNumberRedisTag).filter(
TrayNumberRedisTag.PalletID == eqps.get(key)).first()
if tagvalue.value != value and value == "TRUE": #FALSE---TRUE托盘进罐
reds = db_session.query(TrayNumberRedisTag).filter(
TrayNumberRedisTag.TagID == key).all()
for red in reds:
pvalue = redis_conn.hget(constant.REDIS_TABLENAME,
red.PalletID).decode('utf-8')
red.value = pvalue
red.inTime = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
elif tagvalue.value != value and value == "FALSE": #TRUE---FALSE托盘出罐
reds = db_session.query(TrayNumberRedisTag).filter(
TrayNumberRedisTag.TagID == key).all()
for red in reds:
red.outTime = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
tagvalue.value = value
db_session.commit()
time.sleep(3)
except Exception as e:
print(e)
db_session.rollback()
logger.error(e)
insertSyslog("error", "同步托盘redis信息报错Error：" + str(e),
current_user.Name)
return json.dumps([{
"status": "Error：" + str(e)
}],
cls=Model.BSFramwork.AlchemyEncoder,
ensure_ascii=False)
def keep_plans():
"""保养计划"""
try:
json_data = request.get_json()
# equipments = ['XXF-2', 'XXF-1', 'PYF-1']
equipments = json_data.get('EquipmentCode')
if len(equipments) == 1:
equipment_code = equipments[0]
else:
equipment_code = ' '.join(equipments)
work_time = add_date(json_data.get('WeekTime'),
json_data.get('StartTime'))
work_type = json_data.get('Type')
week_time = '单次' if work_type == '单次' else json_data.get('WeekTime')
data = KeepPlan(EquipmentCode=equipment_code,
No=get_no(json_data.get('ApplyTime')),
Worker=current_user.Name,
ApplyTime=json_data.get('ApplyTime'),
Type=json_data.get('Type'),
StartTime=json_data.get('StartTime'),
Describe=json_data.get('Describe'),
WorkTime=work_time,
WeekTime=week_time)
db_session.add(data)
db_session.commit()
db_session.close()
return json.dumps({
'code': '10001',
'message': '操作成功'
},
cls=AlchemyEncoder,
ensure_ascii=False)
except Exception as e:
logger.error(e)
insertSyslog("error", "保养计划表添加错误：" + str(e), current_user.Name)
return json.dumps({
'code': '20002',
'message': str(e)
},
cls=AlchemyEncoder,
ensure_ascii=False)
def fault():
"""故障恢复"""
try:
json_data = request.json.get('params')
equipment_code = json_data.get('EquipmentCode')
ctrl = ScheduleCTRLWORD('TY')
ctrl.Write_LS_FaultReset(equipment_code)
return json.dumps({
'code': '20001',
'message': '操作成功'
},
cls=AlchemyEncoder,
ensure_ascii=False)
except Exception as e:
logger.error(e)
insertSyslog("error", "故障恢复错误：" + str(e), current_user.Name)
return json.dumps({
'code': '20002',
'message': str(e)
},
cls=AlchemyEncoder,
ensure_ascii=False)
def reset():
"""复位"""
try:
redis_conn = redis.Redis(password=constant.REDIS_PASSWORD,
decode_responses=True)
# if request.method == 'GET':
# data = redis_conn.hget(constant.REDIS_TABLENAME, 'LS_JN_FLAG')
# return json.dumps({'code': '20001', 'message': '成功', 'data': data},
# cls=AlchemyEncoder, ensure_ascii=False)
if request.values.get('reset') == 'yes':
ctrl = ScheduleCTRLWORD('TY')
ctrl.Write_LS_INIWORD('LS1', '100')
ctrl.Write_LS_INIWORD('LS2', '100')
return json.dumps({'code': '20001', 'message': '设置成功'})
if request.values.get('switch') == 'on':
data = redis_conn.hset(constant.REDIS_TABLENAME, 'LS_JN_FLAG', '1')
return json.dumps({
'code': '20001',
'message': '设置成功',
'data': data
})
if request.values.get('switch') == 'off':
data = redis_conn.hset(constant.REDIS_TABLENAME, 'LS_JN_FLAG', '0')
return json.dumps({
'code': '20001',
'message': '设置成功',
'data': data
})
except Exception as e:
logger.error(e)
insertSyslog("error", "工时安排设置出错：" + str(e), current_user.Name)
return json.dumps({
'code': '20002',
'message': str(e)
},
cls=AlchemyEncoder,
ensure_ascii=False)
def change_run():
"""修改机组开关"""
try:
json_data = request.json.get('params')
equipment_code = json_data.get('EquipmentCode')
status = json_data.get('Status')
temperature = json_data.get('Temperature', '100')
ctrl = ScheduleCTRLWORD('TY')
if equipment_code in ['LS1', 'LD1', 'LQT1']:
if equipment_code == 'LS1' and status == 'STOP':
ctrl.Equip_LS1Control(equipment_code, status)
# ctrl.Write_LS_INIWORD(equipment_code, temperature)
else:
ctrl.Equip_LS1Control(equipment_code, status)
if equipment_code in ['LS2', 'LD2', 'LQT2']:
if equipment_code == 'LS2' and status == 'STOP':
ctrl.Equip_LS2Control(equipment_code, status)
# ctrl.Write_LS_INIWORD(equipment_code, temperature)
else:
ctrl.Equip_LS2Control(equipment_code, status)
insertSyslog("机组开关操作", f"对{equipment_code}设备进行了{status}操作",
current_user.Name)
return json.dumps({
'code': '20001',
'message': '操作成功'
},
cls=AlchemyEncoder,
ensure_ascii=False)
except Exception as e:
logger.error(e)
insertSyslog("error", "机组开关修改错误：" + str(e), current_user.Name)
return json.dumps({
'code': '20002',
'message': str(e)
},
cls=AlchemyEncoder,
ensure_ascii=False)
def SapMatailInfoAdd():
if request.method == 'POST':
data = request.values
try:
json_str = json.dumps(data.to_dict())
if len(json_str) > 10:
smi = SapMatailInfo()
sm = db_session.query(SapMatailInfo).filter(
SapMatailInfo.ID == data.get("ID")).first()
smi.AUFNR = sm.AUFNR
smi.RSNUM = sm.RSNUM
smi.RSPOS = sm.RSPOS
smi.VORNR = sm.VORNR
smi.SEQNO = sm.SEQNO
smi.MATNR = sm.MATNR
smi.MAKTX = sm.MAKTX
smi.BDMNG = data.get("BDMNG")
smi.MEINS = sm.MEINS
smi.BWART = sm.BWART
smi.CHARG = data.get("CHARG")
smi.WERKS = sm.WERKS
smi.LGORT = sm.LGORT
smi.WEIGH = sm.WEIGH
smi.Opertation = data.get("Opertation")
smi.BUDAT = data.get("BUDAT")
smi.Status = "未发送"
db_session.add(smi)
db_session.commit()
return json.dumps('OK')
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "SAP流程订单物料信息更新报错Error：" + str(e),
current_user.Name)
return json.dumps("SAP流程订单物料信息更新报错Error",
cls=Model.BSFramwork.AlchemyEncoder,
ensure_ascii=False)
def SapMatailInfoUpdate():
if request.method == 'POST':
data = request.values
try:
json_str = json.dumps(data.to_dict())
if len(json_str) > 10:
ID = data.get('ID')
if ID:
oclass = db_session.query(SapMatailInfo).filter(
SapMatailInfo.ID == ID).first()
oclass.BUDAT = data.get("BUDAT")
oclass.Opertation = data.get("Opertation")
oclass.BDMNG = data.get("BDMNG")
oclass.CHARG = data.get("CHARG")
db_session.commit()
return json.dumps('OK')
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "SAP流程订单物料信息更新报错Error：" + str(e),
current_user.Name)
return json.dumps("SAP流程订单物料信息更新报错Error",
cls=Model.BSFramwork.AlchemyEncoder,
ensure_ascii=False)
def InstrumentationSelect():
if request.method == 'GET':
data = request.values
try:
json_str = json.dumps(data.to_dict())
if len(json_str) > 10:
pages = int(data.get("offset")) # 页数
rowsnumber = int(data.get("limit")) # 行数
inipage = pages * rowsnumber + 0 # 起始页
endpage = pages * rowsnumber + rowsnumber # 截止页
InstrumentationName = data["InstrumentationName"]
if InstrumentationName == "":
count = db_session.query(
Instrumentation).filter_by().count()
oclass = db_session.query(
Instrumentation).filter_by().all()[inipage:endpage]
else:
count = db_session.query(Instrumentation).filter(
Instrumentation.InstrumentationName.like(
"%" + InstrumentationName + "%")).count()
oclass = db_session.query(Instrumentation).filter(
Instrumentation.InstrumentationName.like(
"%" + InstrumentationName +
"%")).all()[inipage:endpage]
jsonoclass = json.dumps(oclass,
cls=AlchemyEncoder,
ensure_ascii=False)
return '{"total"' + ":" + str(
count) + ',"rows"' + ":\n" + jsonoclass + "}"
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "仪器仪表查询报错Error：" + str(e), current_user.Name)
return json.dumps("仪器仪表查询报错",
cls=Model.BSFramwork.AlchemyEncoder,
ensure_ascii=False)
def Sap_WorkReport():
'''SAP报工信息接口'''
if request.method == 'POST':
data = request.values
try:
dic = {}
data_list = []
sbui = db_session.query(SapBrandUnitInfo).filter(
SapBrandUnitInfo.ID == data.get("ID")).first()
AUFNR = sbui.AUFNR
sbuis = db_session.query(SapBrandUnitInfo).filter(
SapBrandUnitInfo.AUFNR == AUFNR,
SapBrandUnitInfo.VORNR < sbui.VORNR).order_by(
desc("VORNR")).all()
for s in sbuis:
if s.Status != "工序报工完成" and s.Status != "工序修改报工完成":
return json.dumps('请按工序顺序进行报工！')
data_dir = {
"RID": str(uuid.uuid4()),
"RIDITEM": str(uuid.uuid4()),
"AUFNR": sbui.AUFNR,
"VORNR": sbui.VORNR,
"FCONF": sbui.FCONF,
"WERKS": "1100",
"PRQTY": sbui.PRQTY,
"SCRAP": "",
"AGRND": "",
"MEINS": sbui.UNIT,
"STEUS": sbui.STEUS,
"HSDAT": sbui.HSDAT[0:10].replace("-", ""),
"QDATE": sbui.QDATE[0:10].replace("-", ""),
"QTY": sbui.QTY,
"NUM1": sbui.NUM1,
"APP_PER": current_user.Name,
"ESDAT": sbui.ActStartTime[0:10].replace("-", ""),
"ESTME": sbui.ActStartTime[11:19].replace(":", ""),
"EFDAT": sbui.ActFinishTime[0:10].replace("-", ""),
"EFTME": sbui.ActFinishTime[11:19].replace(":", ""),
"BUDAT": sbui.BUDAT[0:10].replace("-", ""),
"VGWTS": sbui.VORGSCHL,
"CONFACT1": sbui.VGW01,
"CONFACT2": sbui.VGW02,
"CONFACT3": sbui.VGW02,
"CONFACT4": sbui.VGW04,
"CONFACT5": sbui.VGW05,
"CONFACT6": sbui.VGW06,
"OPDAT": datetime.datetime.now().strftime('%Y%m%d'),
"OPTME": datetime.datetime.now().strftime('%H%M%S')
}
data_list.append(data_dir)
dic["CATEGORY"] = ""
dic["TYPE"] = ""
dic["OPERATION"] = ""
dic["DESCRIPTION"] = ""
dic["DATA"] = data_list
data_json = json.dumps(dic, cls=AlchemyEncoder, ensure_ascii=False)
# headers = {'Content-Type': 'application/soap+xml; charset="UTF-8"'}
t = HttpAuthenticated(username='******', password='******')
client = Client(Model.Global.SAPurl, transport=t)
result = client.service.Z_PP_MES_INTF(data_json, 'PP1003', 'MES')
if result:
re = json.loads(result).get("RETURN").get("MSGTY")
if re == "S":
baog = db_session.query(SapBrandUnitInfo).filter(
SapBrandUnitInfo.ID == data.get("ID")).first()
if baog.Status == "修改报工":
baog.Status = "工序修改报工完成"
else:
baog.Status = "工序报工完成"
db_session.commit()
sbuis = db_session.query(SapBrandUnitInfo).filter(
SapBrandUnitInfo.ID == AUFNR).all()
flag = "True"
for s in sbuis:
if s.Status != "工序报工完成" or s.Status != "工序修改报工完成":
flag = "Flase"
if flag == "True":
sbi = db_session.query(SapBatchInfo).filter(
SapBatchInfo.AUFNR == AUFNR).first()
sbi.Status = "已报工"
return json.dumps('OK')
else:
return json.dumps(
json.loads(result).get("RETURN").get("MESSAGE"))
except Exception as e:
db_session.rollback()
print("调用SAP报工信息接口报错！")
insertSyslog("调用SAP报工信息接口报错", "Sap_WorkReport报错Error：" + str(e),
current_user.Name)
return json.dumps("调用SAP报工信息接口报错！")
def planScheduling():
'''
计划排产
:return:
'''
if request.method == 'POST':
data = request.values
try:
plan_id = data['plan_id']
oc = db_session.query(product_plan).filter(
product_plan.plan_id == plan_id).first()
month = data['month']
mou = month.split("-")
monthRange = calendar.monthrange(int(mou[0]), int(mou[1]))
PRName = db_session.query(ERPproductcode_prname.PRName).filter(
ERPproductcode_prname.product_code ==
oc.product_code).first()[0]
sch = db_session.query(SchedulingStandard).filter(
SchedulingStandard.PRName == PRName).first()
batchnums = int(oc.plan_quantity)
days = batchnums / int(sch.DayBatchNumS) #这批计划要做多少天
re = timeChange(mou[0], mou[1], monthRange[1])
#不能排产的时间
if int(mou[1]) < 10:
mou = mou[0] + "-0" + mou[1]
else:
mou = mou[0] + "-" + mou[1]
schdays = db_session.query(plantCalendarScheduling.start).filter(
plantCalendarScheduling.start.like("%" + mou + "%"),
~plantCalendarScheduling.title.like("%安全库存%")).all(
) #----查询休息的天数排产去除员工不上班的时间
undays = []
if schdays != None:
for i in schdays:
undays.append(i[0])
# 删除上一次排产同品名同月份的数据
solds = db_session.query(Scheduling).filter(
Scheduling.PRName == PRName,
Scheduling.SchedulingTime.like("%" + mou + "%")).all()
for old in solds:
sql = "DELETE FROM Scheduling WHERE ID = " + str(old.ID)
db_session.execute(sql) #删除同意品名下的旧的排产计划
plans = db_session.query(plantCalendarScheduling).filter(
plantCalendarScheduling.title.like(PRName),
plantCalendarScheduling.start.like("%" + mou + "%")).all()
for pl in plans:
sql = sql1 = "DELETE FROM plantCalendarScheduling WHERE ID = " + str(
pl.ID)
db_session.execute(sql) #删除同意品名下的安全库存信息
db_session.commit()
# 去掉不能排产的时间，只剩可以排产的时间
daySchedulings = list(set(re).difference(set(undays)))
daySchedulings = list(daySchedulings)
daySchedulings.sort()
# 排产数据写入数据库
dayBatchNum = db_session.query(
SchedulingStandard.DayBatchNumS).filter(
SchedulingStandard.PRName == PRName).first()[0]
j = 1
k = 1
for day in daySchedulings:
if k > days: #当这个计划所有的批次做完跳出循环
break
for r in range(0, int(dayBatchNum)):
s = Scheduling()
s.SchedulingTime = day
s.PRName = PRName
s.BatchNumS = sch.DayBatchNumS
if j < 10:
s.SchedulingNum = day.replace("-",
"")[2:6] + "600" + str(j)
else:
s.SchedulingNum = day.replace("-",
"")[2:6] + "60" + str(j)
db_session.add(s)
j = j + 1
k = k + 1
db_session.commit()
return 'OK'
except Exception as e:
print(e)
db_session.rollback()
logger.error(e)
insertSyslog("error", "计划排产报错Error：" + str(e), current_user.Name)
return json.dumps("计划排产报错", cls=AlchemyEncoder, ensure_ascii=False)
def selectrundetailbyequipmentcode():
'''
根据设备code查询设备运行情况
:return:
'''
if request.method == 'GET':
data = request.values
try:
db_session.commit()
EquipmentCode = data.get("EquipmentCode")
WorkDate = data.get("WorkDate")
run = db_session.query(EquipmentStatusCount).filter(
EquipmentStatusCount.WorkDate == WorkDate,
EquipmentStatusCount.SYSEQPCode == EquipmentCode,
EquipmentStatusCount.Status == "RUN").all()
stop = db_session.query(EquipmentStatusCount).filter(
EquipmentStatusCount.WorkDate == WorkDate,
EquipmentStatusCount.SYSEQPCode == EquipmentCode,
EquipmentStatusCount.Status == "STOP").all()
fault = db_session.query(EquipmentStatusCount).filter(
EquipmentStatusCount.WorkDate == WorkDate,
EquipmentStatusCount.SYSEQPCode == EquipmentCode,
EquipmentStatusCount.Status == "FAULT").all()
equip = db_session.query(Equipment).filter(
Equipment.EquipmentCode == EquipmentCode).first()
if equip:
pow = equip.Power
else:
pow = ""
dict_run = {}
dict_run["runcount"] = 0 if len(
run) == 0 else run[0].StatusChangeCount
dict_run["stopcount"] = 0 if len(
stop) == 0 else stop[0].StatusChangeCount
dict_run["faultcount"] = 0 if len(
fault) == 0 else fault[0].StatusChangeCount
dict_run["power"] = pow
runtime = 0
for r in run:
runtime = runtime + float(r.Duration)
dict_run["runtime"] = round(runtime, 2)
stoptime = 0
for r in stop:
stoptime = stoptime + float(r.Duration)
dict_run["stoptime"] = round(stoptime, 2)
faulttime = 0
for r in fault:
faulttime = faulttime + float(r.Duration)
dict_run["faulttime"] = round(faulttime, 2)
total_time = runtime + stoptime + faulttime
if total_time != 0:
dict_run["run_Proportion"] = round(
100 * (runtime / total_time), 2)
dict_run["stop_Proportion"] = round(
100 * (stoptime / total_time), 2)
dict_run["fault_Proportion"] = round(
100 * (faulttime / total_time), 2)
else:
dict_run["run_Proportion"] = 0
dict_run["stop_Proportion"] = 0
dict_run["fault_Proportion"] = 0
return json.dumps(dict_run, cls=AlchemyEncoder, ensure_ascii=False)
except Exception as e:
logger.error(e)
insertSyslog("error", "根据设备code查询设备运行情况报错Error：" + str(e),
current_user.Name)
return json.dumps("根据设备code查询设备运行情况报错",
cls=AlchemyEncoder,
ensure_ascii=False)
def SAP_OrderSynchonizes():
'''SAP订单信息同步接口'''
if request.method == 'GET':
data = request.values
try:
dic = {}
data_ma = {
"RID": str(uuid.uuid4()),
"DWERK": "1100",
"DAUAT": data.get("DAUAT"),
"MATNR": "",
"VERID": "",
"AUFNR": "",
"SDATE": data.get("StartTime").replace("-", ""),
"EDATE": data.get("EndTime").replace("-", ""),
"CHARG": "",
"SYSID": "WX_MES",
"OPDAT": datetime.datetime.now().strftime('%Y%m%d'),
"OPTME": datetime.datetime.now().strftime('%H%M%S')
}
dic["CATEGORY"] = ""
dic["TYPE"] = ""
dic["OPERATION"] = ""
dic["DESCRIPTION"] = ""
dic["DATA"] = data_ma
data_json = json.dumps(dic, cls=AlchemyEncoder, ensure_ascii=False)
# headers = {'Content-Type': 'application/soap+xml; charset="UTF-8"'}
t = HttpAuthenticated(username='******', password='******')
client = Client(Model.Global.SAPurl, transport=t)
result = client.service.Z_PP_MES_INTF(data_json, 'PP1001', 'MES')
if result:
hes = json.loads(result).get("HEADER")
for i in hes:
PRNameoclass = db_session.query(
ERPproductcode_prname).filter(
ERPproductcode_prname.product_code.like(
"%" + i.get("MATNR") + "%")).first()
PRName = PRNameoclass.PRName
batchoclass = None #db_session.query(SapBatchInfo).filter(SapBatchInfo.AUFNR == i.get("AUFNR")).first()
if batchoclass:
pm = db_session.query(PlanManager).filter(
PlanManager.BatchID == i.get("CHARG"),
PlanManager.BrandName == PRName).first()
if pm:
if pm.PlanStatus == Model.Global.PlanStatus.Checked.value:
batchoclass.RID = i.get("RID")
batchoclass.AUFNR = i.get("AUFNR")
batchoclass.DAUAT = i.get("DAUAT")
batchoclass.DWERK = i.get("DWERK")
batchoclass.CHARG = i.get("CHARG")
batchoclass.MATNR = i.get("MATNR")
batchoclass.MAKTX = i.get("MAKTX")
batchoclass.GAMNG = i.get("GAMNG")
batchoclass.UNIT = i.get("UNIT")
batchoclass.VERID = i.get("VERID")
batchoclass.RSNUM = i.get("RSNUM")
batchoclass.ROUTN = i.get("ROUTN")
batchoclass.GSTRP = i.get("GSTRP")
batchoclass.GLTRP = i.get("GLTRP")
batchoclass.STATE = i.get("STATE")
batchoclass.PLNNR = i.get("PLNNR")
batchoclass.PLNAL = i.get("PLNAL")
batchoclass.KTEXT = i.get("KTEXT")
batchoclass.GESSTICHPR = i.get("GESSTICHPR")
batchoclass.QBASE = i.get("QBASE")
if batchoclass.Status == "已报工":
batchoclass.Status = "修改报工"
if batchoclass.MatilStatus == "已发送SAP":
batchoclass.MatilStatus = "修改发送"
db_session.commit()
else:
continue
else:
pr = db_session.query(ProductRule).filter(
ProductRule.PRName == PRName).first()
ABatchID = i.get("CHARG")
APlanWeight = i.get("GAMNG")
AUnit = i.get("UNIT")
if "肿节风浸膏" in i.get("MAKTX"):
ABrandName = "肿节风浸膏"
if "健胃消食片浸膏粉" in i.get("MAKTX"):
ABrandName = "健胃消食片浸膏粉"
APlanDate = datetime.datetime.strptime(
i.get("GSTRP"), '%Y%m%d')
APlanDate = APlanDate.strftime('%Y-%m-%d')
PlanCreate = ctrlPlan('PlanCreate')
re = PlanCreate.createLinePlanManager(
"", float(APlanWeight), APlanDate, ABatchID,
str(pr.ID), ABrandName, ABrandName, AUnit,
current_user.Name)
s = SapBatchInfo()
s.RID = i.get("RID")
s.AUFNR = i.get("AUFNR")
s.DAUAT = i.get("DAUAT")
s.DWERK = i.get("DWERK")
s.CHARG = i.get("CHARG")
s.MATNR = i.get("MATNR")
s.MAKTX = i.get("MAKTX")
s.GAMNG = i.get("GAMNG")
s.UNIT = i.get("UNIT")
s.VERID = i.get("VERID")
s.RSNUM = i.get("RSNUM")
s.ROUTN = i.get("ROUTN")
s.GSTRP = i.get("GSTRP")
s.GLTRP = i.get("GLTRP")
s.STATE = i.get("STATE")
s.PLNNR = i.get("PLNNR")
s.PLNAL = i.get("PLNAL")
s.KTEXT = i.get("KTEXT")
s.GESSTICHPR = i.get("GESSTICHPR")
s.QBASE = i.get("QBASE")
s.Status = "未报工"
s.MatilStatus = "未发送SAP"
db_session.add(s)
db_session.commit()
phs = json.loads(result).get("PHASE")
for ph in phs:
brandunitoclass = db_session.query(
SapBrandUnitInfo).filter(
SapBrandUnitInfo.AUFNR == ph.get("AUFNR"),
SapBrandUnitInfo.VORNR == ph.get("VORNR")).first()
if brandunitoclass == None:
sbu = SapBrandUnitInfo()
sbu.RID = ph.get("RID")
sbu.AUFNR = ph.get("AUFNR")
sbu.ROUTN = ph.get("ROUTN")
sbu.VORNR = ph.get("VORNR")
sbu.LTXA1 = ph.get("LTXA1")
sbu.MGVRG = ph.get("MGVRG")
sbu.UNIT = ph.get("UNIT")
sbu.STEUS = ph.get("STEUS")
sbu.VORGSCHL = ph.get("VORGSCHL")
sbu.VGW01 = ph.get("VGW01")
sbu.VGW02 = ph.get("VGW02")
sbu.VGW03 = ph.get("VGW03")
sbu.VGW04 = ph.get("VGW04")
sbu.VGW05 = ph.get("VGW05")
sbu.VGW06 = ph.get("VGW06")
db_session.add(sbu)
db_session.commit()
else:
brandunitoclass.RID = ph.get("RID")
brandunitoclass.AUFNR = ph.get("AUFNR")
brandunitoclass.ROUTN = ph.get("ROUTN")
brandunitoclass.VORNR = ph.get("VORNR")
brandunitoclass.LTXA1 = ph.get("LTXA1")
brandunitoclass.MGVRG = ph.get("MGVRG")
brandunitoclass.UNIT = ph.get("UNIT")
brandunitoclass.STEUS = ph.get("STEUS")
brandunitoclass.VORGSCHL = ph.get("VORGSCHL")
brandunitoclass.VGW01 = ph.get("VGW01")
brandunitoclass.VGW02 = ph.get("VGW02")
brandunitoclass.VGW03 = ph.get("VGW03")
brandunitoclass.VGW04 = ph.get("VGW04")
brandunitoclass.VGW05 = ph.get("VGW05")
brandunitoclass.VGW06 = ph.get("VGW06")
db_session.commit
# sbui = db_session.query(SapBrandUnitInfo).filter(SapBrandUnitInfo.AUFNR == AUFNR).order_by(
# desc("VORNR")).first()
# if sbui:
# sbui.FCONF = "X"
# db_session.commit()
cms = json.loads(result).get("COMPT")
for cm in cms:
matiloclass = db_session.query(SapMatailInfo).filter(
SapMatailInfo.AUFNR == cm.get("AUFNR"),
SapMatailInfo.RSPOS == cm.get("RSPOS")).first()
if matiloclass == None:
sm = SapMatailInfo()
sm.RID = cm.get("RID")
sm.AUFNR = cm.get("AUFNR")
sm.RSNUM = cm.get("RSNUM")
sm.RSPOS = cm.get("RSPOS")
sm.VORNR = cm.get("VORNR")
sm.SEQNO = cm.get("SEQNO")
sm.MATNR = cm.get("MATNR")
sm.MAKTX = cm.get("MAKTX")
sm.BDMNG = cm.get("BDMNG")
sm.MEINS = cm.get("MEINS")
sm.BWART = cm.get("BWART")
sm.CHARG = cm.get("CHARG")
sm.WERKS = cm.get("WERKS")
sm.LGORT = cm.get("LGORT")
sm.WEIGH = cm.get("WEIGH")
sm.Status = "未发送"
db_session.add(sm)
db_session.commit()
else:
matiloclass.RID = cm.get("RID")
matiloclass.AUFNR = cm.get("AUFNR")
matiloclass.RSNUM = cm.get("RSNUM")
matiloclass.RSPOS = cm.get("RSPOS")
matiloclass.VORNR = cm.get("VORNR")
matiloclass.SEQNO = cm.get("SEQNO")
matiloclass.MATNR = cm.get("MATNR")
matiloclass.MAKTX = cm.get("MAKTX")
matiloclass.BDMNG = cm.get("BDMNG")
matiloclass.MEINS = cm.get("MEINS")
matiloclass.BWART = cm.get("BWART")
matiloclass.CHARG = cm.get("CHARG")
matiloclass.WERKS = cm.get("WERKS")
matiloclass.LGORT = cm.get("LGORT")
matiloclass.WEIGH = cm.get("WEIGH")
db_session.commit()
return json.dumps('OK')
except Exception as e:
db_session.rollback()
print("调用SAP订单信息同步接口口报错！")
insertSyslog("接口error", "SAP_OrderSynchonizes报错Error：" + str(e),
current_user.Name)
return json.dumps("调用SAP订单信息同步接口报错！")
def Sap_Matailre():
'''SAP物料信息返回接口'''
if request.method == 'POST':
data = request.values
try:
dic = {}
data_list = []
IDS = json.loads(data.get("IDS"))
AUFNR = ""
for ID in IDS:
smi = db_session.query(SapMatailInfo).filter(
SapMatailInfo.ID == ID).first()
AUFNR = smi.AUFNR
data_dir = {
"RID": str(uuid.uuid4()),
"RIDITEM": str(uuid.uuid4()),
"AUFNR": smi.AUFNR,
"RSNUM": smi.RSNUM,
"RSPOS": smi.RSPOS,
"MATNR": smi.MATNR,
"MAKTX": smi.MAKTX,
"BDMNG": smi.BDMNG,
"MEINS": smi.MEINS,
"CHARG": smi.CHARG,
"LGORT": smi.LGORT,
"WERKS": smi.WERKS,
"BWART": "261",
"BUDAT": smi.BUDAT[0:10].replace("-", ""),
"OPDAT": smi.Opertation[0:10].replace("-", ""),
"OPTME": smi.Opertation[11:19].replace(":", "")
}
data_list.append(data_dir)
dic["CATEGORY"] = ""
dic["TYPE"] = ""
dic["OPERATION"] = ""
dic["DESCRIPTION"] = ""
dic["DATA"] = data_list
data_json = json.dumps(dic, cls=AlchemyEncoder, ensure_ascii=False)
# headers = {'Content-Type': 'application/soap+xml; charset="UTF-8"'}
t = HttpAuthenticated(username='******', password='******')
client = Client(Model.Global.SAPurl, transport=t)
result = client.service.Z_PP_MES_INTF(data_json, 'PP1002', 'MES')
if result:
re = json.loads(result).get("RETURN").get("MSGTY")
if re == "S":
for ID in IDS:
smire = db_session.query(SapMatailInfo).filter(
SapMatailInfo.ID == ID).first()
smire.Status = "已发送"
db_session.commit()
sms = db_session.query(SapMatailInfo).filter(
SapMatailInfo.AUFNR == AUFNR).all()
flag = "True"
for s in sms:
if s.Status != "已发送":
flag = "Flase"
if flag == "True":
sbi = db_session.query(SapBatchInfo).filter(
SapBatchInfo.AUFNR == AUFNR).first()
sbi.MatilStatus = "已发送SAP"
return json.dumps('OK')
else:
return json.dumps(
json.loads(result).get("RETURN").get("MESSAGE"))
except Exception as e:
db_session.rollback()
print("SAP物料信息返回接口报错！")
insertSyslog("SAP物料信息返回接口报错", "Sap_Matailre报错Error：" + str(e),
current_user.Name)
return json.dumps("调用SAP物料信息返回接口！")
def keep_tasks():
"""保养任务表"""
try:
query_data = db_session.query(KeepPlan).filter_by(Status='待保养').all()
if request.method == 'GET':
# 每页多少条
limit = int(request.values.get('limit', '5'))
# 当前页
offset = int(request.values.get('offset', '1'))
for item in query_data:
q = db_session.query(KeepTask).filter_by(No=item.No).first()
if not q and get_time_stamp(item.WorkTime):
data = KeepTask(EquipmentCode=item.EquipmentCode,
No=item.No,
Worker=item.Worker,
Status=item.Status,
ApplyTime=item.ApplyTime,
StartTime=item.StartTime,
WorkTime=item.WorkTime,
WeekTime=item.WeekTime,
Type=item.Type)
db_session.add(data)
db_session.commit()
# if item.Type == '单次':
# pass
# db_session.delete(item)
# db_session.commit()
data = db_session.query(KeepTask).order_by(
KeepTask.ApplyTime.desc()).limit(limit).offset(
(offset - 1) * limit)
total = db_session.query(KeepTask).count()
return json.dumps(
{
'code': '10001',
'message': '操作成功',
'data': {
'rows': data.all(),
'total': total
}
},
cls=AlchemyEncoder,
ensure_ascii=False)
if request.method == 'POST':
json_data = request.values
no = json_data.get('No')
end_time = json_data.get('EndTime')
content = json_data.get('Content')
item = db_session.query(KeepTask).filter_by(No=no).first()
data = KeepRecord(EquipmentCode=item.EquipmentCode,
No=no,
Worker=item.Worker,
Status='已完成',
Type=item.Type,
KeepWorker=current_user.Name,
ApplyTime=item.ApplyTime,
StartTime=item.StartTime,
Describe=item.Describe,
Content=content,
WeekTime=item.WeekTime,
EndTime=end_time)
db_session.delete(item)
db_session.commit()
keep_plan = db_session.query(KeepPlan).filter_by(No=no).first()
if keep_plan and keep_plan.Type == '周期':
keep_plan.WorkTime = add_date(keep_plan.WeekTime,
keep_plan.WorkTime)
db_session.add_all([data, keep_plan])
db_session.commit()
db_session.close()
return json.dumps({
'code': '10001',
'message': '操作成功'
},
cls=AlchemyEncoder,
ensure_ascii=False)
else:
db_session.delete(keep_plan)
db_session.add(data)
db_session.commit()
db_session.close()
return json.dumps({
'code': '10001',
'message': '操作成功'
},
cls=AlchemyEncoder,
ensure_ascii=False)
except Exception as e:
logger.error(e)
insertSyslog("error", "保养任务表修改错误：" + str(e), current_user.Name)
return json.dumps({
'code': '20002',
'message': str(e)
},
cls=AlchemyEncoder,
ensure_ascii=False)
def schedule_lqt():
"""排班日程"""
try:
if request.method == 'GET':
data = db_session.query(Schedulelqt).filter_by(
energystrategyCode=request.values.get('code')).all()
return json.dumps({
'code': '20001',
'message': '成功',
'data': data
},
cls=AlchemyEncoder,
ensure_ascii=False)
if request.method == 'POST':
new_start = request.values.get('start_time')
new_end = request.values.get('end_time')
code = request.values.get('energystrategyCode')
query_list = db_session.query(Schedulelqt).filter_by(
energystrategyCode=code).all()
if query_list:
for item in query_list:
if count_time(item.enablestarttime, item.enableendtime,
new_start, new_end) != 'yes':
return json.dumps({
'code': '20003',
'message': '工作时间设置出现冲突'
})
data = Schedulelqt(enablestarttime=new_start,
enableendtime=new_end,
comment=request.values.get('comment'),
energystrategyCode=code,
lqt1_allowrun=request.values.get('lqt1'),
lqt2_allowrun=request.values.get('lqt2'))
db_session.add(data)
db_session.commit()
db_session.close()
return json.dumps({'code': '20001', 'message': '设置成功'})
else:
data = Schedulelqt(enablestarttime=new_start,
comment=request.values.get('comment'),
energystrategyCode=request.values.get(
'energystrategyCode'),
enableendtime=new_end,
lqt1_allowrun=request.values.get('lqt1'),
lqt2_allowrun=request.values.get('lqt2'))
db_session.add(data)
db_session.commit()
db_session.close()
return json.dumps({'code': '20001', 'message': '设置成功'})
if request.method == 'DELETE':
items = request.values.get('ID').split(',')
for item in items:
data = db_session.query(Schedulelqt).filter_by(
ID=int(item)).first()
db_session.delete(data)
db_session.commit()
return json.dumps({'code': '20001', 'message': '删除成功'})
if request.method == 'PUT':
new_start = request.values.get('start_time')
new_end = request.values.get('end_time')
query_data = db_session.query(Schedulelqt).filter_by(
ID=request.values.get('ID')).first()
code = request.values.get('energystrategyCode')
query_list = db_session.query(Schedulelqt).filter_by(
energystrategyCode=code).all()
results = []
for i in query_list:
if i.ID != query_data.ID:
results.append(i)
if results:
for item in results:
if count_time(item.enablestarttime, item.enableendtime,
new_start, new_end) != 'yes':
return json.dumps({
'code': '20003',
'message': '工作时间设置出现冲突'
})
query_data.enablestarttime = new_start
query_data.enableendtime = new_end
query_data.comment = request.values.get('comment')
query_data.lqt1_allowrun = request.values.get('lqt1')
query_data.lqt2_allowrun = request.values.get('lqt2')
db_session.add(query_data)
db_session.commit()
db_session.close()
return json.dumps({'code': '20001', 'message': '设置成功'})
else:
query_data.enablestarttime = new_start
query_data.enableendtime = new_end
query_data.comment = request.values.get('comment')
query_data.lqt1_allowrun = request.values.get('lqt1')
query_data.lqt2_allowrun = request.values.get('lqt2')
db_session.add(query_data)
db_session.commit()
db_session.close()
return json.dumps({'code': '20001', 'message': '设置成功'})
except Exception as e:
logger.error(e)
insertSyslog("error", "工时安排设置出错：" + str(e), current_user.Name)
return json.dumps({
'code': '20002',
'message': str(e)
},
cls=AlchemyEncoder,
ensure_ascii=False)
def energy_trends():
"""趋势图"""
try:
if request.values.get('TagFlag') == 'first':
# 多个tag点查询一天
TagCodes = request.values.get('TagCodes').split(",")
Begin = request.values.get('begin')
End = request.values.get('end')
data = []
count = 0
for item in TagCodes:
count += 1
sql = "select " + "`SampleTime` as time, " + "`" + item + "`" + " as value" + " from datahistory where" \
" SampleTime between " + "'" + Begin + "'" + " and " + "'" + End + "'"
results = db_session.execute(sql).fetchall()
list1 = []
for result in results[::30]:
list1.append({
f'time{count}':
datetime.strftime(result['time'], "%Y-%m-%d %H:%M:%S"),
f'value{count}':
result['value']
})
# data.append({item: list1})
data.append(list1)
return json.dumps({
'code': '20001',
'message': '成功',
'data': data
},
cls=AlchemyEncoder,
ensure_ascii=False)
else:
# 一个tag查询多天
start_date = datetime.strptime(request.values.get('start_date'),
"%Y-%m-%d")
end_date = datetime.strptime(request.values.get('end_date'),
"%Y-%m-%d")
if start_date != end_date:
date_list = [request.values.get('start_date')]
while True:
start_date += timedelta(days=1)
if start_date == end_date:
date_list.append(
datetime.strftime(end_date, "%Y-%m-%d"))
break
else:
date_list.append(
datetime.strftime(start_date, "%Y-%m-%d"))
Begin = request.values.get("start_time")
End = request.values.get("end_time")
data = []
count = 0
for item in date_list:
count += 1
start_time = item + " " + Begin
end_time = item + " " + End
sql = "select `SampleTime` as time, " + "`" + request.values.get(
'TagCode') + "`" + "as value from " \
"datahistory where SampleTime between " + "'" + start_time + "'" + " and " + "'" + end_time + "'"
results = db_session.execute(sql).fetchall()
list1 = []
for result in results[::30]:
list1.append({
f'time{count}':
datetime.strftime(result['time'],
"%Y-%m-%d %H:%M:%S"),
f'value{count}':
result['value']
})
# data.append({item: list1})
data.append(list1)
return json.dumps(
{
'code': '20001',
'message': '成功',
'data': data,
'date': date_list
},
cls=AlchemyEncoder,
ensure_ascii=False)
else:
Begin = request.values.get("start_time")
End = request.values.get("end_time")
data = []
count = 0
for item in [request.values.get('start_date')]:
count += 1
start_time = item + " " + Begin
end_time = item + " " + End
sql = "select `SampleTime` as time, " + "`" + request.values.get('TagCode') + "`" + "as value from " \
"datahistory where SampleTime between " + "'" + start_time + "'" + " and " + "'" + end_time + "'"
results = db_session.execute(sql).fetchall()
list1 = []
for result in results[::30]:
list1.append({
f'time{count}':
datetime.strftime(result['time'],
"%Y-%m-%d %H:%M:%S"),
f'value{count}':
result['value']
})
# data.append({item: list1})
data.append(list1)
return json.dumps(
{
'code': '20001',
'message': '成功',
'data': data
},
cls=AlchemyEncoder,
ensure_ascii=False)
except Exception as e:
logger.error(e)
insertSyslog("error", "energy_trend错误：" + str(e), current_user.Name)
return json.dumps(
{
'code': '20002',
'message': 'energy_trend错误： ' + str(e)
},
cls=AlchemyEncoder,
ensure_ascii=False)
