云飞公司5类设备数据对接

apps/Equipment/serializers.py

@@ -16,13 +16,13 @@ class SearchEquipSerializer(serializers.Serializer):
             return value
 
 
-class QxzDeviceDetailSerializer(serializers.Serializer):
+class DeviceDetailSerializer(serializers.Serializer):
     device_id = serializers.CharField(help_text="设备号", required=True)
     start_timestamp = serializers.IntegerField(help_text="开始时间戳(秒级)", required=True)
 
     def validate_start_timestamp(self, attrs):
         nowtime = int(time.time())
-        if nowtime - attrs > 24*60*60:
+        if nowtime - attrs > 25*60*60:
             raise serializers.ValidationError("非近一天内时间")
         elif nowtime - attrs < 0:
             raise serializers.ValidationError("请确定是否为秒级时间戳,或非近一天内时间")

apps/Equipment/urls.py

@@ -5,6 +5,21 @@ from . import views
 urlpatterns = [
     url(r'^search/$', views.SearchEquip.as_view(), name='equip_search'),
 
-    url(r'^qxz/detail/$', views.QxzDeviceDetailView.as_view(), name='qxz_detail'),
     url(r'^qxz/list/$', views.QxzDeviceListView.as_view(), name='qxz_list'),
+    url(r'^qxz/detail/$', views.QxzDeviceDetailView.as_view(), name='qxz_detail'),
+
+    url(r'^scd/list/$', views.ScdDeviceListView.as_view(), name='scd_list'),
+    url(r'^scd/detail/$', views.ScdDeviceDetailView.as_view(), name='scd_detail'),
+
+    url(r'^cbd/list/$', views.CbdDeviceListView.as_view(), name='cbd_list'),
+    url(r'^cbd/detail/$', views.CbdDeviceDetailView.as_view(), name='cbd_detail'),
+    url(r'^cbd/photo/$', views.CbdDevicePhotoView.as_view(), name='cbd_photo'),
+
+    url(r'^bzy/list/$', views.BzyDeviceListView.as_view(), name='bzy_list'),
+    url(r'^bzy/detail/$', views.BzyDeviceDetailView.as_view(), name='bzy_detail'),
+    url(r'^bzy/photo/$', views.BzyDevicePhotoView.as_view(), name='bzy_photo'),
+
+    url(r'^xycb/list/$', views.XycbDeviceListView.as_view(), name='scd_list'),
+    url(r'^xycb/detail/$', views.XycbDeviceDetailView.as_view(), name='scd_detail'),
+    
 ]

apps/Equipment/views.py

@@ -2,10 +2,14 @@ from rest_framework.views import APIView
 from rest_framework.response import Response
 from django.core.cache import cache as default_cache
 
-from .serializers import SearchEquipSerializer, QxzDeviceDetailSerializer
+import json
+import ast
+
+from django.conf import settings
+from .serializers import SearchEquipSerializer, DeviceDetailSerializer
 from utils.JWTAuthentication_diy import APIAuthentication
-from utils.permissions import QXZDeviceDetailPermission
-from utils.MyRateThrottle import QxzDeviceListRateThrottle, QxzDeviceDetailRateThrottle
+from utils.permissions import QXZDeviceDetailPermission, ScdDeviceDetailPermission, CbdDeviceDetailPermission, BzyDeviceDetailPermission, XycbDeviceDetailPermission
+from utils.MyRateThrottle import DeviceDetailRateThrottle, QxzDeviceListRateThrottle, ScdDeviceListRateThrottle, CbdDeviceListRateThrottle, DevicePhotoRateThrottle, BzyDeviceListRateThrottle, XycbDeviceListRateThrottle
 from utils.utils import DeviceInfoUtils
 from utils.db_utils import MongoDBTools
 
@@ -64,10 +68,10 @@ class QxzDeviceListView(APIView):
 class QxzDeviceDetailView(APIView):
     authentication_classes = [APIAuthentication]
     permission_classes = [QXZDeviceDetailPermission]
-    throttle_classes = [QxzDeviceDetailRateThrottle]
+    throttle_classes = [DeviceDetailRateThrottle]
     
     def get(self, request, *args, **kwargs):
