def insertRSUDevice(self, data):
s = rsuDeviceManage(self.db)
db = self.getDB("public.device_list")
systemUserID = self.GetSystemUserID()
# 检查序列号是否重复
result = db.findByCond(
"device_sn", "device_sn = '%s' and system_user_id = %d " %
(data['device_sn'], systemUserID))
if len(result['rows']) > 0:
raise BaseError(801, "数据错误：序列号 %s 已经存在！" % data['device_sn'])
# 检查设备编号是否重复
result = db.findByCond(
"device_code", "device_code = '%s' and system_user_id = %d " %
(data['device_code'], systemUserID))
if len(result['rows']) > 0:
raise BaseError(801, "数据错误：设备编号 %s 已经存在！" % data['device_code'])
# 创建设备时默认为未连接状态
data['device_status'] = '5'
data['create_id'] = self.objUserInfo['id']
data['create_time'] = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
data['system_user_id'] = systemUserID
device_id = s.save(data, table='public.device_list')
return device_id
def insertRSUData(self, data):
s = rsuDeviceManage(self.db)
systemUserID = self.GetSystemUserID()
# 检查设备是否是否重复
db = self.getDB("rsu.rsu_list")
result = db.findByCond(
"device_id", "device_id = '%s' and system_user_id = %d " %
(data['device_id'], systemUserID))
if len(result['rows']) > 0:
raise BaseError(801, "数据错误：该设备已经存在！")
# 检查IP地址是否重复
condition = "(ip_address1 = '%s' or ip_address1 = '%s' or ip_address2 = '%s' or ip_address2 = '%s' ) and system_user_id = %d " % (
data['ip_address1'], data['ip_address1'], data['ip_address1'],
data['ip_address2'], systemUserID)
result = db.findByCond("ip_address1", condition)
if len(result['rows']) > 0:
raise BaseError(
801, "数据错误：IP 地址 %s, %s 已经存在！" %
(data['ip_address1'], data['ip_address2']))
data['create_id'] = self.objUserInfo['id']
data['create_time'] = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
data['system_user_id'] = systemUserID
rsu_id = s.save(data, table='rsu.rsu_list')
return rsu_id
def put(self):
alldata = self.getRequestData()
if self.getParam(alldata, "id", 0) == 0:
raise BaseError(801, "必须指定待更新信息的节目栏ID！")
s = programUnitManage(self.db)
lsData = {
'id': 'id',
'name': 'name',
'start_time': 'start_time',
'end_time': 'end_time',
'list_id': 'list_id',
'sort': 'sort',
}
data = {}
for (k, v) in lsData.items():
try:
data[k] = alldata[v]
except:
pass
db = self.getDB("pis.program_unit")
# # 检查名称是否重复
# result = db.findByCond("name", "name = '%s' and id <> %s "%(data['name'], data['id']) )
# if len( result['rows'] ) > 0 :
# raise BaseError(801, "节目栏名称 %s 重复！"%data['name'])
# 检查开始时间和结束时间是否重复
cond = " (start_time < '%s' and end_time > '%s' " % (
data['start_time'], data['end_time'])
cond += " or start_time > '%s' and end_time < '%s' ) and ( id <> %d )" % (
data['start_time'], data['end_time'], data['id'])
cond += " and list_id = %d " % data['list_id']
result = db.findByCond("id", cond)
if len(result['rows']) > 0:
raise BaseError(
801,
"节目栏时间 %s - %s 重复！" % (data['start_time'], data['end_time']))
# # 检查序号是否重复
# result = db.findByCond("id", "sort = %d and list_id = %d and id <> %d"%(data['sort'], data['list_id'], data['id']) )
# if len( result['rows'] ) > 0 :
# raise BaseError(801, "节目栏序号 %d 在节目单中重复！"%data['sort'])
data['update_time'] = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
data['update_id'] = self.objUserInfo['id']
id = s.save(data, data['id'], table='pis.program_unit')
logInfo = "更新节目栏信息：开始时间：%s，结束时间：%s" % (data['start_time'],
data['end_time'])
operation_log(self.db).addLog(self.GetUserInfo(), "programUnitManage",
logInfo, id)
self.response(data)
def delete(self):
alldata = self.getRequestData()
id = self.getParam(alldata, "id", 0)
unit_id = self.getParam(alldata, "unit_id", 0)
if id == 0 and unit_id == 0:
raise BaseError(801, "参数错误：必须指定待更删除的节目ID！")
if id > 0:
# 删除单个节目记录，不删除文件
logInfo = deleteProgramFile(self, alldata['list_id'],
alldata['unit_id'], id, alldata)
elif unit_id > 0:
# 删除节目记录
logInfo = deleteProgramFile(self, alldata['list_id'],
alldata['unit_id'], 0, alldata)
else:
raise BaseError(801, "参数错误：必须指定待更删除的节目ID或节目栏ID！")
# 记录日志并退出
operation_log(self.db).addLog(self.GetUserInfo(), "programInfo",
logInfo, id)
self.response(id)
def delete(self):
alldata = self.getRequestData()
s = programUnitManage(self.db)
unit_id = self.getParam(alldata, "id", 0)
if unit_id == 0:
raise BaseError(801, "必须指定待更删除的节目栏ID！")
list_id = self.getParam(alldata, "list_id", 0)
if list_id == 0:
raise BaseError(801, "必须指定待更删除车站归属的运营线路ID！")
# 不删除节目栏归属的节目信息
# programInfo.deleteProgramFile(self, list_id, unit_id, 0, alldata)
logInfo = "删除节目栏：开始时间：%s, 结束时间：%s" % (alldata['start_time'],
alldata['end_time'])
# 删除节目栏记录
s.remove(unit_id, table="pis.program_unit", key="id", delete=True)
# 记录日志并退出
operation_log(self.db).addLog(self.GetUserInfo(), "programUnitManage",
logInfo, unit_id)
self.response(unit_id)
def post(self):
alldata = self.getRequestData()
s = rsuProjectManage(self.db)
lsData = {
'project_name' : 'project_name',
'project_amount': 'project_amount',
'sign_date' : 'sign_date',
'sign_addr' : 'sign_addr',
'parta_id' : 'parta_id',
'parta_code' : 'parta_code',
'parta_man_name': 'parta_man_name',
'parta_title' : 'parta_title',
'partb_id' : 'partb_id',
'partb_code' : 'partb_code',
'partb_man_name': 'partb_man_name',
'partb_title' : 'partb_title',
}
data = {}
for (k, v) in lsData.items():
try:
data[k] = alldata[v]
except:
pass
# LogI("RSU 项目信息：", data)
system_user_id = self.GetSystemUserID()
db = self.getDB("rsu.rsu_project")
# 只对比记录状态为正常的记录
# 检查合同名称是否重复
result = db.findByCond("project_name", "project_name = '%s' "%(data['project_name']))
if len( result['rows'] ) > 0 :
raise BaseError(801, "数据错误：合同 %s 已经存在！"%data['project_name'])
# 检查合同编号是否重复
result = db.findByCond("parta_code", "parta_code = '%s' and system_user_id = %d"%(data['parta_code'], system_user_id))
if len( result['rows'] ) > 0 :
raise BaseError(801, "数据错误：甲方合同编号 %s 已经存在！"%data['parta_code'])
result = db.findByCond("partb_code", "partb_code = '%s' and system_user_id = %d"%(data['partb_code'], system_user_id))
if len( result['rows'] ) > 0 :
raise BaseError(801, "数据错误：乙方合同编号 %s 已经存在！"%data['partb_code'])
data['create_id'] = self.objUserInfo['id']
data['create_time'] = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
data['system_user_id'] = self.GetSystemUserID()
id = s.save(data, table = 'rsu.rsu_project')
# 创建项目成功，记录日志并退出
operation_log(self.db).addLog(self.GetUserInfo(), "rsuProjectManage",
"%s 创建 RSU 项目：%s"%(self.objUserInfo['name'], data['project_name']), id)
self.response(id)
def delete(self):
fileInfo = self.getRequestData()
s = program_file(self.db)
id = self.getParam(fileInfo, "id", 0)
if id == 0:
raise BaseError(801, "参数错误：缺少待更删除的节目文件ID！")
filename = self.getParam(fileInfo, "file_name", "")
if filename == "":
raise BaseError(801, "参数错误：缺少待更删除的节目文件名称！")
filePath = self.getParam(fileInfo, "file_path", "")
if filePath == "":
raise BaseError(801, "参数错误：缺少待更删除的节目文件路径！")
logInfo = "%s 删除节目文件：名称：%s" % (self.objUserInfo['name'], filename)
# 删除节目文件记录
s.remove(id, table="pis.program_file", key="id", delete=True)
# 删除节目文件
# logI("删除文件:%s"%filePath)
if os.path.exists(filePath):
os.remove(filePath)
# 记录日志并退出
operation_log(self.db).addLog(self.GetUserInfo(), "programFileManage",
logInfo, id)
self.response(id)
def post(self):
alldata = self.getRequestData()
s = gpsModuleManage(self.db)
lsData = {
'name': 'name',
'code': 'code',
'serial_no': 'serial_no',
'device_type': 'device_type',
'vendor': 'vendor',
'mac_addr': 'mac_addr',
'install_date': 'install_date',
'install_batch': 'install_batch',
'install_type': 'install_type',
'install_id': 'install_id',
}
data = {}
for (k, v) in lsData.items():
try:
data[k] = alldata[v]
except:
pass
# LogI("定位模块信息：", data)
db = self.getDB("iot.gps_module")
# 检查定位模块名称是否重复
result = db.findByCond("name", "name = '%s'" % (data['name']))
if len(result['rows']) > 0:
raise BaseError(801, "数据错误：定位模块名称 %s 已经存在！" % data['name'])
# 检查定位模块编号是否重复
result = db.findByCond("code", "code = '%s'" % (data['code']))
if len(result['rows']) > 0:
raise BaseError(801, "数据错误：定位模块编号 %s 已经存在！" % data['code'])
# 检查定位模块MAC地址是否重复
result = db.findByCond("mac_addr",
"mac_addr = '%s'" % (data['mac_addr']))
if len(result['rows']) > 0:
raise BaseError(801, "数据错误：定位模块MAC地址 %s 已经存在！" % data['mac_addr'])
data['create_id'] = self.objUserInfo['id']
data['create_time'] = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
id = s.save(data, table='iot.gps_module')
# 创建定位模块成功，记录日志并退出
operation_log(self.db).addLog(
self.GetUserInfo(), "gpsModuleManage",
"%s 创建定位模块：名称：%s，编号：%s，MAC地址：%s" %
(self.objUserInfo['name'], data['name'], data['code'],
data['mac_addr']), id)
self.response(id)
def patch(self):
alldata = self.getRequestData()
stationID = self.getParam(alldata, "sid", 0)
if stationID == 0:
raise BaseError(801, "参数错误：缺少车站ID！")
op = self.getParam(alldata, "op", "")
if op == "":
raise BaseError(801, "必须指定操作模式！")
# 返回的数据
data = {}
if op == "line" or op == "both":
# 运营线路列表
sql = "select ol.id, ol.name "
sql += " from pis.operation_line ol"
sql += " inner join pis.station_line st on st.station_id = %d and st.line_id = ol.id" % stationID
sql += " order by ol.code"
cur = self.db.getCursor()
cur.execute(sql)
rows = cur.fetchall()
lineList = {}
lineList['struct'] = "id, name"
lineList['rows'] = rows
data['lineList'] = lineList
if op == "data" or op == "both":
# 获取指定车站开行信息
cur = self.db.getCursor()
sql = "select sl.id, sl.line_id, sl.station_id, sl.sort, sl.up_start_time, sl.up_end_time, "
sql += " sl.down_start_time, sl.down_end_time, ol.name "
sql += " from pis.station_line sl"
sql += " inner join pis.operation_line ol on ol.id = sl.line_id"
sql += " where sl.station_id = %s" % stationID
sql += " order by sl.sort"
cur.execute(sql)
rows = cur.fetchall()
selectedLineList = {}
selectedLineList[
'struct'] = "id, line_id, station_id, sort, up_start_time, up_end_time, "
selectedLineList[
'struct'] += "down_start_time, down_end_time, name"
selectedLineList['rows'] = rows
data['selectedLineList'] = selectedLineList
self.response(data)
def UpdateSubLineInfo(self, lid):
if lid == 0:
raise BaseError(801, "参数错误，无线路编号！")
# 获取支线信息
sql = """
select sli.id, sli.line_id, sli.sub_line_name, sli.sub_line_name_en, sli.up_start_station, stus.name, stus.name_en, sli.up_end_station, stue.name, stue.name_en,
sli.down_start_station, stds.name, stds.name_en, sli.down_end_station, stde.name, stde.name_en, sli.up_start_time, sli.up_end_time,
sli.down_start_time, sli.down_end_time from pis.sub_line_info sli
inner join pis.station stus on stus.id = sli.up_start_station
inner join pis.station stue on stue.id = sli.up_end_station
inner join pis.station stds on stds.id = sli.down_start_station
inner join pis.station stde on stde.id = sli.down_end_station
where sli.line_id = %d
""" % lid
cur = self.db.getCursor()
cur.execute(sql)
rows = cur.fetchall()
key = [
'id', 'line_id', 'sub_line_name', 'sub_line_name_en',
'up_start_station', 'up_start_station_name',
'up_start_station_name_en', 'up_end_station',
'up_end_station_name', 'up_end_station_name_en',
'down_start_station', 'down_start_station_name',
'down_start_station_name_en', 'down_end_station',
'down_end_station_name', 'down_end_station_name_en',
'up_start_time', 'up_end_time', 'down_start_time', 'down_end_time'
]
subLineList = []
for item in rows:
subLineInfo = dict(zip(key, item))
subLineList.append(subLineInfo)
msgInfo = {
'msgType': 'line_info',
'lineInfo': subLineList,
}
# 只发送给在线的控制器，非在线控制器在启动时会获取到最新的支线信息
db = self.getDB("pis.controller")
result = db.findByCond("id,code,ip_address,install_type",
"line_id=%d and status = '0' " % lid)
items = dbResultToDict(result)
if len(items) == 0:
raise BaseError(801, "系统错误：无控制器， %d" % lid)
msgInfo['controllerList'] = items
SendMsgToController(self, msgInfo)
return
def InsertProgramInfo(self, lid, uid, file_name, duration, sort):
cur = self.db.getCursor()
# 检查节目文件是否已经存在
sql = "select file_name, file_path from pis.program_file where file_name = '%s'" % file_name
cur.execute(sql)
# logI("查询：%s"%sql)
rows = cur.fetchall()
if len(rows) == 0:
raise BaseError(801, "节目单中文件 %s 不存在，请先上传该文件!" % file_name)
# 文件类型是否支持
filenameItem = file_name.split(".")
itemLen = len(filenameItem)
if itemLen < 2:
raise BaseError(801, "文件名 %s 无扩展名" % file_name)
filetype = filenameItem[itemLen - 1]
if filetype.lower() not in PisConfig['videoType']:
raise BaseError(801, "节目文件 %s 类型不是mp4文件！" % file_name)
filePath = rows[0][1]
fileName = os.path.basename(filePath)
fileInfo = {}
fileInfo['name'] = file_name
fileInfo['list_id'] = lid
fileInfo['unit_id'] = uid
fileInfo['program_type'] = filetype.upper()
fileInfo['file_name'] = fileName
fileInfo['file_path'] = filePath
fileInfo['sort'] = sort
fileInfo['duration'] = duration
sort = sort + 1
fileInfo['program_source'] = ""
fileInfo['uploader_id'] = self.objUserInfo['id']
fileInfo['uploader_name'] = self.objUserInfo['name']
fileInfo['upload_date'] = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
fileInfo['create_time'] = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
fileInfo['create_id'] = self.objUserInfo['id']
s = programUnitManage(self.db)
id = s.save(fileInfo, table='pis.program_info')
fileInfo['code'] = id
s.save(fileInfo, id, table='pis.program_info')
# 记录日志
logInfo = "%s 上传了节目文件：名称：%s" % (self.objUserInfo['name'], file_name)
operation_log(self.db).addLog(self.GetUserInfo(), "programFile",
logInfo, id)
def put(self):
alldata = self.getRequestData()
if self.getParam(alldata, "id", 0) == 0:
raise BaseError(801, "必须指定待更新信息的车辆ID！")
if self.getParam(alldata, "code", 0) == 0:
raise BaseError(801, "必须指定待更新信息的车辆编码！")
s = vehicleManage(self.db)
lsData = {
'id': 'id',
'name': 'name',
'code': 'code',
'serial_no': 'serial_no',
'type': 'type',
'default_count': 'default_count',
'train_id': 'train_id',
'description': 'description',
}
data = {}
for (k, v) in lsData.items():
try:
data[k] = alldata[v]
except:
pass
# 检查车站名称是否重复
db = self.getDB("pis.vehicle")
result = db.findByCond(
"serial_no",
"serial_no = '%s' and id <> %s " % (data['serial_no'], data['id']))
if len(result['rows']) > 0:
raise BaseError(801, "车辆序列号 %s 重复！" % data['serial_no'])
# 检查车辆编号是否重复
result = db.findByCond(
"code", "code = '%s' and id <> %s " % (data['code'], data['id']))
if len(result['rows']) > 0:
raise BaseError(801, "车辆编号 %s 已经存在！" % data['code'])
data['update_time'] = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
data['update_id'] = self.objUserInfo['id']
id = s.save(data, data['id'], table='pis.vehicle')
logInfo = "更新车辆信息：名称：%s，编号：%s" % (data['name'], data['code'])
operation_log(self.db).addLog(self.GetUserInfo(), "vehicleManage",
logInfo, id)
self.response(id)
def sendMessageToDevice(self, paramData):
msgType = self.getParam(paramData, "msgType", "")
if msgType == "":
raise BaseError(801, "参数错误：缺少消息类别")
deviceList = self.getParam(paramData, "deviceList", [])
if len(deviceList) == 0:
raise BaseError(801, "参数错误：无设备列表!")
deviceList = self.getDeviceList(deviceList)
logInfo = ""
data = {}
if msgType == "update":
data['message_type'] = RSU_MSG_UpdateSoftware
file_name = self.getParam(paramData, "file_name", "")
if file_name == "":
raise BaseError(801, "参数错误：无版本文件名称！")
file_path = self.getParam(paramData, "file_path", "")
if file_path == "":
raise BaseError(801, "参数错误：无版本文件路径！")
data['file_name'] = file_name
data['file_path'] = file_path
data['updateMode'] = self.getParam(paramData, "UpdateMode", 0)
logInfo = "%s Send RSU_MSG_UpdateSoftware to device, filename: %s" % (
self.objUserInfo['name'], file_name)
elif msgType == "reboot":
data['message_type'] = RSU_MSG_Reboot
data['delay_second'] = self.getParam(paramData, "delay_second", 0)
data['reboot_mode'] = self.getParam(paramData, "rebootMode", 1)
if data['reboot_mode'] == 0:
modeStr = "Reboot Application"
else:
modeStr = "Reboot System"
logInfo = "%s Send RSU_MSG_Reboot to device, RebootMode: %s, DelayTime: %d" % (
self.objUserInfo['name'], modeStr, data['delay_second'])
# 操作日志
operation_log(self.db).addLog(self.GetUserInfo(), "rsuDeviceManage",
logInfo, 0)
_thread.start_new_thread(self.SendMessage, (
deviceList,
data,
))
self.response(0)
def patch(self):
paramData = self.getRequestData()
op = self.getParam(paramData, "op", "")
if op == "":
raise BaseError(801, "参数错误：缺少操作模式参数OP")
cur = self.db.getCursor()
if op == "list":
# 返回的数据
data = {}
# 版式文件列表
sql = "select pf.id, pf.file_name "
sql += " from pis.program_file pf"
sql += " order by pf.file_name"
cur.execute(sql)
rows = cur.fetchall()
nameList = {}
nameList['struct'] = "id, name"
nameList['rows'] = [(
0,
"选择全部",
)] + rows
data['nameList'] = nameList
# 上传人员列表
sql = "select a.id, a.name "
sql += " from system.account a"
sql += " where a.id = (select distinct(uploader_id) from pis.program_file) "
sql += " order by a.id"
cur.execute(sql)
rows = cur.fetchall()
uploaderList = {}
uploaderList['struct'] = "id, name"
uploaderList['rows'] = [(
'0',
"选择全部",
)] + rows
data['uploaderList'] = uploaderList
self.response(data)
else:
raise BaseError(801, "参数错误：操作类型参数OP值错误！")
def addLog2(self, userInfo, logData):
if not logData['operator_id'] or not logData['menu_code'] or not logData['operation_context'] or not logData['operation_id']:
raise BaseError(801)
logData['system_user_id'] = userInfo['system_user_id']
logData['create_time']=time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(time.time()))
id = self.save(logData, table='system.operation_log')
if id <= 0:
raise BaseError(703)
return True
def post(self):
alldata = self.getRequestData()
s = vehicleManage(self.db)
lsData = {
'name': 'name',
'code': 'code',
'serial_no': 'serial_no',
'type': 'type',
'default_count': 'default_count',
'train_id': 'train_id',
'description': 'description',
}
data = {}
for (k, v) in lsData.items():
try:
data[k] = alldata[v]
except:
pass
# 检查车辆编号是否重复
db = self.getDB("pis.vehicle")
result = db.findByCond("code", "code = '%s' " % data['code'])
if len(result['rows']) > 0:
raise BaseError(801, "车辆编号 %s 已经存在！" % data['code'])
# 检查序列号是否重复
result = db.findByCond("serial_no",
"serial_no = '%s' " % data['serial_no'])
if len(result['rows']) > 0:
raise BaseError(801, "车辆序列号 %s 已经存在！" % data['serial_no'])
# 新建车站
data['create_id'] = self.objUserInfo['id']
data['create_time'] = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
# 创建车站记录
vid = s.save(data, table='pis.vehicle')
# 创建车辆成功，记录日志并退出
operation_log(self.db).addLog(
self.GetUserInfo(), "vehicleManage",
"创建车辆信息：名称：%s，编号：%s" % (data['name'], data['code']), vid)
self.response(vid)
def patch(self):
alldata = self.getRequestData()
op = self.getParam(alldata, "op", "")
if op == "":
raise BaseError(801, "必须指定操作模式！")
if op == "train":
# 列车列表
# 返回的数据
data = {}
sql = "select t.id, t.name "
sql += " from pis.train t"
sql += " order by t.code"
cur = self.db.getCursor()
cur.execute(sql)
rows = cur.fetchall()
# logI("列车", sql, rows)
trainList = {}
trainList['struct'] = "id, name"
trainList['rows'] = rows
data['trainList'] = trainList
self.response(data)
# elif op == "data":
# # 获取所有列车的车辆、控制器信息
# trainList = self.getTrainList()
# treeTreeNode = {}
# treeTreeNode['name'] = "列车列表"
# treeTreeNode['children'] = trainList
# treeTreeNode['chkDisabled'] = True
# treeTreeNode['open'] = True
# treeTreeNode['checked'] = False
# treeTreeNode['isItem'] = False
# treeTreeNode['nodeType'] = 'root'
# logI("列车：", treeTreeNode)
# self.response(treeTreeNode)
else:
raise BaseError(801, "参数错误：指定的操作类型OP错误！")
def put(self):
alldata = self.getRequestData()
if self.getParam(alldata, "id", 0) == 0:
raise BaseError(801, "参数错误：缺少待更新信息的列车ID！")
line_name = self.getParam(alldata, "name", "")
if line_name == "":
raise BaseError(801, "参数错误，无列车名称！")
s = trainManage(self.db)
# 只能更新列车名称及描述
lsData = {
'id': 'id',
'name': 'name',
'name_en': 'name_en',
# 'code' : 'code',
'description': 'description',
}
data = {}
for (k, v) in lsData.items():
try:
data[k] = alldata[v]
except:
pass
# 检查列车名称是否重复
db = self.getDB("pis.train")
result = db.findByCond(
"name", "(name = '%s' or name_en = '%s') and id <> %s " %
(data['name'], data['name_en'], data['id']))
if len(result['rows']) > 0:
raise BaseError(801, "数据错误：列车名称重复！")
data['update_time'] = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
data['update_id'] = self.objUserInfo['id']
id = s.save(data, data['id'], table='pis.train')
logInfo = "更新列车信息：名称：%s，%s，编号：%s" % (data['name'], data['name_en'],
data['code'])
operation_log(self.db).addLog(self.GetUserInfo(), "trainManage",
logInfo, id)
self.response(id)
def delete(self):
alldata = self.getRequestData()
if self.getParam(alldata, "id", 0) == 0:
raise BaseError(801, "必须指定待删除的公告ID！")
bid = self.getParam(alldata, "id", 0)
s = oaBulletinBoardManager(self.db)
sql = " select bb.title, bb.code from oa.bulletinboard bb "
sql += " where bb.id = %s" % bid
cur = self.db.getCursor()
cur.execute(sql)
rows = cur.fetchall()
logInfo = "删除公告：标题：%s, 编号：%s" % (rows[0][0], rows[0][1])
# 删除记录，将数据移动到历史表中
MoveDeleteRecord("oa", "bulletinboard", bid, self.GetUserID())
# 记录日志并退出
operation_log(self.db).addLog(self.GetUserInfo(),
"BulletinBoardManage", logInfo, bid)
self.response(bid)
def delete(self):
alldata = self.getRequestData()
vid = self.getParam(alldata, "vid", 0)
if vid == 0:
raise BaseError(801, "必须指定待更删除的车辆ID！")
sql = " select v.serial_no, v.code from pis.vechicle v "
sql += " where v.id = %s" % vid
cur = self.db.getCursor()
cur.execute(sql)
rows = cur.fetchall()
logInfo = "删除车辆：序列号：%s, 编号：%s" % (rows[0][0], rows[0][1])
# 删除车辆记录
s.remove(vid, table="pis.vechicle", key="id", delete=True)
# 删除车站安装的控制器信息
# 记录日志并退出
operation_log(self.db).addLog(self.GetUserInfo(), "vehicleManage",
logInfo, sid)
# 重新获取线路的车站列表，以更新站点树
# lineNode = lineManage.getStationList(lid)
self.response(vid)
def delete(self):
alldata = self.getRequestData()
subLineID = self.getParam(alldata, "id", 0)
if subLineID == 0:
raise BaseError(801, "参数错误：缺少待更删除的支线ID！")
sql = " select sli.sub_line_name, sli.line_id from pis.sub_line_info sli "
sql += " where sli.id = %s" % subLineID
cur = self.db.getCursor()
cur.execute(sql)
rows = cur.fetchall()
logInfo = "删除运营支线：名称：%s, 所属运营线路ID： %d" % (rows[0][0], rows[0][1])
s = subLineInfoManage(self.db)
s.remove(subLineID, table="pis.sub_line_info", key="id", delete=True)
# 记录日志并退出
operation_log(self.db).addLog(self.GetUserInfo(), "subLineInfoManage",
logInfo, subLineID)
# 更新支线信息
self.UpdateSubLineInfo(rows[0][1])
self.response(subLineID)
def delete(self):
listInfo = self.getRequestData()
# logI("待删除节目单信息：", listInfo)
id = self.getParam(listInfo, "id", 0)
if id == 0:
raise BaseError(801, "参数错误：缺少待更删除的节目单ID！")
logInfo = "%s 删除节目单及相关节目栏、节目信息：节目单名称：%s, 生效效期：%s" % (
self.objUserInfo['name'], listInfo['name'], listInfo['valid_date'])
# 不删除节目文件
# 删除节目单所有的节目信息
s = programList(self.db)
s.remove(id, table="pis.program_info", key="list_id", delete=True)
# 删除节目栏记录
s.remove(id, table="pis.program_unit", key="list_id", delete=True)
# 删除节目单记录
s.remove(id, table="pis.program_list", key="id", delete=True)
# 记录日志并退出
operation_log(self.db).addLog(self.GetUserInfo(), "programList",
logInfo, id)
self.response(id)
def get(self):
lid = int(self.get_argument('lid', default='0'))
if lid == 0:
raise BaseError(801, "参数错误：缺少线路ID！")
rowdata = {}
cur = self.db.getCursor()
sql = "select t.id, t.create_time, t.update_time, t.create_id, t.update_id, "
sql += " t.name, t.name_en, t.code, t.description, t.line_id, t.sort, ol.name "
sql += " from pis.train t "
sql += " inner join pis.operation_line ol on ol.id = t.line_id"
sql += " where t.line_id = %d" % lid
sql += " order by t.code"
cur.execute(sql)
rows = cur.fetchall()
rowdata[
'struct'] = "id, create_time, update_time, create_id, update_id, name, name_en, code, description, line_id, sort, line_name"
rowdata['rows'] = rows
sql = "select count(*) from pis.train t "
cur.execute(sql)
row = cur.fetchone()
rowdata['count'] = row[0]
trainInfo = {}
trainInfo['trainList'] = rowdata
self.response(trainInfo)
def delete(self):
alldata = self.getRequestData()
tid = self.getParam(alldata, "id", 0)
if tid == 0:
raise BaseError(801, "参数错误：缺少待更删除的列车ID！")
sql = " select t.name, t.code from pis.train t "
sql += " where t.id = %s" % tid
cur = self.db.getCursor()
cur.execute(sql)
rows = cur.fetchall()
logInfo = "删除列车：名称：%s, 编号：%s" % (rows[0][0], rows[0][1])
# 删除列车的控制器
sql = "delete from pis.controller ct where ct.install_id = %d and ct.install_type < '2' " % tid
cur.execute(sql)
s = trainManage(self.db)
# 删除列车记录
s.remove(tid, table="pis.train", key="id", delete=True)
# 记录日志并退出
operation_log(self.db).addLog(self.GetUserInfo(), "trainManage",
logInfo, tid)
self.response(tid)
def get(self):
lid = int(self.get_argument('lid', default='0'))
if lid == 0:
raise BaseError(801, "参数错误：缺少线路ID！")
sql = " select st.id, st.name, st.name_en, st.code, st.type, st.ip_address, st.description, st.status"
sql += " from pis.station st"
sql += " inner join pis.station_line sl on sl.station_id = st.id and sl.line_id =%d" % lid
sid = int(self.get_argument('sid', default='0'))
if sid != 0:
sql += " where st.id = %d" % sid
sql += " order by sl.sort"
cur = self.db.getCursor()
cur.execute(sql)
rows = cur.fetchall()
rowdata = {}
stationList = {}
stationList['rows'] = rows
stationList[
'struct'] = "id, name, name_en, code, type, ip_address, description, status"
sql = "select count(st.id) from pis.station st "
sql += " inner join pis.station_line sl on sl.station_id = st.id and sl.line_id =%d" % lid
cur.execute(sql)
row = cur.fetchone()
stationList['count'] = row[0]
self.response(stationList)
def post(self):
alldata = self.getRequestData()
s = lineManage(self.db)
lsData = {
'name': 'name',
'name_en': 'name_en',
'code': 'code',
'memo': 'memo',
}
data = {}
for (k, v) in lsData.items():
try:
data[k] = alldata[v]
except:
pass
# 检查线路名称是否重复
db = self.getDB("pis.operation_line")
result = db.findByCond(
"name",
"name = '%s' or name_en = '%s' " % (data['name'], data['name_en']))
if len(result['rows']) > 0:
raise BaseError(801, "数据错误：运营线路名称已经存在！")
# 检查线路编号是否重复
db = self.getDB("pis.operation_line")
result = db.findByCond("code", "code = '%s' " % data['code'])
if len(result['rows']) > 0:
raise BaseError(801, "数据错误：运营线路编号已经存在！")
data['create_id'] = self.objUserInfo['id']
data['create_time'] = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
id = s.save(data, table='pis.operation_line')
# 创建线路成功，记录日志并退出
operation_log(self.db).addLog(
self.GetUserInfo(), "lineManage",
"创建运营线路：线路名称：%s，线路编号：%s" % (data['name'], data['code']), id)
self.response(id)
def getFileParam(self, file_path):
fileParam = {}
logI("版式文件路径：", file_path)
xmlFilePath = os.path.abspath(file_path)
try:
tree = ET.parse(xmlFilePath)
# print ("tree type:", type(tree))
# 获得根节点
root = tree.getroot()
except Exception as e: #捕获除与程序退出sys.exit()相关之外的所有异常
logI("parse %s fail!" % file_path)
raise BaseError(801, "参数错误：版式文件ID错误，找不到数据！")
# 背景图片
Background = root.findall("Background")
if len(Background) == 0:
raise BaseError(801, "版式文件格式错误：无背景图片定义！")
item = Background[0]
fileParam['background'] = item.attrib['imagepath']
# 各区域参数
fileParam['vedio'] = self.getParamUnit(root, 'Vedio', flag=False)
fileParam['message'] = self.getParamUnit(root, 'Message')
fileParam['emergency'] = self.getParamUnit(root, 'Emergency')
fileParam['date'] = self.getParamUnit(root, 'Date')
fileParam['week_ch'] = self.getParamUnit(root, 'Week_ch')
fileParam['week_en'] = self.getParamUnit(root, 'Week_en')
fileParam['time'] = self.getParamUnit(root, 'Time')
fileParam['first_Up_Station_ch'] = self.getParamUnit(
root, 'First_Up_Station_ch')
fileParam['last_Up_Station_ch'] = self.getParamUnit(
root, 'Last_Up_Station_ch')
fileParam['first_Up_Time'] = self.getParamUnit(root, 'First_Up_Time')
fileParam['last_Up_Time'] = self.getParamUnit(root, 'Last_Up_Time')
fileParam['first_Down_Time'] = self.getParamUnit(
root, 'First_Down_Time')
fileParam['last_Down_Time'] = self.getParamUnit(root, 'Last_Down_Time')
#logI("版式文件参数:", fileParam)
return fileParam
def post(self):
alldata = self.getRequestData()
s = programList(self.db)
lsData = {
'name': 'name',
'valid_date': 'valid_date',
'video_type': 'video_type',
}
data = {}
for (k, v) in lsData.items():
try:
data[k] = alldata[v]
except:
pass
# 检查名称是否重复
db = self.getDB("pis.program_list")
result = db.findByCond("name", "name = '%s' " % data['name'])
if len(result['rows']) > 0:
raise BaseError(801, "数据错误：节目单名称已经存在！")
data['create_id'] = self.objUserInfo['id']
data['create_time'] = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
# 节目单初始值
data['apply_status'] = '1' # 未提交审核
id = s.save(data, table='pis.program_list')
data['code'] = id
s.save(data, id, table='pis.program_list')
# 创建节目栏
hour = 0
while hour < 24:
unit = {
'list_id': id,
'start_time': "%02d:00:00" % hour,
'end_time': "%02d:59:59" % hour,
'sort': hour - 4,
}
hour += 1
uid = s.save(unit, table="pis.program_unit")
unit['code'] = uid
s.save(unit, uid, table="pis.program_unit")
# 创建节目单成功，记录日志并退出
operation_log(self.db).addLog(
self.GetUserInfo(), "listManage", "%s 创建节目单：名称：%s，生效日期：%s" %
(self.objUserInfo['name'], data['name'], data['valid_date']), id)
self.response(id)
def patch(self):
s = messageListManage(self.db)
paramData = self.getRequestData()
dataType = self.getParam( paramData, 'dt', 'current')
if dataType == "current":
tableName = "pis.message_list"
elif dataType == "history":
tableName = "pis.message_list_history"
else:
raise BaseError(801, "参数错误：查询来源类型错误！")
data = {}
cur = self.db.getCursor()
# 发送方列表
sql = "select distinct(sender_name), sender_id from %s where sender_name is not null order by sender_name"%tableName
cur.execute(sql)
rows = cur.fetchall()
senderList = {
'rows' : [("选择全部", 0, "")] + rows,
'struct' : 'name, id',
}
data['senderList'] = senderList
# 消息类别
sql = "select cv.name, cv.code from system.code_value cv "
sql += " where cv.type_code = 'MESSAGE_TYPE' "
sql += " and to_number(cv.code, '999') < 100 and to_number(cv.code, '999') > 1 "
sql += " and POSITION( 'ACK' in cv.description ) = 0"
sql += " order by cv.sort"
cur.execute(sql)
rows = cur.fetchall()
msgTypeList = {
'rows' : [("选择全部", '0', "")] + rows,
'struct' : 'name, code',
}
data['msgTypeList'] = msgTypeList
# 消息发送状态
sql = "select cv.name, cv.code from system.code_value cv where cv.type_code = 'PROGRAM_SEND_STATUS' order by cv.sort "
cur.execute(sql)
rows = cur.fetchall()
sendStatusList = {
'rows' : [("选择全部", '0', "")] + rows,
'struct' : 'name, code',
}
data['sendStatusList'] = sendStatusList
self.response(data)
def SendMessage(self, deviceList, msgData):
rsuMsgServer = None
for item in SystemModuleList:
if item['name'] == 'rsu':
rsuMsgServer = item['server']
if rsuMsgServer == None:
raise BaseError(801, "系统错误：未加载RSU模块，请检查配置文件！")
rsuMsgServer.sendMessage(deviceList, msgData)
