def reget_plc_node(self):
# client = Client('opc.tcp://127.0.0.1:49320')
self.INI_OPC()
try:
if self._plc_using == PLC_STATUS.PLC_A.value:
self._nodels1 = self._plc_a_nodels1
self._nodeld1pv = self._plc_a_nodeld1pv
self._nodelq1pv = self._plc_a_nodelq1pv
self._nodels2 = self._plc_a_nodels2
self._nodeld2pv = self._plc_a_nodeld2pv
self._nodelq2pv = self._plc_a_nodelq2pv
self._nodek1p1 = self._plc_a_nodek1p1
self._nodek2p2 = self._plc_a_nodek2p2
self._nodek3p3 = self._plc_a_nodek3p3
self._nodek4p4 = self._plc_a_nodek4p4
self._nodek5p5 = self._plc_a_nodek5p5
else:
self._nodels1 = self._plc_b_nodels1
self._nodeld1pv = self._plc_b_nodeld1pv
self._nodelq1pv = self._plc_b_nodelq1pv
self._nodels2 = self._plc_b_nodels2
self._nodeld2pv = self._plc_b_nodeld2pv
self._nodelq2pv = self._plc_b_nodelq2pv
self._nodek1p1 = self._plc_b_nodek1p1
self._nodek2p2 = self._plc_b_nodek2p2
self._nodek3p3 = self._plc_b_nodek3p3
self._nodek4p4 = self._plc_b_nodek4p4
self._nodek5p5 = self._plc_b_nodek5p5
except Exception as err:
logger.error("CHANGE_PLC_CTRL_WORD！错误信息为：" + str(err))
pass
def INI_OPC(self):
# client = Client('opc.tcp://127.0.0.1:49320')
try:
self.connect()
self._plc_a_nodels1 = self._client.get_node(PLC_A_NODE_LS1)
self._plc_a_nodeld1pv = self._client.get_node(PLC_A_NODE_LD1PV)
self._plc_a_nodelq1pv = self._client.get_node(PLC_A_NODE_LQ1PV)
self._plc_a_nodels2 = self._client.get_node(PLC_A_NODE_LS2)
self._plc_a_nodeld2pv = self._client.get_node(PLC_A_NODE_LD2PV)
self._plc_a_nodelq2pv = self._client.get_node(PLC_A_NODE_LQ2PV)
self._plc_a_nodek1p1 = self._client.get_node(PLC_A_NODE_K1P1)
self._plc_a_nodek2p2 = self._client.get_node(PLC_A_NODE_K2P2)
self._plc_a_nodek3p3 = self._client.get_node(PLC_A_NODE_K3P3)
self._plc_a_nodek4p4 = self._client.get_node(PLC_A_NODE_K4P4)
self._plc_a_nodek5p5 = self._client.get_node(PLC_A_NODE_K5P5)
self._plc_b_nodels1 = self._client.get_node(PLC_B_NODE_LS1)
self._plc_b_nodeld1pv = self._client.get_node(PLC_B_NODE_LD1PV)
self._plc_b_nodelq1pv = self._client.get_node(PLC_B_NODE_LQ1PV)
self._plc_b_nodels2 = self._client.get_node(PLC_B_NODE_LS2)
self._plc_b_nodeld2pv = self._client.get_node(PLC_B_NODE_LD2PV)
self._plc_b_nodelq2pv = self._client.get_node(PLC_B_NODE_LQ2PV)
self._plc_b_nodek1p1 = self._client.get_node(PLC_B_NODE_K1P1)
self._plc_b_nodek2p2 = self._client.get_node(PLC_B_NODE_K2P2)
self._plc_b_nodek3p3 = self._client.get_node(PLC_B_NODE_K3P3)
self._plc_b_nodek4p4 = self._client.get_node(PLC_B_NODE_K4P4)
self._plc_b_nodek5p5 = self._client.get_node(PLC_B_NODE_K5P5)
except Exception as err:
logger.error("功能INI_CTRL_WORD报错！错误信息为：" + str(err))
pass
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 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 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 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 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 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 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 connect(self):
try:
self.disconnect()
self._client = Client('opc.tcp://127.0.0.1:49320')
self._client.connect()
self._connected = True
except Exception as err:
logger.error("connect报错！错误信息为：" + str(err))
pass
def is_valid(self, proxy):
proxies = {"http": "http://" + proxy, "https": "http://" + proxy, }
try:
requests.get(self.TEST_URL, proxies=proxies, timeout=self.TIMEOUT)
except Exception as e:
logger.error(repr(e))
return False
else:
logger.info("it's works {0}".format(proxy))
return True
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 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 CHANGE_PLC_B_CTRL_WORD(self):
# client = Client('opc.tcp://127.0.0.1:49320')
self.INI_OPC()
try:
self._nodels1 = self._plc_b_nodels1
self._nodeld1pv = self._plc_b_nodeld1pv
self._nodelq1pv = self._plc_b_nodelq1pv
self._nodels2 = self._plc_b_nodels2
self._nodeld2pv = self._plc_b_nodeld2pv
self._nodelq2pv = self._plc_b_nodelq2pv
self._nodek1p1 = self._plc_b_nodek1p1
self._nodek2p2 = self._plc_b_nodek2p2
self._nodek3p3 = self._plc_b_nodek3p3
self._nodek4p4 = self._plc_b_nodek4p4
self._nodek5p5 = self._plc_b_nodek5p5
except Exception as err:
logger.error("CHANGE_PLC_B_CTRL_WORD！错误信息为：" + str(err))
pass
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 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 apicall():
logger.info('<<albert_cls')
try:
start = time.time()
req_data = request.get_data(as_text=True)
logger.info(req_data)
if req_data:
req_data = json.loads(req_data)
text = req_data['text']
task = req_data['task']
dict_res = for_server(text=text, task=task)
logger.info("时间{}".format(time.time() - start))
dict_ = {}
dict_['status'] = 'success'
dict_['results'] = dict_res
return jsonify(dict_)
else:
res = {'status': 'failed', 'results': '没有收到request消息'}
return jsonify(res)
except BadRequestKeyError as e:
logger.error(e)
res = {'status': 'failed', 'results': str(e)}
return jsonify(res)
except FileNotFoundError as e:
logger.error(e)
res = {'status': 'failed', 'results': e.strerror}
return jsonify(res)
except Exception as e:
logger.error(e)
res = {'status': 'failed', 'results': str(e)}
return jsonify(res)
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 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 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 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)
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 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 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)