-        serializer = QxzDeviceDetailSerializer(data=request.query_params)
+        serializer = DeviceDetailSerializer(data=request.query_params)
         serializer.is_valid(raise_exception=True)
         request_data = serializer.validated_data
         start_time, device_id = request_data["start_timestamp"], request_data["device_id"]
@@ -100,3 +104,544 @@ class QxzDeviceDetailView(APIView):
             result["items"].append(item)
         return Response(result)
 
+
+class ScdDeviceListView(APIView):
+    authentication_classes = [APIAuthentication]
+    throttle_classes = [ScdDeviceListRateThrottle]
+
+    def get(self, request, *args, **kwargs):
+        """获取杀虫灯设备列表接口"""
+        uid = request.user
+        
+        wheres = {
+            "device_type_id":2,
+            '$or': [
+                {'owner_uid': uid},
+                {'user_dealer': uid}
+            ]
+        }
+        project = {
+            'id': '$id',
+            'device_id': '$device_id',
+            'uptime': '$uptime',
+            'device_status': '$device_status',
+            'lng': '$lng',
+            'lat': '$lat'
+        }
+        m = MongoDBTools(db_name='smartfarming', table_name='sa_device')
+        data = m.find_many(wheres=wheres, options=project)
+        if data:
+            total_counts = data.count()
+        else:
+            total_counts = 0
+        result = {"total_counts":total_counts,"items":[]}
+        scd_dict_cache = {}
+        for item in data:
+            d_id = item.pop("id")
+            result["items"].append(item)
+            scd_dict_cache[item["device_id"]] = d_id
+        default_cache.set(str(uid)+"_scd_list", scd_dict_cache,60*5)
+        return Response(result)
+
+
+class ScdDeviceDetailView(APIView):
+    authentication_classes = [APIAuthentication]
+    permission_classes = [ScdDeviceDetailPermission]
+    throttle_classes = [DeviceDetailRateThrottle]
+    
+    def get(self, request, *args, **kwargs):
+        serializer = DeviceDetailSerializer(data=request.query_params)
+        serializer.is_valid(raise_exception=True)
+        request_data = serializer.validated_data
+        start_time, device_id = request_data["start_timestamp"], request_data["device_id"]
+
+        uid = request.user
+        scd_dict_cache = default_cache.get(str(uid)+"_scd_list")
+        if scd_dict_cache:
+            d_id = scd_dict_cache[device_id]
+        else:
+            """避免缓存失效"""
+            wheres = {
+                'device_type_id':2,
+                '$or': [
+                    {'owner_uid': uid},
+                    {'user_dealer': uid}
+                ]
+            }
+            project = {
+                'id': '$id',
+                'device_id': '$device_id'
+            }
+            m = MongoDBTools(db_name='smartfarming', table_name='sa_device')
+            data = m.find_many(wheres=wheres, options=project)
+            scd_dict_cache = []
+            for item in data:
+                scd_dict_cache[item["device_id"]]=item["id"]
+            default_cache.set(str(uid)+"_scd_list", scd_dict_cache,60*5)
+            d_id = scd_dict_cache[device_id]
+
+        result = []
+
+        data_m = MongoDBTools(db_name='smartfarming', table_name='sa_device_scd_data')
+        data_wheres = {
+            "device_id": d_id,
+            "addtime": {"$gt":start_time}
+        }
+        data_project = {
+            "addtime": "$addtime",
+            "device_data": "$device_data"
+        }
+        data = data_m.find_many(wheres=data_wheres,options=data_project)
+
+        for item in data:
+            try:
+                device_data = json.loads(item["device_data"])
+            except:
+                device_data = ast.literal_eval(item["device_data"])
+            result.append({"uptime":item["addtime"],"item_data":device_data})
+        return Response(result)
+
+
+class CbdDeviceListView(APIView):
+    authentication_classes = [APIAuthentication]
+    throttle_classes = [CbdDeviceListRateThrottle]
+
+    def get(self, request, *args, **kwargs):
+        """获取测报灯设备列表接口"""
+        uid = request.user
+        
+        wheres = {
+            "device_type_id":3,
+            '$or': [
+                {'owner_uid': uid},
+                {'user_dealer': uid}
+            ]
+        }
+        project = {
+            'id': '$id',
+            'device_id': '$device_id',
+            'disable': '$disable',
+            'uptime': '$uptime',
+            'device_status': '$device_status',
+            'lng': '$lng',
+            'lat': '$lat'
+        }
+        m = MongoDBTools(db_name='smartfarming', table_name='sa_device')
+        data = m.find_many(wheres=wheres, options=project)
+        if data:
+            total_counts = data.count()
+        else:
+            total_counts = 0
+        result = {"total_counts":total_counts,"items":[]}
+        cbd_dict_cache = {}
+        for item in data:
+            d_id = item.pop("id")
+            disable = item.pop("disable")
+            result["items"].append(item)
+            cbd_dict_cache[item["device_id"]] = {"d_id":d_id,"disable":disable}
+        default_cache.set(str(uid)+"_cbd_list", cbd_dict_cache,60*5)
+        return Response(result)
+
+
+class CbdDeviceDetailView(APIView):
+    authentication_classes = [APIAuthentication]
+    permission_classes = [CbdDeviceDetailPermission]
+    throttle_classes = [DeviceDetailRateThrottle]
+    
+    def get(self, request, *args, **kwargs):
+        serializer = DeviceDetailSerializer(data=request.query_params)
+        serializer.is_valid(raise_exception=True)
+        request_data = serializer.validated_data
+        start_time, device_id = request_data["start_timestamp"], request_data["device_id"]
+
+        uid = request.user
+        cbd_dict_cache = default_cache.get(str(uid)+"_cbd_list")
+        if cbd_dict_cache:
+            d_id = cbd_dict_cache[device_id]["d_id"]
+        else:
+            """避免缓存失效"""
+            wheres = {
+                'device_type_id':3,
+                '$or': [
+                    {'owner_uid': uid},
+                    {'user_dealer': uid}
+                ]
+            }
+            project = {
+                'id': '$id',
+                'device_id': '$device_id',
+                'disable': '$disable'
+            }
+            m = MongoDBTools(db_name='smartfarming', table_name='sa_device')
+            data = m.find_many(wheres=wheres, options=project)
+            cbd_dict_cache = {}
+            for item in data:
+                cbd_dict_cache[item["device_id"]]={"d_id":item["id"],"disable":item["disable"]} 
+            default_cache.set(str(uid)+"_cbd_list", cbd_dict_cache,60*5)
+            d_id = cbd_dict_cache[device_id]["d_id"]
+
+        result = []
+
+        data_m = MongoDBTools(db_name='smartfarming', table_name='sa_device_cbd_data')
+        data_wheres = {
+            "device_id": d_id,
+            "addtime": {"$gt":start_time}
+        }
+        data_project = {
+            "addtime": "$addtime",
+            "device_data": "$device_data"
+        }
+        data = data_m.find_many(wheres=data_wheres,options=data_project)
+
+        for item in data:
+            try:
+                device_data = json.loads(item["device_data"])
+            except:
+                device_data = ast.literal_eval(item["device_data"])
+            result.append({"uptime":item["addtime"],"item_data":device_data})
+        return Response(result)
+
+
+class CbdDevicePhotoView(APIView):
+    authentication_classes = [APIAuthentication]
+    permission_classes = [CbdDeviceDetailPermission]
+    throttle_classes = [DevicePhotoRateThrottle]
+    
+    def get(self, request, *args, **kwargs):
+        serializer = DeviceDetailSerializer(data=request.query_params)
+        serializer.is_valid(raise_exception=True)
+        request_data = serializer.validated_data
+        start_time, device_id = request_data["start_timestamp"], request_data["device_id"]
+
+        uid = request.user
+        cbd_dict_cache = default_cache.get(str(uid)+"_cbd_list")
+        if cbd_dict_cache:
+            d_id = cbd_dict_cache[device_id]["d_id"]
+            disable = cbd_dict_cache[device_id]["disable"]
+        else:
+            """避免缓存失效"""
+            wheres = {
+                'device_type_id':3,
+                '$or': [
+                    {'owner_uid': uid},
+                    {'user_dealer': uid}
+                ]
+            }
+            project = {
+                'id': '$id',
+                'device_id': '$device_id',
+                'disable': '$disable'
+            }
+            m = MongoDBTools(db_name='smartfarming', table_name='sa_device')
+            data = m.find_many(wheres=wheres, options=project)
+            cbd_dict_cache = {}
+            for item in data:
+                cbd_dict_cache[item["device_id"]]={"d_id":item["id"],"disable":item["disable"]} 
+            default_cache.set(str(uid)+"_cbd_list", cbd_dict_cache,60*5)
+            d_id = cbd_dict_cache[device_id]["d_id"]
+            disable = cbd_dict_cache[device_id]["disable"]
+
+        result = []
+
+        data_m = MongoDBTools(db_name='smartfarming', table_name='sa_device_cbd_photo')
+        data_wheres = {
+            "device_id": str(d_id),
+            "addtime": {"$gt":start_time}
+        }
+        if disable == 1:
+            data_project = {
+                "addtime": "$addtime",
+                "addr": "$addr",
+                "indentify_photo":"$indentify_photo",
+                "indentify_result":"$indentify_result"
+            }
+        else:
+            data_project = {
+                "addtime": "$addtime",
+                "addr": "$addr"
+            }
+        data = data_m.find_many(wheres=data_wheres,options=data_project)
+
+        for item in data:
+            item_data = {}
+            addr = item["addr"]
+            if addr.startswith("http"):
+                Image = addr
+            elif addr.startswith("/"):
+                Image = settings.CONFIG["image_url"]["image_forward"] + addr
+            else:
+                Image = settings.CONFIG["image_url"]["image_forward"] + "/" +addr
+            item_data["uptime"] = item["addtime"]
+            item_data["Image"] = Image
+            if disable == 1:
+                Result = item["indentify_result"] if item["indentify_result"] else "0"
+                indentify_photo = item["indentify_photo"]
+                if indentify_photo:
+                    if indentify_photo.startswith("http"):
+                        Result_image = indentify_photo
+                    elif indentify_photo.startswith("/"):
+                        Result_image = settings.CONFIG["image_url"]["result_image_forward"] + indentify_photo
+                    else:
+                        Result_image = settings.CONFIG["image_url"]["result_image_forward"] + "/" + indentify_photo
+                else:
+                    Result_image = "0"
+                item_data["Result_image"] = Result_image
+                item_data["Result"] = Result
+
+            result.append(item_data)
+        return Response(result)
+
+
+class BzyDeviceListView(APIView):
+    authentication_classes = [APIAuthentication]
+    throttle_classes = [BzyDeviceListRateThrottle]
+
+    def get(self, request, *args, **kwargs):
+        """获取孢子仪设备列表接口"""
+        uid = request.user
+        
+        wheres = {
+            "device_type_id":7,
+            '$or': [
+                {'owner_uid': uid},
+                {'user_dealer': uid}
+            ]
+        }
+        project = {
+            'id': '$id',
+            'device_id': '$device_id',
+            'uptime': '$uptime',
+            'device_status': '$device_status',
+            'lng': '$lng',
+            'lat': '$lat'
+        }
+        m = MongoDBTools(db_name='smartfarming', table_name='sa_device')
+        data = m.find_many(wheres=wheres, options=project)
+        if data:
+            total_counts = data.count()
+        else:
+            total_counts = 0
+        result = {"total_counts":total_counts,"items":[]}
+        bzy_dict_cache = {}
+        for item in data:
+            d_id = item.pop("id")
+            result["items"].append(item)
+            bzy_dict_cache[item["device_id"]] = d_id
+        default_cache.set(str(uid)+"_bzy_list", bzy_dict_cache,60*5)
+        return Response(result)
+
+
+class BzyDeviceDetailView(APIView):
+    authentication_classes = [APIAuthentication]
+    permission_classes = [BzyDeviceDetailPermission]
+    throttle_classes = [DeviceDetailRateThrottle]
+    
+    def get(self, request, *args, **kwargs):
+        serializer = DeviceDetailSerializer(data=request.query_params)
+        serializer.is_valid(raise_exception=True)
+        request_data = serializer.validated_data
+        start_time, device_id = request_data["start_timestamp"], request_data["device_id"]
+
+        uid = request.user
+        bzy_dict_cache = default_cache.get(str(uid)+"_bzy_list")
+        if bzy_dict_cache:
+            d_id = bzy_dict_cache[device_id]
+        else:
+            """避免缓存失效"""
+            wheres = {
+                'device_type_id':7,
+                '$or': [
+                    {'owner_uid': uid},
+                    {'user_dealer': uid}
+                ]
+            }
+            project = {
+                'id': '$id',
+                'device_id': '$device_id'
+            }
+            m = MongoDBTools(db_name='smartfarming', table_name='sa_device')
+            data = m.find_many(wheres=wheres, options=project)
+            bzy_dict_cache = []
+            for item in data:
+                bzy_dict_cache[item["device_id"]]=item["id"]
+            default_cache.set(str(uid)+"_bzy_list", bzy_dict_cache,60*5)
+            d_id = bzy_dict_cache[device_id]
+
+        result = []
+
+        data_m = MongoDBTools(db_name='smartfarming', table_name='sa_device_bzy_data')
+        data_wheres = {
+            "device_id": d_id,
+            "addtime": {"$gt":start_time}
+        }
+        data_project = {
+            "addtime": "$addtime",
+            "device_data": "$device_data"
+        }
+        data = data_m.find_many(wheres=data_wheres,options=data_project)
+
+        for item in data:
+            try:
+                device_data = json.loads(item["device_data"])
+            except:
+                device_data = ast.literal_eval(item["device_data"])
+            result.append({"uptime":item["addtime"],"item_data":device_data})
+        return Response(result)
+
+
+class BzyDevicePhotoView(APIView):
+    authentication_classes = [APIAuthentication]
+    permission_classes = [BzyDeviceDetailPermission]
+    throttle_classes = [DevicePhotoRateThrottle]
+    
+    def get(self, request, *args, **kwargs):
+        serializer = DeviceDetailSerializer(data=request.query_params)
+        serializer.is_valid(raise_exception=True)
+        request_data = serializer.validated_data
+        start_time, device_id = request_data["start_timestamp"], request_data["device_id"]
+
+        uid = request.user
+        bzy_dict_cache = default_cache.get(str(uid)+"_bzy_list")
+        if bzy_dict_cache:
+            d_id = bzy_dict_cache[device_id]
+        else:
+            """避免缓存失效"""
+            wheres = {
+                'device_type_id':7,
+                '$or': [
+                    {'owner_uid': uid},
+                    {'user_dealer': uid}
+                ]
+            }
+            project = {
+                'id': '$id',
+                'device_id': '$device_id'
+            }
+            m = MongoDBTools(db_name='smartfarming', table_name='sa_device')
+            data = m.find_many(wheres=wheres, options=project)
+            bzy_dict_cache = []
+            for item in data:
+                bzy_dict_cache[item["device_id"]]=item["id"]
+            default_cache.set(str(uid)+"_bzy_list", bzy_dict_cache,60*5)
+            d_id = bzy_dict_cache[device_id]
+
+        result = []
+
+        data_m = MongoDBTools(db_name='smartfarming', table_name='sa_device_bzyphoto')
+        data_wheres = {
+            "device_id": str(d_id),
+            "addtime": {"$gt":start_time}
+        }
+        data_project = {
+            "addtime": "$addtime",
+            "addr": "$addr"
+        }
+        data = data_m.find_many(wheres=data_wheres,options=data_project)
+
+        for item in data:
+            if item["addr"].startswith("http"):
+                Image = item["addr"]
+            elif item["addr"].startswith("/"):
+                Image = settings.CONFIG["image_url"]["bzy_img_forward"] + item["addr"]
+            else:
+                Image = settings.CONFIG["image_url"]["bzy_img_forward"] + "/" + item["addr"]
+
+            result.append({"uptime":item["addtime"],"Image":Image})
+        return Response(result)
+
+
+class XycbDeviceListView(APIView):
+    authentication_classes = [APIAuthentication]
+    throttle_classes = [XycbDeviceListRateThrottle]
+
+    def get(self, request, *args, **kwargs):
+        """获取性诱设备列表接口"""
+        uid = request.user
+        
+        wheres = {
+            "device_type_id":4,
+            '$or': [
+                {'owner_uid': uid},
+                {'user_dealer': uid}
+            ]
+        }
+        project = {
+            'id': '$id',
+            'device_id': '$device_id',
+            'uptime': '$uptime',
+            'device_status': '$device_status',
+            'lng': '$lng',
+            'lat': '$lat'
+        }
+        m = MongoDBTools(db_name='smartfarming', table_name='sa_device')
+        data = m.find_many(wheres=wheres, options=project)
+        if data:
+            total_counts = data.count()
+        else:
+            total_counts = 0
+        result = {"total_counts":total_counts,"items":[]}
+        xycb_dict_cache = {}
+        for item in data:
+            d_id = item.pop("id")
+            result["items"].append(item)
+            xycb_dict_cache[item["device_id"]] = d_id
+        default_cache.set(str(uid)+"_xycb_list", xycb_dict_cache,60*5)
+        return Response(result)
+
+
+class XycbDeviceDetailView(APIView):
+    authentication_classes = [APIAuthentication]
+    permission_classes = [XycbDeviceDetailPermission]
+    throttle_classes = [DeviceDetailRateThrottle]
+    
+    def get(self, request, *args, **kwargs):
+        serializer = DeviceDetailSerializer(data=request.query_params)
+        serializer.is_valid(raise_exception=True)
+        request_data = serializer.validated_data
+        start_time, device_id = request_data["start_timestamp"], request_data["device_id"]
+
+        uid = request.user
+        xycb_dict_cache = default_cache.get(str(uid)+"_xycb_list")
+        if xycb_dict_cache:
+            d_id = xycb_dict_cache[device_id]
+        else:
+            """避免缓存失效"""
+            wheres = {
+                'device_type_id':4,
+                '$or': [
+                    {'owner_uid': uid},
+                    {'user_dealer': uid}
+                ]
+            }
+            project = {
+                'id': '$id',
+                'device_id': '$device_id'
+            }
+            m = MongoDBTools(db_name='smartfarming', table_name='sa_device')
+            data = m.find_many(wheres=wheres, options=project)
+            xycb_dict_cache = []
+            for item in data:
+                xycb_dict_cache[item["device_id"]]=item["id"]
+            default_cache.set(str(uid)+"_scd_list", xycb_dict_cache,60*5)
+            d_id = xycb_dict_cache[device_id]
+
+        result = []
+
+        data_m = MongoDBTools(db_name='smartfarming', table_name='sa_device_xycb_data')
+        data_wheres = {
+            "device_id": d_id,
+            "addtime": {"$gt":start_time}
+        }
+        data_project = {
+            "addtime": "$addtime",
+            "device_data": "$device_data"
+        }
+        data = data_m.find_many(wheres=data_wheres,options=data_project)
+
+        for item in data:
+            try:
+                device_data = json.loads(item["device_data"])
+            except:
+                device_data = ast.literal_eval(item["device_data"])
+            result.append({"uptime":item["addtime"],"item_data":device_data})
+        return Response(result)

