manyi/apps/web/api/views.py

# -*- coding: utf-8 -*-
# !/usr/bin/env python

import logging

import datetime
import simplejson as json
from mongoengine import DoesNotExist
from typing import TYPE_CHECKING

from apilib.utils_datetime import timestamp_to_dt
from apilib.utils_json import JsonResponse
from apps.web.api.exceptions import ApiAuthDeviceException, ApiNoDeviceException, ApiDeviceModeException
from apps.web.api.jn_north.constant import RESPONSE_CODE
from apps.web.api.utils import AES_CBC_PKCS5padding_decrypt, generate_json_token, AES_CBC_PKCS5padding_encrypt, parse_json_token
from apps.web.common.models import District, TempValues
from apps.web.constant import Const, ErrorCode
from apps.web.core.exceptions import ServiceException
from apps.web.core.models import SystemSettings
from apps.web.device.models import Device, Group, Part
from apps.web.south_intf.shangdong_platform import GroupIdMap, ShanDongNorther
from apps.web.south_intf.zhejiang_fire import ZhejiangRSA, ZhejiangAddressType, ZhejiangZone, ZhejiangNorther, Company
from apps.web.api.models import APIStartDeviceRecord

logger = logging.getLogger(__name__)

if TYPE_CHECKING:
    from apps.web.device.models import DeviceDict


# 智慧消防智能管控平台向各平台采集数据
# 获取公钥，此公钥用来加密密码
def getPublicKey(request):
    logger.info('norther some one getPublicKey')
    publicKey = ZhejiangRSA.publicKeyHear.replace('-----BEGIN PUBLIC KEY-----\n', '').replace(
        '\n-----END PUBLIC KEY-----', '')
    publicKey = publicKey.replace('\n', '')
    #     publicKey = base64.b64encode(publicKey)
    return JsonResponse({'code': 0, 'message': u'获取成功', 'data': {'publicKey': publicKey}})


def loginFromNorth(request):
    logger.info('norther some one loginFromNorth')
    username = request.POST.get('username')
    enPassword = request.POST.get('password')

    password = ZhejiangRSA.decrypt(enPassword)
    if password is None:
        return JsonResponse({'code': '1', 'msg': u'用户名或者密码错误', 'data': None})
    try:
        obj = ZhejiangNorther.objects.get(usernameFromHear = username, passwordFromHear = password)
    except Exception, e:
        return JsonResponse({'code': '1', 'msg': u'用户名或者密码错误', 'data': None})

    return JsonResponse({'code': 0, 'message': u'获取成功', 'data': {'tokenId': obj.tokenId}})


def getBuilding(request):
    def get_coordinates_and_nums(groupId):
        devs = Device.objects.filter(groupId = groupId)
        count = devs.count()
        if count == 0:
            return 0.0, 0.0, count
        for dev in devs:
            if dev.location is not None and dev.location.has_key('coordinates'):
                coord = dev.location['coordinates']
                return coord[0], coord[1], count
        return 0.0, 0.0, count

    agentId = request.META.get('HTTP_TOKENID', None)
    logger.info('norther getBuilding data ,token is  %s' % agentId)
    if agentId is None:
        return JsonResponse({'code': 2, 'message': u'获取token失败', 'data': None})
    try:
        norther = ZhejiangNorther.objects.get(tokenId = agentId)
    except Exception, e:
        return JsonResponse({'code': 2, 'message': u'token错误', 'data': None})

    serviceCode = norther.serviceCodeFromNorth

    pageNo = int(request.POST.get('pageNo'))
    pageSize = int(request.POST.get('pageSize'))

    if request.POST.has_key('createDateB'):
        createDateB = timestamp_to_dt(int(request.POST.get('createDateB')))
        createDateE = timestamp_to_dt(int(request.POST.get('createDateE')))

    postId = request.POST.get('postId', None)

    if postId is None:
        dealerIds = [obj.ownerId for obj in Company.objects.filter(agentId = agentId)]

        if request.POST.has_key('updateDateE'):
            updateDateB = timestamp_to_dt(int(request.POST.get('updateDateB')))
            updateDateE = timestamp_to_dt(int(request.POST.get('updateDateE')))
            groups = Group.objects.filter(ownerId__in = dealerIds,
                                          dateTimeUpdated__gte = updateDateB, dateTimeUpdated__lte = updateDateE)
        else:
            groups = Group.objects.filter(ownerId__in = dealerIds,
                                          dateTimeAdded__gte = createDateB, dateTimeAdded__lte = createDateE)
    else:
        groups = Group.objects.filter(id = postId)

    total = groups.count()
    pageCount = total / pageSize + 1
    dataList = []
    for group in groups.paginate(pageNo, pageSize):
        lng, lnt, count = get_coordinates_and_nums(str(group.id))
        data = {
            'buildingId': str(group.id),
            'buildingName': group.groupName,
            'companyId': group.ownerId,
            'address': group.address,
            'buildingType': ZhejiangAddressType.get_typeId(group.addressType),
            'lat': lnt,
            'lng': lng,
            'regionCode': ZhejiangZone.get_distinct_id(District.get_area(group.districtId), group.address),
            'deviceNum': count,
            'producerCode': serviceCode
        }
        dataList.append(data)

    return JsonResponse({'code': 0, 'message': u'获取成功',
                         'data': {'pageNo': pageNo, 'pageSize': pageSize, 'pageCount': pageCount, 'count': total,
                                  'list': dataList}})


