def deleteRtspServerInfo(request):
"""
Rtsp服务信息--删除
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response({"result": 16004001, "msg": getErrMsgByCode(16004001, err)}, content_type="application/json")
if reqbody_verify_admin(reqBody, err_code=16004001) is None:
pass
else:
return reqbody_verify_admin(reqBody, err_code=16004001)
if "id" not in reqBody:
return Response({"result": 16004006, "msg": getErrMsgByCode(16004006, None)}, content_type="application/json")
else:
serverID = reqBody["id"]
try:
rtspServerObj = RTSPServerDB.objects.get(id=serverID)
except Exception as err:
return Response({"result": 16004007, "msg": getErrMsgByCode(16004007, err)}, content_type="application/json")
try:
rtspServerObj.delete()
except Exception as err:
return Response({"result": 16004008, "msg": getErrMsgByCode(16004008, err)}, content_type="application/json")
return Response({"result": 0, "msg": "OK"}, content_type="application/json")
def userAccountRegistered(request):
"""
用户信息--是否注册
registered: 0未注册, 1已注册
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 10006001,
"msg": getErrMsgByCode(10006001, err)
},
content_type="application/json")
if reqbody_verify_admin(reqBody, err_code=10006001) is None:
pass
else:
return reqbody_verify_admin(reqBody, err_code=10006001)
if "login" not in reqBody:
return Response(
{
"result": 10006006,
"msg": getErrMsgByCode(10006006, None)
},
content_type="application/json")
else:
userLogin = reqBody["login"]
resData = {}
try:
userObj = userDB.objects.filter(login=userLogin)
for item in userObj:
print(item.login)
if userObj:
resData["registered"] = 1
else:
resData["registered"] = 0
except Exception as err:
return Response(
{
"result": 10006007,
"msg": getErrMsgByCode(10006007, None)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK",
"data": resData
},
content_type="application/json")
def deleteOptionInfo(request):
"""
配置信息--删除
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 28004001,
"msg": getErrMsgByCode(28004001, err)
},
content_type="application/json")
if reqbody_verify_admin(reqBody, err_code=28004001) is None:
pass
else:
return reqbody_verify_admin(reqBody, err_code=28004001)
if "id" not in reqBody:
return Response(
{
"result": 28004006,
"msg": getErrMsgByCode(28004006, None)
},
content_type="application/json")
else:
optID = reqBody["id"]
try:
optObj = OptionSysDB.objects.get(id=optID)
except Exception as err:
return Response(
{
"result": 28004007,
"msg": getErrMsgByCode(28004007, err)
},
content_type="application/json")
try:
optObj.delete()
except Exception as err:
return Response(
{
"result": 28004008,
"msg": getErrMsgByCode(28004008, err)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK"
},
content_type="application/json")
def rtspDeviceInfoDelete(request):
"""
Rtsp信息--删除
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 17005001,
"msg": getErrMsgByCode(17005001, err)
},
content_type="application/json")
if reqbody_verify_admin(reqBody, err_code=17005001) is None:
pass
else:
return reqbody_verify_admin(reqBody, err_code=17005001)
if "id" not in reqBody:
return Response(
{
"result": 17005006,
"msg": getErrMsgByCode(17005006, None)
},
content_type="application/json")
else:
deviceID = reqBody["id"]
try:
deviceObj = RTSPDeviceDB.objects.get(id=deviceID)
except Exception as err:
return Response(
{
"result": 17005007,
"msg": getErrMsgByCode(17005007, err)
},
content_type="application/json")
try:
deviceObj.delete()
except Exception as err:
return Response(
{
"result": 17005008,
"msg": getErrMsgByCode(17005008, err)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK"
},
content_type="application/json")
def deleteTemplateInfo(request):
"""
SMS短信模板--删除
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 19005001,
"msg": getErrMsgByCode(19005001, err)
},
content_type="application/json")
if reqbody_verify_admin(reqBody, err_code=19005001) is None:
pass
else:
return reqbody_verify_admin(reqBody, err_code=19005001)
if "id" not in reqBody:
return Response(
{
"result": 19005006,
"msg": getErrMsgByCode(19005006, None)
},
content_type="application/json")
else:
infoID = reqBody["id"]
try:
infoObj = infoTempDB.objects.get(id=infoID)
except Exception as err:
return Response(
{
"result": 19005007,
"msg": getErrMsgByCode(19005007, err)
},
content_type="application/json")
try:
infoObj.delete()
except Exception as err:
return Response(
{
"result": 19005008,
"msg": getErrMsgByCode(19005008, err)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK"
},
content_type="application/json")
def AirtspRecordInfoQuery(request):
"""
AI 录像记录--查询
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 17015001,
"msg": getErrMsgByCode(17015001, err)
},
content_type="application/json")
if reqbody_verify_admin(reqBody, err_code=17015001) is None:
pass
else:
return reqbody_verify_admin(reqBody, err_code=17015001)
resData = []
try:
AirtspDeviceObjs = AiRtspRecordDB.objects.all()
for item in AirtspDeviceObjs:
deviceObj = {}
deviceObj["id"] = item.id
deviceObj["ipc"] = item.ipc
deviceObj["record_code"] = item.record_code
deviceObj["start_time"] = item.start_time
deviceObj["end_time"] = item.end_time
resData.append(deviceObj)
except Exception as err:
return Response(
{
"result": 17015006,
"msg": getErrMsgByCode(17015006, err)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK",
"data": resData
},
content_type="application/json")
def addSMSTemplateInfo(request):
"""
SMS短信模板--新增
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 19002001,
"msg": getErrMsgByCode(19002001, err)
},
content_type="application/json")
if reqbody_verify_admin(reqBody, err_code=19002001) is None:
pass
else:
return reqbody_verify_admin(reqBody, err_code=19002001)
if "user" not in reqBody:
return Response(
{
"result": 19002006,
"msg": getErrMsgByCode(19002006, None)
},
content_type="application/json")
else:
userID = reqBody["user"]
if "name" not in reqBody:
return Response(
{
"result": 19002007,
"msg": getErrMsgByCode(19002007, None)
},
content_type="application/json")
else:
tempName = reqBody["name"]
if "content" not in reqBody:
return Response(
{
"result": 19002008,
"msg": getErrMsgByCode(19002008, None)
},
content_type="application/json")
else:
tempContent = reqBody["content"]
if "type" not in reqBody:
return Response(
{
"result": 19002009,
"msg": getErrMsgByCode(19002009, None)
},
content_type="application/json")
else:
tempType = reqBody["type"]
tempInfoObj = infoTempDB()
tempInfoObj.user = userID
tempInfoObj.name = tempName
tempInfoObj.content = tempContent
tempInfoObj.type = tempType
try:
tempInfoObj.save()
except Exception as err:
return Response(
{
"result": 19002010,
"msg": getErrMsgByCode(19002010, err)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK"
},
content_type="application/json")
def rtspDeviceInfoModify(request):
"""
Rtsp设备信息--修改
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 17002001,
"msg": getErrMsgByCode(17002001, err)
},
content_type="application/json")
if reqbody_verify_admin(reqBody, err_code=17002001) is None:
pass
else:
return reqbody_verify_admin(reqBody, err_code=17002001)
if "id" not in reqBody:
return Response(
{
"result": 17002006,
"msg": getErrMsgByCode(17002006, None)
},
content_type="application/json")
else:
deviceID = reqBody["id"]
deviceName = None
deviceDept = None
deviceType = None
deviceServer = None
deviceChannel = None
deviceLon = None
deviceLat = None
deviceHeight = None
deviceLocate = None
deviceEnable = None
deviceManufacturerType = None
devicePermissionsInfo = None
deviceChannelType = None
deviceInterCodeSN = None
deviceMulticastIp = None
deviceMulticastPort = None
if "name" in reqBody:
deviceName = reqBody["name"]
if "dept" in reqBody:
deviceDept = reqBody["dept"]
if "type" in reqBody:
deviceType = reqBody["type"]
if "server" in reqBody:
deviceServer = reqBody["server"]
if "channel" in reqBody:
deviceChannel = reqBody["channel"]
if "longitude" in reqBody:
deviceLon = reqBody["longitude"]
if "latitude" in reqBody:
deviceLat = reqBody["latitude"]
if "height" in reqBody:
deviceHeight = reqBody["height"]
if "locate" in reqBody:
deviceLocate = reqBody["locate"]
if "enable" in reqBody:
deviceEnable = reqBody["enable"]
if "manufacturer_type" in reqBody:
deviceManufacturerType = reqBody["manufacturer_type"]
if "permissions_info" in reqBody:
devicePermissionsInfo = reqBody["permissions_info"]
if "channel_type" in reqBody:
deviceChannelType = reqBody["channel_type"]
if "inter_code_SN" in reqBody:
deviceInterCodeSN = reqBody["inter_code_SN"]
if "multicast_ip" in reqBody:
deviceMulticastIp = reqBody["multicast_ip"]
if "multicast_port" in reqBody:
deviceMulticastPort = reqBody["multicast_port"]
try:
deviceObj = RTSPDeviceDB.objects.get(id=deviceID)
except Exception as err:
return Response(
{
"result": 17002007,
"msg": getErrMsgByCode(17002007, err)
},
content_type="application/json")
if deviceName is not None:
deviceObj.name = deviceName
if deviceDept is not None:
deviceObj.dept = deviceDept
if deviceType is not None:
deviceObj.type = deviceType
if deviceServer is not None:
deviceObj.server = deviceServer
if deviceChannel is not None:
deviceObj.channel = deviceChannel
if deviceLon is not None:
deviceObj.longitude = deviceLon
if deviceLat is not None:
deviceObj.latitude = deviceLat
if deviceHeight is not None:
deviceObj.height = deviceHeight
if deviceLocate is not None:
deviceObj.locate = deviceLocate
if deviceEnable is not None:
deviceObj.enable = deviceEnable
if deviceManufacturerType is not None:
deviceObj.manufacturer_type = deviceManufacturerType
if devicePermissionsInfo is not None:
deviceObj.permissions_info = devicePermissionsInfo
if deviceChannelType is not None:
deviceObj.channel_type = deviceChannelType
if deviceInterCodeSN is not None:
deviceObj.inter_code_SN = deviceInterCodeSN
if deviceMulticastIp is not None:
deviceObj.multicast_ip = deviceMulticastIp
if deviceMulticastPort is not None:
deviceObj.multicast_port = deviceMulticastPort
try:
deviceObj.save()
except Exception as err:
return Response(
{
"result": 17002008,
"msg": getErrMsgByCode(17002008, err)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK"
},
content_type="application/json")
def rtspDeviceInfoAdd(request):
"""
Rtsp设备信息--新增
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 17001001,
"msg": getErrMsgByCode(17001001, err)
},
content_type="application/json")
if reqbody_verify_admin(reqBody, err_code=17001001) is None:
pass
else:
return reqbody_verify_admin(reqBody, err_code=17001001)
if "name" not in reqBody:
return Response(
{
"result": 17001002,
"msg": getErrMsgByCode(17001002, None)
},
content_type="application/json")
else:
deviceName = reqBody["name"]
if "dept" not in reqBody:
return Response(
{
"result": 17001003,
"msg": getErrMsgByCode(17001003, None)
},
content_type="application/json")
else:
deviceDept = reqBody["dept"]
if "type" not in reqBody:
return Response(
{
"result": 17001004,
"msg": getErrMsgByCode(17001004, None)
},
content_type="application/json")
else:
deviceType = reqBody["type"]
if "server" not in reqBody:
return Response(
{
"result": 17001005,
"msg": getErrMsgByCode(17001005, None)
},
content_type="application/json")
else:
deviceServer = reqBody["server"]
if "channel" not in reqBody:
return Response(
{
"result": 17001006,
"msg": getErrMsgByCode(17001006, None)
},
content_type="application/json")
else:
deviceChannel = reqBody["channel"]
if "enable" not in reqBody:
return Response(
{
"result": 17001007,
"msg": getErrMsgByCode(17001007, None)
},
content_type="application/json")
else:
deviceEnable = reqBody["enable"]
# if "longitude" not in reqBody:
# return Response({"result": 17001008, "msg": getErrMsgByCode(17001008, None)}, content_type="application/json")
# else:
# deviceLon = reqBody["longitude"]
# if "latitude" not in reqBody:
# return Response({"result": 17001009, "msg": getErrMsgByCode(17001009, None)}, content_type="application/json")
# else:
# deviceLat = reqBody["latitude"]
#
# if "height" not in reqBody:
# return Response({"result": 17001010, "msg": getErrMsgByCode(17001010, None)}, content_type="application/json")
# else:
# deviceHeight = reqBody["height"]
if "locate" not in reqBody:
return Response(
{
"result": 17001011,
"msg": getErrMsgByCode(17001011, None)
},
content_type="application/json")
else:
deviceLocate = reqBody["locate"]
if "manufacturer_type" not in reqBody:
return Response(
{
"result": 17001012,
"msg": getErrMsgByCode(17001012, None)
},
content_type="application/json")
else:
manufacturerType = reqBody["manufacturer_type"]
if "permissions_info" not in reqBody:
return Response(
{
"result": 17001013,
"msg": getErrMsgByCode(17001013, None)
},
content_type="application/json")
else:
permissionsInfo = reqBody["permissions_info"]
if "channel_type" not in reqBody:
return Response(
{
"result": 17001014,
"msg": getErrMsgByCode(17001014, None)
},
content_type="application/json")
else:
channelType = reqBody["channel_type"]
if "inter_code_SN" not in reqBody:
return Response(
{
"result": 17001015,
"msg": getErrMsgByCode(17001015, None)
},
content_type="application/json")
else:
interCodeSN = reqBody["inter_code_SN"]
# if "multicast_ip" not in reqBody:
# return Response({"result": 17001016, "msg": getErrMsgByCode(17001016, None)}, content_type="application/json")
# else:
# multicastIp = reqBody["multicast_ip"]
# if "multicast_port" not in reqBody:
# return Response({"result": 17001017, "msg": getErrMsgByCode(17001017, None)}, content_type="application/json")
# else:
# multicastPort = reqBody["multicast_port"]
deviceLon = None
deviceLat = None
deviceHeight = None
multicastIp = None
multicastPort = None
if "longitude" in reqBody:
deviceLon = reqBody["longitude"]
if "latitude" in reqBody:
deviceLat = reqBody["latitude"]
if "height" in reqBody:
deviceHeight = reqBody["height"]
if "multicast_ip" in reqBody:
multicastIp = reqBody["multicast_ip"]
if "multicast_port" in reqBody:
multicastPort = reqBody["multicast_port"]
deviceObj = RTSPDeviceDB()
deviceObj.name = deviceName
deviceObj.dept = deviceDept
deviceObj.type = deviceType
deviceObj.server = deviceServer
deviceObj.channel = deviceChannel
deviceObj.enable = deviceEnable
deviceObj.longitude = deviceLon
deviceObj.latitude = deviceLat
deviceObj.height = deviceHeight
deviceObj.locate = deviceLocate
deviceObj.manufacturer_type = manufacturerType
deviceObj.permissions_info = permissionsInfo
deviceObj.channel_type = channelType
deviceObj.inter_code_SN = interCodeSN
deviceObj.multicast_ip = multicastIp
deviceObj.multicast_port = multicastPort
try:
deviceObj.save()
except Exception as err:
Response({
"result": 17001018,
"msg": getErrMsgByCode(17001018, err)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK"
},
content_type="application/json")
def aiRtspDeviceInfoAdd(request):
"""
Rtsp设备信息--新增
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 17011001,
"msg": getErrMsgByCode(17011001, err)
},
content_type="application/json")
if reqbody_verify_admin(reqBody, err_code=17011001) is None:
pass
else:
return reqbody_verify_admin(reqBody, err_code=17011001)
if "ai_id" not in reqBody:
return Response(
{
"result": 17011006,
"msg": getErrMsgByCode(17011006, None)
},
content_type="application/json")
else:
aiId = reqBody["ai_id"]
if "name" not in reqBody:
return Response(
{
"result": 17011007,
"msg": getErrMsgByCode(17011007, None)
},
content_type="application/json")
else:
deviceName = reqBody["name"]
if "dept" not in reqBody:
return Response(
{
"result": 17011008,
"msg": getErrMsgByCode(17011008, None)
},
content_type="application/json")
else:
deviceDept = reqBody["dept"]
if "code" not in reqBody:
return Response(
{
"result": 17011009,
"msg": getErrMsgByCode(17011009, None)
},
content_type="application/json")
else:
deviceCode = reqBody["code"]
if "enable" not in reqBody:
return Response(
{
"result": 17011010,
"msg": getErrMsgByCode(17011010, None)
},
content_type="application/json")
else:
deviceEnable = reqBody["enable"]
if "locate" not in reqBody:
return Response(
{
"result": 17011011,
"msg": getErrMsgByCode(17011011, None)
},
content_type="application/json")
else:
deviceLocate = reqBody["locate"]
if "channel" not in reqBody:
return Response(
{
"result": 17011012,
"msg": getErrMsgByCode(17011012, None)
},
content_type="application/json")
else:
channel = reqBody["channel"]
deviceLon = None
deviceLat = None
deviceHeight = None
if "longitude" in reqBody:
deviceLon = reqBody["longitude"]
if "latitude" in reqBody:
deviceLat = reqBody["latitude"]
if "height" in reqBody:
deviceHeight = reqBody["height"]
deviceObj = videoMonitorDB()
deviceObj.name = deviceName
deviceObj.ai_device_id = aiId
deviceObj.code = deviceCode
deviceObj.channel = channel
deviceObj.dept = deviceDept
deviceObj.enable = deviceEnable
deviceObj.longitude = deviceLon
deviceObj.latitude = deviceLat
deviceObj.height = deviceHeight
deviceObj.locate = deviceLocate
try:
deviceObj.save()
except Exception as err:
Response({
"result": 17011013,
"msg": getErrMsgByCode(17011013, err)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK"
},
content_type="application/json")
def AIrtspDeviceInfoModify(request):
"""
AI Rtsp设备信息--修改
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 17012001,
"msg": getErrMsgByCode(17012001, err)
},
content_type="application/json")
if reqbody_verify_admin(reqBody, err_code=17012001) is None:
pass
else:
return reqbody_verify_admin(reqBody, err_code=17012001)
if "id" not in reqBody:
return Response(
{
"result": 17012006,
"msg": getErrMsgByCode(17012006, None)
},
content_type="application/json")
else:
deviceID = reqBody["id"]
deviceName = None
deviceDept = None
# deviceAiId=None
deviceCode = None
deviceChannel = None
deviceLon = None
deviceLat = None
deviceHeight = None
deviceLocate = None
deviceEnable = None
if "name" in reqBody:
deviceName = reqBody["name"]
if "dept" in reqBody:
deviceDept = reqBody["dept"]
# if "ai_id" in reqBody:
# deviceAiId = reqBody["ai_id"]
if "code" in reqBody:
deviceCode = reqBody["code"]
if "channel" in reqBody:
deviceChannel = reqBody["channel"]
if "longitude" in reqBody:
deviceLon = reqBody["longitude"]
if "latitude" in reqBody:
deviceLat = reqBody["latitude"]
if "height" in reqBody:
deviceHeight = reqBody["height"]
if "locate" in reqBody:
deviceLocate = reqBody["locate"]
if "enable" in reqBody:
deviceEnable = reqBody["enable"]
try:
deviceObj = videoMonitorDB.objects.get(id=deviceID)
except Exception as err:
return Response(
{
"result": 17012007,
"msg": getErrMsgByCode(17012007, err)
},
content_type="application/json")
if deviceName is not None:
deviceObj.name = deviceName
if deviceDept is not None:
deviceObj.dept = deviceDept
# if deviceAiId is not None:
# deviceObj.ai_device_id = deviceAiId
if deviceCode is not None:
deviceObj.code = deviceCode
if deviceChannel is not None:
deviceObj.channel = deviceChannel
if deviceLon is not None:
deviceObj.longitude = deviceLon
if deviceLat is not None:
deviceObj.latitude = deviceLat
if deviceHeight is not None:
deviceObj.height = deviceHeight
if deviceLocate is not None:
deviceObj.locate = deviceLocate
if deviceEnable is not None:
deviceObj.enable = deviceEnable
try:
deviceObj.save()
except Exception as err:
return Response(
{
"result": 17012008,
"msg": getErrMsgByCode(17012008, err)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK"
},
content_type="application/json")
def addOptionInfo(request):
"""
配置信息--新增
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 28001001,
"msg": getErrMsgByCode(28001001, err)
},
content_type="application/json")
if reqbody_verify_admin(reqBody, err_code=28001001) is None:
pass
else:
return reqbody_verify_admin(reqBody, err_code=28001001)
if "name" not in reqBody:
return Response(
{
"result": 28001006,
"msg": getErrMsgByCode(28001006, None)
},
content_type="application/json")
else:
optName = reqBody["name"]
if "key" not in reqBody:
return Response(
{
"result": 28001007,
"msg": getErrMsgByCode(28001007, None)
},
content_type="application/json")
else:
optKey = reqBody["key"]
if "value" not in reqBody:
return Response(
{
"result": 28001008,
"msg": getErrMsgByCode(28001008, None)
},
content_type="application/json")
else:
optValue = reqBody["value"]
if "modify" not in reqBody:
return Response(
{
"result": 28001009,
"msg": getErrMsgByCode(28001009, None)
},
content_type="application/json")
else:
optModify = reqBody["modify"]
try:
optObj = OptionSysDB.objects.filter(opt_key=optKey)
except Exception as err:
return Response(
{
"result": 28001010,
"msg": getErrMsgByCode(28001010, err)
},
content_type="application/json")
if optObj:
return Response(
{
"result": 28001011,
"msg": getErrMsgByCode(28001011, None)
},
content_type="application/json")
optObj = OptionSysDB()
optObj.opt_name = optName
optObj.opt_key = optKey
optObj.opt_value = optValue
optObj.opt_modify = optModify
try:
optObj.save()
except Exception as err:
return Response(
{
"result": 28001012,
"msg": getErrMsgByCode(28001012, err)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK",
"data": optObj.id
},
content_type="application/json")
def rtspRecordInfoQuery(request):
"""
录像记录--查询
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 17010001,
"msg": getErrMsgByCode(17010001, err)
},
content_type="application/json")
if reqbody_verify_admin(reqBody, err_code=17010001) is None:
pass
else:
return reqbody_verify_admin(reqBody, err_code=17010001)
# deviceID = None
# if "device" not in reqBody:
# return Response({"result": 17010006, "msg": getErrMsgByCode(17010006, None)}, content_type="application/json")
# else:
# deviceID = reqBody["device"]
afterTime = None
beforeTime = None
indexPage = None
countInfo = None
orderInfo = None
if "after" in reqBody:
afterTime = reqBody["after"]
if "before" in reqBody:
beforeTime = reqBody["before"]
if "page" in reqBody:
indexPage = reqBody["page"]
if "count" in reqBody:
countInfo = reqBody["count"]
if "order" in reqBody:
orderInfo = reqBody["order"]
resData = {}
try:
if afterTime and beforeTime:
recordObjs = RTSPRecordDB.objects.filter(type=0,
time__gt=afterTime,
time__lt=beforeTime)
else:
# recordObjs = RTSPRecordDB.objects.filter(ipc=deviceID, type=0)
recordObjs = RTSPRecordDB.objects.filter(type=0)
if orderInfo == 1:
recordObjs = recordObjs.order_by("-time")
else:
recordObjs = recordObjs.order_by("time")
resultInfoListAll = []
for obj in recordObjs:
imInfo = {}
imInfo["id"] = obj.id
imInfo["ipc"] = obj.ipc
imInfo["user"] = obj.user
imInfo["record_code"] = obj.record_code
imInfo["type"] = obj.type
imInfo["start"] = obj.time
# endObj = RTSPRecordDB.objects.filter(ipc=deviceID, record_code=obj.record_code, type=1)
endObj = RTSPRecordDB.objects.filter(record_code=obj.record_code,
type=1)
if endObj:
imInfo["end"] = endObj[0].time
resultInfoListAll.append(imInfo)
resultInfoList = []
if indexPage and countInfo:
indexStart = (indexPage - 1) * countInfo
if indexStart < 0:
indexStart = 0
indexEnd = indexStart + countInfo
if indexEnd >= len(resultInfoListAll):
indexEnd = len(resultInfoListAll)
resultInfoList = resultInfoListAll[indexStart:indexEnd]
else:
resultInfoList = resultInfoListAll
resData["total"] = len(resultInfoListAll)
resData["info"] = resultInfoList
except Exception as err:
return Response(
{
"result": 17010007,
"msg": getErrMsgByCode(17010007, err)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK",
"data": resData
},
content_type="application/json")
def rtspDeviceInfoSort(request):
"""
Rtsp设备信息--排序
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 17006001,
"msg": getErrMsgByCode(17006001, err)
},
content_type="application/json")
if reqbody_verify_admin(reqBody, err_code=17006001) is None:
pass
else:
return reqbody_verify_admin(reqBody, err_code=17006001)
if "id" not in reqBody:
return Response(
{
"result": 17006006,
"msg": getErrMsgByCode(17006006, None)
},
content_type="application/json")
else:
deptID = reqBody["id"]
if "devices" not in reqBody:
return Response(
{
"result": 17006007,
"msg": getErrMsgByCode(17006007, None)
},
content_type="application/json")
else:
deviceList = reqBody["devices"]
savePoint = transaction.savepoint()
try:
i = 1
for device in deviceList:
RTSPDeviceDB.objects.filter(id=device).update(position=i)
i += 1
except Exception as err:
transaction.savepoint_rollback(savePoint)
return Response(
{
"result": 17006008,
"msg": getErrMsgByCode(17006008, err)
},
content_type="application/json")
transaction.savepoint_commit(savePoint)
return Response({
"result": 0,
"msg": "OK"
},
content_type="application/json")
def userInfoAdd(request):
"""
用户信息--新增
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 10002001,
"msg": getErrMsgByCode(10002001, err)
},
content_type="application/json")
if reqbody_verify_admin(reqBody, err_code=10002001) is None:
pass
else:
return reqbody_verify_admin(reqBody, err_code=10002001)
if "login" not in reqBody:
return Response(
{
"result": 10002006,
"msg": getErrMsgByCode(10002006, None)
},
content_type="application/json")
else:
userLogin = reqBody["login"]
if userDB.objects.filter(login=userLogin):
return Response(
{
"result": 10002007,
"msg": getErrMsgByCode(10002007, None)
},
content_type="application/json")
if "password" not in reqBody:
return Response(
{
"result": 10002008,
"msg": getErrMsgByCode(10002008, None)
},
content_type="application/json")
else:
userPwd = reqBody["password"]
if "nickname" not in reqBody:
return Response(
{
"result": 10002009,
"msg": getErrMsgByCode(10002009, None)
},
content_type="application/json")
else:
userName = reqBody["nickname"]
if "dept" not in reqBody:
return Response(
{
"result": 10002010,
"msg": getErrMsgByCode(10002010, None)
},
content_type="application/json")
else:
userDept = reqBody["dept"]
if "enable" not in reqBody:
return Response(
{
"result": 10002012,
"msg": getErrMsgByCode(10002012, None)
},
content_type="application/json")
else:
userEnable = reqBody["enable"]
if "role" not in reqBody:
return Response(
{
"result": 10002013,
"msg": getErrMsgByCode(10002013, None)
},
content_type="application/json")
else:
userRole = reqBody["role"]
userLat = None
userLon = None
userHeight = None
userLocal = None
if userRole < 10:
if "latitude" not in reqBody:
userLat = 0.0
else:
userLat = reqBody["latitude"]
if "longitude" not in reqBody:
userLon = 0.0
else:
userLon = reqBody["longitude"]
if "height" not in reqBody:
userHeight = 0.0
else:
userHeight = reqBody["height"]
if "locate" not in reqBody:
userLocal = ""
else:
userLocal = reqBody["locate"]
userObj = userDB()
userObj.login = userLogin
userObj.password = mysql_password(userPwd)
userObj.nickname = userName
userObj.dept = userDept
userObj.enable = userEnable
userObj.role = userRole
if userRole < 10:
userObj.latitude = userLat
userObj.longitude = userLon
userObj.height = userHeight
userObj.locate = userLocal
if "email" in reqBody:
userObj.email = reqBody["email"]
if "mobile" in reqBody:
userObj.mobile = reqBody["mobile"]
if "phone" in reqBody:
userObj.phone = reqBody["phone"]
if "level" in reqBody:
userObj.level = reqBody["level"]
savePoint = transaction.savepoint()
try:
userObj.save()
except Exception as err:
transaction.savepoint_rollback(savePoint)
Response({
"result": 10002019,
"msg": getErrMsgByCode(10002019, None)
},
content_type="application/json")
transaction.savepoint_commit(savePoint)
addOperationLog(reqBody["login"], "添加用户", "用户添加成功", "用户添加成功")
return Response({
"result": 0,
"msg": "OK"
},
content_type="application/json")
def memberInfoSort(request):
"""
部门成员信息--排序
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 11007001,
"msg": getErrMsgByCode(11007001, err)
},
content_type="application/json")
if reqbody_verify_admin(reqBody, err_code=11007001) is None:
pass
else:
return reqbody_verify_admin(reqBody, err_code=11007001)
if "id" not in reqBody:
return Response(
{
"result": 11007006,
"msg": getErrMsgByCode(11007006, None)
},
content_type="application/json")
else:
deptID = reqBody["id"]
if "member" not in reqBody:
return Response(
{
"result": 11007007,
"msg": getErrMsgByCode(11007007, None)
},
content_type="application/json")
else:
memberList = reqBody["member"]
savePoint = transaction.savepoint()
try:
i = 1
for member in memberList:
userDB.objects.filter(id=member, dept=deptID).update(position=i)
i += 1
except Exception as err:
transaction.savepoint_rollback(savePoint)
return Response(
{
"result": 11007008,
"msg": getErrMsgByCode(11007008, err)
},
content_type="application/json")
transaction.savepoint_commit(savePoint)
return Response({
"result": 0,
"msg": "OK"
},
content_type="application/json")
def deleteDeptInfo(request):
"""
部门信息--删除
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 11004001,
"msg": getErrMsgByCode(11004001, err)
},
content_type="application/json")
if reqbody_verify_admin(reqBody, err_code=11004001) is None:
pass
else:
return reqbody_verify_admin(reqBody, err_code=11004001)
tokenInfo = tokenDecode(reqBody["token"])
if "id" not in reqBody:
return Response(
{
"result": 11004006,
"msg": getErrMsgByCode(11004006, None)
},
content_type="application/json")
else:
deptID = reqBody["id"]
subDeptIDs = getSubDeptList(deptID)
if subDeptIDs is None:
pass
else:
return Response(
{
"result": 11004007,
"msg": getErrMsgByCode(11004007, None)
},
content_type="application/json")
deptMemberIDs = getDeptMemeberList(deptID)
if deptMemberIDs is None:
pass
else:
return Response(
{
"result": 11004008,
"msg": getErrMsgByCode(11004008, None)
},
content_type="application/json")
try:
deptObj = deptDB.objects.get(id=deptID)
deptObj.delete()
except Exception as err:
return Response(
{
"result": 11004009,
"msg": getErrMsgByCode(11004009, err)
},
content_type="application/json")
addOperationLog(tokenInfo["login"], "删除部门信息", "删除部门信息成功", "删除部门信息成功")
return Response({
"result": 0,
"msg": "OK"
},
content_type="application/json")
def modifyDeptInfo(request):
"""
部门信息--修改
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 11002001,
"msg": getErrMsgByCode(11002001, err)
},
content_type="application/json")
if reqbody_verify_admin(reqBody, err_code=11002001) is None:
pass
else:
return reqbody_verify_admin(reqBody, err_code=11002001)
tokenInfo = tokenDecode(reqBody["token"])
if "id" not in reqBody:
return Response(
{
"result": 11002006,
"msg": getErrMsgByCode(11002006, None)
},
content_type="application/json")
else:
deptID = reqBody["id"]
deptName = None
deptPID = None
deptEnable = None
if "name" in reqBody:
deptName = reqBody["name"]
if "pid" in reqBody:
deptPID = reqBody["pid"]
if "enable" in reqBody:
deptEnable = reqBody["enable"]
deptPath = None
if deptPID is not None:
try:
pDeptObj = deptDB.objects.get(id=deptPID)
if pDeptObj.path == "/":
deptPath = pDeptObj.path + str(deptPID)
else:
deptPath = pDeptObj.path + "/" + str(deptPID)
except deptDB.DoesNotExist:
return Response(
{
"result": 11002007,
"msg": getErrMsgByCode(11002007, None)
},
content_type="application/json")
try:
deptObj = deptDB.objects.get(id=deptID)
if deptName is not None:
deptObj.name = deptName
if deptPID is not None:
deptObj.pid = deptPID
if deptEnable is not None:
deptObj.enable = deptEnable
if deptPath is not None:
deptObj.path = deptPath
deptObj.save()
except Exception as err:
return Response(
{
"result": 11002008,
"msg": getErrMsgByCode(11002008, err)
},
content_type="application/json")
addOperationLog(tokenInfo["login"], "修改部门信息", "修改部门信息成功", "修改部门信息成功")
return Response({
"result": 0,
"msg": "OK"
},
content_type="application/json")
def addDeptInfo(request):
"""
部门信息--新增
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 11001001,
"msg": getErrMsgByCode(11001001, err)
},
content_type="application/json")
if reqbody_verify_admin(reqBody, err_code=11001001) is None:
pass
else:
return reqbody_verify_admin(reqBody, err_code=11001001)
tokenInfo = tokenDecode(reqBody["token"])
if "name" not in reqBody:
return Response(
{
"result": 11001006,
"msg": getErrMsgByCode(11001006, None)
},
content_type="application/json")
else:
deptName = reqBody["name"]
if "pid" not in reqBody:
return Response(
{
"result": 11001007,
"msg": getErrMsgByCode(11001007, None)
},
content_type="application/json")
else:
deptPID = reqBody["pid"]
if "enable" not in reqBody:
return Response(
{
"result": 11001008,
"msg": getErrMsgByCode(11001008, None)
},
content_type="application/json")
else:
deptEnable = reqBody["enable"]
if "position" not in reqBody:
deptPosition = 32767
else:
deptPosition = reqBody["position"]
try:
pDeptObj = deptDB.objects.get(id=deptPID)
if pDeptObj.path == "/":
deptPath = pDeptObj.path + str(deptPID)
else:
deptPath = pDeptObj.path + "/" + str(deptPID)
except deptDB.DoesNotExist:
return Response(
{
"result": 11001009,
"msg": getErrMsgByCode(11001009, None)
},
content_type="application/json")
try:
deptInfo = deptDB(name=deptName,
pid=deptPID,
enable=deptEnable,
path=deptPath,
position=deptPosition)
deptInfo.save()
except Exception as err:
return Response(
{
"result": 11001010,
"msg": getErrMsgByCode(11001010, err)
},
content_type="application/json")
addOperationLog(tokenInfo["login"], "新增部门信息", "新增部门信息成功", "新增部门信息成功")
return Response({
"result": 0,
"msg": "OK"
},
content_type="application/json")
def queryOperationInfo(request):
"""
操作日志--查询
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 23002001,
"msg": getErrMsgByCode(23002001, err)
},
content_type="application/json")
if reqbody_verify_admin(reqBody, err_code=23002001) is None:
pass
else:
return reqbody_verify_admin(reqBody, err_code=23002001)
deptID = None
if "dept" in reqBody:
deptID = reqBody["dept"]
if "user_login_list" in reqBody:
userLoginList = reqBody["user_login_list"]
else:
userLoginList = getAllDeptMemberLoginList(deptID)
afterTime = None
beforeTime = None
indexPage = None
countInfo = None
orderInfo = None
if "after" in reqBody:
afterTime = reqBody["after"]
if "before" in reqBody:
beforeTime = reqBody["before"]
if "page" in reqBody:
indexPage = reqBody["page"]
if "count" in reqBody:
countInfo = reqBody["count"]
if "order" in reqBody:
orderInfo = reqBody["order"]
resData = {}
try:
if afterTime and beforeTime:
imLogObjs = OperationLogDB.objects.filter(user__in=userLoginList,
time__gt=afterTime,
time__lt=beforeTime)
else:
imLogObjs = OperationLogDB.objects.filter(user__in=userLoginList)
if orderInfo == 1:
imLogObjs = imLogObjs.order_by("-time")
else:
imLogObjs = imLogObjs.order_by("time")
if indexPage and countInfo:
indexStart = (indexPage - 1) * countInfo
if indexStart < 0:
indexStart = 0
indexEnd = indexStart + countInfo
if indexEnd >= imLogObjs.count():
indexEnd = imLogObjs.count()
resultObjList = imLogObjs[indexStart:indexEnd]
else:
resultObjList = imLogObjs
resultInfoList = []
for obj in resultObjList:
imInfo = {}
imInfo["id"] = obj.id
imInfo["user"] = obj.user
imInfo["type"] = obj.type
imInfo["result"] = obj.result
imInfo["note"] = obj.note
imInfo["time"] = obj.time
resultInfoList.append(imInfo)
resData["total"] = imLogObjs.count()
resData["info"] = resultInfoList
except Exception as err:
return Response(
{
"result": 23002006,
"msg": getErrMsgByCode(23002006, err)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK",
"data": resData
},
content_type="application/json")
def addRtspServerInfo(request):
"""
Rtsp服务信息--新增
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response({"result": 16001001, "msg": getErrMsgByCode(16001001, err)}, content_type="application/json")
if reqbody_verify_admin(reqBody, err_code=16001001) is None:
pass
else:
return reqbody_verify_admin(reqBody, err_code=16001001)
if "name" not in reqBody:
return Response({"result": 16001006, "msg": getErrMsgByCode(16001006, None)}, content_type="application/json")
else:
serverName = reqBody["name"]
if "ip" not in reqBody:
return Response({"result": 16001007, "msg": getErrMsgByCode(16001007, None)}, content_type="application/json")
else:
serverIP = reqBody["ip"]
if "port" not in reqBody:
return Response({"result": 16001008, "msg": getErrMsgByCode(16001008, None)}, content_type="application/json")
else:
serverPort = reqBody["port"]
if "user" not in reqBody:
return Response({"result": 16001009, "msg": getErrMsgByCode(16001009, None)}, content_type="application/json")
else:
serverUser = reqBody["user"]
if "password" not in reqBody:
return Response({"result": 16001010, "msg": getErrMsgByCode(16001010, None)}, content_type="application/json")
else:
serverPassword = reqBody["password"]
if "channels" not in reqBody:
return Response({"result": 16001011, "msg": getErrMsgByCode(16001011, None)}, content_type="application/json")
else:
serverChannels = reqBody["channels"]
if "type" not in reqBody:
return Response({"result": 16001012, "msg": getErrMsgByCode(16001012, None)}, content_type="application/json")
else:
serverType = reqBody["type"]
if "enable" not in reqBody:
return Response({"result": 16001013, "msg": getErrMsgByCode(16001013, None)}, content_type="application/json")
else:
serverEnable = reqBody["enable"]
rtspServerObj = RTSPServerDB()
rtspServerObj.name = serverName
rtspServerObj.ip = serverIP
rtspServerObj.port = serverPort
rtspServerObj.user = serverUser
rtspServerObj.password = serverPassword
rtspServerObj.channels = serverChannels
rtspServerObj.type = serverType
rtspServerObj.enable = serverEnable
try:
rtspServerObj.save()
except Exception as err:
return Response({"result": 16001014, "msg": getErrMsgByCode(16001014, err)}, content_type="application/json")
return Response({"result": 0, "msg": "OK"}, content_type="application/json")
def modifyTemplateInfo(request):
"""
SMS短信模板--修改
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 19003001,
"msg": getErrMsgByCode(19003001, err)
},
content_type="application/json")
if reqbody_verify_admin(reqBody, err_code=19003001) is None:
pass
else:
return reqbody_verify_admin(reqBody, err_code=19003001)
if "id" not in reqBody:
return Response(
{
"result": 19003006,
"msg": getErrMsgByCode(19003006, None)
},
content_type="application/json")
else:
infoID = reqBody["id"]
tempName = None
tempContent = None
tempType = None
if "name" in reqBody:
tempName = reqBody["name"]
if "content" in reqBody:
tempContent = reqBody["content"]
if "type" in reqBody:
tempType = reqBody["type"]
try:
infoObj = infoTempDB.objects.get(id=infoID)
except Exception as err:
return Response(
{
"result": 19003007,
"msg": getErrMsgByCode(19003007, err)
},
content_type="application/json")
if tempName is not None:
infoObj.name = tempName
if tempContent is not None:
infoObj.content = tempContent
if tempType is not None:
infoObj.type = tempType
try:
infoObj.save()
except Exception as err:
return Response(
{
"result": 19003008,
"msg": getErrMsgByCode(19003008, err)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK"
},
content_type="application/json")
def modifyRtspServerInfo(request):
"""
Rtsp服务信息--修改
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response({"result": 16002001, "msg": getErrMsgByCode(16002001, err)}, content_type="application/json")
if reqbody_verify_admin(reqBody, err_code=16002001) is None:
pass
else:
return reqbody_verify_admin(reqBody, err_code=16002001)
if "id" not in reqBody:
return Response({"result": 16002006, "msg": getErrMsgByCode(16002006, None)}, content_type="application/json")
else:
serverID = reqBody["id"]
serverName = None
serverIP = None
serverPort = None
serverUser = None
serverPassword = None
serverChannels = None
serverType = None
serverEnable = None
if "name" in reqBody:
serverName = reqBody["name"]
if "ip" in reqBody:
serverIP = reqBody["ip"]
if "port" in reqBody:
serverPort = reqBody["port"]
if "user" in reqBody:
serverUser = reqBody["user"]
if "password" in reqBody:
serverPassword = reqBody["password"]
if "channels" in reqBody:
serverChannels = reqBody["channels"]
if "type" in reqBody:
serverType = reqBody["type"]
if "enable" in reqBody:
serverEnable = reqBody["enable"]
try:
rtspServerObj = RTSPServerDB.objects.get(id=serverID)
except Exception as err:
return Response({"result": 16002007, "msg": getErrMsgByCode(16002007, err)}, content_type="application/json")
if serverName is not None:
rtspServerObj.name = serverName
if serverIP is not None:
rtspServerObj.ip = serverIP
if serverPort is not None:
rtspServerObj.port = serverPort
if serverUser is not None:
rtspServerObj.user = serverUser
if serverPassword is not None:
rtspServerObj.password = serverPassword
if serverChannels is not None:
rtspServerObj.channels = serverChannels
if serverType is not None:
rtspServerObj.type = serverType
if serverEnable is not None:
rtspServerObj.enable = serverEnable
try:
rtspServerObj.save()
except Exception as err:
return Response({"result": 16002008, "msg": getErrMsgByCode(16002008, err)}, content_type="application/json")
return Response({"result": 0, "msg": "OK"}, content_type="application/json")
def modifyOptionInfo(request):
"""
配置信息--修改
modify: 0不可修改, 1可修改
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 28002001,
"msg": getErrMsgByCode(28002001, err)
},
content_type="application/json")
if reqbody_verify_admin(reqBody, err_code=28002001) is None:
pass
else:
return reqbody_verify_admin(reqBody, err_code=28002001)
if "id" not in reqBody:
return Response(
{
"result": 28002006,
"msg": getErrMsgByCode(28002006, None)
},
content_type="application/json")
else:
optID = reqBody["id"]
try:
optObj = OptionSysDB.objects.get(id=optID)
except Exception as err:
return Response(
{
"result": 28002007,
"msg": getErrMsgByCode(28002007, err)
},
content_type="application/json")
if optObj.opt_modify == 0:
return Response(
{
"result": 28002008,
"msg": getErrMsgByCode(28002008, None)
},
content_type="application/json")
if "name" in reqBody:
optObj.opt_name = reqBody["name"]
if "value" in reqBody:
optObj.opt_value = reqBody["value"]
if "modify" in reqBody:
optObj.opt_modify = reqBody["modify"]
try:
optObj.save()
except Exception as err:
return Response(
{
"result": 28002009,
"msg": getErrMsgByCode(28002009, err)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK"
},
content_type="application/json")
