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 = 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()
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 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 post(self):
alldata = self.getRequestData()
system_user_id = self.GetSystemUserID()
s = componentManage(self.db)
lsData = {
'code': 'code',
'name': 'name',
'name_en': 'name_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.component_list')
# 检查名称是否重复
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'], "component_serial")
if serialNo == -1:
raise BaseError(801, "获取设备类型序列号出错！")
# 部件编号规则：CMP_AAAAAAAA。其中，AAAAAAAA为部件序列号，从参数表中获取。
data['code'] = "CMP_%08d" % serialNo
data['system_user_id'] = system_user_id
data['create_id'] = userInfo['id']
data['create_time'] = GetSystemTime()
component_id = s.save(data, table='public.component_list')
logInfo = "创建组件：%s，%s" % (data['name'], data['name_en'])
operation_log(self.db).addLog(self.GetUserInfo(), "componentManage",
logInfo, component_id)
self.response(component_id)
def put(self):
alldata = self.getRequestData()
if self.getParam(alldata, "id", 0) == 0:
raise BaseError(801, "参数错误：缺少待更新设备类型的ID！")
s = deviceTypeManage(self.db)
system_user_id = self.GetSystemUserID()
lsData = {
'id': 'id',
'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",
"id != %d and (name = '%s' or name_en = '%s') and system_user_id = %d"
% (data['id'], data['name'], data['name_en'], system_user_id))
if len(result['rows']) > 0:
raise BaseError(801, "参数错误：设备类型名称已经存在！")
# 在更新时，不再更新编号
userInfo = self.GetUserInfo()
data['update_id'] = userInfo['id']
data['update_time'] = GetSystemTime()
device_id = s.save(data, data['id'], table='public.device_type')
logInfo = "更新设备类型：%s，%s" % (data['name'], data['name_en'])
operation_log(self.db).addLog(userInfo, "propertyManage", logInfo,
device_id)
self.response(device_id)
def post(self):
alldata = self.getRequestData()
lsData = {
'area_type': 'area_type',
'area_code': 'area_code',
'area_name': 'area_name',
'area_name_en': 'area_name_en',
'tier': 'tier',
'parent_area_id': 'parent_area_id',
'flag': 'flag',
}
data = {}
for (k, v) in lsData.items():
try:
data[k] = alldata[v]
except:
pass
if 'area_code' not in data or 'area_name' not in data or 'area_name_en' not in data or 'parent_area_id' not in data:
raise BaseError(801, "参数错误：缺少区域数据！")
# 区域代码、名称均可以重复，因此不做检查
# 但是区域代码+名称+parent_area_id不能重复
db = self.getDB("system.area_code")
result = db.findByCond(
"area_code",
"area_code = '%s' and area_name = '%s' and parent_area_id = %d" %
((data['area_code'], data['area_name'], data['parent_area_id'])))
if len(result['rows']) > 0:
raise BaseError(
801, "数据错误：区域信息 %s, %s 重复 %s！" %
(data['area_name'], data['area_code']))
data['create_id'] = self.objUserInfo['id']
data['create_time'] = GetSystemTime()
s = areaCodeManage(self.db)
id = s.save(data, table="system.area_code")
if id <= 0:
raise BaseError(703) #参数错误
operation_log(self.db).addLog(self.GetUserInfo(), "areaCodeManage",
"创建区域-%s" % data['area_name'], id)
self.response(id)
def get(self):
type_code = self.get_argument('type_code', default='')
if type_code == '':
raise BaseError(801, "参数错误：无数据字典类型Code！")
rowdata = {}
cur = self.db.getCursor()
sql = """
select cv.id, cv.type_id, cv.type_code, cv.code, cv.name as valuename, cv.sort, cv.status,
cv.create_id, cv.create_time, cv.update_id, cv.update_time, cv.description, b.name, c.name
from system.code_value cv
left join system.account b on cv.create_id=b.id
left join system.account c on cv.update_id=c.id
where cv.type_code='%s'
order by cv.sort
""" % type_code
cur.execute(sql)
rows = cur.fetchall()
rowdata[
'struct'] = "id, type_id, type_code, code, name, sort, status, create_id, create_time, update_id, update_time, description, update_name, create_name"
rowdata['rows'] = rows
self.response(rowdata)
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 put(self):
alldata = self.getRequestData()
if self.getParam(alldata, "id", 0) == 0:
raise BaseError(801, "参数错误：缺少待更新供应商的ID！")
s = vendorManage(self.db)
lsData = {
'id': 'id',
'vendor_id': 'vendor_id',
'vendor_type': 'vendor_type',
'certifaction_date': 'certifaction_date',
'certifaction_desc': 'certifaction_desc',
'start_date': 'start_date',
'end_date': 'end_date',
'certifaction_status': 'certifaction_status',
'system_user_id': 'system_user_id',
}
data = {}
for (k, v) in lsData.items():
try:
data[k] = alldata[v]
except:
pass
db = self.getDB('public.vendor_list')
# 检查名称是否重复
result = db.findByCond(
"vendor_id", "id != %d and (vendor_id = '%d') " %
(data['id'], data['vendor_id']))
if len(result['rows']) > 0:
raise BaseError(801, "参数错误：供应商名称已经存在！")
# 在更新时，不再更新供应商编号
userInfo = self.GetUserInfo()
data['update_id'] = userInfo['id']
data['update_time'] = GetSystemTime()
vendor_id = s.save(data, data['id'], table='public.vendor_list')
logInfo = "更新供应商：%s，%s" % (alldata['name'], alldata['name_en'])
operation_log(self.db).addLog(userInfo, "vendorManage", logInfo,
vendor_id)
self.response(vendor_id)
def post(self):
alldata = self.getRequestData()
lsData = {
'code': 'code',
'name': 'name',
'sort': 'sort',
'tier': 'tier',
'parent_code': 'parent_code',
'parent_id': 'parent_id',
}
data = {}
for (k, v) in lsData.items():
try:
data[k] = alldata[v]
except:
pass
if 'code' not in data or 'name' not in data or 'sort' not in data or 'tier' not in data or 'parent_id' not in data or 'parent_code' not in data:
raise BaseError(801, "参数错误：缺少菜单数据！")
db = self.getDB("system.menu")
# 检查菜单编码是否重复
result = db.findByCond("code", "code = '%s' " % (data['code']))
if len(result['rows']) > 0:
raise BaseError(801, "数据错误：菜单编号 %s！" % (data['code']))
data['create_id'] = self.objUserInfo['id']
data['create_time'] = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
s = menuManage(self.db)
id = s.save(data, table="system.menu")
if id <= 0:
raise BaseError(703) #参数错误
operation_log(self.db).addLog(self.GetUserInfo(), "menuManage",
"创建菜单-%s" % data['name'], id)
self.response(id)
def delete(self):
alldata = self.getRequestData()
if 'id' not in alldata or alldata['id'] < 0:
raise BaseError(801)
self.deleteSubMenu(alldata['id'])
operation_log(self.db).addLog(self.GetUserInfo(), "menuManage",
"删除菜单-%s" % alldata['name'],
alldata['id'])
self.response(0)
def patch(self):
allParam = self.getRequestData()
op = self.getParam(allParam, 'op', '')
if op == '':
raise BaseError(801, '系统错误：缺少操作类型OP')
allData = {}
if op == "area":
# 根据地址获取相应的区域数据
addrList = self.getParam(allParam, 'addr', '')
if len(addrList) == 0:
raise BaseError(801, '无有效地址！')
# 根据地址信息进行匹配
Address = []
for addr in addrList:
Address.append(getAreaInfo(self, addr))
allData['Address'] = Address
self.response(allData)
def get(self):
if not self.objUserInfo:
raise BaseError(604)
userInfo = self.GetUserInfo()
opUserID = int(self.get_argument('id', default='0'))
queryGroupID = int(self.get_argument('gid', default='0'))
offset = int(self.get_argument('o', default='1'))
rowlimit = int(self.get_argument('r', default='20'))
offset = (offset - 1) * rowlimit
rowdata = {}
cur = self.db.getCursor()
sql = "select ug.id, ug.create_time, ug.update_time, ug.create_id, ug.update_id, ug.name, ug.c_name, "
sql += " ug.description, ug.group_type"
sql += " from system.user_group ug "
sql_where = " where ug.name != 'supervisors'"
if userInfo['system_user_id'] != 1:
sql_where += " and ug.system_user_id = %d " % userInfo[
'system_user_id']
if queryGroupID > 0:
sql_where += " and ug.id = %d" % queryGroupID
sql += sql_where
sql += " order by ug.c_name"
sql += " limit " + str(rowlimit) + " offset " + str(offset)
cur.execute(sql)
rows = cur.fetchall()
rowdata[
'struct'] = "id, create_time, update_time, create_id, update_id, name, c_name, "
rowdata['struct'] += " description, group_type"
rowdata['rows'] = rows
sql = "select count(*) from system.user_group ug "
sql += sql_where
cur.execute(sql)
row = cur.fetchone()
rowdata['count'] = row[0]
self.response(rowdata)
def delete(self):
alldata = self.getRequestData()
vendorID = self.getParam(alldata, "id", 0)
if vendorID == 0:
raise BaseError(801, "参数错误：缺少待删除的供应商ID！")
logInfo = '供应商 %s 被删除' % alldata['vendor_name']
# 删除记录
s = vendorManage(self.db)
s.remove(vendorID, table="public.vendor_list", key="id", delete=True)
# 记录日志并退出
operation_log(self.db).addLog(self.GetUserInfo(), "vendorManage",
logInfo, vendorID)
self.response(vendorID)
def delete(self):
alldata = self.getRequestData()
orgID = self.getParam(alldata, "id", 0)
if orgID == 0:
raise BaseError(801, "参数错误：缺少待删除的供应商ID！")
logInfo = '组织团体 %s 被删除' % alldata['name']
# 删除记录
s = organizationManage(self.db)
s.remove(orgID, table="public.organization", key="id", delete=True)
# 记录日志并退出
operation_log(self.db).addLog(self.GetUserInfo(), "organizationManage",
logInfo, orgID)
self.response(orgID)
def delete(self):
alldata = self.getRequestData()
itemID = self.getParam(alldata, "id", 0)
if itemID == 0:
raise BaseError(801, "参数错误：缺少待删除的组件ID！")
logInfo = '组件 %s 被删除' % alldata['name']
# 删除记录
s = componentManage(self.db)
s.remove(itemID, table="public.component_list", key="id", delete=True)
# 记录日志并退出
operation_log(self.db).addLog(self.GetUserInfo(), "componentManage",
logInfo, itemID)
self.response(itemID)
def delete(self):
alldata = self.getRequestData()
itemID = self.getParam(alldata, "id", 0)
if itemID == 0:
raise BaseError(801, "参数错误：缺少待删除的设备类型ID！")
logInfo = '设备类型 %s 被删除' % alldata['name']
# 删除记录
s = deviceTypeManage(self.db)
data = {'id': itemID}
device_id = s.save(data, data['id'], table='public.device_type')
# s.remove( itemID, table = "public.device_type", key = "id", delete = True)
# 记录日志并退出
operation_log(self.db).addLog(self.GetUserInfo(), "deviceTypeManage",
logInfo, itemID)
self.response(itemID)
def patch(self):
paramData = self.getRequestData()
if 'op' not in paramData:
raise BaseError(900)
# 获取用户组清单
if paramData['op'] == 'gl':
userInfo = self.GetUserInfo()
sql = " select ug.id, ug.c_name from system.user_group ug"
sql += " where ug.name != 'supervisors' and ug.system_user_id = %d " % userInfo[
'system_user_id']
sql += " order by ug.c_name"
rowdata = {}
cur = self.db.getCursor()
cur.execute(sql)
rows = cur.fetchall()
groupList = {}
groupList['struct'] = "id, name"
groupList['rows'] = [(
0,
"选择全部",
)] + rows
self.response(groupList)
# 获取用户组成员
elif paramData['op'] == 'gm':
groupID = self.getParam(paramData, 'gid', 0)
uname = self.getParam(paramData, 'un', "")
offset = self.getParam(paramData, 'o', 0)
rowlimit = self.getParam(paramData, 'r', 20)
accountInfo = account.getAccountInfo(self, 0, uname, groupID, None,
None, offset, rowlimit)
self.response(accountInfo)
def delete(self):
paramData = self.getRequestData()
groupID = self.getParam(paramData, 'gid', 0)
groupName = self.getParam(paramData, 'gn', "")
if groupID == 0 or groupName == "":
raise BaseError(801, "参数错误，没有指定需要删除的用户组")
s = userGroupManage(self.db)
r = s.remove(groupID, table='system.user_group', delete=True)
s.remove(groupID,
table="system.user_group_menu",
key="group_id",
delete=True)
s.remove(groupID,
table="system.user_group_member",
key="group_id",
delete=True)
# 操作成功，记录日志并返回
operation_log(self.db).addLog(self.GetUserInfo(), 'groupManage',
"删除了一个用户组：%s" % groupName, groupID)
self.response(r)
def post(self):
# 取POST Form提交的数据
alldata = self.getRequestData()
lsData = {
'code': 'code',
'name': 'name',
'status': 'status',
'description': 'description',
}
data = {}
for (k, v) in lsData.items():
try:
data[k] = alldata[v]
except:
pass
s = DataDictTypeManage(self.db)
db = self.getDB("system.code_type")
# 检查名称是否重复
result = db.findByCond(
"code",
"code = '%s' or name = '%s' " % (data['code'], data['name']))
if len(result['rows']) > 0:
raise BaseError(
801,
"数据错误：字典类型编号 %s 或名称 %s 已经存在！" % (data['code'], data['name']))
id = s.save(data, table='system.code_type')
operation_log(self.db).addLog(
self.GetUserInfo(), "dictManage",
self.objUserInfo['name'] + " 创建数据字典 " + alldata['name'], id)
self.response(id)
def SetSystemUserMenu(self, systemUserID, groupID, menuList):
if systemUserID == 0 or groupID == 0 or len(menuList) == 0:
raise BaseError(801, "参数错误：设置菜单权限时参数错误！")
s = systemUserManage(self.db)
# 删除现有系统用户菜单数据，不管是新建还是更新模式
db = self.getDB("system.system_user_menu")
db.deleteByCond("system_user_id = %d" % systemUserID)
# 删除系统用户的管理员用户组菜单数据
db = self.getDB("system.user_group_menu")
db.deleteByCond("group_id = %d" % groupID)
db = self.getDB("system.menu_item")
for menuID in menuList:
# 添加系统用户的菜单权限
tempData = {
'create_time':
datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
'create_id':
self.objUserInfo['id'],
'system_user_id':
systemUserID,
'menu_id':
menuID,
}
s.save(tempData, table='system.system_user_menu')
# 添加系统用户管理员用户组的菜单项权限数据
# 查找菜单ID对应的菜单项ID，当前模式中，一个菜单只有一个菜单项
result = db.findByCond('id', "menu_id = %d" % menuID)
if len(result['rows']) == 0:
raise BaseError(801, "数据错误：菜单 %d 无对应的菜单项！" % menuID)
keys = result["struct"].split(",")
menuItemIDList = []
for item in result['rows']:
data = dict(zip(keys, item))
menuItemIDList.append(data)
data = {
'create_time':
datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
'create_id':
self.objUserInfo['id'],
'group_id':
groupID,
'menu_item_id':
menuItemIDList[0]['id'],
'system_user_id':
systemUserID,
}
s.save(data, table='system.user_group_menu')
# 在更新系统用户菜单权限时，需要更新现有系统用户创建的用户组的菜单权限：
# 原来有的菜单权限，现在没有了，需要删除；
# 原来没有的，现在有的菜单权限，不需要添加，由系统用户的管理员进行设置；
return
def post(self):
fname = self.get_argument('file_name')
file_content_type = self.get_argument('file_content_type')
file_path = self.get_argument('file_path')
file_size = self.get_argument('file_size')
#获取文件类型
fnames = fname.split('.')
if len(fnames) > 1:
file_type = fnames[-1]
#文件重命名
new_name = file_path + '.' + file_type;
if os.path.exists(new_name):
new_name = file_path + str(random.randint(100,999)) + '.' + file_type;
os.rename(file_path, new_name)
#产生url地址
url = new_name
else:
new_name = file_path
url = new_name
file_type = file_content_type
url = url.replace(config.FileUploadRootPath,config.FileUrlRoot)
#保存到文件表中
s = menuManage.menuManage(self.db)
user = self.objUserInfo
uid = "1"
if user :
uid = user["id"]
file_data={
"file_name" : fname,
"create_time" : self.now_time(),
"update_time" : self.now_time(),
"path" : url,
"create_id" : uid,
"update_id" : uid,
"file_size" :file_size,
"file_type" :file_type,
"store_path" :new_name
}
fid = s.save(file_data,table='public.file')
file_data["id"] = fid
file_data["file_size"] = file_size
file_data["file_content_type"] = file_content_type
file_data["file_path"] = new_name
# PIS 业务需要将上传的文件复制到指定目录
service_type = self.get_argument('service_type', default = "")
if service_type == "program_list":
# logI("Upload programFile")
pass
elif service_type == "program_file":
# 节目文件存放目录, root/videofile
filePath = "%s/videofile/"%(config.PisConfig['PISFileRoot'])
file_data['file_path'] = moveFile( file_data['store_path'], filePath, os.path.basename(file_data['store_path']))
file_data['video_type'] = self.get_argument('video_type', default = '1')
programFile.uploadProgramFile(self, file_data)
# 移动文件后删除此文件记录
s.remove( fid, table = "public.file", key = "id", delete = True)
elif service_type == "format_file":
# 版式文件存放目录, root/formatfile/filename
filePath = "%s/formatfile/"%(config.PisConfig['PISFileRoot'])
file_new_path = moveFile( file_data['store_path'], filePath, os.path.basename(file_data['store_path']))
file_data['file_new_path'] = os.path.basename(file_new_path)
formatFileList.uploadFormatFile(self, file_data)
# 移动文件后删除此文件记录
s.remove( fid, table = "public.file", key = "id", delete = True)
elif service_type == "update_software":
# 版本升级文件存在在, root/update
filePath = "%s/update/"%(config.PisConfig['PISFileRoot'])
file_data['file_new_path'] = moveFile( file_data['store_path'], filePath, os.path.basename(file_data['store_path']))
# 移动文件后删除此文件记录
s.remove( fid, table = "public.file", key = "id", delete = True)
elif service_type == "logo_file":
# 业务类型Logo文件
filePath = os.environ['SRVDIR'] + '/src/app/resource/images/logo/'
file_data['file_new_path'] = moveFile( file_data['store_path'], filePath, file_data['file_name'])
# 移动文件后删除此文件记录
s.remove( fid, table = "public.file", key = "id", delete = True)
elif service_type == "rsuDevice":
# 不需要做处理
# logI("上传了RSU设备数据文件")
pass
elif service_type == "rsuUpdateFile":
# 需要将版本文件移动到RSU FTP目录
filePath = "%s/update/"%RSU_Root_Path
file_data['file_new_path'] = moveFile( file_data['store_path'], filePath, file_data['file_name'])
# 移动文件后删除此文件记录
s.remove( fid, table = "public.file", key = "id", delete = True)
else:
msg = "参数错误：上传文件的业务属性 %s 错误！"%service_type
logI(msg)
raise BaseError(801, msg )
self.response(file_data)
def post(self):
alldata = self.getRequestData()
systemUserID = self.GetSystemUserID()
# 属性归属的componentID，暂时一个属性只能归属一个组件，不能归属多个组件
oid = int(self.getParam(alldata, "component_id", "0"))
if oid == 0:
raise BaseError(801, "缺少属性归属的组件ID！")
s = propertyManage(self.db)
lsData = {
'name': 'name',
'name_en': 'name_en',
'value_type': 'value_type',
'value_s': 'value_s',
'value_i': 'value_i',
'value_f': 'value_f',
'description': 'description',
}
data = {}
for (k, v) in lsData.items():
try:
data[k] = alldata[v]
except:
pass
db = self.getDB('public.property_list')
# 检查名称是否重复
result = db.findByCond(
"name",
"(name = '%s' or name_en = '%s') and system_user_id = %d " %
(data['name'], data['name_en'], systemUserID))
if len(result['rows']) > 0:
raise BaseError(801, "参数错误：属性名称已经存在！")
userInfo = self.GetUserInfo()
serialNo = GetSerialNo(systemUserID, 'property_serial')
if serialNo == -1:
raise BaseError(801, '系统错误：获取序列号失败！')
# 属性类型编码规则：PRP_AAA_BBBBBBBB。其中，AAA为属性值类型，取值为STR、INT或FLT，BBBBBBBB为属性序列号值。
data['code'] = 'PRP-' + data['value_type'] + '-%08d' % (serialNo + 1)
data['system_user_id'] = systemUserID
data['create_id'] = userInfo['id']
data['create_time'] = GetSystemTime()
property_id = s.save(data, table='public.property_list')
logInfo = "创建属性：%s，%s" % (data['name'], data['name_en'])
operation_log(self.db).addLog(self.GetUserInfo(), "propertyManage",
logInfo, property_id)
# 记录归属关系
data = {
'component_id': oid,
'property_id': property_id,
'system_user_id': systemUserID,
}
s.save(data, table='public.component_property_list')
self.response(property_id)
def post(self):
# 取POST Form提交的数据
alldata = self.getRequestData()
s = DataDictValue(self.db)
lsData = {
'type_id': 'type_id',
'type_code': 'type_code',
'code': 'code',
'name': 'name',
'sort': 'sort',
'status': 'status',
'description': 'description',
}
data = {}
for (k, v) in lsData.items():
try:
data[k] = alldata[v]
except:
pass
if 'code' not in data.keys():
raise BaseError(801, "参数错误，无数据字典值code！")
if 'name' not in data.keys():
raise BaseError(801, "参数错误，无数据字典值名称！")
if 'sort' not in data.keys():
raise BaseError(801, "参数错误，无数据字典值序号！")
if 'status' not in data.keys():
data['status'] = 1
db = self.getDB("system.code_value")
# 检查名称是否重复
result = db.findByCond(
"code", "type_code = '%s' and (code = '%s' or name = '%s') " %
(data['type_code'], data['code'], data['name']))
if len(result['rows']) > 0:
raise BaseError(
801,
"数据错误：字典条目编号 %s 或名称 %s 已经存在！" % (data['code'], data['name']))
# 检查顺序是否重复
result = db.findByCond(
"code", "type_code = '%s' and (sort = '%s')" %
(data['type_code'], data['sort']))
if len(result['rows']) > 0:
raise BaseError(
801, "数据错误：字典条目 %s 序号 %s 重复！" % (data['name'], data['sort']))
# 创建字典条目
data['create_id'] = self.objUserInfo['id']
data['create_time'] = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
id = s.save(data, table='system.code_value')
operation_log(self.db).addLog(
self.GetUserInfo(), "dictManage",
self.objUserInfo['name'] + " 新增字典值 " + data['name'], id)
self.response(id)
def put(self):
alldata = self.getRequestData()
if self.getParam(alldata, "id", 0) == 0:
raise BaseError(801, "参数错误：缺少待更新系统用户的ID！")
line_name = self.getParam(alldata, "user_name", "")
if line_name == "":
raise BaseError(801, "参数错误，无系统用户中文名称！")
line_name_en = self.getParam(alldata, "user_name_en", "")
if line_name_en == "":
raise BaseError(801, "参数错误，无系统用户英文名称！")
s = systemUserManage(self.db)
lsData = {
'id': 'id',
'user_name': 'user_name',
'user_name_en': 'user_name_en',
'logo_vertical': 'logo_vertical',
'logo_horizontal': 'logo_horizontal',
'admin_group_id': 'admin_group_id',
'admin_account_id': 'admin_account_id',
'user_service': 'user_service',
'abbr_name': 'abbr_name',
'abbr_name_en': 'abbr_name_en',
'app_name': 'app_name',
'app_name_en': 'app_name_en',
'user_desc': 'user_desc',
}
data = {}
for (k, v) in lsData.items():
try:
data[k] = alldata[v]
except:
pass
# 检查名称是否重复
db = self.getDB("system.system_user_list")
result = db.findByCond(
"user_name",
"( user_name = '%s' or user_name_en = '%s' ) and id <> %s " %
(data['user_name'], data['user_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='system.system_user_list')
# 检查是否需要更新密码
accountInfo = self.getParam(alldata, 'accountInfo', {})
if not accountInfo:
raise BaseError(801, '参数错误：无用户信息参数！')
# 只更新管理员密码，其他管理员信息由管理员自己更新
if 'id' in accountInfo and 'pass' in accountInfo:
# 更新用户密码
accountData = {
'id': accountInfo['id'],
'pass': accountInfo['pass'],
}
s.save(accountData, accountInfo['id'], table='system.account')
# 更新菜单权限
menuList = self.getParam(alldata, "menuList", [])
if len(menuList) == 0:
raise BaseError(801, "参数错误：没有设置菜单权限！")
self.SetSystemUserMenu(data['id'], data['admin_group_id'], menuList)
logInfo = "更新系统用户信息：%s，%s" % (data['user_name'], data['user_name_en'])
operation_log(self.db).addLog(self.GetUserInfo(), "systemUserManage",
logInfo, id)
self.response(id)
def put(self):
alldata = self.getRequestData()
s = DataDictValue(self.db)
# 字典条目归属的字段类型ID及code默认不可能改变
lsData = {
'id': 'id',
'type_id': 'type_id',
'type_code': 'type_code',
'code': 'code',
'name': 'name',
'sort': 'sort',
'status': 'status',
'description': 'description',
}
data = {}
for (k, v) in lsData.items():
try:
data[k] = alldata[v]
except:
pass
if 'id' not in data.keys():
raise BaseError(801, "参数错误，无数据字典值ID！")
if 'code' not in data.keys():
raise BaseError(801, "参数错误，无数据字典值code！")
if 'name' not in data.keys():
raise BaseError(801, "参数错误，无数据字典值名称！")
if 'sort' not in data.keys():
raise BaseError(801, "参数错误，无数据字典值序号！")
if 'status' not in data.keys():
data['status'] = 1
db = self.getDB("system.code_value")
# 检查名称是否重复
result = db.findByCond(
"code",
"type_code = '%s' and (code = '%s' or name = '%s') and id <> %d " %
(data['type_code'], data['code'], data['name'], data['id']))
if len(result['rows']) > 0:
raise BaseError(
801,
"数据错误：字典条目编号 %s 或名称 %s 已经存在！" % (data['code'], data['name']))
# 检查顺序是否重复
result = db.findByCond(
"code", "type_code = '%s' and sort = '%s' and id <> %d" %
(data['type_code'], data['sort'], data['id']))
if len(result['rows']) > 0:
raise BaseError(
801, "数据错误：字典条目 %s 序号 %s 重复！" % (data['name'], data['sort']))
id = s.save(data, data['id'], table='system.code_value', key='id')
operation_log(self.db).addLog(
self.GetUserInfo(), "dictManage",
self.objUserInfo['name'] + " 修改字典值 " + data['name'], data['id'])
self.response(data)
def patch(self):
paramData = self.getRequestData()
systemUserID = self.GetSystemUserID()
op = self.getParam(paramData, "op", "")
cur = self.db.getCursor()
allData = {}
if op == 'list':
# 获取所有组织团体清单
sql = """
select po.id, po.name
from public.organization po
where po.system_user_id = %d
""" % systemUserID
cur.execute(sql)
rows = cur.fetchall()
organizationList = {}
organizationList['rows'] = [(
0,
"选择全部",
)] + rows
organizationList['struct'] = 'id, name'
allData['organizationList'] = organizationList
# 所有供应商清单
sql = """
select vl.id, po.name
from public.vendor_list vl
inner join public.organization po on po.id = vl.vendor_id
where po.system_user_id = %d
""" % systemUserID
cur.execute(sql)
rows = cur.fetchall()
allVendorList = {}
allVendorList['rows'] = [(
0,
"选择全部",
)] + rows
allVendorList['struct'] = 'id, name'
allData['allVendorList'] = allVendorList
# 获取供应商状态类别清单
sql = "select cv.code, cv.name "
sql += " from system.code_value cv"
sql += " where cv.type_code = 'VENDOR_COOPERATION_STATUS' "
sql += " order by cv.sort"
cur = self.db.getCursor()
cur.execute(sql)
rows = cur.fetchall()
statusTypeList = {}
statusTypeList['struct'] = "code, name"
statusTypeList['rows'] = [(
'0',
"选择全部",
)] + rows
allData['statusTypeList'] = statusTypeList
# 获取供应商类型清单
sql = "select cv.code, cv.name "
sql += " from system.code_value cv"
sql += " where cv.type_code = 'VENDOR_TYPE' "
sql += " order by cv.sort"
cur = self.db.getCursor()
cur.execute(sql)
rows = cur.fetchall()
vendorTypeList = {}
vendorTypeList['struct'] = "code, name"
vendorTypeList['rows'] = [(
'0',
"选择全部",
)] + rows
allData['vendorTypeList'] = vendorTypeList
elif op == 'orginfo':
paramData = self.getRequestData()
orgid = int(self.getParam(paramData, "vid", "0"))
sql = """
select po.id, po.name, po.name_en, po.abbr, po.abbr_en, po.organization_type, po.registe_addr, po.current_addr, po.business_scope,
po.contactor_name, po.contactor_mobile, po.description, po.system_user_id
from public.organization po
where po.id = %d
""" % orgid
cur.execute(sql)
rows = cur.fetchall()
organizationList = {}
organizationList['rows'] = rows
organizationList[
'struct'] = 'id, name, name_en, abbr, abbr_en, organization_type, registe_addr, current_addr, business_scope, contactor_name, contactor_mobile, description, system_user_id'
allData['organizationList'] = organizationList
elif op == 'area':
# 根据供应商编码获取相应的区域数据
code = self.getParam(paramData, 'code', '')
if code == '':
raise BaseError(801, '缺少供应商编码！')
# 根据编码数据获得地址代码
# 供应商代码规则：VDR-SSPPPCCCDDD-XXXXXX，SS为国家代码，PPP为省份代码，CCC为城市代码，DDD为区县代码
countryCode = code[4:6]
provinceCode = code[6:9]
cityCode = code[9:12]
districtCode = code[12:15]
logI("Code: %s, %s, %s, %s, %s" %
(code, countryCode, provinceCode, cityCode, districtCode))
countryData = {}
provinceData = {}
cityData = {}
districtData = {'id': 0, 'area_name': '', 'area_name_en': ''}
# 查找国家代码
db = self.getDB('system.area_code')
result = db.findByCond(
"id,area_name,area_name_en",
"area_type = 'S' and area_code = '%s' " % (countryCode))
if len(result['rows']) == 0:
# 如果没有找到国家代码，则默认为中国
result = db.findByCond("id,area_name,area_name_en",
"area_code = '%s'" % defaultCountryCode)
if len(result['rows']) == 0:
raise BaseError(
801, '系统错误：区域代码中无默认国家代码（%s）数据' % defaultCountryCode)
countryData['id'] = result['rows'][0][0]
countryData['area_name'] = result['rows'][0][1]
countryData['area_name_en'] = result['rows'][0][2]
# 查找省份
result = db.findByCond(
"id,area_name,area_name_en",
"area_type = 'P' and area_code = '%s' and parent_area_id = %d "
% (provinceCode, countryData['id']))
if len(result['rows']) == 0:
raise BaseError(801, '系统错误：获取省份代码（%s）失败！' % provinceCode)
provinceData['id'] = result['rows'][0][0]
provinceData['area_name'] = result['rows'][0][1]
provinceData['area_name_en'] = result['rows'][0][2]
# 查找城市
result = db.findByCond(
"id,area_name,area_name_en",
"area_type = 'C' and area_code = '%s' and parent_area_id = %d "
% (cityCode, provinceData['id']))
if len(result['rows']) == 0:
raise BaseError(801, '系统错误：获取城市代码（%s）失败！' % cityCode)
cityData['id'] = result['rows'][0][0]
cityData['area_name'] = result['rows'][0][1]
cityData['area_name_en'] = result['rows'][0][2]
# 查找区县
if districtCode != '000':
# 非直辖市，一定有区县代码
result = db.findByCond(
"id,area_name,area_name_en",
"area_type = 'D' and area_code = '%s' and parent_area_id = %d "
% (districtCode, cityData['id']))
if len(result['rows']) == 0:
raise BaseError(801, '系统错误：获取区县代码（%s）失败！' % districtCode)
districtData['id'] = result['rows'][0][0]
districtData['area_name'] = result['rows'][0][1]
districtData['area_name_en'] = result['rows'][0][2]
allData['countryData'] = countryData
allData['provinceData'] = provinceData
allData['cityData'] = cityData
allData['districtData'] = districtData
elif op == 'check':
# 审核供应商
userInfo = self.GetUserInfo()
vendorID = int(self.getParam(paramData, "id", "0"))
vendorName = self.getParam(paramData, "vendor_name", "")
result = self.getParam(paramData, "result", "")
opinion = self.getParam(paramData, "opinion", "")
currentTime = GetSystemTime()
data = {
'vendor_id': vendorID,
'checker_id': userInfo['id'],
'checker_name': userInfo['name'],
'check_date': currentTime,
'check_opinion': opinion,
'check_result': result,
}
s = vendorManage(self.db)
# 新增审批记录
s.save(data, table="public.vendor_check_history")
logInfo = "%s 审批了供应商 %s ，审批结果：%s, 审批意见：%s， 时间：%s" % (
data['checker_name'], vendorName, result, opinion,
data['check_date'])
operation_log(self.db).addLog(self.GetUserInfo(), "vendorManage",
logInfo, vendorID)
# 更新供应商状态
data = {
'certifaction_status': 'CO' if result == 'pass' else 'CI',
'certifaction_date': GetSystemTime('-', '', ''),
}
s.save(data, vendorID, table='public.vendor_list')
logInfo = "%s 更新了供应商 %s 状态为 %s，时间：%s" % (
userInfo['name'], vendorName, data['certifaction_status'],
currentTime)
operation_log(self.db).addLog(self.GetUserInfo(), "vendorManage",
logInfo, vendorID)
self.response(allData)
def post(self):
alldata = self.getRequestData()
s = systemUserManage(self.db)
lsData = {
'user_name': 'user_name',
'user_name_en': 'user_name_en',
'admin_account_id': 'admin_account_id',
'admin_group_id': 'admin_group_id',
'logo_vertical': 'logo_vertical',
'logo_horizontal': 'logo_horizontal',
'user_desc': 'user_desc',
'user_service': 'user_service',
'abbr_name': 'abbr_name',
'abbr_name_en': 'abbr_name_en',
'app_name': 'app_name',
'app_name_en': 'app_name_en',
}
data = {}
for (k, v) in lsData.items():
try:
data[k] = alldata[v]
except:
pass
line_name = self.getParam(alldata, "user_name", "")
if line_name == "":
raise BaseError(801, "参数错误，无系统用户中文名称！")
line_name_en = self.getParam(alldata, "user_name_en", "")
if line_name_en == "":
raise BaseError(801, "参数错误，无系统用户英文名称！")
db = self.getDB("system.system_user_list")
# 检查名称是否重复
result = db.findByCond(
"user_name", "user_name = '%s' or user_name_en = '%s' " %
(data['user_name'], data['user_name_en']))
if len(result['rows']) > 0:
raise BaseError(801, "参数错误：系统用户名称已经存在！")
# 创建用户组
db = self.getDB("system.user_group")
groupInfo = self.getParam(alldata, 'groupInfo', {})
groupNameEN = self.getParam(groupInfo, 'name', '')
groupNameCN = self.getParam(groupInfo, 'c_name', '')
if groupNameEN == '' or groupNameCN == '':
raise BaseError(801, '参数错误：无用户组名称！')
result = db.findByCond("name", "name = '%s'" % groupNameEN)
if len(result['rows']) > 0:
raise BaseError(801, "数据错误：用户组名称已经存在！")
currentTime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
groupData = {
'name': groupNameEN,
'c_name': groupNameCN,
'group_type': '1',
'system_user_id': 0,
'description': groupNameCN,
'create_time': currentTime,
'create_id': self.objUserInfo['id'],
}
groupID = s.save(groupData, table='system.user_group')
# 创建用户
accountInfo = self.getParam(alldata, 'accountInfo', {})
if not accountInfo:
raise BaseError(801, '参数错误：无用户信息参数！')
lsData = {
'user_name': 'user_name',
'pass': '******',
'name': 'name',
'country': 'country',
'company': 'company',
'dept_name': 'dept_name',
'description': 'description',
'mobile_phone1': 'mobile_phone1',
'mobile_phone2': 'mobile_phone2',
'mailbox': 'mailbox',
'id_no': 'id_no',
'address1': 'address1',
'address2': 'address2',
'photo_path': 'photo_path',
'sex': 'sex',
'default_language': 'default_language',
}
accountData = {}
for (k, v) in lsData.items():
try:
accountData[k] = accountInfo[v]
except:
pass
accountData['user_type'] = '0' # 用户类型：本单位用户
accountData['status'] = '2' # 状态：正常
db = self.getDB("system.account")
result = db.findByCond("user_name",
"user_name = '%s'" % (accountData['user_name']))
if len(result['rows']) > 0:
raise BaseError(801, "数据错误：用户名已经存在！")
accountData['create_id'] = self.objUserInfo['id']
accountData['create_time'] = currentTime
accountID = s.save(accountData, table='system.account')
# 添加用户组成员
groupMemberData = {
'group_id': groupID,
'user_id': accountID,
}
groupMemberID = s.save(groupMemberData,
table='system.user_group_member')
# 创建系统用户
data['create_id'] = self.objUserInfo['id']
data['create_time'] = currentTime
data['admin_account_id'] = accountID
data['admin_group_id'] = groupID
systemUserID = s.save(data, table='system.system_user_list')
# 更新用户组及用户的system_user_id
tempData = {
'system_user_id': systemUserID,
}
s.save(tempData, groupMemberID, table='system.user_group')
s.save(tempData, groupID, table='system.user_group_member')
s.save(tempData, accountID, table='system.account')
# 创建系统用户菜单权限
menuList = self.getParam(alldata, "menuList", [])
if len(menuList) == 0:
raise BaseError(801, "参数错误：没有设置菜单权限！")
self.SetSystemUserMenu(systemUserID, groupID, menuList)
# 添加用户组菜单数据
logInfo = "创建系统用户：%s，%s" % (data['user_name'], data['user_name_en'])
operation_log(self.db).addLog(self.GetUserInfo(), "systemUserManage",
logInfo, systemUserID)
self.response(systemUserID)
def post(self):
alldata = self.getRequestData()
s = vendorManage(self.db)
lsData = {
'vendor_id': 'vendor_id',
'vendor_type': 'vendor_type',
'certifaction_desc': 'certifaction_desc',
'start_date': 'start_date',
'end_date': 'end_date',
'certifaction_status': 'certifaction_status',
'system_user_id': 'system_user_id',
}
data = {}
for (k, v) in lsData.items():
try:
data[k] = alldata[v]
except:
pass
db = self.getDB('public.vendor_list')
# 检查Vendor是否重复，同一个System_User_ID里面的Vender只能有一个
result = db.findByCond(
"vendor_id", "vendor_id = %d and system_user_id = %d " %
(data['vendor_id'], data['system_user_id']))
if len(result['rows']) > 0:
raise BaseError(801, "参数错误：供应商名称已经存在！")
db = self.getDB('public.organization')
result = db.findByCond(
"name, name_en, current_addr", "id = %d and system_user_id = %d " %
(data['vendor_id'], data['system_user_id']))
if len(result['rows']) == 0:
raise BaseError(801, "参数错误：供应商不存在！")
name = result['rows'][0][0]
name_en = result['rows'][0][1]
current_addr = result['rows'][0][2]
areaInfo = getAreaInfo(self, current_addr)
if areaInfo['country']['id'] == 0:
countryCode = 'CN'
else:
countryCode = areaInfo['country']['area_code']
provinceCode = areaInfo['province']['area_code']
cityCode = areaInfo['city']['area_code']
districtCode = areaInfo['district']['area_code']
userInfo = self.GetUserInfo()
serialNo = GetSerialNo(userInfo['system_user_id'], 'vendor_serial',
False)
if serialNo == -1:
raise BaseError(801, '系统错误：获取供应商序列号失败！')
data[
'vendor_code'] = 'VDR-' + countryCode + provinceCode + cityCode + districtCode + '-%08d' % (
serialNo + 1)
logI("Code: %s" % data['vendor_code'])
data['system_user_id'] = userInfo['system_user_id']
data['certifaction_status'] = 'CI'
data['certifaction_date'] = GetSystemTime()
data['create_id'] = userInfo['id']
data['create_time'] = GetSystemTime()
vendor_id = s.save(data, table='public.vendor_list')
logInfo = "创建供应商：%s，%s" % (name, name_en)
operation_log(self.db).addLog(self.GetUserInfo(), "vendorManage",
logInfo, vendor_id)
self.response(vendor_id)