def getCompany(request):
    agentId = request.META.get('HTTP_TOKENID', None)
    if agentId is None:
        return JsonResponse({'code': 2, 'message': u'获取token失败', 'data': None})

    logger.info('norther getCompany,token is %s' % agentId)

    try:
        norther = ZhejiangNorther.objects.get(tokenId = agentId)
    except Exception, e:
        return JsonResponse({'code': 2, 'message': u'token错误', 'data': None})

    pageNo = int(request.POST.get('pageNo'))
    pageSize = int(request.POST.get('pageSize'))

    if request.POST.has_key('createDateB'):
        createDateB = timestamp_to_dt(int(request.POST.get('createDateB')))
        createDateE = timestamp_to_dt(int(request.POST.get('createDateE')))

    postId = request.POST.get('postId', None)

    if postId is None:
        if request.POST.has_key('updateDateE'):
            updateDateB = timestamp_to_dt(int(request.POST.get('updateDateB')))
            updateDateE = timestamp_to_dt(int(request.POST.get('updateDateE')))
            companys = Company.objects.filter(agentId = agentId,
                                              dateTimeUpdated__gte = updateDateB, dateTimeUpdated__lte = updateDateE)
        else:
            companys = Company.objects.filter(agentId = agentId, dateTimeAdded__gte = createDateB,
                                              dateTimeAdded__lte = createDateE)
    else:
        companys = Company.objects.filter(ownerId = postId)

    total = companys.count()
    pageCount = total / pageSize + 1
    dataList = []
    for com in companys.paginate(pageNo, pageSize):
        data = {
            'companyId': str(com.ownerId),
            'companyName': com.name,
            'companyCode': com.unifiedSocialCreditCode,
            'address': com.address,
            'contactName': com.contactName,
            'contactTel': com.telephone,
        }
        dataList.append(data)

    return JsonResponse({'code': 0, 'message': u'获取成功',
                         'data': {'pageNo': pageNo, 'pageSize': pageSize, 'pageCount': pageCount, 'count': total,
                                  'list': dataList}})


