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 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 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 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 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 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 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 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 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 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 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 getDeptIotDevice(request):
"""
获取部门树状IOT设备
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 11008001,
"msg": getErrMsgByCode(11008001, err)
},
content_type="application/json")
try:
deptID = 1
deptInfo = deptDB.objects.get(id=1)
resdata = []
resData = {}
resData["id"] = deptInfo.id
resData["name"] = deptInfo.name
resData["pid"] = deptInfo.pid
resData["path"] = deptInfo.path
resData["label"] = deptInfo.name
resData["value"] = deptInfo.id
subDeptList = []
getSubDeptTreeListMy(deptID, subDeptList)
resData["children"] = subDeptList
resdata.append(resData)
except Exception as err:
return Response(
{
"result": 11003005,
"msg": getErrMsgByCode(11003005, err)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK",
"data": resdata
},
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 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 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 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 userLogin(request):
"""
用户信息--登录
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 10000001,
"msg": getErrMsgByCode(10000001, err)
},
content_type="application/json")
if "login" not in reqBody:
return Response(
{
"result": 10000002,
"msg": getErrMsgByCode(10000002, None)
},
content_type="application/json")
else:
loginName = reqBody["login"]
if "password" not in reqBody:
return Response(
{
"result": 10000003,
"msg": getErrMsgByCode(10000003, None)
},
content_type="application/json")
else:
loginPwd = reqBody["password"]
try:
userObj = userDB.objects.get(login=loginName)
except userDB.DoesNotExist:
return Response(
{
"result": 10000004,
"msg": getErrMsgByCode(10000004, None)
},
content_type="application/json")
if userObj.password != mysql_password(loginPwd):
return Response(
{
"result": 10000005,
"msg": getErrMsgByCode(10000005, None)
},
content_type="application/json")
if userObj.enable == 0:
return Response(
{
"result": 10000006,
"msg": getErrMsgByCode(10000007, None)
},
content_type="application/json")
strTime = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
tokenValue = tokenEncode({
"id": userObj.id,
"login": userObj.login,
"time": strTime
})
print(tokenValue)
if tokenValue is None:
return Response(
{
"result": 10000007,
"msg": getErrMsgByCode(10000007, None)
},
content_type="application/json")
resData = {}
resData["id"] = userObj.id
resData["login"] = userObj.login
resData["nickname"] = userObj.nickname
resData["enable"] = userObj.enable
resData["token"] = tokenValue
return Response({
"result": 0,
"msg": "OK",
"data": resData
},
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 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 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 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 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 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 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 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 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 userLogout(request):
"""
用户信息--登出
:return:
"""
try:
reqBody = json.loads(request.body)
except Exception as err:
return Response(
{
"result": 10001001,
"msg": getErrMsgByCode(10001001, err)
},
content_type="application/json")
if "login" not in reqBody:
return Response(
{
"result": 10001002,
"msg": getErrMsgByCode(10001002, None)
},
content_type="application/json")
else:
loginName = reqBody["login"]
if "token" not in reqBody:
return Response(
{
"result": 10001003,
"msg": getErrMsgByCode(10002002, None)
},
content_type="application/json")
else:
loginToken = reqBody["token"]
tokenInfo = tokenDecode(loginToken)
if tokenInfo is None:
return Response(
{
"result": 10001004,
"msg": getErrMsgByCode(10001004, None)
},
content_type="application/json")
tokenCache = tokenQuery(loginName)
if tokenCache != loginToken:
return Response(
{
"result": 10001005,
"msg": getErrMsgByCode(10001005, None)
},
content_type="application/json")
if tokenDelete(loginName) is False:
return Response(
{
"result": 10001006,
"msg": getErrMsgByCode(10001006, None)
},
content_type="application/json")
return Response({
"result": 0,
"msg": "OK"
},
content_type="application/json")
