kedong/smartfarming/views/counts_views.py

from django.core.paginator import Paginator
import logging
import datetime
from operator import itemgetter
from django.db.models import Q, Sum, Count
from django.conf import settings
from rest_framework.views import APIView
from rest_framework.response import Response
from smartfarming.models.ascend import MongoBase, MongoLandInfo, MongoPlantInfo, MongoAreaJob, LandPlanInfo, CountryModel, PlanWeekend
from smartfarming.models.user import DeviceUser
from smartfarming.models.device import MongoDevice
from smartfarming.models.worm_forecast import MongoCBDphoto
from smartfarming.models.pest_count import MongoCBDPestWarning
from smartfarming.models.weather import MongoQXZ_Alarm_Log_New
from smartfarming.serializers.ascend_serializers import LandPlanInfoSerializers
from smartfarming.serializers.pests_serializers import MongoCBDPestWarningSerializers, MongoQXZAlarmLogNewSerializers
from smartfarming.utils import get_recent_month, get_weather
from smartfarming.api.views.forecast.all_dict import insect_dict
from smartfarming.models.device import MongoDevice
from smartfarming.models.ascend import MongoBase


logger = logging.getLogger("myapp")

class LandPlanInfoAPIView(APIView):

    def post(self, request):
        # 种植采收列表及统计信息
        request_data = request.data 
        plan = request_data.get("plan")
        year = request_data.get("year")
        page_num = int(request_data.get("pagenum")) if request_data.get("pagenum") else 1
        page_size = int(request_data.get("pagesize")) if request_data.get("pagesize") else 10
        start_timestamp, end_timestatmp = 0, 0
        queryset = LandPlanInfo.objects.filter(is_delete=1).exclude(recovery_time=0).order_by("-addtime")
        if year:
            start_timestamp = datetime.datetime(int(year), 1,1,0,0).timestamp()
            end_timestatmp = datetime.datetime(int(year), 12,31,23,59).timestamp()            
            queryset = queryset.filter(addtime__gte=start_timestamp, addtime__lte=end_timestatmp)
        if plan:
            ids_lst = MongoPlantInfo.objects.filter(plantname__icontains=plan).values_list("id", flat=True)
            queryset = queryset.filter(plan_ids__in = ids_lst)
        total_obj = queryset.count()
        paginator = Paginator(queryset, page_size)
        page_obj = paginator.get_page(page_num)
        serializers = LandPlanInfoSerializers(page_obj, many=True)
        # 折线图
        # 获取最近5年年份列表
        current_year = datetime.datetime.now().year
        year_list = [year for year in range(current_year, current_year - 6, -1)]        
        year_value = LandPlanInfo.objects.all().exclude(recovery_time=0).values_list("addtime", flat=True).order_by("-addtime")
        years = []
        for year in year_value:
            y = datetime.datetime.fromtimestamp(year).year
            if y not in years and y in year_list:
                years.append(y)
        years.reverse()
        # 获取最近5年的作物ID
        if years:
            end = datetime.datetime(int(years[-1]) -5, 12,31,23,59).timestamp()
            start = datetime.datetime(int(years[-1]), 12,31,23,59).timestamp()
            plan_ids = LandPlanInfo.objects.filter(recovery_time__gte=end, recovery_time__lte=start).exclude(recovery_time=0).distinct().values_list("plan_id", flat=True).order_by("plan_id")
            counts = []
            # 组织具体数据
            for i in years:
                start_timestamp = datetime.datetime(i, 1,1,0,0).timestamp()
                end_timestatmp = datetime.datetime(i, 12,31,23,59).timestamp()
                plan_totals = LandPlanInfo.objects.filter(
                    recovery_time__gte=start_timestamp, 
                    recovery_time__lte=end_timestatmp).exclude(recovery_time=0).values("plan_id").annotate(total=Sum("recovery_kg")).order_by("plan_id").values_list("plan_id", "total")
                # 作物 id：总质量
                inners = {}
                for k in plan_totals:
                    inners[str(k[0])] = k[1]
                pid =[]
                for j in plan_ids:
                    pid.append(inners.get(str(j), 0))
                counts.append(pid)
            transpose_matrix = [[row[i] for row in counts] for i in range(len(counts[0]))]
            plannames = []
            # 组织农作物
            for p in plan_ids:
                plan_obj = MongoPlantInfo.objects.filter(id=p)
                if plan_obj:
                    planname = plan_obj.first().plantname +"-"+ plan_obj.first().planttype
                else:
                    planname = ""
                plannames.append(planname)
            return Response({
                "code": 0, 
                "msg": "success", 
                "data": serializers.data, 
                "count": total_obj, 
                "charts": {
                    "years": years,
                    "data": transpose_matrix,
                    "plan": plannames
                }
            })
        else:
            return Response({
                "code": 0, 
                "msg": "success", 
                "data": [], 
                "count": 0, 
                "charts": {
                    "years": [],
                    "data": [],
                    "plan": []
                }
            })