def getEquipment(request):
    agentId = request.META.get('HTTP_TOKENID', None)
    if agentId is None:
        return JsonResponse({'code': 2, 'message': u'获取token失败', 'data': None})

    logger.info('norther getEquipment,token is %s' % agentId)

    try:
        norther = ZhejiangNorther.objects.get(tokenId = agentId)
    except Exception, e:
        return JsonResponse({'code': 2, 'message': u'token错误', 'data': None})

    serviceCode = norther.serviceCodeFromNorth

    pageNo = int(request.POST.get('pageNo'))
    pageSize = int(request.POST.get('pageSize'))

    if request.POST.has_key('createDateB'):
        createDateB = timestamp_to_dt(int(request.POST.get('createDateB'))).strftime('%Y-%m-%d %H:%M:%S')
        createDateE = timestamp_to_dt(int(request.POST.get('createDateE'))).strftime('%Y-%m-%d %H:%M:%S')

    postId = request.POST.get('postId', None)

    companyDict = {}
    if postId is None:
        dealerIds = []
        for obj in Company.objects.filter(agentId = agentId):
            companyDict[obj.ownerId] = obj.manufacturer
            dealerIds.append(obj.ownerId)
        if request.POST.has_key('updateDateE'):
            updateDateB = timestamp_to_dt(int(request.POST.get('updateDateB')))
            updateDateE = timestamp_to_dt(int(request.POST.get('updateDateE')))
            devs = Device.objects.filter(ownerId__in = dealerIds,
                                         dateTimeUpdated__gte = updateDateB, dateTimeUpdated__lte = updateDateE)
        else:
            devs = Device.objects.filter(ownerId__in = dealerIds,
                                         dateTimeAdded__gte = createDateB, dateTimeAdded__lte = createDateE)
    else:
        company = Company.objects.get(ownerId = postId)
        companyDict[company.ownerId] = company.manufacturer
        devs = Device.objects.filter(ownerId = postId)

    total = devs.count()
    pageCount = total / pageSize + 1
    dataList = []
    for devObj in devs.paginate(pageNo, pageSize):
        group = Group.get_group(devObj.groupId)

        dev = Device.get_dev(devObj.devNo)  # type: DeviceDict

        status = dev.status
        online = dev.online
        if status == Const.DEV_WORK_STATUS_FORBIDDEN:
            strStatus = '2'  # 禁用
        elif not online:
            strStatus = '3'  # 离线
        else:
            strStatus = '1'  # 在线

        partNum = Part.objects.filter(logcicalCode = devObj.logicalCode).count()

        data = {
            'deviceId': str(devObj.logicalCode),
            'deviceName': u'充电桩',
            'deviceType': '5',  # 智能充电桩
            'address': group.get('address', "") if group is not None else '',
            'lat': devObj.location['coordinates'][1] if devObj.location is not None and devObj.location.has_key(
                'coordinates') else 0.0,
            'lng': devObj.location['coordinates'][0] if devObj.location is not None and devObj.location.has_key(
                'coordinates') else 0.0,
            'companyId': devObj.ownerId,
            'buildingId': devObj.groupId,
            'producerCode': serviceCode,
            'installDate': devObj.dateTimeAdded,
            'deviceStatus': strStatus,
            'deviceManufactory': companyDict.get(devObj.ownerId, u'充电桩生产厂家'),
            'partsNum': partNum
        }

        dataList.append(data)

    return JsonResponse({'code': 0, 'message': u'获取成功',
                         'data': {'pageNo': pageNo, 'pageSize': pageSize, 'pageCount': pageCount, 'count': total,
                                  'list': dataList}})


def getParts(request):
    agentId = request.META.get('HTTP_TOKENID', None)
    if agentId is None:
        return JsonResponse({'code': 2, 'message': u'获取token失败', 'data': None})

    logger.info('norther getParts,token is %s' % agentId)

    pageNo = int(request.POST.get('pageNo'))
    pageSize = int(request.POST.get('pageSize'))

    if request.POST.has_key('createDateB'):
        createDateB = timestamp_to_dt(int(request.POST.get('createDateB')))
        createDateE = timestamp_to_dt(int(request.POST.get('createDateE')))

    postId = request.POST.get('postId', None)
    companyDict = {}
    if postId is None:
        dealerIds = []
        for obj in Company.objects.filter(agentId = agentId):
            companyDict[obj.ownerId] = obj.manufacturer
            dealerIds.append(obj.ownerId)

        lcList = []
        for dealerId in dealerIds:
            groupIds = Group.get_group_ids_of_dealer(dealerId)
            devNoList = Device.get_devNos_by_group(groupIds)
            for devNo in devNoList:
                lcList.append(Device.get_logicalCode_by_devNo(devNo))

        if request.POST.has_key('updateDateE'):
            updateDateB = timestamp_to_dt(int(request.POST.get('updateDateB')))
            updateDateE = timestamp_to_dt(int(request.POST.get('updateDateE')))
            parts = Part.objects.filter(logicalCode__in = lcList,
                                        dateTimeUpdated__gte = updateDateB, dateTimeUpdated__lte = updateDateE)
        else:
            parts = Part.objects.filter(logicalCode__in = lcList,
                                        dateTimeAdded__gte = createDateB, dateTimeAdded__lte = createDateE)

    else:
        company = Company.objects.get(ownerId = postId)
        companyDict[company.ownerId] = company.manufacturer
        lcList = []
        groupIds = Group.get_group_ids_of_dealer(postId)
        devNoList = Device.get_devNos_by_group(groupIds)
        for devNo in devNoList:
            lcList.append(Device.get_logicalCode_by_devNo(devNo))

        parts = Part.objects.filter(logicalCode__in = lcList)

    total = parts.count()
    pageCount = total / pageSize + 1
    dataList = []
    logicalCodes = set([obj.logicalCode for obj in parts.paginate(pageNo, pageSize)])
    devDict = {}
    for lc in logicalCodes:
        dev = Device.get_dev_by_logicalCode(lc)
        group = Group.get_group(dev['groupId'])
        devDict[lc] = group['address']

    for obj in parts.paginate(pageNo, pageSize):
        data = {
            'partsId': str(obj.id),
            'partsName': u'标准充电口',
            'address': devDict.get(obj.logicalCode),
            'deviceId': obj.logicalCode,
            'partsManufactory': companyDict.get(obj.ownerId, u'充电桩生产厂家'),
            'installDate': obj.dateTimeAdded,
            'partsStatus': '1',
            'partsType': Part.objects(id = obj.id)[0].partType,
        }

        dataList.append(data)

    return JsonResponse({'code': 0, 'message': u'获取成功',
                         'data': {'pageNo': pageNo, 'pageSize': pageSize, 'pageCount': pageCount, 'count': total,
                                  'list': dataList}})