formal.json

@@ -26,6 +26,9 @@
 	"image_url": {
 		"image": "https://bigdata-image.oss-cn-hangzhou.aliyuncs.com/Basics/cbd",
 		"discern" : "https://bigdata-image.oss-cn-hangzhou.aliyuncs.com/Result/cbd",
-		"discernB" : "https://bigdata-image.oss-cn-hangzhou.aliyuncs.com/ResultB/cbd"
+		"discernB" : "https://bigdata-image.oss-cn-hangzhou.aliyuncs.com/ResultB/cbd",
+		"image_forward": "http://8.136.98.49:8003/Basics/cbd",
+		"result_image_forward": "http://8.136.98.49:8003/Result/cbd",
+		"bzy_img_forward": "http://8.136.98.49:8003/bzy_photo"
 	}
 }

test.json

@@ -1,31 +1,34 @@
 {
 	"mysql": {
-		"host": "localhost",
+		"host": "114.115.147.140",
 		"port": 3306,
 		"user": "api",
 		"pwd": "yfkj@6020"
 	},
 	"redis": {
-		"host": "localhost",
+		"host": "114.115.147.140",
 		"port": "56379",
 		"password": "yf6021",
-        "url": "redis://:yf6021@127.0.0.1:56379/12"
+        "url": "redis://:yf6021@114.115.147.140:56379/12"
 	},
 	"bigdatamysql": {
-		"host": "localhost",
+		"host": "114.115.147.140",
 		"port": 3306,
 		"user": "root",
 		"pwd": "yfkj@6020"
 	},
 	"bigdatamongo": {
-		"host": "localhost",
+		"host": "114.115.147.140",
 		"port": 27017,
 		"user": "root",
 		"pwd": "yfkj@6020"
 	},
 	"image_url": {
 		"image": "http://bigdata-all.oss-accelerate.aliyuncs.com/Basics/cbd",
-		"discern" : "http://bigdata-all.oss-accelerate.aliyuncs.com/Result/cbd",
-		"discernB" : "http://bigdata-all.oss-accelerate.aliyuncs.com/ResultB/cbd"
+		"discern": "http://bigdata-all.oss-accelerate.aliyuncs.com/Result/cbd",
+		"discernB": "http://bigdata-all.oss-accelerate.aliyuncs.com/ResultB/cbd",
+		"image_forward": "http://114.115.147.140:8004/Basics/cbd",
+		"result_image_forward": "http://114.115.147.140:8004/Result/cbd",
+		"bzy_img_forward": "http://114.115.147.140/bzy_photo"
 	}
 }

