def saveJsonData(request):
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 24001001,
"msg": getErrMsgByCode(24001001, err)
},
content_type="application/json")
if reqbody_verify(reqBody, err_code=24001001) is None:
pass
else:
return reqbody_verify(reqBody, err_code=24001001)
userLogin = None
if "login" in reqBody:
userLogin = reqBody["login"]
else:
return Response(
{
"result": 24001006,
"msg": getErrMsgByCode(24001006, None)
},
content_type="application/json")
userData = None
if "data" in reqBody:
userData = reqBody["data"]
else:
return Response(
{
"result": 24001007,
"msg": getErrMsgByCode(24001007, None)
},
content_type="application/json")
result = None
if userLogin and userData:
userLogin = "******" + userLogin
result = setValueToCache(userLogin, userData)
if result is None:
return Response(
{
"result": 24001008,
"msg": getErrMsgByCode(24001008, None)
},
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": 11004001,
"msg": getErrMsgByCode(11004001, err)
},
content_type="application/json")
if reqbody_verify(reqBody, err_code=17005001) is None:
pass
else:
return reqbody_verify(reqBody, err_code=17005001)
if "id" not in reqBody:
return Response(
{
"result": 11004006,
"msg": getErrMsgByCode(11004006, None)
},
content_type="application/json")
else:
deviceID = reqBody["id"]
try:
deviceObj = RTSPDeviceDB.objects.get(id=deviceID)
except Exception as err:
return Response(
{
"result": 11004007,
"msg": getErrMsgByCode(11004007, err)
},
content_type="application/json")
try:
deviceObj.delete()
except Exception as err:
return Response(
{
"result": 11004008,
"msg": getErrMsgByCode(11004008, err)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK"
},
content_type="application/json")
def AIrtspDeviceInfoQueryAll(request):
"""
AI Rtsp设备信息--全部
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 17013001,
"msg": getErrMsgByCode(17013001, err)
},
content_type="application/json")
if reqbody_verify(reqBody, err_code=17013001) is None:
pass
else:
return reqbody_verify(reqBody, err_code=17013001)
resData = []
try:
rtspDeviceObjs = videoMonitorDB.objects.all()
for item in rtspDeviceObjs:
deviceObj = {}
deviceObj["id"] = item.id
deviceObj["name"] = item.name
deviceObj["dept"] = item.dept
deviceObj["ai_id"] = item.ai_device_id
deviceObj["code"] = item.code
deviceObj["channel"] = item.channel
deviceObj["longitude"] = item.longitude
deviceObj["latitude"] = item.latitude
deviceObj["height"] = item.height
deviceObj["locate"] = item.locate
deviceObj["enable"] = item.enable
resData.append(deviceObj)
except Exception as err:
return Response(
{
"result": 17013006,
"msg": getErrMsgByCode(17013006, err)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK",
"data": resData
},
content_type="application/json")
def queryRtspServerInfo(request):
"""
Rtsp服务信息--查询
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response({"result": 16003001, "msg": getErrMsgByCode(16003001, err)}, content_type="application/json")
if reqbody_verify(reqBody, err_code=16003001) is None:
pass
else:
return reqbody_verify(reqBody, err_code=16003001)
tokenInfo = tokenDecode(reqBody["token"])
serverID = None
if tokenInfo["role"] >= 10:
if "id" in reqBody:
serverID = reqBody["id"]
else:
if "id" in reqBody:
serverID = reqBody["id"]
else:
return Response({"result": 16003005, "msg": getErrMsgByCode(16003005, None)}, content_type="application/json")
resData = []
try:
if serverID is None:
sipServerObjs = RTSPServerDB.objects.all()
else:
sipServerObjs = RTSPServerDB.objects.filter(id=serverID)
for item in sipServerObjs:
serverObj = {}
serverObj["id"] = item.id
serverObj["name"] = item.name
serverObj["ip"] = item.ip
serverObj["port"] = item.port
serverObj["user"] = item.user
serverObj["password"] = item.password
serverObj["channels"] = item.channels
serverObj["type"] = item.type
serverObj["enable"] = item.enable
resData.append(serverObj)
except Exception as err:
return Response({"result": 16003006, "msg": getErrMsgByCode(16003006, err)}, content_type="application/json")
return Response({"result": 0, "msg": "OK", "data": resData}, content_type="application/json")
def queryDeptInfo(request):
"""
部门信息--查询
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 11003001,
"msg": getErrMsgByCode(11003001, err)
},
content_type="application/json")
if reqbody_verify(reqBody, err_code=11003001) is None:
pass
else:
return reqbody_verify(reqBody, err_code=11003001)
resData = {}
tokenInfo = tokenDecode(reqBody["token"])
deptID = tokenInfo["dept"]
try:
deptInfo = deptDB.objects.get(id=deptID)
resData["id"] = deptInfo.id
resData["name"] = deptInfo.name
resData["pid"] = deptInfo.pid
resData["path"] = deptInfo.path
resData["enable"] = deptInfo.enable
resData["register"] = deptInfo.register
subDeptList = []
getSubDeptTreeList(deptID, subDeptList)
resData["children"] = subDeptList
except Exception as err:
return Response(
{
"result": 11003005,
"msg": getErrMsgByCode(11003005, err)
},
content_type="application/json")
addOperationLog(tokenInfo["login"], "查询部门信息", "查询部门信息成功", "查询部门信息成功")
return Response({
"result": 0,
"msg": "OK",
"data": resData
},
content_type="application/json")
def queryOptionInfo(request):
"""
配置信息--查询
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 28003001,
"msg": getErrMsgByCode(28003001, err)
},
content_type="application/json")
if reqbody_verify(reqBody, err_code=28003001) is None:
pass
else:
return reqbody_verify(reqBody, err_code=28003001)
try:
optObjs = OptionSysDB.objects.all()
except Exception as err:
return Response(
{
"result": 28003005,
"msg": getErrMsgByCode(28003005, err)
},
content_type="application/json")
resData = []
for opt in optObjs:
optInfo = {}
optInfo["id"] = opt.id
optInfo["name"] = opt.opt_name
optInfo["key"] = opt.opt_key
optInfo["value"] = opt.opt_value
optInfo["modify"] = opt.opt_modify
resData.append(optInfo)
return Response({
"result": 0,
"msg": "OK",
"data": resData
},
content_type="application/json")
def queryTemplateInfo(request):
"""
SMS短信模板--查询
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 19004001,
"msg": getErrMsgByCode(19004001, err)
},
content_type="application/json")
if reqbody_verify(reqBody, err_code=19004001) is None:
pass
else:
return reqbody_verify(reqBody, err_code=19004001)
resData = []
try:
hazardsInfoObjs = infoTempDB.objects.all()
for item in hazardsInfoObjs:
infoObj = {}
infoObj["id"] = item.id
infoObj["user"] = item.user
infoObj["name"] = item.name
infoObj["content"] = item.content
infoObj["type"] = item.type
infoObj["time"] = item.time
resData.append(infoObj)
except Exception as err:
return Response(
{
"result": 19004006,
"msg": getErrMsgByCode(19004006, err)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK",
"data": resData
},
content_type="application/json")
def getJsonData(request):
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 24002001,
"msg": getErrMsgByCode(24002001, err)
},
content_type="application/json")
if reqbody_verify(reqBody, err_code=24002001) is None:
pass
else:
return reqbody_verify(reqBody, err_code=24002001)
userLogin = None
if "login" in reqBody:
userLogin = reqBody["login"]
else:
return Response(
{
"result": 24002006,
"msg": getErrMsgByCode(24002006, None)
},
content_type="application/json")
result = None
if userLogin:
userLogin = "******" + userLogin
result = tokenQuery(userLogin)
if result is None:
return Response(
{
"result": 24002007,
"msg": getErrMsgByCode(24002007, None)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK",
"data": result
},
content_type="application/json")
def userInfoQuery(request):
"""
用户信息--查询
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 10004001,
"msg": getErrMsgByCode(10004001, err)
},
content_type="application/json")
if reqbody_verify(reqBody, err_code=10004001) is None:
pass
else:
return reqbody_verify(reqBody, err_code=10004001)
try:
userObj = userDB.objects.all()
except Exception as err:
return Response(
{
"result": 10004006,
"msg": getErrMsgByCode(10004006, err)
},
content_type="application/json")
resDataList = []
for item in userObj:
resData = {}
resData["id"] = item.id
resData["login"] = item.login
resData["nickname"] = item.nickname
resData["enable"] = item.enable
resDataList.append(resData)
return Response({
"result": 0,
"msg": "OK",
"data": resDataList
},
content_type="application/json")
def userInfoDelete(request):
"""
用户信息--删除
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 10005001,
"msg": getErrMsgByCode(10005001, err)
},
content_type="application/json")
if reqbody_verify(reqBody, err_code=10005001) is None:
pass
else:
return reqbody_verify(reqBody, err_code=10005001)
if "id" not in reqBody:
return Response(
{
"result": 10005005,
"msg": getErrMsgByCode(10005005, None)
},
content_type="application/json")
else:
userID = reqBody["id"]
try:
userObj = userDB.objects.get(id=userID)
except Exception as err:
return Response(
{
"result": 10005006,
"msg": getErrMsgByCode(10005007, err)
},
content_type="application/json")
if userObj.login == "admin":
return Response(
{
"result": 10005007,
"msg": getErrMsgByCode(10005008, None)
},
content_type="application/json")
savePoint = transaction.savepoint()
try:
userObj.delete()
except Exception as err:
transaction.savepoint_rollback(savePoint)
return Response(
{
"result": 10005008,
"msg": getErrMsgByCode(10005009, err)
},
content_type="application/json")
transaction.savepoint_commit(savePoint)
return Response({
"result": 0,
"msg": "OK"
},
content_type="application/json")
def userInfoModify(request):
"""
用户信息--修改
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 10003001,
"msg": getErrMsgByCode(10003001, err)
},
content_type="application/json")
if reqbody_verify(reqBody, err_code=10003001) is None:
pass
else:
return reqbody_verify(reqBody, err_code=10003001)
tokenInfo = tokenDecode(reqBody["token"])
if "id" not in reqBody:
return Response(
{
"result": 10003005,
"msg": getErrMsgByCode(10003005, None)
},
content_type="application/json")
else:
userID = reqBody["id"]
if userDB.objects.filter(id=userID).count() == 0:
return Response(
{
"result": 10003006,
"msg": getErrMsgByCode(10003006, None)
},
content_type="application/json")
userPwd = None
userName = None
userEnable = None
if "password" not in reqBody:
pass
else:
userPwd = reqBody["password"]
if "nickname" not in reqBody:
pass
else:
userName = reqBody["nickname"]
if "enable" not in reqBody:
pass
else:
userEnable = reqBody["enable"]
userObj = userDB.objects.get(id=userID)
if userPwd is not None:
userObj.password = mysql_password(userPwd)
if userName is not None:
userObj.nickname = userName
if userEnable is not None:
userObj.enable = userEnable
savePoint = transaction.savepoint()
try:
userObj.save()
except Exception as err:
transaction.savepoint_rollback(savePoint)
return Response(
{
"result": 10003007,
"msg": getErrMsgByCode(10003007, 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(reqBody, err_code=10002001) is None:
pass
else:
return reqbody_verify(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 "enable" not in reqBody:
return Response(
{
"result": 10002010,
"msg": getErrMsgByCode(10002010, None)
},
content_type="application/json")
else:
userEnable = reqBody["enable"]
userObj = userDB()
userObj.login = userLogin
userObj.password = mysql_password(userPwd)
userObj.nickname = userName
userObj.enable = userEnable
savePoint = transaction.savepoint()
try:
userObj.save()
except Exception as err:
transaction.savepoint_rollback(savePoint)
Response({
"result": 10002011,
"msg": getErrMsgByCode(10002011, None)
},
content_type="application/json")
transaction.savepoint_commit(savePoint)
return Response({
"result": 0,
"msg": "OK"
},
content_type="application/json")
def rtspRecordInfoAdd(request):
"""
Rtsp设备录像信息--添加
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 17009001,
"msg": getErrMsgByCode(17009001, err)
},
content_type="application/json")
if reqbody_verify(reqBody, err_code=17009001) is None:
pass
else:
return reqbody_verify(reqBody, err_code=17009001)
if "device" not in reqBody:
return Response(
{
"result": 17009006,
"msg": getErrMsgByCode(17009006, None)
},
content_type="application/json")
else:
deviceID = reqBody["device"]
if "user" not in reqBody:
return Response(
{
"result": 17009007,
"msg": getErrMsgByCode(17009007, None)
},
content_type="application/json")
else:
userID = reqBody["user"]
if "type" not in reqBody:
return Response(
{
"result": 17009008,
"msg": getErrMsgByCode(17009008, None)
},
content_type="application/json")
else:
recordType = reqBody["type"]
recordCode = None
# if recordType == 1:
if "record_code" not in reqBody:
return Response(
{
"result": 17009009,
"msg": getErrMsgByCode(17009009, None)
},
content_type="application/json")
else:
recordCode = reqBody["record_code"]
# else:
# recordCode = str(deviceID) + "." + str(userID) + "." + str(time.time())
try:
recordObj = RTSPRecordDB()
recordObj.user = userID
recordObj.ipc = deviceID
recordObj.type = recordType
recordObj.record_code = recordCode
recordObj.save()
except Exception as err:
return Response(
{
"result": 17009010,
"msg": getErrMsgByCode(17009010, err)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK",
"recordCode": recordCode
},
content_type="application/json")
def rtspDeviceRollingQuery(request):
"""
Rtsp设备轮询列表--查询
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 17008001,
"msg": getErrMsgByCode(17008001, err)
},
content_type="application/json")
if reqbody_verify(reqBody, err_code=17008001) is None:
pass
else:
return reqbody_verify(reqBody, err_code=17008001)
if "user" not in reqBody:
return Response(
{
"result": 17008006,
"msg": getErrMsgByCode(17008006, None)
},
content_type="application/json")
else:
userID = reqBody["user"]
resData = []
try:
ipcObjList = RTSPRollingDB.objects.filter(user=userID)
for ipcItem in ipcObjList:
ipcObj = RTSPDeviceDB.objects.filter(id=ipcItem.ipc).first()
if not ipcObj:
continue
deviceInfo = {}
deviceInfo["id"] = ipcObj.id
deviceInfo["name"] = ipcObj.name
deviceInfo["dept"] = ipcObj.dept
deviceInfo["type"] = ipcObj.type
deviceInfo["server"] = ipcObj.server
deviceInfo["channel"] = ipcObj.channel
deviceInfo["longitude"] = ipcObj.longitude
deviceInfo["latitude"] = ipcObj.latitude
deviceInfo["height"] = ipcObj.height
deviceInfo["locate"] = ipcObj.locate
deviceInfo["enable"] = ipcObj.enable
deviceInfo["position"] = ipcObj.position
resData.append(deviceInfo)
except Exception as err:
return Response(
{
"result": 17008007,
"msg": getErrMsgByCode(17008007, err)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK",
"data": resData
},
content_type="application/json")
def queryDeptMemberInfo(request):
"""
部门成员信息--查询
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 11005001,
"msg": getErrMsgByCode(11005001, err)
},
content_type="application/json")
if reqbody_verify(reqBody, err_code=11005001) is None:
pass
else:
return reqbody_verify(reqBody, err_code=11005001)
tokenInfo = tokenDecode(reqBody["token"])
if "id" not in reqBody:
return Response(
{
"result": 11005005,
"msg": getErrMsgByCode(11005005, None)
},
content_type="application/json")
else:
deptID = reqBody["id"]
resData = []
try:
if int(deptID) == 1:
memberInfoList = userDB.objects.all().order_by("position")
else:
memberInfoList = userDB.objects.filter(
dept=deptID).order_by("position")
if memberInfoList:
for obj in memberInfoList:
userObj = {}
userObj["id"] = obj.id
userObj["login"] = obj.login
userObj["nickname"] = obj.nickname
userObj["dept"] = obj.dept
userObj["email"] = obj.email
userObj["enable"] = obj.enable
userObj["height"] = obj.height
userObj["latitude"] = obj.latitude
userObj["level"] = obj.level
userObj["locate"] = obj.locate
userObj["longitude"] = obj.longitude
userObj["mobile"] = obj.mobile
userObj["phone"] = obj.phone
userObj["position"] = obj.position
userObj["role"] = obj.role
userObj["register"] = obj.register
resData.append(userObj)
except Exception as err:
return Response(
{
"result": 11005006,
"msg": getErrMsgByCode(11005006, None)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK",
"data": resData
},
content_type="application/json")
def userInfoModify(request):
"""
用户信息--修改
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 10003001,
"msg": getErrMsgByCode(10003001, err)
},
content_type="application/json")
if reqbody_verify(reqBody, err_code=10003001) is None:
pass
else:
return reqbody_verify(reqBody, err_code=10003001)
tokenInfo = tokenDecode(reqBody["token"])
if "id" not in reqBody:
return Response(
{
"result": 10003005,
"msg": getErrMsgByCode(10003005, None)
},
content_type="application/json")
else:
userID = reqBody["id"]
if (tokenInfo["role"] < 10) and (tokenInfo["id"] != reqBody["id"]):
return Response(
{
"result": 10003006,
"msg": getErrMsgByCode(10003006, None)
},
content_type="application/json")
if userDB.objects.filter(id=userID).count() == 0:
return Response(
{
"result": 10003007,
"msg": getErrMsgByCode(10003007, None)
},
content_type="application/json")
userPwd = None
userName = None
userDept = None
userEmail = None
userEnable = None
userHeight = None
userLat = None
userLevel = None
userLocate = None
userLon = None
userMobile = None
userPhone = None
if "password" not in reqBody:
pass
else:
userPwd = reqBody["password"]
if "nickname" not in reqBody:
pass
else:
userName = reqBody["nickname"]
if "dept" not in reqBody:
pass
else:
userDept = reqBody["dept"]
if "default_group" not in reqBody:
pass
else:
userGroup = reqBody["default_group"]
if "email" not in reqBody:
pass
else:
userEmail = reqBody["email"]
if "enable" not in reqBody:
pass
else:
userEnable = reqBody["enable"]
if "height" not in reqBody:
pass
else:
userHeight = reqBody["height"]
if "latitude" not in reqBody:
pass
else:
userLat = reqBody["latitude"]
if "level" not in reqBody:
pass
else:
userLevel = reqBody["level"]
if "locate" not in reqBody:
pass
else:
userLocate = reqBody["locate"]
if "longitude" not in reqBody:
pass
else:
userLon = reqBody["longitude"]
if "mobile" not in reqBody:
pass
else:
userMobile = reqBody["mobile"]
if "phone" not in reqBody:
pass
else:
userPhone = reqBody["phone"]
userObj = userDB.objects.get(id=userID)
if userPwd is not None:
userObj.password = mysql_password(userPwd)
if userName is not None:
userObj.nickname = userName
if userDept is not None:
userObj.dept = userDept
if userEmail is not None:
userObj.email = userEmail
if userEnable is not None:
userObj.enable = userEnable
if userHeight is not None:
userObj.height = userHeight
if userLat is not None:
userObj.latitude = userLat
if userLevel is not None:
userObj.level = userLevel
if userLocate is not None:
userObj.locate = userLocate
if userLon is not None:
userObj.longitude = userLon
if userMobile is not None:
userObj.mobile = userMobile
if userPhone is not None:
userObj.phone = userPhone
savePoint = transaction.savepoint()
try:
userObj.save()
except Exception as err:
transaction.savepoint_rollback(savePoint)
return Response(
{
"result": 10003008,
"msg": getErrMsgByCode(10003008, err)
},
content_type="application/json")
transaction.savepoint_commit(savePoint)
addOperationLog(userObj.login, "修改用户信息", "用户信息修改成功", "用户信息修改成功")
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": 11002001,
"msg": getErrMsgByCode(11002001, err)
},
content_type="application/json")
if reqbody_verify(reqBody, err_code=17002001) is None:
pass
else:
return reqbody_verify(reqBody, err_code=17002001)
if "id" not in reqBody:
return Response(
{
"result": 11002006,
"msg": getErrMsgByCode(11002006, None)
},
content_type="application/json")
else:
deviceID = reqBody["id"]
deviceName = None
deviceIP = None
longitude = None
latitude = None
address = None
observation_area = None
observation_target = None
# enable=None
bin_id = None
tide_level_name = None
tide_level_code = None
wave_heigh_name = None
wave_heigh_code = None
wave_direction_name = None
wave_direction_code = None
Port = None
if "name" in reqBody:
deviceName = reqBody["name"]
if "ip" in reqBody:
deviceIP = reqBody["ip"]
if "longitude" in reqBody:
longitude = reqBody["longitude"]
if "latitude" in reqBody:
latitude = reqBody["latitude"]
if "address" in reqBody:
address = reqBody["address"]
if "observation_area" in reqBody:
observation_area = reqBody["observation_area"]
if "observation_target" in reqBody:
observation_target = reqBody["observation_target"]
# if "enable" in reqBody:
# enable = reqBody["enable"]
if "bin_id" in reqBody:
bin_id = reqBody["bin_id"]
if "tide_level_name" in reqBody:
tide_level_name = reqBody["tide_level_name"]
if "tide_level_code" in reqBody:
tide_level_code = reqBody["tide_level_code"]
if "wave_heigh_name" in reqBody:
wave_heigh_name = reqBody["wave_heigh_name"]
if "wave_heigh_code" in reqBody:
wave_heigh_code = reqBody["wave_heigh_code"]
if "wave_direction_name" in reqBody:
wave_direction_name = reqBody["wave_direction_name"]
if "wave_direction_code" in reqBody:
wave_direction_code = reqBody["wave_direction_code"]
if "port" in reqBody:
Port = reqBody["port"]
try:
deviceObj = RTSPDeviceDB.objects.get(id=deviceID)
except Exception as err:
return Response(
{
"result": 11002007,
"msg": getErrMsgByCode(11002007, err)
},
content_type="application/json")
if deviceName is not None:
deviceObj.name = deviceName
if deviceIP is not None:
deviceObj.ip = deviceIP
if longitude is not None:
deviceObj.longitude = longitude
if latitude is not None:
deviceObj.latitude = latitude
if address is not None:
deviceObj.address = address
if observation_area is not None:
deviceObj.observation_area = observation_area
if observation_target is not None:
deviceObj.observation_target = observation_target
# if enable is not None:
# deviceObj.enable = enable
if bin_id is not None:
deviceObj.bin_id = bin_id
if tide_level_name is not None:
deviceObj.tide_level_name = tide_level_name
if tide_level_code is not None:
deviceObj.tide_level_code = tide_level_code
if wave_heigh_name is not None:
deviceObj.wave_heigh_name = wave_heigh_name
if wave_heigh_code is not None:
deviceObj.wave_heigh_code = wave_heigh_code
if wave_direction_name is not None:
deviceObj.wave_direction_name = wave_direction_name
if wave_direction_code is not None:
deviceObj.wave_direction_code = wave_direction_code
if Port is not None:
deviceObj.port = Port
try:
deviceObj.save()
except Exception as err:
return Response(
{
"result": 11002008,
"msg": getErrMsgByCode(11002008, err)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK"
},
content_type="application/json")
def querySMSLogInfo(request):
"""
SMS信息记录--查询
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 19006001,
"msg": getErrMsgByCode(19006001, err)
},
content_type="application/json")
if reqbody_verify(reqBody, err_code=19006001) is None:
pass
else:
return reqbody_verify(reqBody, err_code=19006001)
deptID = None
if "dept" in reqBody:
deptID = reqBody["dept"]
if "user_id_list" in reqBody:
userIDList = reqBody["user_id_list"]
else:
userIDList = getAllDeptMemberList(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:
smsLogObjs = smsLogDB.objects.filter(user_id__in=userIDList,
time__gt=afterTime,
time__lt=beforeTime)
else:
smsLogObjs = smsLogDB.objects.filter(user_id__in=userIDList)
if orderInfo == 1:
smsLogObjs = smsLogObjs.order_by("-time")
else:
smsLogObjs = smsLogObjs.order_by("time")
if indexPage and countInfo:
indexStart = (indexPage - 1) * countInfo
if indexStart < 0:
indexStart = 0
indexEnd = indexStart + countInfo
if indexEnd >= smsLogObjs.count():
indexEnd = smsLogObjs.count()
resultObjList = smsLogObjs[indexStart:indexEnd]
else:
resultObjList = smsLogObjs
resultInfoList = []
print(format(resultObjList))
for obj in resultObjList:
smsInfo = {}
smsInfo["id"] = obj.id
smsInfo["user_id"] = obj.user_id
smsInfo["name"] = obj.name
smsInfo["phone"] = obj.phone
smsInfo["content"] = obj.content
smsInfo["type"] = obj.type
smsInfo["time"] = obj.time
resultInfoList.append(smsInfo)
resData["total"] = smsLogObjs.count()
resData["info"] = resultInfoList
except Exception as err:
return Response(
{
"result": 19006006,
"msg": getErrMsgByCode(19006006, err)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK",
"data": resData
},
content_type="application/json")
def sendSMSInfo(request):
"""
发送手机短信
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 19001001,
"msg": getErrMsgByCode(19001001, err)
},
content_type="application/json")
if reqbody_verify(reqBody, err_code=19001001) is None:
pass
else:
return reqbody_verify(reqBody, err_code=19001001)
if "user_list" not in reqBody:
return Response(
{
"result": 19001006,
"msg": getErrMsgByCode(19001006, None)
},
content_type="application/json")
else:
userList = reqBody["user_list"]
if "content" not in reqBody:
return Response(
{
"result": 19001007,
"msg": getErrMsgByCode(19001007, None)
},
content_type="application/json")
else:
contentText = reqBody["content"]
numList = ""
for user in userList:
if len(numList) > 0:
numList += ","
userPhone = user["phone"]
numList += userPhone
paramData = {}
paramData["SpCode"] = smsRequestID
paramData["LoginName"] = smsSysAccount
paramData["Password"] = smsSysAuth
paramData["MessageContent"] = contentText.encode("gb2312")
paramData["SerialNumber"] = str(time.time())
paramData["ScheduleTime"] = ""
paramData["ExtendAccessNum"] = ""
paramData["f"] = "1"
paramData["UserNumber"] = numList
try:
resultResponse = requests.get(smsSystemUrl,
params=paramData,
timeout=2)
except Exception as err:
return Response(
{
"result": 19001008,
"msg": getErrMsgByCode(19001008, err)
},
content_type="application/json")
else:
resultDict = parse.parse_qs(resultResponse.text)
result = resultDict["result"][0]
if int(result) != 0:
print(int(result))
print(resultDict["description"][0])
return Response(
{
"result": 19001009,
"msg": getErrMsgByCode(19001009,
resultDict["description"][0])
},
content_type="application/json")
else:
fallList = []
if "faillist" in resultDict.keys():
fallList = resultDict["faillist"][0].split(",")
logList = []
for user in userList:
logObj = {}
logObj["user_id"] = user["id"]
logObj["name"] = user["name"]
logObj["phone"] = user["phone"]
logObj["content"] = contentText
if user["phone"] in fallList:
logObj["type"] = 0
else:
logObj["type"] = 1
logList.append(logObj)
savePoint = transaction.savepoint()
try:
for item in logList:
logInfoObj = smsLogDB()
logInfoObj.user_id = item["user_id"]
logInfoObj.name = item["name"]
logInfoObj.phone = item["phone"]
logInfoObj.content = item["content"]
logInfoObj.type = item["type"]
logInfoObj.save()
except Exception as err:
transaction.savepoint_rollback(savePoint)
return Response(
{
"result": 19001010,
"msg": getErrMsgByCode(19001010, err)
},
content_type="application/json")
transaction.savepoint_commit(savePoint)
return Response({
"result": 0,
"msg": "OK"
},
content_type="application/json")
def userInfoQuery(request):
"""
用户信息--查询
:return:
"""
print(format(request.body))
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 10004001,
"msg": getErrMsgByCode(10004001, err)
},
content_type="application/json")
if reqbody_verify(reqBody, err_code=10004001) is None:
pass
else:
return reqbody_verify(reqBody, err_code=10004001)
tokenInfo = tokenDecode(reqBody["token"])
if "id" not in reqBody:
userID = tokenInfo["id"]
else:
userID = reqBody["id"]
if (tokenInfo["role"] < 9) and (tokenInfo["id"] != reqBody["id"]):
return Response(
{
"result": 10004006,
"msg": getErrMsgByCode(10004006, None)
},
content_type="application/json")
try:
userObj = userDB.objects.get(id=userID)
except Exception as err:
return Response(
{
"result": 10004007,
"msg": getErrMsgByCode(10004007, err)
},
content_type="application/json")
resData = {}
resData["id"] = userObj.id
resData["login"] = userObj.login
resData["nickname"] = userObj.nickname
resData["dept"] = userObj.dept
resData["email"] = userObj.email
resData["enable"] = userObj.enable
resData["height"] = userObj.height
resData["latitude"] = userObj.latitude
resData["level"] = userObj.level
resData["locate"] = userObj.locate
resData["longitude"] = userObj.longitude
resData["mobile"] = userObj.mobile
resData["phone"] = userObj.phone
resData["register"] = userObj.register
resData["role"] = userObj.role
resData["position"] = userObj.position
addOperationLog(userObj.login, "查询用户信息", "查询用户信息成功", "查询用户信息成功")
return Response({
"result": 0,
"msg": "OK",
"data": resData
},
content_type="application/json")
def rtspDeviceRollingAdd(request):
"""
Rtsp设备轮询列表--增加
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 17007001,
"msg": getErrMsgByCode(17007001, err)
},
content_type="application/json")
if reqbody_verify(reqBody, err_code=17007001) is None:
pass
else:
return reqbody_verify(reqBody, err_code=17007001)
if "user" not in reqBody:
return Response(
{
"result": 17007006,
"msg": getErrMsgByCode(17007006, None)
},
content_type="application/json")
else:
userID = reqBody["user"]
if "devices" not in reqBody:
return Response(
{
"result": 17007007,
"msg": getErrMsgByCode(17007007, None)
},
content_type="application/json")
else:
deviceList = reqBody["devices"]
savePoint = transaction.savepoint()
try:
RTSPRollingDB.objects.filter(user=userID).delete()
except Exception as err:
transaction.savepoint_rollback(savePoint)
return Response(
{
"result": 17007008,
"msg": getErrMsgByCode(17007008, err)
},
content_type="application/json")
try:
for device in deviceList:
rollObj = RTSPRollingDB()
rollObj.user = userID
rollObj.ipc = device
rollObj.enable = 1
rollObj.save()
except Exception as err:
transaction.savepoint_rollback(savePoint)
return Response(
{
"result": 17007009,
"msg": getErrMsgByCode(17007009, err)
},
content_type="application/json")
transaction.savepoint_commit(savePoint)
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": 11001001,
"msg": getErrMsgByCode(11001001, err)
},
content_type="application/json")
if reqbody_verify(reqBody, err_code=17001001) is None:
pass
else:
return reqbody_verify(reqBody, err_code=17001001)
if "ip" not in reqBody:
return Response(
{
"result": 11001006,
"msg": getErrMsgByCode(11001006, None)
},
content_type="application/json")
else:
deviceIp = reqBody["ip"]
if "name" not in reqBody:
return Response(
{
"result": 11001007,
"msg": getErrMsgByCode(11001007, None)
},
content_type="application/json")
else:
deviceName = reqBody["name"]
# if "longitude" not in reqBody:
# return Response({"result": 11001008, "msg": getErrMsgByCode(11001008, None)}, content_type="application/json")
# else:
# longitude = reqBody["longitude"]
# if "latitude" not in reqBody:
# return Response({"result": 11001009, "msg": getErrMsgByCode(11001009, None)}, content_type="application/json")
# else:
# latitude = reqBody["latitude"]
if "address" not in reqBody:
return Response(
{
"result": 11001010,
"msg": getErrMsgByCode(11001010, None)
},
content_type="application/json")
else:
address = reqBody["address"]
if "observation_area" not in reqBody:
return Response(
{
"result": 11001011,
"msg": getErrMsgByCode(11001011, None)
},
content_type="application/json")
else:
observation_area = reqBody["observation_area"]
if "observation_target" not in reqBody:
return Response(
{
"result": 11001012,
"msg": getErrMsgByCode(11001012, None)
},
content_type="application/json")
else:
observation_target = reqBody["observation_target"]
# if "enable" not in reqBody:
# return Response({"result": 11001013, "msg": getErrMsgByCode(11001013, None)}, content_type="application/json")
# else:
# enable = reqBody["enable"]
#
# if "bin_id" not in reqBody:
# return Response({"result": 11001014, "msg": getErrMsgByCode(11001014, None)}, content_type="application/json")
# else:
# bin_id = reqBody["bin_id"]
longitude = None
latitude = None
bin_id = None
tide_level_name = None
tide_level_code = None
wave_heigh_name = None
wave_heigh_code = None
wave_direction_name = None
wave_direction_code = None
port = None
if "tide_level_name" in reqBody:
tide_level_name = reqBody["tide_level_name"]
if "tide_level_code" in reqBody:
tide_level_code = reqBody["tide_level_code"]
if "wave_heigh_name" in reqBody:
wave_heigh_name = reqBody["wave_heigh_name"]
if "wave_heigh_code" in reqBody:
wave_heigh_code = reqBody["wave_heigh_code"]
if "wave_direction_name" in reqBody:
wave_direction_name = reqBody["wave_direction_name"]
if "wave_direction_code" in reqBody:
wave_direction_code = reqBody["wave_direction_code"]
if "port" in reqBody:
port = reqBody["port"]
if "longitude" in reqBody:
longitude = reqBody["longitude"]
if "latitude" in reqBody:
latitude = reqBody["latitude"]
if "bin_id" in reqBody:
bin_id = reqBody["bin_id"]
deviceObj = RTSPDeviceDB()
deviceObj.ip = deviceIp
deviceObj.name = deviceName
deviceObj.address = address
deviceObj.observation_area = observation_area
deviceObj.observation_target = observation_target
if longitude:
deviceObj.longitude = longitude
if latitude:
deviceObj.latitude = latitude
if bin_id:
deviceObj.bin_id = bin_id
if tide_level_name:
deviceObj.tide_level_name = tide_level_name
if tide_level_code:
deviceObj.tide_level_code = tide_level_code
if wave_heigh_name:
deviceObj.wave_heigh_name = wave_heigh_name
if wave_heigh_code:
deviceObj.wave_heigh_code = wave_heigh_code
if wave_direction_name:
deviceObj.wave_direction_name = wave_direction_name
if wave_direction_code:
deviceObj.wave_direction_code = wave_direction_code
if port:
deviceObj.port = port
try:
deviceObj.save()
except Exception as err:
Response({
"result": 11001015,
"msg": getErrMsgByCode(11001015, err)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK"
},
content_type="application/json")
def queryDeptDevice(request):
"""
部门设备信息--查询
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 11008001,
"msg": getErrMsgByCode(11008001, err)
},
content_type="application/json")
if reqbody_verify(reqBody, err_code=11008001) is None:
pass
else:
return reqbody_verify(reqBody, err_code=11008001)
tokenInfo = tokenDecode(reqBody["token"])
if "id" not in reqBody:
return Response(
{
"result": 11008006,
"msg": getErrMsgByCode(11008006, None)
},
content_type="application/json")
else:
deptID = reqBody["id"]
deptList = getSubDeptList(deptID)
if deptList:
deptList.insert(0, deptID)
else:
deptList = [].append(deptID)
resData = {}
try:
ipcObjList = rtspDeviceDB.objects.filter(
dept__in=deptList).order_by("position")
iotObjList = iotDeviceDB.objects.filter(dept__in=deptList)
if ipcObjList:
ipcInfoList = []
for ipcObj in ipcObjList:
ipcInfo = {}
ipcInfo["id"] = ipcObj.id
ipcInfo["name"] = ipcObj.name
ipcInfo["dept"] = ipcObj.dept
ipcInfo["type"] = ipcObj.type
ipcInfo["server"] = ipcObj.server
ipcInfo["channel"] = ipcObj.channel
ipcInfo["longitude"] = ipcObj.longitude
ipcInfo["latitude"] = ipcObj.latitude
ipcInfo["height"] = ipcObj.height
ipcInfo["locate"] = ipcObj.locate
ipcInfo["enable"] = ipcObj.enable
ipcInfoList.append(ipcInfo)
resData["ipc"] = ipcInfoList
if iotObjList:
iotInfoList = []
for iotObj in iotObjList:
iotInfo = {}
iotInfo["id"] = iotObj.id
iotInfo["name"] = iotObj.name
iotInfo["dept"] = iotObj.dept
iotInfo["code"] = iotObj.code
iotInfo["type"] = iotObj.type
iotInfo["type_name"] = iotObj.type_name
iotInfo["ipc"] = iotObj.ipc
iotInfo["generic_plan"] = iotObj.generic_plan
iotInfo["sms_level_1"] = iotObj.sms_level_1
iotInfo["sms_level_2"] = iotObj.sms_level_2
iotInfo["longitude"] = iotObj.longitude
iotInfo["latitude"] = iotObj.latitude
iotInfo["height"] = iotObj.height
iotInfo["locate"] = iotObj.locate
iotInfo["enable"] = iotObj.enable
iotInfoList.append(iotInfo)
resData["iot"] = iotInfoList
except Exception as err:
return Response(
{
"result": 11008007,
"msg": getErrMsgByCode(11008007, err)
},
content_type="application/json")
addOperationLog(tokenInfo["login"], "查询部门设备信息", "查询部门设备信息成功", "查询部门设备信息成功")
return Response({
"result": 0,
"msg": "OK",
"data": resData
},
content_type="application/json")
def rtspDeviceInfoQueryAll(request):
"""
Rtsp设备信息--全部
:return:
"""
print(format(request.body))
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 11003001,
"msg": getErrMsgByCode(11003001, err)
},
content_type="application/json")
if reqbody_verify(reqBody, err_code=11003001) is None:
pass
else:
return reqbody_verify(reqBody, err_code=17003001)
indexPage = None
countInfo = None
Type = None
if "page" in reqBody:
indexPage = reqBody["page"]
if "count" in reqBody:
countInfo = reqBody["count"]
if "type" in reqBody:
Type = reqBody["type"]
resData = {}
try:
if Type:
if Type == 0:
rtspDeviceObjs = RTSPDeviceDB.objects.filter(
bin_id_isnull=True)
else:
rtspDeviceObjs = RTSPDeviceDB.objects.filter(
bin_id_isnull=False)
else:
rtspDeviceObjs = RTSPDeviceDB.objects.all()
resultObjList = rtspDeviceObjs
resultInfoList = []
for item in resultObjList:
deviceObj = {}
deviceObj["id"] = item.id
deviceObj["ip"] = item.ip
deviceObj["name"] = item.name
deviceObj["longitude"] = item.longitude
deviceObj["latitude"] = item.latitude
deviceObj["address"] = item.address
deviceObj["observation_area"] = item.observation_area
deviceObj["observation_target"] = item.observation_target
deviceObj["bin_id"] = item.bin_id
deviceObj["tide_level_name"] = item.tide_level_name
deviceObj["tide_level_code"] = item.tide_level_code
deviceObj["wave_heigh_name"] = item.wave_heigh_name
deviceObj["wave_heigh_code"] = item.wave_heigh_code
deviceObj["wave_direction_name"] = item.wave_direction_name
deviceObj["wave_direction_code"] = item.wave_direction_code
deviceObj["port"] = item.port
resultInfoList.append(deviceObj)
if indexPage and countInfo:
indexStart = (indexPage - 1) * countInfo
if indexStart < 0:
indexStart = 0
indexEnd = indexStart + countInfo
if indexEnd >= rtspDeviceObjs.count():
indexEnd = rtspDeviceObjs.count()
resultInfoList = resultInfoList[indexStart:indexEnd]
else:
resultInfoList = resultInfoList
resData["info"] = resultInfoList
except Exception as err:
return Response(
{
"result": 11003006,
"msg": getErrMsgByCode(11003006, err)
},
content_type="application/json")
resData["total"] = resultObjList.count()
return Response({
"result": 0,
"msg": "OK",
"data": resData
},
content_type="application/json")
def rtspDeviceInfoQuery(request):
"""
Rtsp设备信息--按设备查询
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 17004001,
"msg": getErrMsgByCode(17004001, err)
},
content_type="application/json")
if reqbody_verify(reqBody, err_code=17004001) is None:
pass
else:
return reqbody_verify(reqBody, err_code=17004001)
if "id" not in reqBody:
return Response(
{
"result": 17004005,
"msg": getErrMsgByCode(17004005, None)
},
content_type="application/json")
else:
deviceID = reqBody["id"]
deviceInfo = {}
try:
deviceObj = RTSPDeviceDB.objects.get(id=deviceID)
deviceInfo["id"] = deviceObj.id
deviceInfo["name"] = deviceObj.name
deviceInfo["dept"] = deviceObj.dept
deviceInfo["type"] = deviceObj.type
deviceInfo["server"] = deviceObj.server
deviceInfo["channel"] = deviceObj.channel
deviceInfo["longitude"] = deviceObj.longitude
deviceInfo["latitude"] = deviceObj.latitude
deviceInfo["height"] = deviceObj.height
deviceInfo["locate"] = deviceObj.locate
deviceInfo["enable"] = deviceObj.enable
deviceInfo["position"] = deviceObj.position
deviceInfo["manufacturer_type"] = deviceObj.manufacturer_type
deviceInfo["permissions_info"] = deviceObj.permissions_info
deviceInfo["channel_type"] = deviceObj.channel_type
deviceInfo["inter_code_SN"] = deviceObj.inter_code_SN
deviceInfo["multicast_ip"] = deviceObj.multicast_ip
deviceInfo["multicast_port"] = deviceObj.multicast_port
except Exception as err:
return Response(
{
"result": 17004006,
"msg": getErrMsgByCode(17004006, err)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK",
"data": deviceInfo
},
content_type="application/json")
def rtspDeviceInfoBatchAdd(request):
"""
Rtsp设备信息--批量新增
:return:
"""
try:
reqBodys = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 11001001,
"msg": getErrMsgByCode(11001001, err)
},
content_type="application/json")
if reqbody_verify(reqBodys, err_code=17001001) is None:
pass
else:
return reqbody_verify(reqBodys, err_code=17001001)
if "infoList" not in reqBodys:
return Response(
{
"result": 11001016,
"msg": getErrMsgByCode(11001016, None)
},
content_type="application/json")
else:
infoList = reqBodys["infoList"]
for reqBody in infoList:
if "ip" not in reqBody:
return Response(
{
"result": 11001006,
"msg": getErrMsgByCode(11001006, None)
},
content_type="application/json")
else:
deviceIp = reqBody["ip"]
if "name" not in reqBody:
return Response(
{
"result": 11001007,
"msg": getErrMsgByCode(11001007, None)
},
content_type="application/json")
else:
deviceName = reqBody["name"]
if "address" not in reqBody:
return Response(
{
"result": 11001010,
"msg": getErrMsgByCode(11001010, None)
},
content_type="application/json")
else:
address = reqBody["address"]
if "observation_area" not in reqBody:
return Response(
{
"result": 11001011,
"msg": getErrMsgByCode(11001011, None)
},
content_type="application/json")
else:
observation_area = reqBody["observation_area"]
if "observation_target" not in reqBody:
return Response(
{
"result": 11001012,
"msg": getErrMsgByCode(11001012, None)
},
content_type="application/json")
else:
observation_target = reqBody["observation_target"]
longitude = None
latitude = None
bin_id = None
tide_level_name = None
tide_level_code = None
wave_heigh_name = None
wave_heigh_code = None
wave_direction_name = None
wave_direction_code = None
port = None
if "tide_level_name" in reqBody:
tide_level_name = reqBody["tide_level_name"]
if "tide_level_code" in reqBody:
tide_level_code = reqBody["tide_level_code"]
if "wave_heigh_name" in reqBody:
wave_heigh_name = reqBody["wave_heigh_name"]
if "wave_heigh_code" in reqBody:
wave_heigh_code = reqBody["wave_heigh_code"]
if "wave_direction_name" in reqBody:
wave_direction_name = reqBody["wave_direction_name"]
if "wave_direction_code" in reqBody:
wave_direction_code = reqBody["wave_direction_code"]
if "port" in reqBody:
port = reqBody["port"]
if "longitude" in reqBody:
longitude = reqBody["longitude"]
if "latitude" in reqBody:
latitude = reqBody["latitude"]
if "bin_id" in reqBody:
bin_id = reqBody["bin_id"]
savePoint = transaction.savepoint()
try:
deviceObj = RTSPDeviceDB()
deviceObj.ip = deviceIp
deviceObj.name = deviceName
deviceObj.address = address
deviceObj.observation_area = observation_area
deviceObj.observation_target = observation_target
if longitude:
deviceObj.longitude = longitude
if latitude:
deviceObj.latitude = latitude
if bin_id:
deviceObj.bin_id = bin_id
if tide_level_name:
deviceObj.tide_level_name = tide_level_name
if tide_level_code:
deviceObj.tide_level_code = tide_level_code
if wave_heigh_name:
deviceObj.wave_heigh_name = wave_heigh_name
if wave_heigh_code:
deviceObj.wave_heigh_code = wave_heigh_code
if wave_direction_name:
deviceObj.wave_direction_name = wave_direction_name
if wave_direction_code:
deviceObj.wave_direction_code = wave_direction_code
if port:
deviceObj.port = port
deviceObj.save()
except Exception as err:
transaction.savepoint_rollback(savePoint)
Response(
{
"result": 11001015,
"msg": getErrMsgByCode(11001015, err)
},
content_type="application/json")
transaction.savepoint_commit(savePoint)
return Response({
"result": 0,
"msg": "OK"
},
content_type="application/json")
def rtspDeviceInfoQueryAll(request):
"""
Rtsp设备信息--全部
:return:
"""
print(format(request.body))
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 17003001,
"msg": getErrMsgByCode(17003001, err)
},
content_type="application/json")
if reqbody_verify(reqBody, err_code=17003001) is None:
pass
else:
return reqbody_verify(reqBody, err_code=17003001)
indexPage = None
countInfo = None
if "page" in reqBody:
indexPage = reqBody["page"]
if "count" in reqBody:
countInfo = reqBody["count"]
resData = {}
try:
rtspDeviceObjs = RTSPDeviceDB.objects.all().order_by("position")
resultObjList = rtspDeviceObjs
resultInfoList = []
for item in resultObjList:
deviceObj = {}
deviceObj["id"] = item.id
deviceObj["name"] = item.name
deviceObj["dept"] = item.dept
deviceObj["type"] = item.type
deviceObj["server"] = item.server
deviceObj["channel"] = item.channel
deviceObj["longitude"] = item.longitude
deviceObj["latitude"] = item.latitude
deviceObj["height"] = item.height
deviceObj["locate"] = item.locate
deviceObj["enable"] = item.enable
deviceObj["position"] = item.position
deviceObj["manufacturer_type"] = item.manufacturer_type
deviceObj["permissions_info"] = item.permissions_info
deviceObj["channel_type"] = item.channel_type
deviceObj["inter_code_SN"] = item.inter_code_SN
deviceObj["multicast_ip"] = item.multicast_ip
deviceObj["multicast_port"] = item.multicast_port
resultInfoList.append(deviceObj)
if indexPage and countInfo:
indexStart = (indexPage - 1) * countInfo
if indexStart < 0:
indexStart = 0
indexEnd = indexStart + countInfo
if indexEnd >= rtspDeviceObjs.count():
indexEnd = rtspDeviceObjs.count()
resultInfoList = resultInfoList[indexStart:indexEnd]
else:
resultInfoList = resultInfoList
resData["info"] = resultInfoList
except Exception as err:
return Response(
{
"result": 17003006,
"msg": getErrMsgByCode(17003006, err)
},
content_type="application/json")
resData["total"] = resultObjList.count()
return Response({
"result": 0,
"msg": "OK",
"data": resData
},
content_type="application/json")