# ---- 以下为山东省能源局平台接口

def queryToken(request):
    """
    省平台 获取token接口
    OperatorID 组织机构代码
    OperatorSecret 组织机构的密钥
    :param request:
    :return:
    """
    payload = json.loads(request.body)

    logger.info("[query token] payload = {}".format(payload))

    try:
        Data = json.loads(request.body).get("Data")
        data = json.loads(AES_CBC_PKCS5padding_decrypt(Data))
    except Exception as e:
        logger.exception(e)
        return JsonResponse({"Ret": RESPONSE_CODE.ERROR_POST, "Msg": u"请求参数错误（1002）"})

    OperatorID = data.get("OperatorID")
    OperatorSecret = data.get("OperatorSecret")

    logger.info("[query token] OperatorID = {}, OperatorSecret = {}".format(OperatorID, OperatorSecret))

    if not all((OperatorID, OperatorSecret)):
        return JsonResponse({"Ret": 4003, "Msg": u"请求参数错误"})

    try:
        norther = ShanDongNorther.objects.filter(northOperatorID = OperatorID, northOperatorSecret = OperatorSecret).first()
    except DoesNotExist:
        return JsonResponse({"Ret": 4004, "Msg": u"请求参数错误"})
    except Exception as e:
        return JsonResponse({"Ret": 500, "Msg": u"系统错误"})

    expire = 60 * 60 * 24 * 7
    result = {
        "OperatorID": norther.agentOperatorID,
        "SuccStat": 0,
        "AccessToken": generate_json_token(data=norther.get_token_data(), expire=expire),
        "TokenAvailableTime": expire,
        "FailReason": None
    }
    logger.debug("[queryToken] return result = {}".format(result))

    # 拉取的时候加密 显式指明加密秘钥为 pull
    resultData = AES_CBC_PKCS5padding_encrypt(
        json.dumps(result),
        dataSecret=norther.pullDataSecret,
        dataSecretIV=norther.pullDataSecretIV
    )
    sig = norther.get_sig(resultData)

    return JsonResponse({
        "Ret": RESPONSE_CODE.SUCCESS,
        "Msg": u"请求成功",
        "Data": resultData,
        "Sig": sig
    })


