def fur_result(furnace_id: str, img_idx: str, furnace_state: str,
model_name: str, res: ResponseBase):
session = mysql_session.session()
# r_key = 'fur_result_{}_{}'.format(furnace_id, img_idx)
# 不做缓存
try:
# if r.exists(r_key):
# data = {'img_origin': '', 'img_detection': '','final_rst':'','img_nums':''}
# res.data = hash2obj(data, r_key)
# pass
# 根据furnace_id寻找 A1 服务器地址
# else:
series = furnace_id[0]
id = furnace_id[1:]
db_data = session.query(FurnaceList.server_ip).filter(
FurnaceList.furnace_id == id,
FurnaceList.furnace_series == series).first()
server_ip = db_data[0]
addr = ''
if img_idx == '':
addr = 'http://{}:5000/furnace_detection_first?device_id={}&device_state={}&model_name={}'.format(
server_ip, furnace_id, furnace_state, model_name)
else:
addr = 'http://{}:5000/furnace_detection?device_id={}&img_idx={}&device_state={}&model_name={}'.format(
server_ip, furnace_id, img_idx, furnace_state, model_name)
resp = s_reqs.get(addr, timeout=5).json()
res.data = resp
# set_redis(resp, r_key, 60)
pass
except Exception as e:
res.error(Error.SERVER_EXCEPTION)
logger.error(e)
pass
session.close()
return res.__dict__
def server_list(res: ResponseBase):
session = mysql_session.session()
data = {'server_list': []}
r_key = 'server_list'
try:
if redis_session.exists(r_key):
data = redis_session.get_redis_str(r_key)
pass
else:
db_data = session.query(
ServerList.server_ip).filter(ServerList.state > 0).all()
server_list = []
for i in db_data:
server_list.append(i[0])
data['server_list'] = server_list
if len(server_list) > 0:
redis_session.set_redis_str(data, r_key, 60 * 60 * 24)
else:
res.code = 1
pass
except Exception as e:
res.error(Error.SERVER_EXCEPTION)
logger.error(e)
pass
session.close()
res.data = data
return res.__dict__
def fur_state(item: ReqUpdateFurState, res: ResponseBase, host: str):
session = mysql_session.session()
try:
data = session.query(FurnaceList).filter(
FurnaceList.furnace_id == item.furnace_id,
FurnaceList.furnace_series == item.furnace_series).first()
if data == None:
fl = FurnaceList()
fl.gmt_create = datetime.now()
fl.setData(item, host)
session.add(fl)
session.commit()
res.succ()
pass
else:
data.setData(item, host)
session.commit()
res.succ()
pass
except Exception as e:
res.error(Error.OPT_ERR)
logger.error(e)
pass
session.close()
return res.__dict__
def craft_off_prop(dtype: int,craft: str,res: ResponseBase):
data = {'seed_off':0,'seed_total':0,'shoulder_off':0,'shoulder_total':0}
r_key = f'craft_off_{craft}_{dtype}'
session = mysql_session.session()
try:
if redis_session.exists(r_key):
data = redis_session.get_redis_str(r_key)
pass
else:
# 查询数据库
condition = []
db_data = []
if craft == 'shoulder':
condition.append(ShoulderCraft.gmt_update >= get_startdate(dtype))
db_data = session.query(ShoulderCraft.shoulder_off,func.count('*')).filter(and_(*condition)).group_by(ShoulderCraft.shoulder_off).order_by(ShoulderCraft.shoulder_off).all()
if len(db_data)>0:
l = np.array(db_data)[:,1]
data['shoulder_off'] = int(l[1])
data['shoulder_total'] = int(l[0] + l[1])
if craft == 'seed':
condition.append(SeedCraft.gmt_update >= get_startdate(dtype))
db_data = session.query(SeedCraft.seed_off,func.count('*')).filter(and_(*condition)).group_by(SeedCraft.seed_off).order_by(SeedCraft.seed_off).all()
if len(db_data)>0:
l = np.array(db_data)[:,1]
data['seed_off'] = int(l[1])
data['seed_total'] = int(l[0] + l[1])
except Exception as e:
res.error(Error.SERVER_EXCEPTION)
logger.error(e)
pass
session.close()
res.data = data
return res
def regular_std_stic():
session = mysql_session.session()
try:
print('wc')
# 查询数据库 当天的数据
now = datetime.now()
before = now - timedelta(days=1) # 一天前
# save_time = now - timedelta(minutes=10)
cdt_weld = []
cdt_weld.append(TempCraft.gmt_update >= before)
cdt_weld.append(TempCraft.gmt_update < now)
db_weld = session.query(TempCraft.weld_std, func.count('*')).filter(
and_(*cdt_weld)).group_by(TempCraft.weld_std).all()
mg_weld_obj = CommonStd(now, 'weld')
for item in db_weld:
if item[0] == 0: mg_weld_obj.std_o = item[1]
elif item[0] == 1: mg_weld_obj.std = item[1]
else: pass
# 更新
logger.error('update_weld', mg_weld_obj.__dict__)
mongo_session.insert_collection('std_stic', mg_weld_obj.__dict__)
cdt_seed = []
cdt_seed.append(SeedCraft.gmt_update >= before)
cdt_seed.append(SeedCraft.gmt_update < now)
db_seed = session.query(SeedCraft.seed_std, func.count('*')).filter(
and_(*cdt_seed)).group_by(SeedCraft.seed_std).all()
mg_seed_obj = SeedStd(now, 'seed')
for item in db_seed:
if item[0] == 1: mg_seed_obj.std = item[1]
elif item[0] == 2: mg_seed_obj.l_o = item[1]
elif item[0] == 3: mg_seed_obj.s_o = item[1]
elif item[0] == 4: mg_seed_obj.b_o = item[1]
else: pass
# 更新
logger.error('update_seed', mg_seed_obj.__dict__)
mongo_session.insert_collection('std_stic', mg_seed_obj.__dict__)
cdt_shoulder = []
cdt_shoulder.append(ShoulderCraft.gmt_update >= before)
cdt_shoulder.append(ShoulderCraft.gmt_update < now)
db_shoulder = session.query(ShoulderCraft.shoulder_std,
func.count('*')).filter(
and_(*cdt_shoulder)).group_by(
ShoulderCraft.shoulder_std).all()
mg_shoulder_obj = CommonStd(now, 'shoulder')
for item in db_shoulder:
if item[0] == 0: mg_shoulder_obj.std_o = item[1]
elif item[0] == 1: mg_shoulder_obj.std = item[1]
else: pass
# 更新
logger.error('update_shoulder', mg_shoulder_obj.__dict__)
mongo_session.insert_collection('std_stic', mg_shoulder_obj.__dict__)
except Exception as e:
logger.error(e)
pass
session.close()
return None
def current_fur_list(series: str, res: ResponseBase):
session = mysql_session.session()
data = {'fur_list': [], 'series': ''}
r_key = f'current_fur_list_{series}'
try:
if redis_session.exists(r_key):
data = redis_session.get_redis_str(r_key)
pass
else:
db_data = session.query(
FurnaceList.furnace_id, FurnaceList.furnace_state).filter(
FurnaceList.furnace_series == series).order_by(
FurnaceList.furnace_id).all()
fur_list = []
if len(db_data) > 0:
for i in db_data:
fur_list.append(
CurrentFurList(series + str(i[0]), i[1]).__dict__)
data['fur_list'] = fur_list
data['series'] = series
if len(fur_list) > 0:
redis_session.set_redis_str(data, r_key, 30)
pass
else:
res.error(Error.NO_DATA)
pass
except Exception as e:
res.error(Error.SERVER_EXCEPTION)
logger.error(e)
pass
session.close()
res.data = data
return res.__dict__
def shoulder_pd_dist(dtype: int,res: ResponseBase):
data = {'shoulder_pd_list': []}
r_key = f'shoulder_pd_list_{dtype}'
session = mysql_session.session()
try:
if redis_session.exists(r_key):
data = redis_session.get_redis_str(r_key)
pass
else:
# 查询数据库
condition = []
condition.append(ShoulderCraft.gmt_update >= get_startdate(dtype))
db_data = session.query(ShoulderCraft.shoulder_powerdec).filter(and_(*condition)).all()
shoulder_pd_list = []
if len(db_data)>0:
l = np.array(db_data)[:,0]
cso = CommonSticOp(l)
cso.get_dist(5)
for item in cso.result:
shoulder_pd_list.append(CommonListItem(item[0],item[1]).__dict__)
data['shoulder_pd_list'] = shoulder_pd_list
if len(shoulder_pd_list) > 0:
redis_session.set_redis_str(data,r_key, 1)
pass
except Exception as e:
res.error(Error.SERVER_EXCEPTION)
logger.error(e)
pass
session.close()
res.data = data
return res
def get_server_lists(res: ResponseBase, ipt: str, idx: int, size: int):
session = mysql_session.session()
data = CommonList()
r_key = "server_lists_" + ipt
try:
if redis_session.exists(r_key):
# data = redis_session.hash2obj(data.__dict__, r_key)
data = redis_session.get_redis_str(r_key)
pass
else:
ipt = '%{}%'.format(ipt)
db_data = session.query(ServerList).filter(
and_(ServerList.server_ip.like(ipt),
ServerList.state > 0)).all()
for i in db_data:
re = RespServerList(i).__dict__
data.list.append(re)
data.total = len(db_data)
if len(data.list) > 0:
# redis_session.set_redis(data.__dict__, r_key, 60*60)
redis_session.set_redis_str(data.__dict__, r_key, 60 * 60)
pass
res.data = data
except Exception as e:
res.error(Error.OPTION_ERR)
logger.error(e)
pass
session.close() # 关闭session
return res
def get_furnace_lists(res: ResponseBase, id: str, series: str, status: str,
idx: int, size: int):
session = mysql_session.session()
data = CommonList()
# r_key = "furnace_lists_{}_{}".format(series, id)
r_key = f'furnace_lists_{series}_{id}'
try:
if redis_session.exists(r_key):
data = redis_session.get_redis_str(r_key)
pass
else:
# 多条件查询
condition = []
if series != '':
condition.append(FurnaceList.furnace_series == series)
if id != '':
condition.append(FurnaceList.furnace_id == int(id))
if status != '':
condition.append(FurnaceList.furnace_state == int(status))
db_data = session.query(FurnaceList).filter(and_(*condition)).all()
for i in db_data:
re = RespFurnaceList(i).__dict__
data.list.append(re)
data.total = len(db_data)
if len(data.list) > 0:
redis_session.set_redis_str(data.__dict__, r_key, 60)
pass
res.data = data
except Exception as e:
res.error(Error.OPTION_ERR)
logger.error(e)
pass
session.close() # 关闭session
return res
def mod_server(item: ReqModifyServer, res: ResponseBase):
session = mysql_session.session()
try:
# 删除相关缓存
scan = redis_session.scan(match='server_list*')
for i in scan[1]:
redis_session.delete(i)
data = session.query(ServerList).filter(
ServerList.server_ip == item.server_ip).first()
if data == None:
sl = ServerList()
sl.gmt_create = datetime.now()
sl.setData(item)
session.add(sl)
session.commit()
res.succ()
pass
else:
data.setData(item)
session.commit()
res.succ()
pass
except Exception as e:
res.error(Error.OPTION_ERR)
logger.error(e)
pass
session.close() # 关闭session
return res
def series_list(res: ResponseBase):
session = mysql_session.session()
data = {'series_list': []}
r_key = 'series_list'
try:
if redis_session.exists(r_key):
data = redis_session.get_redis_str(r_key)
pass
else:
db_data = session.query(FurnaceList.furnace_series,
func.count('*').label("count")).group_by(
FurnaceList.furnace_series).all()
series_list = []
for i in db_data:
series_list.append(i[0])
series_list.sort(key=None, reverse=False)
data['series_list'] = series_list
if len(series_list) > 0:
redis_session.set_redis_str(data, r_key, 60 * 60 * 24)
pass
pass
except Exception as e:
res.error(Error.SERVER_EXCEPTION)
logger.error(e)
pass
session.close()
res.data = data
return res.__dict__
def up_history_broken(item: ReqUpdateHistoryBroken, res: ResponseBase,
host: str):
session = mysql_session.session()
try:
data = session.query(BrokenHistoryResult).filter(
and_(BrokenHistoryResult.date == item.date,
BrokenHistoryResult.server_ip == host)).first()
if data == None:
bhr = BrokenHistoryResult()
bhr.gmt_update = datetime.now()
bhr.setData(item, host)
session.add(bhr)
session.commit()
res.succ()
pass
else:
data.setData(item, host)
session.commit()
res.succ()
pass
except Exception as e:
res.error(Error.OPT_ERR)
logger.error(e)
pass
# 删除相关缓存
scan = redis_session.scan(match='history_broken*')
for i in scan[1]:
redis_session.delete(i)
session.close()
return res.__dict__
def temp_std(dtype: int, res: ResponseBase):
data = {'temp_std_list': [],'total':0}
r_key = f'temp_std_list_{dtype}'
session = mysql_session.session()
try:
if redis_session.exists(r_key):
data = redis_session.get_redis_str(r_key)
pass
else:
temp_std_list = []
condition = []
condition.append(TempCraft.gmt_update >= get_startdate(dtype))
db_data = session.query(TempCraft.weld_std,func.count('*')).filter(and_(*condition)).group_by(TempCraft.weld_std).order_by(TempCraft.weld_std).all()
for child in db_data:
data['total'] += child[1]
std_dict = {'0':'控制不达标','1':'控制达标'}
temp_std_list = mysql_init_data(db_data,std_dict,CommonListItem)
data['temp_std_list'] = temp_std_list
if len(temp_std_list) > 0:
redis_session.set_redis_str(data,r_key, gr_sec(0))
pass
except Exception as e:
res.error(Error.SERVER_EXCEPTION)
logger.error(e)
pass
session.close()
res.data = data
return res
def shoulder_type_stic(dtype: int, res: ResponseBase):
data = {'shoulder_type_list': [], 'total': 0}
r_key = f'shoulder_type_list_{dtype}'
session = mysql_session.session()
try:
if redis_session.exists(r_key):
data = redis_session.get_redis_str(r_key)
pass
else:
shoulder_type_list = []
condition = []
condition.append(ShoulderCraft.gmt_update >= get_startdate(dtype))
db_data = session.query(ShoulderCraft.shoulder_type,func.count('*')).filter(and_(*condition)).group_by(ShoulderCraft.shoulder_type).order_by(ShoulderCraft.shoulder_type).all()
for child in db_data:
data['total'] += child[1]
shoulder_type_list = mysql_init_data(db_data,shoulder_model,CommonListItem)
data['shoulder_type_list'] = shoulder_type_list
if len(shoulder_type_list) > 0:
redis_session.set_redis_str(data,r_key, 1)
pass
except Exception as e:
res.error(Error.SERVER_EXCEPTION)
logger.error(e)
pass
session.close()
res.data = data
return res
def temp_type_stic(dtype: int, res: ResponseBase):
data = {'temp_type_list': [],'total':0}
r_key = f'temp_type_list_{dtype}'
session = mysql_session.session()
try:
if redis_session.exists(r_key):
data = redis_session.get_redis_str(r_key)
pass
else:
temp_type_list = []
condition = []
condition.append(TempCraft.gmt_update >= get_startdate(dtype))
db_data = session.query(TempCraft.weld_type,func.count('*')).filter(and_(*condition)).group_by(TempCraft.weld_type).order_by(TempCraft.weld_type).all()
for child in db_data:
data['total'] += child[1]
# tm_keys_list = list(temp_model.keys())
# temp_keys_list = []
# for item in db_data:
# temp_keys_list.append(f'{item[0]}')
# temp_type_list.append(CommonListItem(temp_model[f'{item[0]}'],item[1]).__dict__)
# d_set = sort(list(set(tm_keys_list).difference(set(temp_keys_list))))
# for i in d_set:
# temp_type_list.insert(tm_keys_list.index(i),CommonListItem(temp_model[f'{i}'],0).__dict__)
temp_type_list = mysql_init_data(db_data,temp_model,CommonListItem)
data['temp_type_list'] = temp_type_list
if len(temp_type_list) > 0:
redis_session.set_redis_str(data,r_key, gr_sec(0))
pass
except Exception as e:
res.error(Error.SERVER_EXCEPTION)
logger.error(e)
pass
session.close()
res.data = data
return res
def shoulder_wt_dist(dtype: int, res:ResponseBase):
data = {'shoulder_wt_list': [], 'mean':0, 'total':0}
r_key = f'shoulder_wt_list_{dtype}'
session = mysql_session.session()
try:
if redis_session.exists(r_key):
data = redis_session.get_redis_str(r_key)
pass
else:
# 查询数据库
condition = []
condition.append(ShoulderCraft.gmt_update >= get_startdate(dtype))
db_data = session.query(ShoulderCraft.shoulder_wt).filter(and_(*condition)).all()
shoulder_wt_list = []
if len(db_data)>0:
l = np.array(db_data)[:,0]
data['mean'] = round(np.mean(l),4)
data['total'] = len(l)
# for key,value in interval_static(l).items():
# shoulder_wt_list.append(CommonFitListItem(key,value,0).__dict__)
cso = CommonSticOp(l)
cso.get_dist_fit()
for item in cso.result:
shoulder_wt_list.append(CommonFitListItem(item[0],item[1],round(item[2],4)).__dict__)
data['shoulder_wt_list'] = shoulder_wt_list
if len(shoulder_wt_list) > 0:
redis_session.set_redis_str(data,r_key, 1)
pass
except Exception as e:
res.error(Error.SERVER_EXCEPTION)
logger.error(e)
pass
session.close()
res.data = data
return res
def up_temp_process(item: ReqTempProcess, res: ResponseBase):
# 更新 数据
session = mysql_session.session()
try:
tc = TempCraft()
tc.setData(item)
session.add(tc)
session.commit()
mongo_session.insert_collection(f'{tc.furnace_id}_craft',tc.chg2mongo())
res.succ()
pass
except Exception as e:
res.error(Error.OPT_ERR)
logger.error(e)
pass
session.close()
return res
def up_seed_process(item: ReqSeedProcess, res: ResponseBase):
session = mysql_session.session()
try:
sc = SeedCraft()
sc.setData(item)
session.add(sc)
session.commit()
mongo_session.insert_collection(f'{sc.furnace_id}_craft',sc.chg2mongo())
res.succ()
pass
except Exception as e:
res.error(Error.OPT_ERR)
logger.error(e)
pass
session.close()
return res
def up_cyl_process(item: ReqCylProcess, res: ResponseBase):
session = mysql_session.session()
# 更新 数据
try:
# 保存数据库 mysql
cc = CylCraft()
cc.setData(item)
session.add(cc)
session.commit()
mongo_session.insert_collection(f'{cc.furnace_id}_craft',cc.chg2mongo())
res.succ()
pass
except Exception as e:
res.error(Error.OPT_ERR)
logger.error(e)
pass
session.close()
return res
def history_broken(type: int, res: ResponseBase):
session = mysql_session.session()
data = {'broken_list': []}
r_key = f'history_broken_{type}'
try:
if redis_session.exists(r_key):
data = redis_session.get_redis_str(r_key)
pass
else:
dt_ago = (datetime.now() - timedelta(days=30)).date()
if type == '1': # shouldering
db_data = session.query(
BrokenHistoryResult.date,
func.sum(
BrokenHistoryResult.shouldering_broken_nums).label(
"count")).filter(
BrokenHistoryResult.date >= dt_ago).group_by(
BrokenHistoryResult.date).order_by(
BrokenHistoryResult.date).all()
elif type == '2':
db_data = session.query(
BrokenHistoryResult.date,
func.sum(BrokenHistoryResult.diameter_broken_nums).label(
"count")).filter(
BrokenHistoryResult.date >= dt_ago).group_by(
BrokenHistoryResult.date).order_by(
BrokenHistoryResult.date).all()
else:
db_data = []
pass
broken_list = []
for i in db_data:
broken_list.append(
CommonListItem(str(i[0]), int(i[1])).__dict__)
data['broken_list'] = broken_list
if len(broken_list) > 0:
redis_session.set_redis_str(data, r_key, 60 * 60 * 2)
except Exception as e:
res.error(Error.SERVER_EXCEPTION)
logger.error(e)
pass
session.close()
res.data = data
return res.__dict__
def up_shoulder_process(item: ReqShoulderProcess, res: ResponseBase):
session = mysql_session.session()
# 更新 数据
try:
# 保存数据库 mysql
shc = ShoulderCraft()
shc.setData(item)
session.add(shc)
session.commit()
mongo_session.insert_collection(f'{shc.furnace_id}_craft',shc.chg2mongo())
res.succ()
pass
except Exception as e:
res.error(Error.OPT_ERR)
logger.error(e)
pass
session.close()
return res
def seed_type_stic(dtype: int, res: ResponseBase):
data = {'seed_type_list': [], 'total':0}
r_key = f'seed_type_list_{dtype}'
session = mysql_session.session()
try:
if redis_session.exists(r_key):
data = redis_session.get_redis_str(r_key)
pass
else:
seed_type_list = []
condition = []
condition.append(SeedCraft.gmt_update >= get_startdate(dtype))
condition.append(SeedCraft.seed_type <= 4)
db_data = session.query(SeedCraft.seed_type,func.count('*')).filter(and_(*condition)).group_by(SeedCraft.seed_type).order_by(SeedCraft.seed_type).all()
for child in db_data:
data['total'] += child[1]
# db_data = session.query(SeedCraft.seed_type,func.count(case(whens=((SeedCraft.seed_type.in_([1,2,3,4]),1),),else_=0))).filter(and_(*condition)).group_by(SeedCraft.seed_type).all()
# sm_keys_list = list(seed_model.keys())
# temp_keys_list = []
# for item in db_data:
# temp_keys_list.append(f'{item[0]}')
# seed_type_list.append(CommonListItem(seed_model[f'{item[0]}'],item[1]).__dict__)
# # 初始化未添加的内容
# d_map = map(int,list(set(sm_keys_list).difference(set(temp_keys_list))))
# d_set = sorted(list(d_map))
# for i in d_set:
# seed_type_list.insert(sm_keys_list.index(f'{i}'),CommonListItem(seed_model[f'{i}'],0).__dict__)
seed_type_list = mysql_init_data(db_data,seed_model,CommonListItem)
data['seed_type_list'] = seed_type_list
if len(seed_type_list) > 0:
redis_session.set_redis_str(data,r_key, 60)
pass
except Exception as e:
res.error(Error.SERVER_EXCEPTION)
logger.error(e)
pass
session.close()
res.data = data
return res
def temp_wt_group_dist(dtype: int, res: ResponseBase):
data = {'temp_wtg_list': [],'mean_list':[]}
r_key = f'temp_wtg_list_{dtype}'
session = mysql_session.session()
try:
if redis_session.exists(r_key):
data = redis_session.get_redis_str(r_key)
pass
else:
# 查询数据库
temp_wtg_list = []
mean_list = []
for i in temp_model.keys():
condition = []
condition.append(TempCraft.gmt_update >= get_startdate(dtype))
condition.append(TempCraft.weld_type == int(i))
db_data = session.query(TempCraft.weld_wt,TempCraft.weld_type).filter(and_(*condition)).all()
if len(db_data):
l = np.array(db_data)[:,0]
# mean_list.append({'type':temp_model[i],'mean':np.mean(l),'count':len(l)})
cso = CommonSticOp(l)
cso.get_dist(interv=1)
for item in cso.result:
temp_wtg_list.append(GroupListItem(temp_model[i],item[0],item[1]).__dict__)
data['temp_wtg_list'] = temp_wtg_list
# data['mean_list'] = mean_list
if len(temp_wtg_list) > 0 and len(mean_list) > 0:
# redis_session.set_redis_str(data,r_key, 10)
redis_session.set_redis_str(data,r_key,gr_sec(0))
pass
except Exception as e:
res.error(Error.SERVER_EXCEPTION)
logger.error(e)
pass
session.close()
res.data = data
return res
def temp_ot(dtype: int, res: ResponseBase):
data = {'temp_ot_list':[]}
r_key = f'temp_ot_list_{dtype}'
session = mysql_session.session()
try:
if redis_session.exists(r_key):
data = redis_session.get_redis_str(r_key)
pass
else:
temp_ot_list = []
for i in temp_model.keys():
condition = []
condition.append(TempCraft.gmt_update >= get_startdate(dtype))
condition.append(TempCraft.weld_type == int(i))
db_data = session.query(TempCraft.weld_wt,TempCraft.weld_type).filter(and_(*condition)).all()
# 计算超时
if len(db_data)>0:
l = np.array(db_data)[:,0]
rest = calculate_ot(l,2)
temp_ot_list.append(GroupListItem('超时',temp_model[i],rest[0]).__dict__)
temp_ot_list.append(GroupListItem('未超时',temp_model[i],rest[1]).__dict__)
else:
temp_ot_list.append(GroupListItem('超时',temp_model[i],0).__dict__)
temp_ot_list.append(GroupListItem('未超时',temp_model[i],0).__dict__)
data['temp_ot_list'] = temp_ot_list
if len(temp_ot_list) > 0:
redis_session.set_redis_str(data,r_key, 60)
pass
pass
except Exception as e:
res.error(Error.SERVER_EXCEPTION)
logger.error(e)
pass
session.close()
res.data = data
return res
def online_fur(res: ResponseBase):
session = mysql_session.session()
data = {'online_list': []}
r_key = 'online_list'
try:
if redis_session.exists(r_key):
data = redis_session.get_redis_str(r_key)
pass
else:
db_data = session.query(
FurnaceList.furnace_state,
func.count('*').label("count")).filter(
FurnaceList.furnace_state < 99).group_by(
FurnaceList.furnace_state).order_by(
FurnaceList.furnace_state).all()
# dm_keys_list = list(dict_model.keys())
# temp_keys_list = []
# for item in db_data:
# temp_keys_list.append(f'{item[0]}')
# data.online_list.append(CommonListItem(dict_model[f'{item[0]}'], item[1]).__dict__)
# d_map = map(int,list(set(dm_keys_list).difference(set(temp_keys_list))))
# d_set = sorted(list(d_map))
# for i in d_set:
# data.online_list.insert(dm_keys_list.index(f'{i}'),CommonListItem(dict_model[f'{i}'],0).__dict__)
online_list = mysql_init_data(db_data, dict_model, CommonListItem)
data['online_list'] = online_list
if len(online_list) > 0:
redis_session.set_redis_str(data, r_key, 60)
pass
except Exception as e:
res.error(Error.SERVER_EXCEPTION)
logger.error(e)
pass
session.close()
res.data = data
return res.__dict__