utils/MyRateThrottle.py

@@ -1,5 +1,26 @@
 from rest_framework.throttling import SimpleRateThrottle
 
+
+class DeviceDetailRateThrottle(SimpleRateThrottle):
+    scope = "devicedetail"
+
+    def get_cache_key(self, request, view):
+        uid = request.user
+        device_id = request.query_params.get("device_id","")
+        key = str(uid) + device_id + "detail_rate"
+        return key
+
+
+class DevicePhotoRateThrottle(SimpleRateThrottle):
+    scope = "devicedetail"
+
+    def get_cache_key(self, request, view):
+        uid = request.user
+        device_id = request.query_params.get("device_id","")
+        key = str(uid) + device_id + "photo_rate"
+        return key
+
+
 class QxzDeviceListRateThrottle(SimpleRateThrottle):
     scope = "devicelist"
 
@@ -9,11 +30,36 @@ class QxzDeviceListRateThrottle(SimpleRateThrottle):
         return key
 
 
-class QxzDeviceDetailRateThrottle(SimpleRateThrottle):
-    scope = "devicedetail"
+class ScdDeviceListRateThrottle(SimpleRateThrottle):
+    scope = "devicelist"
 
     def get_cache_key(self, request, view):
         uid = request.user
-        device_id = request.query_params.get("device_id","")
-        key = str(uid) + device_id + "detail_rate"
+        key = str(uid) + "_scdlist_rate"
+        return key
+
+
+class CbdDeviceListRateThrottle(SimpleRateThrottle):
+    scope = "devicelist"
+
+    def get_cache_key(self, request, view):
+        uid = request.user
+        key = str(uid) + "_cbdlist_rate"
+        return key
+
+
+class BzyDeviceListRateThrottle(SimpleRateThrottle):
+    scope = "devicelist"
+
+    def get_cache_key(self, request, view):
+        uid = request.user
+        key = str(uid) + "_bzylist_rate"
+        return key
+
+class XycbDeviceListRateThrottle(SimpleRateThrottle):
+    scope = "devicelist"
+
+    def get_cache_key(self, request, view):
+        uid = request.user
+        key = str(uid) + "_xycblist_rate"
         return key