def queryStationInfo(request):
    """
    省平台拉去数据接口
    LastQueryTime  上次查询时间 格式 yyyy-MM-dd HH:mm:ss ，可以为空，如果不 填写，则查询所有的充电站信息
    PageNo
    PageSize
    :param request:
    :return:
    """
    token = request.META.get('HTTP_AUTHORIZATION', "").replace("Bearer", "").strip()
    logger.info('[queryStationsInfo] , token = {}'.format(token))

    # 验证身份
    tokenData = parse_json_token(token)
    if not tokenData:
        return JsonResponse({"Ret": RESPONSE_CODE.ERROR_TOKEN, "Msg": u"请求参数错误（1001）"})

    # 获取这个平台下面的所有的northers记录
    northers = ShanDongNorther.get_norther(**tokenData)
    if not northers:
        return JsonResponse({"Ret": RESPONSE_CODE.ERROR_PARAM, "Msg": u"请求参数错误（1002）"})

    # 准备token所获取的参数信息
    norther = northers.first()
    northerMap = {norther.dealerId: norther for norther in northers}
    pullDataSecret = norther.pullDataSecret
    pullDataSecretIV = norther.pullDataSecretIV

    # 这个平台下的所有对接过的经销商
    dealerIds = [_.dealerId for _ in northers]

    try:
        Data = json.loads(request.body).get("Data")
        data = json.loads(AES_CBC_PKCS5padding_decrypt(
            Data,
            dataSecret=pullDataSecret,
            dataSecretIV=pullDataSecretIV
        ))
    except Exception as e:
        logger.exception(e)
        return JsonResponse({"Ret": RESPONSE_CODE.ERROR_POST, "Msg": u"请求参数错误（1004）"})

    logger.info('[queryStationsInfo] , data = {}'.format(data))

    pageNo = int(data.get('PageNo', 1))
    pageSize = int(data.get('PageSize', 10))

    filters = {
        "ownerId__in": dealerIds
    }

    # 查询充电站信息 （Group）
    query = Group.objects.filter(**filters).only("id")
    StationInfos = list()

    # 修改一下 只允许上传的是 汽车装的
    groupIds = [str(item.id) for item in query if Device.objects.filter(groupId = str(item.id), devType__code__in=[
        Const.DEVICE_TYPE_CODE_CAR_CHARGING_CY_V2, Const.DEVICE_TYPE_CODE_CAR_CHARGING_CY,
        Const.DEVICE_TYPE_CODE_CHARGING_HONGZHUO
    ]).count()]

    groupQuery = Group.objects.filter(id__in = groupIds).only("id", "ownerId")
    pageCount = groupQuery.count() / pageSize + 1
    for item in groupQuery.paginate(pageNo, pageSize):
        # 获取站点信息
        groupId = str(item.id)
        _norther = northerMap[item.ownerId]

        dev = Device.objects.filter(groupId = groupId)
        if not dev:
            continue

        # 我们的GroupID是24位，省平台的是20位，这个地方做个映射表
        GroupIdMap.add(groupId)

        StationInfos.append(ShanDongNorther.get_station(groupId, _norther))

    result = {
        "PageNo": pageNo,
        "ItemSize": pageSize,
        "PageCount": pageCount,
        "StationInfos": StationInfos
    }
    resultData = AES_CBC_PKCS5padding_encrypt(
        json.dumps(result),
        dataSecret=pullDataSecret,
        dataSecretIV=pullDataSecretIV
    )
    sig = norther.get_sig(resultData)

    logger.info("[queryStationsInfo], result = {}".format(resultData))

    return JsonResponse({
        "Ret": 0,
        "Msg": u"请求成功",
        "Data": resultData,
        "Sig": sig
    })