class PlanNameAPIView(APIView):

    def post(self, request):
        try:
            # 作物名字
            plan_ids = LandPlanInfo.objects.filter(is_delete=1).exclude(recovery_time=0).values_list("plan_id", flat=True).order_by("-addtime")
            plans = MongoPlantInfo.objects.filter(is_delete=1, id__in=plan_ids).values_list("plantname", flat=True).distinct()
            return Response({"code": 0, "msg": "success", "data": plans})
        except Exception as e:
            logger.error(e)
            return Response({"code": 0, "msg": "success", "data": []})
        

class PlanAreaAPIView(APIView):

    def post(self, request):
        # 种植面积与作物个数统计
        try:
            land_plan_ids = LandPlanInfo.objects.filter(status="采收").filter(recovery_kg=0).values("land_id", "plan_id")
            plan_land = []
            plans = []
            plan_area = 0
            for i in land_plan_ids:
                landarea = MongoLandInfo.objects.get(id=i.get("land_id")).landarea
                plant = MongoPlantInfo.objects.get(id=i.get("plan_id"))
                plantname = f"{plant.plantname}({plant.planttype})"
                plan_land.append(
                    {
                        "name": plantname,
                        "value": round(float(landarea), 2)
                    }
                )
                plans.append(plantname) if plantname not in plans else None 
                plan_area += round(float(landarea), 2)
            return Response({"code": 0, "msg": "success", "data": {"lands_area": round(plan_area, 2), "plans_count": len(plans), "p_list": plan_land}})
        except Exception as e:
            logger.error(e)
            return Response({"code": 0, "msg": "请检查数据"})


class DeviceCountAPIView(APIView):

    def post(self, request):
        # 统计设备在线或离线统计
        device_status = MongoDevice.objects.values("device_status").annotate(total=Count("id"))
        online = 0
        offline = 0
        for k in device_status:
            if k.get("device_status") == 1:
                online = k.get("total")
            if k.get("device_status") == 0:
                offline = k.get("total")

        # 设备分类 
        device_type = MongoDevice.objects.values("device_type_id").annotate(total=Count("id"))
        config_dict = settings.CONFIG.get("device_type_zh")
        device_type = {config_dict.get(str(result["device_type_id"])): result["total"] for result in device_type}
        return Response({
            "code": 0, 
            "msg": "success", 
            "data": {
                "device_status": {"online": online, "offline": offline},
                "device_category": device_type
                }
            })


class RecentPestCountAPIView(APIView):

    def post(self, request):
        # 统计最近一个月的害虫排名
        start = get_recent_month(1)
        data = MongoCBDphoto.objects.filter(uptime__gte=start).values_list("indentify_result", flat=True)
        try:
            pest_count = {}
            for i in data:
                tp_lst = i.split("#")
                for k in tp_lst:
                    if k:
                        pest = k.split(",")
                        if len(pest) == 2:
                            p_0 = pest[0]
                            p_1 = pest[1]
                            p_name = insect_dict.get(p_0)
                            if p_name not in pest_count.keys():
                                pest_count[p_name] = int(p_1)
                            else:
                                pest_count[p_name] += int(p_1)
                        else:
                            logger.error(f"害虫识别格式有误：{k}")
            result = sorted(pest_count.items(), key=itemgetter(1), reverse=False)
            result = {m[0]:m[1] for m in result[-10:]}
            return Response({"code": 0, "msg": "success", "data": result})
        except Exception as e:
            logger.error(e)
            return Response({"code": 2, "msg": "数据有误,请核查"})