utils/permissions.py

@@ -47,14 +47,14 @@ class QXZDeviceDetailPermission(BasePermission):
                 return False
         else:
             wheres = {
-                "device_type_id":5,
+                'device_type_id':5,
                 '$or': [
                     {'owner_uid': uid},
                     {'user_dealer': uid}
                 ]
             }
             project = {
-                'device_id': '$device_id',
+                'device_id': '$device_id'
             }
             m = MongoDBTools(db_name='smartfarming', table_name='sa_device')
             data = m.find_many(wheres=wheres, options=project)
@@ -66,3 +66,158 @@ class QXZDeviceDetailPermission(BasePermission):
                 return True
             else:
                 return False
+
+
+class ScdDeviceDetailPermission(BasePermission):
+    message = "非此账户下设备"
+    
+    def has_permission(self, request, view):
+        uid = request.user
+        device_id = request.query_params.get("device_id")
+        if device_id is None:
+            return True
+        scd_dict_cache = default_cache.get(str(uid)+"_scd_list")
+        if scd_dict_cache:
+            if device_id in scd_dict_cache:
+                return True
+            else:
+                return False
+        else:
+            wheres = {
+                'device_type_id':2,
+                '$or': [
+                    {'owner_uid': uid},
+                    {'user_dealer': uid}
+                ]
+            }
+            project = {
+                'id': '$id',
+                'device_id': '$device_id'
+            }
+            m = MongoDBTools(db_name='smartfarming', table_name='sa_device')
+            data = m.find_many(wheres=wheres, options=project)
+            scd_dict_cache = {}
+            for item in data:
+                scd_dict_cache[item["device_id"]]=item["id"]
+            default_cache.set(str(uid)+"_scd_list", scd_dict_cache,60*5)
+            if device_id in scd_dict_cache:
+                return True
+            else:
+                return False
+
+
+class CbdDeviceDetailPermission(BasePermission):
+    message = "非此账户下设备"
+    
+    def has_permission(self, request, view):
+        uid = request.user
+        device_id = request.query_params.get("device_id")
+        if device_id is None:
+            return True
+        cbd_dict_cache = default_cache.get(str(uid)+"_cbd_list")
+        if cbd_dict_cache:
+            if device_id in cbd_dict_cache:
+                return True
+            else:
+                return False
+        else:
+            wheres = {
+                'device_type_id':3,
+                '$or': [
+                    {'owner_uid': uid},
+                    {'user_dealer': uid}
+                ]
+            }
+            project = {
+                'id': '$id',
+                'device_id': '$device_id',
+                'disable': '$disable'
+            }
+            m = MongoDBTools(db_name='smartfarming', table_name='sa_device')
+            data = m.find_many(wheres=wheres, options=project)
+            cbd_dict_cache = {}
+            for item in data:
+                cbd_dict_cache[item["device_id"]]={"d_id":item["id"],"disable":item["disable"]} 
+            default_cache.set(str(uid)+"_cbd_list", cbd_dict_cache,60*5)
+            if device_id in cbd_dict_cache:
+                return True
+            else:
+                return False
+
+
+class BzyDeviceDetailPermission(BasePermission):
+    message = "非此账户下设备"
+    
+    def has_permission(self, request, view):
+        uid = request.user
+        device_id = request.query_params.get("device_id")
+        if device_id is None:
+            return True
+        bzy_dict_cache = default_cache.get(str(uid)+"_bzy_list")
+        print(type(bzy_dict_cache))
+        print(bzy_dict_cache)
+        if bzy_dict_cache:
+            if device_id in bzy_dict_cache:
+                return True
+            else:
+                return False
+        else:
+            wheres = {
+                'device_type_id':7,
+                '$or': [
+                    {'owner_uid': uid},
+                    {'user_dealer': uid}
+                ]
+            }
+            project = {
+                'id': '$id',
+                'device_id': '$device_id'
+            }
+            m = MongoDBTools(db_name='smartfarming', table_name='sa_device')
+            data = m.find_many(wheres=wheres, options=project)
+            bzy_dict_cache = {}
+            for item in data:
+                bzy_dict_cache[item["device_id"]]=item["id"]
+            default_cache.set(str(uid)+"_bzy_list", bzy_dict_cache,60*5)
+            if device_id in bzy_dict_cache:
+                return True
+            else:
+                return False
+
+
+class XycbDeviceDetailPermission(BasePermission):
+    message = "非此账户下设备"
+    
+    def has_permission(self, request, view):
+        uid = request.user
+        device_id = request.query_params.get("device_id")
+        if device_id is None:
+            return True
+        xycb_dict_cache = default_cache.get(str(uid)+"_xycb_list")
+        if xycb_dict_cache:
+            if device_id in xycb_dict_cache:
+                return True
+            else:
+                return False
+        else:
+            wheres = {
+                'device_type_id':4,
+                '$or': [
+                    {'owner_uid': uid},
+                    {'user_dealer': uid}
+                ]
+            }
+            project = {
+                'id': '$id',
+                'device_id': '$device_id'
+            }
+            m = MongoDBTools(db_name='smartfarming', table_name='sa_device')
+            data = m.find_many(wheres=wheres, options=project)
+            xycb_dict_cache = {}
+            for item in data:
+                xycb_dict_cache[item["device_id"]]=item["id"]
+            default_cache.set(str(uid)+"_xycb_list", xycb_dict_cache,60*5)
+            if device_id in xycb_dict_cache:
+                return True
+            else:
+                return False