def queryStationStats(request):
    """
    省平台 省级平台定期获取每个充电站在某个周期内的统计信息
    StationID
    StartTime
    EndTime
    :param request:
    :return:
    """
    token = request.META.get('HTTP_AUTHORIZATION', "").replace("Bearer", "").strip()
    logger.info('[queryStationStats] , token = {}'.format(token))

    # 验证身份
    tokenData = parse_json_token(token)
    if not tokenData:
        return JsonResponse({"Ret": RESPONSE_CODE.ERROR_TOKEN, "Msg": u"请求参数错误（1001）"})
    northers = ShanDongNorther.get_norther(**tokenData)
    if not northers:
        return JsonResponse({"Ret": RESPONSE_CODE.ERROR_PARAM, "Msg": u"请求参数错误（1002）"})

    # 准备token所获取的参数信息
    norther = northers.first()
    pullDataSecret = norther.pullDataSecret
    pullDataSecretIV = norther.pullDataSecretIV

    logger.debug("[queryStationStats] request body = {}".format(request.body))

    if not request.body:
        return JsonResponse({"Ret": RESPONSE_CODE.ERROR_POST, "Msg": u"请求参数错误（1003）"})

    try:
        Data = json.loads(request.body).get("Data")
        data = json.loads(AES_CBC_PKCS5padding_decrypt(
            Data,
            dataSecret=pullDataSecret,
            dataSecretIV=pullDataSecretIV
        ))
    except Exception as e:
        logger.exception(e)
        return JsonResponse({"Ret": RESPONSE_CODE.ERROR_POST, "Msg": u"请求参数错误（1004）"})

    logger.info('[queryStationStats], data = {}'.format(data))

    stationID = data.get("StationID")
    startTime = data.get("StartTime")
    endTime = data.get("EndTime")

    startTimeObj = datetime.datetime.strptime(startTime, "%Y-%m-%d")
    endTimeObj = datetime.datetime.strptime(endTime, "%Y-%m-%d")

    groupId = GroupIdMap.get_groupId(stationID)

    res = ShanDongNorther.get_station_state(groupId, startTimeObj, endTimeObj)
    res.update({
        "StationID": stationID,
        "StartTime": startTime,
        "EndTime": endTime
    })

    result = {"StationStats": res}
    resultData = AES_CBC_PKCS5padding_encrypt(
        json.dumps(result),
        dataSecret=pullDataSecret,
        dataSecretIV=pullDataSecretIV
    )
    sig = norther.get_sig(resultData)
    logger.debug("[queryStationStats] return result = {}".format(result))

    return JsonResponse({
        "Ret": 0,
        "Msg": u"请求成功",
        "Data": resultData,
        "Sig": sig
    })


def queryStationStatus(request):
    """
    省平台 用于批量查询设备实时状态
    :param request:
    :return:
    """
    token = request.META.get('HTTP_AUTHORIZATION', "").replace("Bearer", "").strip()
    logger.info('[queryStationStatus] , token = {}'.format(token))

    # 验证身份
    tokenData = parse_json_token(token)
    if not tokenData:
        return JsonResponse({"Ret": RESPONSE_CODE.ERROR_TOKEN, "Msg": u"请求参数错误（1001）"})
    northers = ShanDongNorther.get_norther(**tokenData)
    if not northers:
        return JsonResponse({"Ret": RESPONSE_CODE.ERROR_PARAM, "Msg": u"请求参数错误（1002）"})

    # 准备token所获取的参数信息
    norther = northers.first()
    pullDataSecret = norther.pullDataSecret
    pullDataSecretIV = norther.pullDataSecretIV

    logger.debug("[queryStationStatus] request body = {}".format(request.body))

    if not request.body:
        return JsonResponse({"Ret": RESPONSE_CODE.ERROR_POST, "Msg": u"请求参数错误（1003）"})

    try:
        Data = json.loads(request.body).get("Data")
        data = json.loads(AES_CBC_PKCS5padding_decrypt(
            Data,
            dataSecret=pullDataSecret,
            dataSecretIV=pullDataSecretIV
        ))
    except Exception as e:
        logger.exception(e)
        return JsonResponse({"Ret": RESPONSE_CODE.ERROR_POST, "Msg": u"请求参数错误（1004）"})

    stationIDs = data.get("StationIDs")
    if not isinstance(stationIDs, list):
        return JsonResponse({"Ret": 4004, "Msg": u"系统错误"})

    StationStatusInfos = list()
    for stationID in stationIDs:
        groupId = GroupIdMap.get_groupId(stationID)

        StationStatusInfos.append(
            {
                "StationID": stationID,
                "ConnectorStatusInfos": ShanDongNorther.get_station_status(groupId)
            }
        )

    result = {
        "StationStatusInfos": StationStatusInfos
    }
    resultData = AES_CBC_PKCS5padding_encrypt(
        json.dumps(result),
        dataSecret=pullDataSecret,
        dataSecretIV=pullDataSecretIV
    )
    sig = norther.get_sig(resultData)
    logger.debug("[queryStationStatus] return result = {}".format(result))

    return JsonResponse({
        "Ret": 0,
        "Msg": u"请求成功",
        "Data": resultData,
        "Sig": sig
    })


