def model_state(server_ip: str, res: ResponseBase):
data = {'model_list': []}
r_key = f'model_list_{server_ip}'
try:
if redis_session.exists(r_key):
data = redis_session.get_redis_str(r_key)
pass
else:
addr = 'http://{}:5000/model_status'.format(server_ip)
resp = s_reqs.get(addr, timeout=5)
res_dict = resp.json()
model_list = []
for key in res_dict:
if key in dict_model_index.keys():
model_list.append(
RespModelState(key, dict_model_index.get(key),
res_dict.get(key)).__dict__)
continue
model_list.sort(key=lambda x: x['key'], reverse=False)
data['model_list'] = model_list
if len(model_list) > 0:
redis_session.set_redis_str(data, r_key, 30)
pass
res.data = data
except Exception as e:
res.error(Error.SERVER_EXCEPTION)
logger.error(e)
pass
return res.__dict__
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
async def get_craft_off_prop(type: int = 1,craft = ''):
res = ResponseBase()
if craft in ['seed','shoulder']:
craft_off_prop(type,craft,res)
else:
res.error(Error.PARAM_ERR)
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 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
async def get_single_seed_history_lates(furnace_id: str = ''):
res = ResponseBase()
if furnace_id:
single_seed_history_lates(furnace_id,res)
else:
res.error(Error.PARAM_ERR)
return res
async def modify_server(item: ReqModifyServer):
res = ResponseBase()
if valid_ip(item.server_ip):
mod_server(item, res)
else:
res.error(Error.PARAM_ERR)
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 user_list(value: str, res: ResponseBase):
data = {'user_list': [], 'total': 0}
try:
search_col = {'username': {'$regex': f'{value}'}, 'state': 1} # 模糊匹配
return_type = {
'_id': 0,
'username': 1,
'login_time': 1,
'type': 1,
'state': 1
}
mg_data = mongo_session.select_all_collection('user_info',
search_col,
return_type,
sort_col='update',
sort='desc')
if len(mg_data) > 0:
data['user_list'] = mg_data
data['total'] = len(mg_data)
res.data = data
pass
except Exception as e:
res.error(Error.OPT_ERR)
logger.error(e)
pass
return res
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__
async def get_shoulder_dvt_dist(dvt: str = '',type: int = 2):
res = ResponseBase()
if dvt in ['l','d']:
shoulder_dvt_dist(dvt,type,res)
else:
res.error(Error.PARAM_ERR)
return res
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 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 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 seed_wt_dist(dtype: int, res: ResponseBase):
data = {'seed_wt_list': [],'mean':0,'total':0}
r_key = f'seed_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(SeedCraft.gmt_update >= get_startdate(dtype))
db_data = session.query(SeedCraft.seed_wt).filter(and_(*condition)).all()
seed_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():
# seed_wt_list.append(CommonFitListItem(key,value,0).__dict__)
cso = CommonSticOp(l)
cso.get_dist_fit()
for item in cso.result:
seed_wt_list.append(CommonFitListItem(item[0],item[1],round(item[2],4)).__dict__)
data['seed_wt_list'] = seed_wt_list
if len(seed_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
async def modify_server():
res = ResponseBase()
item = ReqModifyServer(**request.get_json())
if valid_ip(item.server_ip):
mod_server(item, res)
else:
res.error(Error.PARAM_ERR)
return res.__dict__
async def get_single_seed_history_lates(furnace_id: str = ''):
res = ResponseBase()
furnace_id = request.args.get('furnace_id', '')
if furnace_id:
single_seed_history_lates(furnace_id, res)
else:
res.error(Error.PARAM_ERR)
return res.__dict__
async def get_model_state():
res = ResponseBase()
server_ip = request.args.get('server_ip', '')
if valid_ip(server_ip):
model_state(server_ip, res)
else:
res.error(Error.PARAM_ERR)
return res.__dict__
async def get_shoulder_dvt_dist():
res = ResponseBase()
dvt = request.args.get('dvt', '')
type = request.args.get('type', 2)
if dvt in ['l', 'd']:
shoulder_dvt_dist(dvt, type, res)
else:
res.error(Error.PARAM_ERR)
return res.__dict__
async def temp_process(item: ReqTempProcess, request: Request):
res = ResponseBase()
if item.server_ip == None or not valid_ip(item.server_ip):
item.server_ip = request.client.host
if item.valid():
up_temp_process(item, res)
else:
res.error(Error.PARAM_ERR)
return res
async def get_craft_off_prop():
res = ResponseBase()
type = request.args.get('type', 1)
craft = request.args.get('craft', '')
if craft in ['seed', 'shoulder']:
craft_off_prop(type, craft, res)
else:
res.error(Error.PARAM_ERR)
return res.__dict__
async def find_course_selective(current_user: User = Depends(get_current_active_user),
request: FindCourseListRequest = Body(None, title="课程筛选条件")):
'''
这是查找课程列表的接口，可以根据id，名称，科目去筛选
'''
sql_exec = find_course_selective_sql_append(request)
result = sql_helper.fetch_all2(sql_exec)
responseVo = ResponseBase()
responseVo.data = {"courses": result}
return responseVo
async def shoulder_process():
res = ResponseBase()
item = ReqShoulderProcess(**request.get_json())
if item.server_ip == None or not valid_ip(item.server_ip):
item.server_ip = request.remote_addr
if item.valid():
up_shoulder_process(item, res)
else:
res.error(Error.PARAM_ERR)
return res.__dict__
async def get_fur_result():
res = ResponseBase()
furnace_id = request.args.get('furnace_id', '')
img_idx = request.args.get('img_idx', '')
furnace_state = request.args.get('furnace_state', '')
model_name = request.args.get('model_name', '')
if furnace_id:
fur_result(furnace_id, img_idx, furnace_state, model_name, res)
else:
res.error(Error.PARAM_ERR)
return res.__dict__
async def update_user(item: ReqUpdateUser):
res = ResponseBase()
# 校验 token
admin = token2user(item.token)
if admin != None:
up_user(admin, item, res)
pass
else:
res.error(Error.TOKEN_OT)
pass
return res
async def get_fur_result(fur_series: str = '',
fur_id: str = '',
device_state: str = '',
model_name: str = ''):
res = ResponseBase()
if fur_id and fur_series:
fur_result(fur_series, fur_id, device_state, model_name, res)
pass
else:
res.error(Error.PARAM_ERR)
return res
def login(item: ReqLogin, res: ResponseBase):
# denglu
data = {'token': '', 'account': '', 'type': 0}
try:
search_col = {'username': item.username, 'state': 1}
user_dict = mongo_session.select_one_collection(
'user_info', search_col)
if user_dict == None:
res.error(Error.PARAM_ERR, err_msg="用户不存在")
return res
if user_dict['password'] != item.password:
res.error(Error.PARAM_ERR, err_msg="密码错误")
return res
# 成功 更新登录时间
user_dict['login_time'] = datetime.now()
mongo_session.save_collection('user_info', user_dict)
# 生成token
token = get_token(item.username)
data['token'] = token
data['account'] = user_dict['username']
data['type'] = user_dict['type']
print(data)
if user_dict['type'] == 1:
data['server_ip'] = user_dict['server_ip']
# token存入 redis
redis_session.set(token, item.username, 60 * 60)
res.msg = "登录成功"
res.data = data
pass
except Exception as e:
res.error(Error.OPT_ERR)
logger.error(e)
pass
return res
def model_state(server_ip: str, res: ResponseBase):
data = {'model_list': []}
try:
if redis_session.exists(server_ip) == 0:
res.error(Error.NO_DATA)
return res
h = redis_session.hget(server_ip, 'model_list')
if h:
data['model_list'] = json.loads(h)
pass
res.data = data
except Exception as e:
res.error(Error.SERVER_EXCEPTION)
logger.error(e)
pass
return res
async def cyl_process():
res = ResponseBase()
item = ReqCylProcess(**request.get_json())
if item.server_ip == None or not valid_ip(item.server_ip):
item.server_ip = request.remote_addr
up_cyl_process(item, res)
return res.__dict__
async def server_lists():
res = ResponseBase()
ipt = request.args.get('ipt', '')
idx = request.args.get('idx', 0)
size = request.args.get('size', 10)
get_server_lists(res, ipt, idx, size)
return res.__dict__
