def exportToExcel(self, rowdata):
key = [
'id', 'create_time', 'update_time', 'create_id', 'update_id',
'code', 'name', 'valid_date', 'apply_id', 'apply_name',
'apply_date', 'checker_id', 'checker_name', 'check_date',
'apply_status', 'video_type', 'sender_id', 'sender_name',
'send_date', 'send_time', 'send_status'
]
messageList = []
for i, item in enumerate(rowdata):
messageInfo = dict(zip(key, item))
messageList.append(messageInfo)
cur = self.db.getCursor()
utils.getDataDict(cur, messageList, "send_status",
"PROGRAM_SEND_STATUS", "send_status_name")
utils.getDataDict(cur, messageList, "apply_status",
"PROGRAM_APPLY_STATUS", "apply_status_name")
data = []
sn = 1
for item in messageList:
if 'send_status_name' not in item:
item['send_status_name'] = "未发送"
if 'apply_status_name' not in item:
item['apply_status_name'] = "未提交"
itemData = []
itemData.append(sn)
sn = sn + 1
itemData.append(item['name']) # 节目单名称
itemData.append(item['valid_date']) # 生效日期
itemData.append(item['apply_name']) # 申请人姓名
itemData.append(item['apply_date']) # 申请日期
itemData.append(item['checker_name'])
itemData.append(item['check_date']) # 审核日期
itemData.append(item['apply_status_name']) # 申请状态
itemData.append(item['sender_name']) # 发送人姓名
itemData.append(item['send_date']) # 发送日期
itemData.append(item['send_time']) # 发送日期
itemData.append(item['send_status_name']) # 发送状态
data.append(itemData)
struct = "SN, 节目单名称, 生效日期, 申请人姓名, 申请日期, 审核人姓名, 审核日期, 申请状态, 发送者姓名, 发送日期, 发送时间, 发送状态"
path = {}
path = excel.createTempFile("xls")
excel.saveExcel(path['path'], struct, data)
logInfo = " %s 下载了节目单清单 " % self.objUserInfo['name']
operation_log(self.db).addLog(self.GetUserInfo(), "listManage",
logInfo, 0)
self.response(path)
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 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):
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 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 put(self):
alldata = self.getRequestData()
s = DataDictTypeManage(self.db)
lsData = {
'id': 'id',
'code': 'code',
'name': 'name',
'status': 'status',
'description': 'description',
}
data = {}
for (k, v) in lsData.items():
try:
data[k] = alldata[v]
except:
pass
# 检查名称是否重复
db = self.getDB("system.code_type")
result = db.findByCond(
"code", "( code = '%s' or name = '%s' ) and id <> %s " %
(data['code'], data['name'], data['id']))
if len(result['rows']) > 0:
raise BaseError(
801,
"数据错误：字典类型编号 %s 或名称 %s 已经存在！" % (data['code'], data['name']))
id = s.save(data, data['id'], table='system.code_type', key='id')
operation_log(self.db).addLog(self.GetUserInfo(), "dictManage",
"更新数据字典信-%s" % data['name'], data['id'])
self.response(data)
def delete(self):
paramData = self.getRequestData()
device_id = self.getParam(paramData, "device_id", 0)
sql = "select dl.device_code, dl.device_name from public.device_list dl where dl.id = %d" % device_id
cur = self.db.getCursor()
cur.execute(sql)
rows = cur.fetchall()
if len(rows) == 0:
self.response(0)
logInfo = "%s 删除设备：%s(%s)" % (self.objUserInfo['name'], rows[0][1],
rows[0][0])
# 删除记录，将数据移动到历史表中
MoveDeleteRecord("public", "device_list", device_id, self.GetUserID())
rsuid = int(self.getParam(paramData, "id", 0))
MoveDeleteRecord("rsu", "rsu_list", rsuid, self.GetUserID())
# 更新成功，记录日志并退出
operation_log(self.db).addLog(self.GetUserInfo(), "rsuDeviceManage",
logInfo, device_id)
self.response(device_id)
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 exportToExcel(self, rowdata):
key = [
'id', 'create_time', 'update_time', 'create_id', 'update_id',
'msg_list_id', 'sender_type', 'sender_name', 'sender_code',
'send_date', 'send_time', 'sender_addr', 'receiver_type',
'receiver_name', 'receiver_code', 'receive_date', 'receive_time',
'receiver_addr', 'message_type', 'message_sn', 'content_type',
'bin_content', 'text_content', 'send_status'
]
messageList = []
for i, item in enumerate(rowdata):
messageInfo = dict(zip(key, item))
messageList.append(messageInfo)
cur = self.db.getCursor()
utils.getDataDict(cur, messageList, "send_status",
"PROGRAM_SEND_STATUS", "send_status_name")
utils.getDataDict(cur, messageList, "message_type",
"MSG_TYPE_CONTROLLER", "message_type_name")
data = []
sn = 1
for item in messageList:
if 'send_status_name' not in item:
item['send_status_name'] = "未发送"
if 'apply_status_name' not in item:
item['apply_status_name'] = "未提交"
itemData = []
itemData.append(sn)
sn = sn + 1
itemData.append(messageInfo['sender_name'])
itemData.append(messageInfo['send_date'])
itemData.append(messageInfo['send_time'])
itemData.append(messageInfo['receiver_name'])
itemData.append(messageInfo['receive_date'])
itemData.append(messageInfo['receive_time'])
itemData.append(messageInfo['message_type'])
itemData.append(messageInfo['message_sn'])
itemData.append(messageInfo['text_content'])
data.append(itemData)
struct = "SN, 发送方名称, 发送日期, 发送时间, 接收方名称, 接收日期, 接收时间, 消息类别, 消息序号, 消息正文"
path = {}
path = excel.createTempFile("xls")
excel.saveExcel(path['path'], struct, data)
logInfo = " %s 下载了消息发送详单 " % self.objUserInfo['name']
operation_log(self.db).addLog(self.GetUserInfo(), "messageManage",
logInfo, 0)
self.response(path)
def delete(self):
alldata = self.getRequestData()
itemID = self.getParam(alldata, "id", 0)
if itemID == 0:
raise BaseError(801, "参数错误：缺少待删除的属性ID！")
# 属性归属的componentID，暂时一个属性只能归属一个组件，不能归属多个组件
oid = int(self.getParam(alldata, "component_id", "0"))
if oid == 0:
raise BaseError(801, "缺少属性归属的组件ID！")
logInfo = '属性 %s 被删除' % alldata['name']
# 删除记录
s = propertyManage(self.db)
s.remove(itemID, table="public.property_list", key="id", delete=True)
# 记录日志并退出
operation_log(self.db).addLog(self.GetUserInfo(), "propertyManage",
logInfo, itemID)
# 删除和组件的关系
s.remove(itemID,
table="public.component_property_list",
key="property_id",
delete=True)
self.response(itemID)
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):
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 put(self):
alldata = self.getRequestData()
# 更新的时候只能更新路径
lsData = {'id': 'id', 'menu_code': 'menu_code', 'path': 'path'}
data = {}
for (k, v) in lsData.items():
try:
data[k] = alldata[v]
except:
pass
if 'id' not in data or 'path' not in data or 'menu_code' not in data:
raise BaseError(801, "参数错误：缺少菜单项数据！")
data['update_id'] = self.objUserInfo['id']
data['update_time'] = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
s = MenuItem(self.db)
id = s.save(data, data['id'], table="system.menu_item")
operation_log(self.db).addLog(
self.GetUserInfo(), "menuItemManage",
"更新菜单项: code: %s, path: %s" % (data['menu_code'], data['path']),
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 = 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 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 post(self):
alldata = self.getRequestData()
s = rsuDeviceManage(self.db)
# 分别向 device_list 和 rsu_list 插入数据
lsData = {
'device_name': 'device_name',
'device_name_en': 'device_name_en',
'device_code': 'device_code',
'device_sn': 'device_sn',
'device_desc': 'device_desc',
'device_type_id': 'device_type_id',
'vendor_id': 'vendor_id',
'produce_date': 'produce_date',
'produce_batch': 'produce_batch',
'produce_location': 'produce_location',
'qr_code': 'qr_code',
'start_used_date': 'start_used_date',
'end_used_date': 'end_used_date',
# 'device_status' : 'device_status',
}
data = {}
for (k, v) in lsData.items():
try:
data[k] = alldata[v]
except:
pass
device_id = self.insertRSUDevice(data)
lsData = {
'ip_address1': 'ip_address1',
'ip_address2': 'ip_address2',
'longtitude': 'longtitude',
'latitude': 'latitude',
'project_id': 'project_id',
'install_location': 'install_location',
'map_location': 'map_location',
'install_date': 'install_date',
}
data = {}
for (k, v) in lsData.items():
try:
data[k] = alldata[v]
except:
pass
rsu_id = self.insertRSUData(data)
# 创建RSU成功，记录日志并退出
operation_log(self.db).addLog(
self.GetUserInfo(), "rsuDeviceManage", "%s 创建RSU设备：名称：%s" %
(self.objUserInfo['name'], alldata['device_name']), rsu_id)
self.response(rsu_id)
def put(self):
alldata = self.getRequestData()
if self.getParam(alldata, "id", 0) == 0:
raise BaseError(801, "参数错误：缺少待更新供应商的ID！")
s = organizationManage(self.db)
lsData = {
'id': 'id',
'name': 'name',
'name_en': 'name_en',
'abbr': 'abbr',
'abbr_en': 'abbr_en',
'registe_date': 'registe_date',
'registe_addr': 'registe_addr',
'organization_type': 'organization_type',
'current_addr': 'current_addr',
'business_scope': 'business_scope',
'social_credit_code': 'social_credit_code',
'legal_representative': 'legal_representative',
'legal_id_type': 'legal_id_type',
'legal_id_no': 'legal_id_no',
'contactor_name': 'contactor_name',
'contactor_mobile': 'contactor_mobile',
'logo_file': 'logo_file',
'description': 'description',
'system_user_id': 'system_user_id',
}
data = {}
for (k, v) in lsData.items():
try:
data[k] = alldata[v]
except:
pass
db = self.getDB('public.organization')
# 检查是否重复，同一个System_User_ID里面只能有一个
result = db.findByCond(
"name",
" (name = '%s' or name_en = '%s') and system_user_id = %d and id <> %d"
% (data['name'], data['name_en'], data['system_user_id'],
data['id']))
if len(result['rows']) > 0:
raise BaseError(801, "参数错误: 组织 %s 已经存在！" % data['name'])
userInfo = self.GetUserInfo()
data['update_id'] = userInfo['id']
data['update_time'] = GetSystemTime()
id = s.save(data, data['id'], table='public.organization')
logInfo = "更新组织团体信息：%s，%s" % (data['name'], data['name_en'])
operation_log(self.db).addLog(userInfo, "organizationManage", logInfo,
id)
self.response(id)
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 exportToExcel(self, rowdata):
key = [
'id', 'vendor_id', 'vendor_code', 'name', 'name_en', 'abbr',
'abbr_en', 'abbr', 'abbr_en', 'registe_addr', 'current_addr',
'logo_file', 'contactor_name', 'contactor_mobile', 'vendor_type',
'description', 'certifaction_status', 'certifaction_date',
'certifaction_desc', 'start_date', 'end_date'
]
vendorList = []
for i, item in enumerate(rowdata):
vendorInfo = dict(zip(key, item))
vendorList.append(vendorInfo)
cur = self.db.getCursor()
getDataDict(cur, vendorList, "certifaction_status",
"VENDOR_COOPERATION_STATUS", "status_name")
getDataDict(cur, vendorList, "vendor_type", "VENDOR_TYPE",
"vendor_type_name")
data = []
sn = 1
for item in vendorList:
itemData = []
itemData.append(sn)
sn = sn + 1
itemData.append(item['name'])
itemData.append(item['name_en'])
itemData.append(item['abbr'])
itemData.append(item['registe_addr'])
itemData.append(item['contactor_name'])
itemData.append(item['contactor_mobile'])
itemData.append(item['vendor_type_name'])
itemData.append(item['description'])
itemData.append(item['status_name'])
itemData.append(item['certifaction_date'])
itemData.append(item['start_date'])
itemData.append(item['end_date'])
itemData.append(item['certifaction_desc'])
data.append(itemData)
struct = "SN, 供应商名称, 供应商名称（英）, 供应商缩写, 供应商地址, 联系人, 联系电话, 供应商类型, 供应商描述, 供应商状态, 认证日期, 合作开始日期, 合作结束日期"
path = {}
path = excel.createTempFile("xls")
excel.saveExcel(path['path'], struct, data)
logInfo = " %s 下载了供应商清单 " % self.objUserInfo['name']
operation_log(self.db).addLog(self.GetUserInfo(), "vendorManage",
logInfo, 0)
self.response(path)
def exportToExcel(self, rowdata):
key = [
'id', 'name', 'name_en', 'abbr', 'abbr_en', 'organization_type',
'registe_date', 'registe_addr', 'current_addr', 'business_scope',
'social_credit_code', 'legal_representative', 'legal_id_type',
'legal_id_no', 'contactor_name', 'contactor_mobile', 'logo_file',
'description', 'system_user_id'
]
organizationList = []
for i, item in enumerate(rowdata):
organizationInfo = dict(zip(key, item))
organizationList.append(organizationInfo)
cur = self.db.getCursor()
getDataDict(cur, organizationList, "organization_type",
"ORGANIZATION_TYPE", "organization_type_name")
data = []
sn = 1
for item in organizationList:
itemData = []
itemData.append(sn)
sn = sn + 1
itemData.append(item['name'])
itemData.append(item['name_en'])
itemData.append(item['abbr'])
itemData.append(item['abbr_en'])
itemData.append(item['organization_type_name'])
itemData.append(item['registe_date'])
itemData.append(item['registe_addr'])
itemData.append(item['current_addr'])
itemData.append(item['business_scope'])
itemData.append(item['social_credit_code'])
itemData.append(item['legal_representative'])
itemData.append(item['contactor_name'])
itemData.append(item['contactor_mobile'])
itemData.append(item['description'])
data.append(itemData)
struct = "SN, 名称, 名称（英）, 中文缩写, 英文缩写, 类型, 注册日期, 注册地址, 当前地址, 经营范围, 社会信用代码, 法人代表, 联系人员, 电话号码, 描述"
path = {}
path = excel.createTempFile("xls")
excel.saveExcel(path['path'], struct, data)
logInfo = " %s 下载了组织团体清单 " % self.objUserInfo['name']
operation_log(self.db).addLog(self.GetUserInfo(), "organizationManage",
logInfo, 0)
self.response(path)
def post(self):
alldata = self.getRequestData()
system_user_id = self.GetSystemUserID()
s = deviceTypeManage(self.db)
lsData = {
'code': 'code',
'name': 'name',
'name_en': 'name_en',
'abbr_en': 'abbr_en',
'description': 'description',
'system_user_id': 'system_user_id',
}
data = {}
for (k, v) in lsData.items():
try:
data[k] = alldata[v]
except:
pass
db = self.getDB('public.device_type')
# 检查名称是否重复
result = db.findByCond(
"name",
" (name = '%s' or name_en = '%s' ) and system_user_id = %d " %
(data['name'], data['name_en'], system_user_id))
if len(result['rows']) > 0:
raise BaseError(801, "参数错误：设备名称 %s 已经存在！" % data['name'])
userInfo = self.GetUserInfo()
serialNo = GetSerialNo(userInfo['system_user_id'],
"device_type_serial")
if serialNo == -1:
raise BaseError(801, "获取设备类型序列号出错！")
# 设备类型编号规则：DEV_AAAAAA，AAAAAA为序列号，为参数表中的值
data['code'] = "DEV-TYPE-%06d" % serialNo
data['system_user_id'] = system_user_id
data['create_id'] = userInfo['id']
data['create_time'] = GetSystemTime()
logI("设备类型：", data)
device_id = s.save(data, table='public.device_type')
logInfo = "创建设备类型：%s，%s" % (data['name'], data['name_en'])
operation_log(self.db).addLog(self.GetUserInfo(), "deviceTypeManage",
logInfo, device_id)
self.response(device_id)
def post(self):
alldata = self.getRequestData()
s = programUnitManage(self.db)
lsData = {
'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")
# 检查开始时间和结束时间是否重复
cond = " (start_time < '%s' and end_time > '%s' ) " % (
data['start_time'], data['end_time'])
cond += " or ( start_time > '%s' and end_time < '%s' )" % (
data['start_time'], data['end_time'])
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']))
# 新建节目栏
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.program_unit')
data['code'] = id
s.save(data, id, table='pis.program_unit')
# 创建节目栏成功，记录日志并退出
operation_log(self.db).addLog(
self.GetUserInfo(), "programUnitManage",
"创建节目栏信息：开始时间：%s，结束时间：%s" % (data['start_time'], data['end_time']),
id)
data['id'] = id
self.response(data)
def exportStationInfo(self, lid):
sql = "select st.id, st.code, st.name, st.ip_address"
sql += " from pis.station st"
sql += " inner join pis.station_line sl on sl.station_id = st.id"
sql += " where sl.line_id = %s " % lid
sql += " order by st.code"
cur = self.db.getCursor()
cur.execute(sql)
rows = cur.fetchall()
key = ['id', 'code', 'name', 'ip_address']
data = []
sn = 1
for item in rows:
station = dict(zip(key, item))
data.append(
[sn, station['code'], station['name'], station['ip_address']])
sn = sn + 1
sql = " select lc.code, lc.name, lc.ip_address"
sql += " from pis.controller lc"
sql += " where lc.install_id = %s and lc.install_type >= '2' and lc.install_type <= '4' " % station[
'id']
sql += " order by lc.code "
cur.execute(sql)
rowsdata = cur.fetchall()
key2 = ['code', 'name', 'ip_address']
for iteminfo in rowsdata:
controller = dict(zip(key2, iteminfo))
data.append([
sn, '', '', '', controller['code'], controller['name'],
controller['ip_address']
])
sn = sn + 1
struct = "SN, 车站编号, 车站名称, 服务器地址, 控制器编号, 控制器类型, 控制器地址"
path = {}
path = excel.createTempFile("xls")
excel.saveExcel(path['path'], struct, data)
logInfo = " %s 下载了车站信息 " % self.objUserInfo['name']
operation_log(self.db).addLog(self.GetUserInfo(), "listManage",
logInfo, 0)
self.response(path)
def delete(self):
alldata = self.getRequestData()
systemUserID = self.getParam(alldata, "id", 0)
if systemUserID == 0:
raise BaseError(801, "参数错误：缺少待删除的系统用户ID！")
db = self.getDB("system.system_user_list")
result = db.findByCond('user_name,user_name_en',
"id = %d" % systemUserID)
if len(result['rows']) == 0:
raise BaseError(801, "参数错误：无法找到系统用户：%d" % systemUserID)
rows = result['rows']
logInfo = "删除系统用户：%s, %s" % (rows[0][0], rows[0][1])
# 删除用户组成员数据
db = self.getDB("system.user_group_member")
db.deleteByCond(
'group_id in (select id from system.user_group where system_user_id = %d)'
% systemUserID)
# 删除用户组菜单数据
db = self.getDB("system.user_group_menu")
db.deleteByCond(
'group_id in (select id from system.user_group where system_user_id = %d)'
% systemUserID)
# 删除用户数据
db = self.getDB("system.account")
db.deleteByCond('system_user_id = %d' % systemUserID)
# 删除用户组数据
db = self.getDB("system.user_group")
db.deleteByCond('system_user_id = %d' % systemUserID)
# 删除日志记录数据
db = self.getDB("system.operation_log")
db.deleteByCond('system_user_id = %d' % systemUserID)
# 删除系统用户菜单数据
db = self.getDB("system.system_user_menu")
db.deleteByCond('system_user_id = %d' % systemUserID)
# 删除记录
s = systemUserManage(self.db)
s.remove(systemUserID,
table="system.system_user_list",
key="id",
delete=True)
# 记录日志并退出
operation_log(self.db).addLog(self.GetUserInfo(), "systemUserManage",
logInfo, systemUserID)
self.response(systemUserID)
def exportToExcel(self, rowdata):
key = [
'id', 'name', 'code', 'serial_no', 'device_type', 'vendor',
'mac_addr', 'install_date', 'install_batch', 'install_type',
'install_id', 'status', 'addr'
]
moduleList = []
for i, item in enumerate(rowdata):
logInfo = dict(zip(key, item))
moduleList.append(logInfo)
cur = self.db.getCursor()
utils.getDataDict(cur, moduleList, "device_type",
"GPS_MODULE_DEVICE_TYPE", "device_type_name")
utils.getDataDict(cur, moduleList, "install_type",
"GPS_MODULE_INSTALL_TYPE", "install_type_name")
utils.getDataDict(cur, moduleList, "status", "GPS_MODULE_STATUS",
"status_name")
data = []
sn = 1
for module in moduleList:
itemData = []
itemData.append(sn)
sn = sn + 1
itemData.append(module['name'])
itemData.append(module['code'])
itemData.append(module['serial_no'])
itemData.append(module['device_type_name'])
itemData.append(module['vendor'])
itemData.append(module['mac_addr'])
itemData.append(module['install_date'])
itemData.append(module['install_batch'])
itemData.append(module['install_type_name'])
itemData.append(module['status_name'])
itemData.append(module['addr'])
data.append(itemData)
struct = "SN, 名称, 编号, 序列号, 设备类型, 厂家, MAC地址, 安装日期, 安装批次, 安装类型, 状态, 最新位置"
path = {}
path = excel.createTempFile("xls")
excel.saveExcel(path['path'], struct, data)
logInfo = " %s 下载了定位模块清单 " % self.objUserInfo['name']
operation_log(self.db).addLog(self.GetUserInfo(), "gpsModuleManage",
logInfo, 0)
return path
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 delete(self):
alldata = self.getRequestData()
s = DataDictTypeManage(self.db)
r = s.remove(alldata['id'], delete=True)
operation_log(self.db).addLog(
self.GetUserInfo(), "dictManage",
self.objUserInfo['name'] + "删除字典" + alldata['name'], alldata['id'])
self.response(r)
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)
