def addUpdateEletronicBatchDataStore(PUID, BatchID, ke, val):
try:
oc = db_session.query(EletronicBatchDataStore).filter(
EletronicBatchDataStore.PUID == PUID,
EletronicBatchDataStore.BatchID == BatchID,
EletronicBatchDataStore.Content == ke).first()
if oc == None:
db_session.add(
EletronicBatchDataStore(BatchID=BatchID,
PUID=PUID,
Content=ke,
OperationpValue=val,
Operator=current_user.Name))
else:
oc.Content = ke
oc.OperationpValue = val
oc.Operator = current_user.Name
db_session.commit()
except Exception as e:
db_session.rollback()
print(e)
logger.error(e)
insertSyslog("error", "保存更新EletronicBatchDataStore报错：" + str(e),
current_user.Name)
return json.dumps("保存更新EletronicBatchDataStore报错",
cls=AlchemyEncoder,
ensure_ascii=False)
def userloginauthentication():
'''
用户登陆认证
:return:
'''
try:
if request.method == 'POST':
data = request.values
WorkNumber = data.get('WorkNumber')
password = data.get('password')
# 验证账户与密码
user = db_session.query(User).filter_by(WorkNumber=WorkNumber).first()
resp = make_response()
if user and (user.confirm_password(password) or user.Password == password):
login_user(user) # login_user(user)调用user_loader()把用户设置到db_session中
user.session_id = str(time.time())
user.LastLoginTime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
db_session.commit()
return 'OK'
else:
return '用户名密码错误'
except Exception as e:
print(e)
db_session.rollback()
logger.error(e)
return json.dumps([{"status": "Error:" + str(e)}], cls=AlchemyEncoder, ensure_ascii=False)
def delete(tablename, delete_data):
'''
:param tablename: 要进行删除信息的model
:param recv_data: 要进行更新的数据，数据类型为list，list中的每个元素为需要删除的每条记录的ID
:return: 返回json信息，包含status，message
'''
if hasattr(tablename, '__tablename__'):
try:
jsonstr = json.dumps(delete_data.to_dict())
if len(jsonstr) > 10:
jsonnumber = re.findall(r"\d+\.?\d*", jsonstr)
for key in jsonnumber:
id = int(key)
try:
oclass = db_session.query(tablename).filter_by(ID=id).first()
db_session.delete(oclass)
db_session.commit()
except Exception as ee:
db_session.rollback()
insertSyslog("error", "删除户ID为"+str(id)+"报错Error：" + str(ee), current_user.Name)
return json.dumps("删除用户报错", cls=AlchemyEncoder,ensure_ascii=False)
return 'OK'
except Exception as e:
db_session.rollback()
logger.error(e)
insertSyslog("error", "%s数据删除报错："%tablename + str(e), current_user.Name)
return json.dumps('数据删除失败！')
def PermissionsSave():
if request.method == 'POST':
data = request.values
try:
datastr = json.loads(data.get("data"))
#删除之前的权限
perss = db_session.query(Permission).filter(Permission.WorkNumber == datastr[0].get("WorkNumber")).all()
for pe in perss:
db_session.delete(pe)
db_session.commit()
for i in datastr:
per = Permission()
per.MenuName = i.get("MenuName")
per.MenuType = i.get("MenuType")
per.MenuCode = i.get("MenuCode")
per.Name = i.get("Name")
per.WorkNumber = i.get("WorkNumber")
db_session.add(per)
db_session.commit()
return 'OK'
except Exception as e:
db_session.rollback()
print(e)
logger.error(e)
insertSyslog("error", "添加用户报错Error：" + str(e), current_user.Name)
return json.dumps([{"status": "Error:" + str(e)}], cls=AlchemyEncoder, ensure_ascii=False)
def PermissionsMenus():
if request.method == 'GET':
data = request.values
try:
MenuName = data.get("MenuName")
MenuType = data.get("MenuType")
if MenuName == None:
MenuNames = db_session.query(Permission.MenuName).filter(Permission.WorkNumber == current_user.WorkNumber, Permission.MenuType == MenuType).all()
else:
ParentNode = db_session.query(ModulMenus.ID).filter(ModulMenus.ModulMenuName == MenuName).first()
pmenus = db_session.query(ModulMenus.ModulMenuName).filter(ModulMenus.ParentNode == ParentNode,ModulMenus.MenuType == MenuType).all()
cmenus = db_session.query(Permission.MenuName).filter(Permission.WorkNumber == current_user.WorkNumber).all()
MenuNames = list(set(pmenus).intersection(set(cmenus)))
dir = []
for mn in MenuNames:
meu = db_session.query(ModulMenus).filter(ModulMenus.ModulMenuName == mn).first()
dir.append(meu)
if dir:
dir = sorted(dir, key=lambda aa: aa.ID)
return json.dumps(dir, cls=AlchemyEncoder, ensure_ascii=False)
except Exception as e:
db_session.rollback()
print(e)
logger.error(e)
insertSyslog("error", "添加用户报错Error：" + str(e), current_user.Name)
return json.dumps([{"status": "Error:" + str(e)}], cls=AlchemyEncoder, ensure_ascii=False)
def saverolepermission():
'''
角色添加权限
:return:
'''
if request.method == 'POST':
data = request.values
try:
roleID = data.get("roleID")
permissionIDs = data.get("permissionIDs")
if permissionIDs:
permissionIDs = eval(permissionIDs)
roleclass = db_session.query(Role).filter(Role.ID == int(roleID)).first()
sql = "delete from RolePermission where RoleID = " + roleID
db_session.execute(sql)
db_session.commit()
for pid in permissionIDs:
permissioncalss = db_session.query(Permission).filter(Permission.ID == int(pid)).first()
rpclas = db_session.query(RolePermission).filter(RolePermission.RoleID == roleclass.ID, RolePermission.PermissionID == permissioncalss.ID).first()
if not rpclas:
rp = RolePermission()
rp.RoleID = roleclass.ID
rp.RoleName = roleclass.RoleName
rp.PermissionID = permissioncalss.ID
rp.PermissionName = permissioncalss.PermissionName
db_session.add(rp)
db_session.commit()
return json.dumps("OK", cls=AlchemyEncoder, ensure_ascii=False)
except Exception as e:
db_session.rollback()
print(e)
logger.error(e)
insertSyslog("error", "角色添加权限Error：" + str(e), current_user.Name)
def UpdateUser():
if request.method == 'POST':
data = request.values
str = request.get_json()
try:
json_str = json.dumps(data.to_dict())
if len(json_str) > 10:
id = int(data['ID'])
user = db_session.query(User).filter_by(id=id).first()
user.Name = data['Name']
user.WorkNumber = data['WorkNumber']
ocal = db_session.query(User).filter(User.WorkNumber == user.WorkNumber).first()
if ocal != None:
if ocal.id != id:
return "工号重复，请重新修改！"
user.Password = user.password(data['Password'])
user.OrganizationName = data['OrganizationName']
user.RoleName = data['RoleName']
db_session.commit()
return 'OK'
except Exception as e:
db_session.rollback()
print(e)
logger.error(e)
insertSyslog("error", "更新用户报错Error：" + str(e), current_user.Name)
return json.dumps([{"status": "Error:" + str(e)}], cls=AlchemyEncoder, ensure_ascii=False)
def addUser():
if request.method == 'POST':
data = request.values
str = request.get_json()
try:
json_str = json.dumps(data.to_dict())
if len(json_str) > 10:
user = User()
user.WorkNumber=data['WorkNumber']
ocal = db_session.query(User).filter(User.WorkNumber == user.WorkNumber).first()
if ocal != None:
return "工号重复，请重新录入！"
user.Name=data['Name']
user.Password=user.password(data['Password'])
# print(user.Password)
user.Status="1" # 登录状态先设置一个默认值1：已登录，0：未登录
user.Creater=current_user.Name
user.CreateTime=datetime.datetime.now()
user.LastLoginTime=datetime.datetime.now()
user.IsLock='false' # data['IsLock'],
user.OrganizationName=data['OrganizationName']
user.RoleName=data['RoleName']
db_session.add(user)
db_session.commit()
return 'OK'
except Exception as e:
db_session.rollback()
print(e)
logger.error(e)
insertSyslog("error", "添加用户报错Error：" + str(e), current_user.Name)
return json.dumps([{"status": "Error:" + str(e)}], cls=AlchemyEncoder, ensure_ascii=False)
def allUnitDataMutual():
if request.method == 'POST':
data = request.values
data = data.to_dict()
try:
for key in data.keys():
if key == "Name":
continue
if key == "BatchID":
continue
val = data.get(key)
addUpdateEletronicBatchDataStore(data.get("Name"),
data.get("BatchID"), key, val)
return 'OK'
except Exception as e:
db_session.rollback()
print(e)
logger.error(e)
insertSyslog("error", "所有工艺段保存查询操作报错Error：" + str(e),
current_user.Name)
return json.dumps([{
"status": "Error：" + str(e)
}],
cls=AlchemyEncoder,
ensure_ascii=False)
if request.method == 'GET':
data = request.values
try:
json_str = json.dumps(data.to_dict())
if len(json_str) > 2:
PUID = data['Name']
BatchID = data['BatchID']
oclasss = db_session.query(EletronicBatchDataStore).filter(
EletronicBatchDataStore.BatchID == BatchID,
EletronicBatchDataStore.PUID == PUID).all()
dic = {}
for oclass in oclasss:
dic[oclass.Content] = oclass.OperationpValue
return json.dumps(dic, cls=AlchemyEncoder, ensure_ascii=False)
except Exception as e:
db_session.rollback()
print(e)
logger.error(e)
insertSyslog("error", "所有工艺段保存查询操作报错Error：" + str(e),
current_user.Name)
return json.dumps([{
"status": "Error：" + str(e)
}],
cls=AlchemyEncoder,
ensure_ascii=False)
def OperatorCheckSaveUpdate():
'''操作人检查人确认'''
if request.method == 'GET':
data = request.values
try:
ConfirmFlow = data.get("ConfirmFlow")
BatchNum = data.get("BatchNum")
Confirmer = data.get("Confirmer")
key = data.get("key")
oclass = db_session.query(FlowConfirm).filter(
FlowConfirm.BatchNum == BatchNum,
FlowConfirm.key == key).first()
if oclass == None or oclass == "":
db_session.add(
FlowConfirm(BatchNum=BatchNum,
ConfirmFlow=ConfirmFlow,
Confirmer=Confirmer,
ConfirmTime=datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S'),
key=key))
db_session.add(
AuditTrace(Operation=ConfirmFlow,
DeitalMSG="用户：" + Confirmer + " 节点：" +
ConfirmFlow + "确认",
ReviseDate=datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S'),
User=current_user.Name))
else:
oclass.Confirmer = Confirmer
oclass.UpdateTime = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
db_session.add(
AuditTrace(Operation=ConfirmFlow + "修改",
DeitalMSG="用户：" + Confirmer + " 节点：" +
ConfirmFlow + "修改",
ReviseDate=datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S'),
User=current_user.Name))
db_session.commit()
return 'OK'
except Exception as e:
db_session.rollback()
print(e)
logger.error(e)
insertSyslog("error", "/OperatorCheckSaveUpdate报错：" + str(e),
current_user.Name)
return json.dumps("保存更新EletronicBatchDataStore报错",
cls=AlchemyEncoder,
ensure_ascii=False)
def selectrole():
'''
查询角色
:return:
'''
try:
if request.method == 'POST':
data = request.values
ID = data.get("ID")
oclass = db_session.query(Role).filter(Role.ID == ID).first()
return json.dumps(oclass, cls=AlchemyEncoder, ensure_ascii=False)
except Exception as e:
print(e)
db_session.rollback()
logger.error(e)
return json.dumps([{"status": "Error:" + str(e)}], cls=AlchemyEncoder, ensure_ascii=False)
def insertSyslog(operationType, operationContent, userName):
try:
if operationType == None: operationType = ""
if operationContent == None:
operationContent = ""
else:
operationContent = str(operationContent)
if userName == None: userName = ""
ComputerName = socket.gethostname()
db_session.add(
SysLog(OperationType=operationType, OperationContent=operationContent,OperationDate=datetime.datetime.now(), UserName=userName,
ComputerName=ComputerName, IP=socket.gethostbyname(ComputerName)))
db_session.commit()
except Exception as e:
db_session.rollback()
print(e)
logger.error(e)
def addrole():
'''
添加角色
:return:
'''
try:
if request.method == 'POST':
role = Role()
role.RoleName = "角色名字"
role.Description = ""
role.RoleCode = "角色编码"
db_session.add(role)
db_session.commit()
except Exception as e:
print(e)
db_session.rollback()
logger.error(e)
return json.dumps([{"status": "Error:" + str(e)}], cls=AlchemyEncoder, ensure_ascii=False)
def login():
try:
if request.method == 'GET':
return render_template('./main/login.html')
if request.method == 'POST':
data = request.values
work_number = data.get('WorkNumber')
password = data.get('password')
# 验证账户与密码
user = db_session.query(User).filter_by(
WorkNumber=work_number).first()
if user and (user.confirm_password(password)
or user.Password == password):
login_user(
user) # login_user(user)调用user_loader()把用户设置到db_session中
# 查询用户当前菜单权限
roles = db_session.query(
User.RoleName).filter_by(WorkNumber=work_number).all()
menus = []
for role in roles:
for index in role:
role_id = db_session.query(
Role.ID).filter_by(RoleName=index).first()
menu = db_session.query(Menu.ModuleCode).join(
Role_Menu,
isouter=True).filter_by(Role_ID=role_id).all()
for li in menu:
menus.append(li[0])
session['menus'] = menus
return redirect('/')
# 认证失败返回登录页面
error = '用户名或密码错误'
return render_template('./main/login.html', error=error)
except InvalidRequestError:
db_session.rollback()
except Exception as e:
print(e)
logger.error(e)
return json.dumps([{
"status": "Error:" + str(e)
}],
cls=AlchemyEncoder,
ensure_ascii=False)
def saveuserusershiftsgroup():
'''
用户添加班组
:return:
'''
if request.method == 'POST':
data = request.values
try:
userID = data.get("userID")
shiftsgroupIDs = data.get("shiftsgroupIDs")
if shiftsgroupIDs:
shiftsgroupIDs = eval(shiftsgroupIDs)
userclass = db_session.query(User).filter(
User.ID == int(userID)).first()
sql = "delete from usershiftsgroup where UserID = " + userID
db_session.execute(sql)
db_session.commit()
for pid in shiftsgroupIDs:
shiftsgroupcalss = db_session.query(ShiftsGroup).filter(
ShiftsGroup.ID == int(pid)).first()
rpclas = db_session.query(UserShiftsGroup).filter(
UserShiftsGroup.UserID == userclass.ID,
UserShiftsGroup.ShiftsGroupID ==
shiftsgroupcalss.ID).first()
if not rpclas:
rp = UserShiftsGroup()
rp.UserID = userclass.ID
rp.Name = userclass.Name
rp.ShiftsGroupID = shiftsgroupcalss.ID
rp.ShiftsGroupName = shiftsgroupcalss.ShiftsGroupName
db_session.add(rp)
db_session.commit()
return json.dumps("OK", cls=AlchemyEncoder, ensure_ascii=False)
except Exception as e:
db_session.rollback()
print(e)
logger.error(e)
insertSyslog("error", "角色添加权限Error：" + str(e), current_user.Name)
def saveroleuser():
'''
用户添加角色
:return:
'''
if request.method == 'POST':
data = request.values
try:
UserID = data.get("UserID")
RoleIDs = data.get("RoleIDs")
if RoleIDs:
RoleIDs = eval(RoleIDs)
userclass = db_session.query(User).filter(
User.ID == int(UserID)).first()
sql = "delete from RoleUser where UserID = " + UserID
db_session.execute(sql)
db_session.commit()
for pid in RoleIDs:
rolecalss = db_session.query(Role).filter(
Role.ID == int(pid)).first()
rpclas = db_session.query(RoleUser).filter(
RoleUser.UserID == userclass.ID,
RoleUser.RoleID == rolecalss.ID).first()
if not rpclas:
rp = RoleUser()
rp.UserID = userclass.ID
rp.UserName = userclass.Name
rp.RoleID = rolecalss.ID
rp.RoleName = rolecalss.RoleName
db_session.add(rp)
db_session.commit()
return json.dumps("OK", cls=AlchemyEncoder, ensure_ascii=False)
except Exception as e:
db_session.rollback()
print(e)
logger.error(e)
insertSyslog("error", "用户添加角色Error：" + str(e), current_user.Name)
def login():
try:
if request.method == 'GET':
return render_template('./main/login.html')
if request.method == 'POST':
data = request.values
WorkNumber = data.get('WorkNumber')
password = data.get('password')
# 验证账户与密码
if WorkNumber:
user = db_session.query(User).filter_by(WorkNumber=WorkNumber).first()
if user and (user.confirm_password(password) or user.Password == password):
login_user(user) # login_user(user)调用user_loader()把用户设置到db_session中
user.session_id = str(time.time())
db_session.commit()
# roles = db_session.query(User.RoleName).filter_by(WorkNumber=WorkNumber).all()
# menus = []
# for role in roles:
# for index in role:
# role_id = db_session.query(Role.ID).filter_by(RoleName=index).first()
# menu = db_session.query(Menu.ModuleCode).join(Role_Menu, isouter=True).filter_by(Role_ID=role_id).all()
# for li in menu:
# menus.append(li[0])
# session['menus'] = menus
# user.Status = "1"
# db_session.commit()
use = db_session.query(User).filter_by(WorkNumber=WorkNumber).first()
# return redirect('/')
return render_template('./main/heatmap.html')
# 认证失败返回登录页面
error = '用户名或密码错误'
return render_template('./main/login.html', error=error)
except Exception as e:
print(e)
db_session.rollback()
logger.error(e)
return json.dumps([{"status": "Error:" + str(e)}], cls=AlchemyEncoder, ensure_ascii=False)
def update(tablename, new_data):
'''
:param tablename:要进行更新的model
:param new_data: 要进行更新的数据，数据类型为dict，key为model的字段属性，value为要更新的值
:return: 返回json信息，包含status，message
'''
if hasattr(tablename, '__tablename__'):
if isinstance(new_data, dict) and len(new_data) > 0:
try:
oclass = db_session.query(tablename).filter(tablename.ID==new_data['ID']).first()
if oclass:
for key in new_data:
if hasattr(oclass, key) and key != 'ID':
setattr(oclass, key, new_data[key])
db_session.add(oclass)
db_session.commit()
return 'OK'
else:
return json.dumps('当前记录不存在！', cls=AlchemyEncoder, ensure_ascii=False)
except Exception as e:
db_session.rollback()
logger.error(e)
insertSyslog("error", "%s数据更新报错："%tablename + str(e), current_user.Name)
return json.dumps('数据更新失败！', cls=AlchemyEncoder, ensure_ascii=False)
def insert(tablename, data):
'''
:param tablename: 要进行插入数据的model
:param insert_dict: 要进行插入的数据，数据类型为dict，key为model的字段属性，value为要插入的值
:return: 返回json信息，包含status，message
'''
if hasattr(tablename, '__tablename__'):
oclass = tablename()
if isinstance(data, dict) and len(data) > 0:
try:
# if "ID" in data.keys():
# popdata = data.pop("ID")
for key in data:
if key != "ID":
setattr(oclass, key, data[key])
db_session.add(oclass)
db_session.commit()
return 'OK'
except Exception as e:
print(e)
db_session.rollback()
logger.error(e)
insertSyslog("error", "%s数据添加报错："%tablename + str(e), current_user.Name)
return json.dumps('数据添加失败！')
def deleteUser():
if request.method == 'POST':
data = request.values
try:
jsonstr = json.dumps(data.to_dict())
if len(jsonstr) > 10:
jsonnumber = re.findall(r"\d+\.?\d*", jsonstr)
for key in jsonnumber:
id = int(key)
try:
oclass = db_session.query(User).filter_by(id=id).first()
db_session.delete(oclass)
db_session.commit()
except Exception as ee:
db_session.rollback()
print(ee)
insertSyslog("error", "删除户ID为"+string(id)+"报错Error：" + string(ee), current_user.Name)
return json.dumps("删除用户报错", cls=AlchemyEncoder,ensure_ascii=False)
return 'OK'
except Exception as e:
print(e)
logger.error(e)
insertSyslog("error", "删除用户报错Error：" + str(e), current_user.Name)
return json.dumps([{"status": "Error:" + str(e)}], cls=AlchemyEncoder, ensure_ascii=False)
def insertdb_datasummaryanalysis():
'''
数据汇总分析数据写入
:return:
'''
if request.method == 'GET':
data = request.values
try:
CollectDay = data.get("CollectDay")
CollectClass = data.get("CollectClass")
#数据写入----------------------------------------------------------
db_session.commit()
collectdays_list = []
if CollectClass == "day":
collectdays_list.append(CollectDay)
elif CollectClass == "month":
for i in range(calendar.monthrange(int(CollectDay[0:4]), int(CollectDay[5:7]))[1] + 1)[1:]:
collectdays_list.append(CollectDay[0:8]+("0"+str(i) if i<10 else str(i)))
for i in collectdays_list:
if datetime.datetime.strptime(i, '%Y-%m-%d') <= (datetime.datetime.now() - datetime.timedelta(days=1)):
dasoc = db_session.query(DataSummaryAnalysis).filter(DataSummaryAnalysis.CollectionDate == i).first()
if not dasoc:
daysta = i + " 00:00:00"
dayend = i + " 23:59:59"
dsa = DataSummaryAnalysis()
sql = "SELECT SUM(`MB2TCP3.A_ACR_12.Ep_total_q`) AS ConsumptionLfirst,SUM(`MB2TCP3.A_ACR_20.Ep_total_q`) AS ConsumptionLsecond FROM incrementelectrictable WHERE CollectionDate BETWEEN '" \
+ daysta + "' AND '" + dayend + "'"
re = db_session.execute(sql).fetchall()
ConsumptionLfirst = 0
ConsumptionLsecond = 0
for oc in re:
ConsumptionLfirst = 0 if oc["ConsumptionLfirst"] == None or oc["ConsumptionLfirst"] == "" else round(int(oc["ConsumptionLfirst"]),2)
ConsumptionLsecond = 0 if oc["ConsumptionLsecond"] == None or oc["ConsumptionLsecond"] == "" else round(int(oc["ConsumptionLsecond"]))
sql1 = "SELECT AVG(TY_CO2_AVG) AS CarbonDioxideContent,AVG(ZT01_TEMP_AVG) AS PlatformTemperature,AVG(ZT01_SD_AVG) AS PlatformHumidity,AVG(ZT02_TEMP_AVG) AS StationHallTemperature,AVG(ZT02_SD_AVG) AS StationHallHumidity" \
" FROM datahistory WHERE TY_CO2_AVG != 'None' AND TY_CO2_AVG != 'init' AND ZT01_TEMP_AVG != 'None' AND ZT01_TEMP_AVG != 'init' AND ZT01_SD_AVG != 'None' " \
"AND ZT01_SD_AVG != 'init' AND ZT02_TEMP_AVG != 'None' AND ZT02_TEMP_AVG != 'init' AND ZT02_SD_AVG != 'None' AND ZT02_SD_AVG != 'init' AND SampleTime BETWEEN '" + daysta + "' AND '" + dayend + "'"
re1 = db_session.execute(sql1).fetchall()
CarbonDioxideContent = ""
PlatformHumidity = ""
PlatformTemperature = ""
StationHallTemperature = ""
StationHallHumidity = ""
for j in re1:
CarbonDioxideContent = 0 if j["CarbonDioxideContent"] == None else round(float(j["CarbonDioxideContent"]), 2)
PlatformHumidity = 0 if j["PlatformHumidity"] == None else round(float(j["PlatformHumidity"]), 2)
PlatformTemperature = 0 if j["PlatformTemperature"] == None else round(float(j["PlatformTemperature"]), 2)
StationHallTemperature = 0 if j["StationHallTemperature"] == None else round(float(j["StationHallTemperature"]), 2)
StationHallHumidity = 0 if j["StationHallHumidity"] == None else round(float(j["StationHallHumidity"]), 2)
dsa.CollectionDate = i
dsa.CarbonDioxideContent = CarbonDioxideContent
dsa.ConsumptionLfirst = ConsumptionLfirst
dsa.ConsumptionLsecond = ConsumptionLsecond
dsa.ConsumptionLtotal = ConsumptionLsecond + ConsumptionLfirst
dsa.PlatformHumidity = PlatformHumidity
dsa.PlatformTemperature = PlatformTemperature
dsa.StationHallTemperature = StationHallTemperature
dsa.StationHallHumidity = StationHallHumidity
db_session.add(dsa)
db_session.commit()
#数据查询-------------------------------------------------------------
pages = int(data.get("offset")) # 页数
rowsnumber = int(data.get("limit")) # 行数
inipage = pages * rowsnumber + 0 # 起始页
endpage = pages * rowsnumber + rowsnumber # 截止页
if CollectClass == "month":
ocalss = db_session.query(DataSummaryAnalysis).filter(DataSummaryAnalysis.CollectionDate.between(CollectDay[0:7],
CollectDay[0:8]+str(calendar.monthrange(int(CollectDay[0:4]), int(CollectDay[5:7]))[1]))).order_by(desc("ID")).all()[inipage:endpage]
total = db_session.query(DataSummaryAnalysis).filter(
DataSummaryAnalysis.CollectionDate.between(CollectDay[0:7],
CollectDay[0:8] + str(
calendar.monthrange(int(CollectDay[0:4]),
int(CollectDay[5:7]))[1]))).count()
elif CollectClass == "day":
ocalss = db_session.query(DataSummaryAnalysis).filter(
DataSummaryAnalysis.CollectionDate == CollectDay).order_by(desc("ID")).all()[inipage:endpage]
total = db_session.query(DataSummaryAnalysis).filter(
DataSummaryAnalysis.CollectionDate == CollectDay).count()
jsonocalss = json.dumps(ocalss, cls=AlchemyEncoder, ensure_ascii=False)
return '{"total"' + ":" + str(total) + ',"rows"' + ":\n" + jsonocalss + "}"
except Exception as e:
db_session.rollback()
print(e)
logger.error(e)
insertSyslog("error", "数据汇总分析数据写入查询报错Error：" + str(e), current_user.Name)