# 网站顶部滚动预警信息
class AlermNewsAPIView(APIView):

    def post(self, request):
        try:
            myuser = request.myuser
            try:
                ip = request.META['HTTP_X_FORWARDED_FOR']
            except Exception as e:
                ip = request.META['REMOTE_ADDR']
            # 获取天气预警
            weather_data = get_weather(ip)
            weather = []
            for i in weather_data:
                alarm = i.get("alarm")
                if alarm:
                    for k in alarm:
                        weather.append(k.get("alarm_content"))
            # 获取虫睛预警
            user_id = str(myuser.id)
            pest_query = MongoCBDPestWarning.objects.all().order_by("-id")[:3]
            pest = []
            for p in pest_query:
                content = p.warning_content
                pest.append(content.replace("【云飞科技】尊敬的用户:", "").replace(",(详情请登陆http://hnyfwlw.com查看)", "").replace(",请注意防范(详情请登陆http://hnyfwlw.com查看)", ""))
            # 气象预警
            qx_query = MongoQXZ_Alarm_Log_New.objects.filter(user_id=user_id).order_by('-id')[:3]
            qx = []
            for q in qx_query:
                qx.append(q.warning_content)
            data = []
            if weather:
                for i in weather:
                    data.append(i)
            if pest:
                for i in pest:
                    data.append(i)
            if qx:
                for i in qx:
                    data.append(i)
            return Response({"code": 0,"msg":"success", "data": data})
        except Exception as e:
            logger.error(e)
            return Response({"code": 2, "msg": "获取数据失败"})
        
class APPAlarmAPIView(APIView):

    def post(self, request):
        # 气象站与测报预警
        request_data = request.data 
        type_id = request_data.get("type_id")
        data = {}
        if type_id == "3":
            # 虫情
            query = MongoCBDPestWarning.objects.all().order_by("-upltime")
            pest_serializers = MongoCBDPestWarningSerializers(query, many=True)
            data = pest_serializers.data 
        elif type_id == "5":
            query = MongoQXZ_Alarm_Log_New.objects.filter(warning_name="5").order_by("-upl_time")
            qxz_serializers = MongoQXZAlarmLogNewSerializers(query, many=True)
            data = qxz_serializers.data
        elif type_id == "8":
            query = MongoQXZ_Alarm_Log_New.objects.filter(warning_name="8").order_by("-upl_time")
            qxz_serializers = MongoQXZAlarmLogNewSerializers(query, many=True)
            data = qxz_serializers.data
        return Response({"code": 0, "msg": "success", "data": data})
        

class QxzCameraList(APIView):
    permission_classes = []
    authentication_classes = []
    def post(self, request):
        # 气象与监控绑定列表
        qxz_ids = MongoDevice.objects.filter(device_type_id__in = [5, 8]).values("device_id")
        cam_ids = MongoDevice.objects.filter(device_type_id = 6).values_list("device_id", flat=True)
        return Response({"code": 0,"msg":"success", "data": {"qxz_ids": qxz_ids, "cam_ids": cam_ids}})
    

class QxzCameraUpdate(APIView):
    permission_classes = []
    authentication_classes = []
    def post(self, request):
        # 气象与监控更新
        request_data = request.data 
        try:
            qx_id = request_data.get("qx_id")
            ca_id = request_data.get("ca_id")
            qx_lng_lat = MongoDevice.objects.filter(device_id=qx_id).values_list("lng", "lat")
            ca_obj = MongoDevice.objects.get(device_id=ca_id)
            if qx_lng_lat:
                ca_obj.lng = float(qx_lng_lat[0][0]) + 0.00004
                ca_obj.lat = float(qx_lng_lat[0][1]) + 0.00004
                ca_obj.save()
            return Response({"code": 0,"msg":"success"})
        except Exception as e:
            logger.error(e)
            return Response({"code": 2,"msg":"失败"})
        
    
class KeDongOverAPIView(APIView):

    def post(self, request): 
        # 我的信息
        try:
            country_count = CountryModel.objects.all().count()
            area = MongoBase.objects.all().first().base_area
            device = MongoDevice.objects.all().count()
            return Response({
                "code": 0,
                "msg":"success", 
                "data": {
                    "country_count": country_count, 
                    "area": area, 
                    "device": device
                }
            })
        except Exception as e:
            logger.error(e)
            return Response({"code": 2,"msg":"失败"})