def queryEquipBusinessPolicy(request):
    """
    省平台 用于查询运营商的充电设备接口计费模型信息
    :param request:
    :return:
    """
    # 验证身份
    token = request.META.get('HTTP_AUTHORIZATION', "").replace("Bearer", "").strip()
    logger.info('[queryEquipBusinessPolicy] , token = {}'.format(token))

    tokenData = parse_json_token(token)
    if not tokenData:
        return JsonResponse({"Ret": RESPONSE_CODE.ERROR_TOKEN, "Msg": u"请求参数错误（1001）"})
    northers = ShanDongNorther.get_norther(**tokenData)
    if not northers:
        return JsonResponse({"Ret": RESPONSE_CODE.ERROR_PARAM, "Msg": u"请求参数错误（1002）"})

    # 准备token所获取的参数信息
    norther = northers.first()
    pullDataSecret = norther.pullDataSecret
    pullDataSecretIV = norther.pullDataSecretIV

    # 验证参数
    logger.debug("[queryEquipBusinessPolicy] request body = {}".format(request.body))

    if not request.body:
        return JsonResponse({"Ret": RESPONSE_CODE.ERROR_POST, "Msg": u"请求参数错误（1003）"})

    try:
        Data = json.loads(request.body).get("Data")
        data = json.loads(AES_CBC_PKCS5padding_decrypt(
            Data,
            dataSecret=pullDataSecret,
            dataSecretIV=pullDataSecretIV
        ))
    except Exception as e:
        logger.exception(e)
        return JsonResponse({"Ret": RESPONSE_CODE.ERROR_POST, "Msg": u"请求参数错误（1004）"})

    equipBizSeq = data.get("EquipBizSeq")
    connectorID = data.get("ConnectorID")

    policyInfo = ShanDongNorther.get_policy_info(connectorID)

    result = {
        "EquipBizSeq": equipBizSeq,
        "ConnectorID": connectorID,
        "SuccStat": 0 if policyInfo else 1,
        "FailReason": 0 if policyInfo else 1,
        "SumPeriod": 1,
        "PolicyInfos": [policyInfo] if policyInfo else None
    }
    resultData = AES_CBC_PKCS5padding_encrypt(
        json.dumps(result),
        dataSecret=pullDataSecret,
        dataSecretIV=pullDataSecretIV
    )
    sig = norther.get_sig(resultData)

    logger.debug("[queryEquipBusinessPolicy] return result = {}".format(result))

    return JsonResponse({
        "Ret": 0,
        "Msg": u"请求成功",
        "Data": resultData,
        "Sig": sig
    })


#####################
####   通用接口   ####
#####################
def send_api_order(payload, dealer, func):
    device = Device.get_dev_by_logicalCode(payload['deviceCode'])  # type: DeviceDict
    if not device:
        raise ApiNoDeviceException()

    if not device.is_authorized_to_dealer(str(dealer.id)):
        raise ApiAuthDeviceException()

    if device.isApi == False:
        raise ApiDeviceModeException()

    record = APIStartDeviceRecord(orderNo = payload.get('orderNo', ''),
                                  deviceCode = payload.get('deviceCode', ''),
                                  createTime = payload.get('createTime', ''),
                                  notifyUrl = payload.get('payload', ''),
                                  apiConf = getattr(dealer, 'api_conf'),
                                  channel = payload.get('channel', ''),
                                  devNo = device['devNo'],
                                  ownerId = device['ownerId'],
                                  attachParas = payload.get('attachParas', {}))
    record.save()

    err_code = ErrorCode.EXCEPTION
    err_msg = u'系统错误'
    result = {}

    try:
        smartBox = device.deviceAdapter
        result = eval('smartBox.{}(record=payload)'.format(func))

        err_code = result.get('rst')
        err_msg = str(result.get('desc', ''))

    except ServiceException as e:
        logger.error('start device({}) failed error(code={},msg={})'.format(device['devNo'], e.result.get('result'),
                                                                            e.result.get('description')))

        err_code = e.result.get('result')
        err_msg = str(e.result.get('description'))

    except Exception as e:
        logger.exception('start device({}) failed error={}'.format(device['devNo'], e))
        err_code = ErrorCode.EXCEPTION
        err_msg = str(e)

    finally:
        try:
            record.errCode = err_code
            record.errMsg = err_msg
            record.servicedInfo = result
            record.servicedInfo.update({'function': func})
            record.save()
        except Exception as e:
            logger.exception(e)

    return {'status': err_code, 'desc': err_msg, 'result': result}