manyi/apps/web/core/adapter/yuewantong.py

# coding=utf-8

"""
清远粤万通充电桩 2020-09-03修改
计费模式分为  按功率计费（服务器不断的算钱有没有用完， 服务器下发停止）
            按时间计费（一次性下发时间，不需要服务器停止）
            按电量计费(用到最后收集电量 进行判定)
            chargeType

收费模式分为  预付费方式（服务器先收钱， 收完了之后在启动设备， 如果存在没有使用完的钱 需要退还到用户的账户）
            后付费方式（先不收钱， 等用户使用完了之后再计算总的钱，然后结束这笔订单，将所需的费用写入， 同时执行订单支付，如账户余额不足支付， 标记等待下次支付）


套餐模式分为  正常套餐（标记好多少钱，最多就用这么多）
            充满自停套餐（不知道多少钱，反正一直充，充满为止，一般的处理方式是下发一个极大值）


fill_2_hexByte 函数统一修改为 int_to_hex
在发送断电指令之后，主板不会新上报端口信息，而是直接结束

"""
import binascii
import datetime
import logging
import simplejson as json
from pandas import Interval

from apilib.monetary import RMB
from apps.common.utils import int_to_hex
from apps.web.constant import Const, DeviceCmdCode, MQTT_TIMEOUT
from apps.web.core.adapter.base import SmartBox, reverse_hex
from apps.web.core.exceptions import ServiceException
from apps.web.core.networking import MessageSender
from apps.web.device.models import Device, DevicePortReport
from apps.web.user.models import ServiceProgress
from apps.web.utils import concat_user_login_entry_url

logger = logging.getLogger(__name__)


class YueWanTong(SmartBox):

    PORT_STATUS_MAP = {
        "0": Const.DEV_WORK_STATUS_IDLE,
        "1": Const.DEV_WORK_STATUS_WORKING,
        "2": Const.DEV_WORK_STATUS_APPOINTMENT,
        "3": Const.DEV_WORK_STATUS_FAULT,
        "4": Const.DEV_WORK_STATUS_FAULT,
        "5": Const.DEV_WORK_STATUS_FAULT,
        "6": Const.DEV_WORK_STATUS_FAULT
    }

    DEFAULT_MIN_CHARGE_TIME = 5
    DEFAULT_PORT_NUM = 12
    DEFAULT_MIN_POWER = 20
    DEFAULT_MAX_POWER = 500
    DEFAULT_FLOAT_TIME = 2
    DEFAULT_IC_CODE = "0001"
    DEFAULT_MIN_CONSUME = 0
    DEFAULT_POWER_PACKAGE = [
        {
            "lowLimit": 0,
            "upLimit": 250,
            "price": 1,
        },
        {
            "lowLimit": 250,
            "upLimit": 360,
            "price": 1,
        },
        {
            "lowLimit": 360,
            "upLimit": 500,
            "price": 1,
        }
    ]
    DEFAULT_ELEC_PRICE = 1
    DEFAULT_PAY_AFTER_USE = False
    DEFAULT_CHARGE_TYPE = "time"        # 默认的计费模式 是时间计费 （功率不分档）

    # 服务费电费
    DEFAULT_ELEC_CHARGE = 0.5
    DEFAULT_SERVICE_CHARGE = 0.5

    @staticmethod
    def _suit_power_package(powerPackage):
        """
        对于功率套餐的适配
        旧版本是  100-200w x 元 y 分钟
        新版本是  100-200w x 元 1 小时
        :param powerPackage:
        :return:
        """
        newPowerPackage = list()
        for _item in powerPackage:
            # 旧版本的
            if "time" not in _item:
                newPowerPackage.append(_item)
            else:
                # 做一个数据的适配
                price = float(_item["price"]) / (int(_item["time"]) / 60.0)
                newPowerPackage.append({
                    "upLimit": _item["upLimit"], "lowLimit": _item["lowLimit"], "price": str(RMB(price))
                })

        return newPowerPackage

    @staticmethod
    def _to_ascii(s):
        """
        将 字符串 转换为 16进制ascii 表达形式
        :param s: 原始字符串
        :return:
        """
        return binascii.hexlify(s)

    @staticmethod
    def _to_str(h):
        """
        将 16进制ascii 转换成 字符串
        :param h:
        :return:
        """
        return binascii.unhexlify(h)

    @staticmethod
    def _transform_time(needTime, unit):
        """
        根据单位 将套餐时间转换成分钟
        :param needTime: int
        :param unit: unicode
        :return:
        """
        if unit == u"小时":
            needTime = needTime * 60
        elif unit == u"分钟":
            needTime = needTime
        elif unit == u"秒":
            needTime = needTime // 60
        elif unit == u"次":
            needTime = None
        else:
            raise ServiceException({'result': 2, 'description': u'套餐错误'})

        return needTime

    def _send_data(self, funCode, sendData, cmd=None, timeout=MQTT_TIMEOUT.NORMAL, orderNo=None):
        """
        发送报文封装
        :param funCode:
        :param sendData:
        :param cmd:
        :param timeout:
        :param orderNo:
        :return:
        """
        if cmd is None:
            cmd = DeviceCmdCode.OPERATE_DEV_SYNC

        result = MessageSender.send(device = self.device, cmd = cmd, payload = {
            "IMEI": self._device["devNo"],
            "funCode": funCode,
            "data": sendData
        }, timeout = timeout)

        if result.has_key("rst"):
            if result["rst"] == -1:
                raise ServiceException({'result': 2, 'description': u'充电桩正在玩命找网络，请稍候再试'})
            elif result["rst"] == 1:
                raise ServiceException({'result': 2, 'description': u'充电桩主板连接故障'})
            elif result["rst"] == 0:
                return result
            else:
                raise ServiceException({'result': 2, 'description': u'系统错误'})
        else:
            raise ServiceException({'result': 2, 'description': u'系统错误'})

    def _start_device(self, orderNo, port, chargeTime=None):
        """
        开始充电
        :param orderNo: 下发的订单编号
        :param port: 开启的端口号
        :param chargeTime: 充电的最大时间，如果是充满自停，则设置为最大时间
        :return:
        """
        if chargeTime is None:
            chargeTime = 0xFFFF
        if orderNo is None:
            orderNo = 0

        orderNoHex = int_to_hex(int(orderNo), 14, reverse=True)
        portHex = int_to_hex(int(port), 2, reverse=True)
        chargeTimeHex = int_to_hex(int(chargeTime), 4, reverse=True)

        sendData = "{}{}{}010000".format(orderNoHex, portHex, chargeTimeHex)
        result = self._send_data("B2", sendData, timeout=MQTT_TIMEOUT.START_DEVICE, orderNo=orderNo)

        return result

    def _stop_device(self, orderNo, port):
        """
        停止充电
        :param orderNo: 提供开始充电的时候的订单号
        :param port: 端口号
        :return:
        """
        orderNoHex = int_to_hex(int(orderNo), 14, reverse=True)
        portHex = int_to_hex(int(port), 2, reverse=True)

        sendData = "{}{}0000120000".format(orderNoHex, portHex)

        result = self._send_data("B2", sendData, timeout=MQTT_TIMEOUT.START_DEVICE, orderNo=orderNo)

        return result

    @staticmethod
    def _parse_device_stop(data):
        """
        主动下发停止指令设备的回复 与结束上报不一样
        :param data:
        :return:
        """
        statusMap = {
            "00": Const.DEV_WORK_STATUS_IDLE,
            "01": Const.DEV_WORK_STATUS_WORKING,
            "02": Const.DEV_WORK_STATUS_APPOINTMENT,
            "03": Const.DEV_WORK_STATUS_FAULT,          # 故障
            "04": Const.DEV_WORK_STATUS_FAULT,          # 烟感
            "05": Const.DEV_WORK_STATUS_FAULT,          # 雨感
            "06": Const.DEV_WORK_STATUS_FAULT           # 设备锁定
        }

        orderHexNo = reverse_hex(data[8:22])
        portHex = data[22:24]
        voltage = int(reverse_hex(data[24:28]), 16)
        power = int(reverse_hex(data[32:36]), 16)
        elec = int(reverse_hex(data[36:44]), 16) / 1000.0
        chargeTime = int(reverse_hex(data[44:48]), 16)
        status = statusMap.get(data[52: 54], Const.DEV_WORK_STATUS_IDLE)

        return {
            "orderNoHex": orderHexNo,
            "portHex": portHex,
            "orderNo": int(orderHexNo, 16),
            "portStr": str(int(portHex, 16)),
            "voltage": voltage,
            "power": power,
            "elec": elec,
            "chargeTime": chargeTime,
            "status": status
        }

    def _read_port_status(self):
        """
        从设备端读取端口状态 仅仅只包含状态量
        :return:
        """
        result = self._send_data("B3", sendData="00")
        data = result.get("data", "")[8: -4]

        lockPorts = self.device.otherConf.get("lockPorts") or list()

        portInfo = dict()
        while data:
            tempPort = str(int(data[0: 2], 16))
            tempStatus = self.PORT_STATUS_MAP.get(data[34: 36], Const.DEV_WORK_STATUS_IDLE) if tempPort not in lockPorts else Const.DEV_WORK_STATUS_FORBIDDEN

            portInfo.update({tempPort: tempStatus})

            data = data[4: ]

        return portInfo

    def _read_port_charge_status(self):
        """
        从设备读取设备端口的状态 详细数据，包含电流 功率 电压 电量 时间 等等
        :return:
        """
        result = self._send_data("B4", sendData="00")
        data = result.get("data", "")[8: -4]

        lockPorts = self.device.otherConf.get("lockPorts") or list()

        portInfo = dict()
        while data:
            tempPort = str(int(data[0: 2], 16))
            tempVoltage = int(reverse_hex(data[2: 6]), 16)
            tempPower = int(reverse_hex(data[10: 14]), 16)
            tempElec = int(reverse_hex(data[14: 22]), 16) / 1000.0
            tempTime = int(reverse_hex(data[22: 26]), 16)
            tempTemper = int(reverse_hex(data[30: 34]), 16)
            tempStatus = self.PORT_STATUS_MAP.get(data[34: 36], Const.DEV_WORK_STATUS_IDLE) if tempPort not in lockPorts else Const.DEV_WORK_STATUS_FORBIDDEN

            portInfo.update({
                tempPort: {
                    "voltage": tempVoltage,
                    "elec": tempElec,
                    "power": tempPower,
                    "chargeTime": tempTime,
                    "temperature": tempTemper,
                    "status": tempStatus
                }
            })

            data = data[36: ]

        return portInfo

    def _reboot_device(self):
        """
        重启设备
        :return:
        """
        result = self._send_data("B5", sendData="00")
        status = result["data"][8: 10]
        if status != "01":
            raise ServiceException({'result': 2, 'description': u'设备重启失败，请重新操作试试'})

    def _lock_unlock_device(self, lock):
        """
        锁定/解锁设备
        :param lock: True / False
        :return:
        """
        # 设备锁定发送 00 / 解锁发送 01
        sendData = int_to_hex(int(lock), 2, reverse=True)

        message = "设备锁定失败" if lock else "设备解锁失败"

        result = self._send_data("B6", sendData=sendData)
        status = result["data"][8: 10]
        if status != "01":
            raise ServiceException({'result': 2, 'description': u'{}，请重新操作试试'.format(message)})

    def _sync_device_time(self):
        """
        开机后设备向服务器请求同步时间，服务器回复设备
        :return:
        """
        nowTime = datetime.datetime.now()
        yearHex = int_to_hex(nowTime.year, 4, reverse=True)
        monthHex = int_to_hex(nowTime.month, 2)
        dayHex = int_to_hex(nowTime.day, 2)
        hourHex = int_to_hex(nowTime.hour, 2)
        minuteHex = int_to_hex(nowTime.minute, 2)
        secondHex = int_to_hex(nowTime.second, 2)

        sendData = yearHex + monthHex + dayHex + hourHex + minuteHex + secondHex + "00"
        self._send_data("A1", sendData=sendData, cmd=DeviceCmdCode.OPERATE_DEV_NO_RESPONSE)

    def _sync_device_settings(self):
        """
        开机后设备向服务器请求同步参数 包括需要扫描的二维码，刷卡前缀 最小功率最大功率等
        :return:
        """
        otherConf = self._device.get("otherConf", dict())

        # 扫描的设备二维码
        qr_code_url = concat_user_login_entry_url(l = self._device["logicalCode"])

        snCode = otherConf.get("snCode", self._device["logicalCode"].replace("G", ""))
        minPower = otherConf.get("minPower", YueWanTong.DEFAULT_MIN_POWER)
        maxPower = otherConf.get("maxPower", YueWanTong.DEFAULT_MAX_POWER)
        floatTime = otherConf.get("floatTime", YueWanTong.DEFAULT_FLOAT_TIME)
        ICSetupCode = otherConf.get("ICSetupCode", YueWanTong.DEFAULT_IC_CODE)

        qrCodeLenHex = int_to_hex(len(qr_code_url), 2)
        minPowerHex = int_to_hex(int(minPower), 4, reverse=True)
        maxPowerHex = int_to_hex(int(maxPower), 4, reverse=True)
        floatTimeHex = int_to_hex(int(floatTime), 4, reverse=True)

        qrCodeHex = self._to_ascii(qr_code_url)
        snCodeHex = self._to_ascii(snCode)
        ICSetupCodeHex = self._to_ascii(ICSetupCode)

        sendData = snCodeHex + minPowerHex + maxPowerHex + floatTimeHex + ICSetupCodeHex + qrCodeLenHex + qrCodeHex
        self._send_data("A2", sendData=sendData, cmd=DeviceCmdCode.OPERATE_DEV_NO_RESPONSE)

    @staticmethod
    def _parse_card_start(data):
        """
        解析刷卡启动的数据
        :param data:
        :return:
        """
        cardPre = YueWanTong._to_str(data[8: 16])
        cardNo = YueWanTong._to_str(data[16: 32])
        portStr = str(int(data[32: 34], 16))

        return {
            "cardPre": cardPre,
            "cardNo": cardNo,
            "portStr": portStr,
            "portStrHex": data[32:34],
            "cardCode": data[8: 32]
        }

    @staticmethod
    def _parse_card_stop(data):
        """
        解析刷卡结束 数据
        :param data:
        :return:
        """
        cardInfo = YueWanTong._parse_card_start(data)
        orderNoHex = data[34: 48]
        orderNo = str(int(reverse_hex(orderNoHex), 16))

        cardInfo.update({
            "orderNo": orderNo,
            "orderNoHex": orderNoHex
        })
        return  cardInfo

    @staticmethod
    def _parse_report(data):
        """
        设备 每10分钟 每个端口 上报一次充电状态
        电压 电流 功率 端口状态 温度 是 当前值
        电量 时间（断电保护） 是累计值
        电流 暂时用不上 不用解析
        :param data:
        :return:
        """
        statusMap = {
            "00": Const.DEV_WORK_STATUS_IDLE,
            "01": Const.DEV_WORK_STATUS_WORKING,
            "02": Const.DEV_WORK_STATUS_APPOINTMENT,
            "03": Const.DEV_WORK_STATUS_FAULT,          # 故障
            "04": Const.DEV_WORK_STATUS_FAULT,          # 烟感
            "05": Const.DEV_WORK_STATUS_FAULT,          # 雨感
            "06": Const.DEV_WORK_STATUS_FAULT           # 设备锁定
        }

        orderNoHex = data[8: 22]
        orderNo = str(int(reverse_hex(orderNoHex), 16))

        portStr = str(int(data[22: 24], 16))
        voltage = int(reverse_hex(data[24: 28]), 16)
        power = int(reverse_hex(data[32: 36]), 16)
        elec = int(reverse_hex(data[36: 44]), 16) / 1000.0
        chargeTime = int(reverse_hex(data[44: 48]), 16)
        temperature = int(reverse_hex(data[52: 56]), 16)
        status = statusMap.get(data[56: 58], Const.DEV_WORK_STATUS_IDLE)

        return {
            "orderNo": orderNo,
            "orderNoHex": orderNoHex,
            "portStr": portStr,
            "voltage": voltage,
            "power": power,
            "elec": elec,
            "chargeTime": chargeTime,
            "temperature": temperature,
            "status": status
        }

    @staticmethod
    def _parse_all_report(data):
        data = data[8: -4]
        result = list()
        while data:
            orderNoHex = data[: 14]
            orderNo = str(int(reverse_hex(data[:14]), 16))
            portStr = str(int(data[14: 16], 16))
            voltage = int(reverse_hex(data[16: 20]), 16)
            power = int(reverse_hex(data[24: 28]), 16)
            elec = int(reverse_hex(data[28: 36]), 16) / 1000.0
            chargeTime = int(reverse_hex(data[36: 40]), 16)
            temperature = int(reverse_hex(data[44: 48]), 16)
            status = YueWanTong.PORT_STATUS_MAP.get(data[48: 50], Const.DEV_WORK_STATUS_IDLE)

            data = data[50: ]
            result.append({
                "orderNo": orderNo,
                "orderNoHex": orderNoHex,
                "portStr": portStr,
                "voltage": voltage,
                "power": power,
                "elec": elec,
                "chargeTime": chargeTime,
                "temperature": temperature,
                "status": status
            })

        return {"subChargeList": result}

    @staticmethod
    def _parse_fault(data):
        """
        解析故障上报数据
        :param data:
        :return:
        """
        # TODO zjl 目前只有三个，后续可能会增加
        faultMap = {
            "1001": u"烟雾报警",
            "1002": u"雨感报警",
            "1003": u"温度报警"
        }
        portStr = str(int(data[8: 10], 16))
        faultHex = data[10: 14]
        fault = str(int(faultHex[2: 4] + faultHex[: 2], 16))
        faultReason = faultMap.get(fault)

        return {
            "portHex": data[8: 10],
            "portStr": portStr,
            "faultCode": fault,
            "statusInfo": faultReason
        }

    @staticmethod
    def _parse_stop(data):
        """
        解析充电结束上报事件，与状态上报类似
        :param data:
        :return:
        """
        reasonMap = {
            "00": u"充满自停",
            "01": u"未检测到充电设备",
            "02": u"过载结束",
            "03": u"电压输出故障",
            "04": u"刷卡结束",
            "05": u"充满自停",
            "06": u"密码开锁结束订单"
        }

        orderNoHex = data[8: 22]
        orderNo = str(int(reverse_hex(orderNoHex), 16))

        portHex = data[22: 24]
        portStr = str(int(data[22: 24], 16))
        voltage = int(reverse_hex(data[24: 28]), 16)
        power = int(reverse_hex(data[32: 36]), 16)
        elec = int(reverse_hex(data[36: 44]), 16) / 1000.0
        chargeTime = int(reverse_hex(data[44: 48]), 16)
        temperature = int(reverse_hex(data[52: 56]), 16)

        reasonCode = data[56: 58]
        reason = reasonMap.get(reasonCode)

        return {
            "orderNoHex": orderNoHex,
            "orderNo": orderNo,
            "portHex": portHex,
            "portStr": portStr,
            "voltage": voltage,
            "power": power,
            "elec": elec,
            "chargeTime": chargeTime,
            "temperature": temperature,
            "reasonCode": reasonCode,
            "reason": reason
        }

    def _ack(self, ack_id):
        self._send_data(funCode='AK', sendData=ack_id, cmd=DeviceCmdCode.OPERATE_DEV_NO_RESPONSE)

    def get_port_status_from_dev(self):
        """
        从设备端 获取端口信息 充电/空闲
        :return:
        """
        portInfo = self._read_port_status()

        portDict = dict()
        for portStr, status in portInfo.items():
            portDict[portStr] = {"status": status}

        # 更新可用端口数量
        allPorts, usedPorts, usePorts = self.get_port_static_info(portDict)
        Device.update_dev_control_cache(
            self._device["devNo"],
            {
                "allPorts": allPorts,
                "usedPorts": usedPorts,
                "usePorts": usePorts
            }
        )

        # 更新端口状态
        devCache = Device.get_dev_control_cache(self._device["devNo"])
        for port, info in portDict.items():
            if port in devCache and isinstance(info, dict):
                devCache[port].update({"status": info["status"]})
            else:
                devCache[port] = info
        Device.update_dev_control_cache(self._device["devNo"], devCache)

        return portDict

    def get_port_status(self, force = False):
        """
        获取端口状态
        :param force:
        :return:
        """

        self.get_port_status_from_dev()

        # 获取端口缓存
        devCache = Device.get_dev_control_cache(self._device["devNo"])
        if "allPorts" not in devCache:
            self.get_port_status_from_dev()
            devCache = Device.get_dev_control_cache(self._device["devNo"])

        allPorts = devCache.get("allPorts")
        if allPorts is None:
            raise ServiceException({'result': 2, 'description': u'充电端口信息获取失败'})

        # 获取显示端口的数量 客户要求可以设置 显示给用户多少个端口
        showPortNum = self._device.get("otherConf", {}).get("actualPortNum", self.DEFAULT_PORT_NUM)
        statusDict = dict()
        showStatusDict = dict()

        for portNum in xrange(allPorts):
            portStr = str(portNum + 1)
            tempDict = devCache.get(portStr, {})
            if "status" in tempDict:
                statusDict[portStr] = {"status": tempDict["status"]}
            elif "isStart" in tempDict:
                if tempDict["isStart"]:
                    statusDict[portStr] = {"status": Const.DEV_WORK_STATUS_WORKING}
                else:
                    statusDict[portStr] = {"status": Const.DEV_WORK_STATUS_IDLE}
            else:
                statusDict[portStr] = {"status": Const.DEV_WORK_STATUS_IDLE}

            if int(portStr) <= int(showPortNum):
                showStatusDict[portStr] = {"status": statusDict[portStr]["status"]}

        allPorts, usedPorts, usePorts = self.get_port_static_info(statusDict)
        portsDict = {"allPorts": allPorts, "usedPorts": usedPorts, "usePorts": usePorts}
        Device.update_dev_control_cache(self._device["devNo"], portsDict)

        # 返还的是要显示的端口数量
        return showStatusDict

    def get_port_info(self, line=None):
        """
        获取单一的端口状态
        :param line:
        :return:
        """
        if line is None:
            return
        portStr = str(line)

        # 设备端读取端口状态
        result = self._read_port_charge_status()
        portInfo = result.get(portStr, {})

        # 缓存端读取设备端口状态
        devCache = Device.get_dev_control_cache(self._device["devNo"])
        portCache = devCache.get(portStr, {})

        portCache.update(portInfo)
        Device.update_dev_control_cache(self._device["devNo"], {portStr: portCache})

        if portCache.get('chargeType') == 'billAsService':
            elecCharge = round(self.device.otherConf.get("elecCharge", YueWanTong.DEFAULT_ELEC_CHARGE), 2)
            serviceCharge = round(self.device.otherConf.get("serviceCharge", YueWanTong.DEFAULT_SERVICE_CHARGE), 2)
            portCache['elecFee'] = round(portInfo.get('elec', 0) * elecCharge, 2)
            portCache['serviceFee'] = round(portInfo.get('elec', 0) * serviceCharge, 2)

        return portCache

    def get_dev_setting(self):
        """
        读取设备设置
        显示的有： IC卡设置码 最小充电功率 最大充电功率 浮充时间 显示的端口数量
        :return:
        """
        otherConf = self._device.get("otherConf", {})
        powerPackage = otherConf.get("powerPackage", YueWanTong.DEFAULT_POWER_PACKAGE)

        newPowerPackage = YueWanTong._suit_power_package(powerPackage)
        payAfterUse = int(otherConf.get("payAfterUse", False))      # 前台接受的是数值模型

        # 电费 + 服务费
        elecCharge = round(otherConf.get("elecCharge", YueWanTong.DEFAULT_ELEC_CHARGE), 2)
        serviceCharge = round(otherConf.get("serviceCharge", YueWanTong.DEFAULT_SERVICE_CHARGE), 2)


        return {
            "minPower": otherConf.get("minPower", YueWanTong.DEFAULT_MIN_POWER),
            "maxPower": otherConf.get("maxPower", YueWanTong.DEFAULT_MAX_POWER),
            "floatTime": otherConf.get("floatTime", YueWanTong.DEFAULT_FLOAT_TIME),
            "ICSetupCode": otherConf.get("ICSetupCode", YueWanTong.DEFAULT_IC_CODE),

            "actualPortNum": otherConf.get("actualPortNum", YueWanTong.DEFAULT_PORT_NUM),

            "minConsume": otherConf.get("minConsume", YueWanTong.DEFAULT_MIN_CONSUME),
            "refundProtectTime": otherConf.get("refundProtectTime", YueWanTong.DEFAULT_MIN_CHARGE_TIME),
            "minAfterStartCoins": otherConf.get("minAfterStartCoins", 2),
            "payAfterUse": payAfterUse,

            "chargeType": otherConf.get("chargeType", YueWanTong.DEFAULT_CHARGE_TYPE),
            "elecPrice": otherConf.get("elecPrice", YueWanTong.DEFAULT_ELEC_PRICE),
            "powerPackage": newPowerPackage,

            # 电费 + 服务费
            "elecCharge": elecCharge,
            "serviceCharge": serviceCharge,
        }

    def update_device_conf(self, data):
        minPower = data.get("minPower")
        maxPower = data.get("maxPower")
        floatTime = data.get("floatTime")
        ICSetupCode = data.get("ICSetupCode")

        actualPortNum = data.get("actualPortNum")
        minConsume = data.get("minConsume")
        payAfterUse = data.get("payAfterUse")
        refundProtectTime = data.get("refundProtectTime")
        minAfterStartCoins = data.get("minAfterStartCoins")

        powerPackage = data.get("powerPackage")
        chargeType = data.get("chargeType")
        elecPrice = data.get("elecPrice")

        # 电费 + 服务费
        elecCharge = round(data.get("elecCharge", YueWanTong.DEFAULT_ELEC_CHARGE), 2)
        serviceCharge = round(data.get("serviceCharge", YueWanTong.DEFAULT_SERVICE_CHARGE), 2)

        otherConf = self._device.get("otherConf", {})

        otherConf.update({
            "minPower": int(minPower),
            "maxPower": int(maxPower),
            "floatTime": int(floatTime),
            "ICSetupCode": ICSetupCode,

            "actualPortNum": int(actualPortNum),

            "minConsume": float(minConsume),
            "minAfterStartCoins": float(minAfterStartCoins),
            "refundProtectTime": int(refundProtectTime),
            "payAfterUse": bool(int(payAfterUse)),

            "chargeType": chargeType,
            "elecPrice": float(elecPrice),
            "powerPackage": powerPackage,

            # 服务费 + 电量
            "elecCharge": elecCharge,
            "serviceCharge": serviceCharge,
        })

        devNo = self._device["devNo"]
        try:
            Device.objects.filter(devNo=devNo).update(otherConf=otherConf)

        except Exception as e:
            logger.error(e)
            raise ServiceException({'result': 2, 'description': u'设置错误，请重新操作试试'})

        Device.invalid_device_cache(devNo)

    def set_device_function(self, request, lastSetConf):
        """
        设备功能
        :param request:
        :param lastSetConf:
        :return:
        """
        lockDevice = request.POST.get("lockDevice", None)
        rebootDevice = request.POST.get("rebootDevice", None)
        setToDevice = request.POST.get("setToDevice", None)

        if rebootDevice is not None:
            self._reboot_device()
            return

        if lockDevice is not None and lockDevice in ("false", "true"):
            lockDevice = json.loads(lockDevice)
            self._lock_unlock_device(lockDevice)
            return

        # 下发所有参数到设备，这个地方做一个保护 ，设备正在工作的时候不让设置参数
        if setToDevice is not None:
            self._sync_device_settings()
            return

    def set_device_function_param(self, request, lastSetConf):
        """
        设置设备参数 需要对参数规则做校验
        :param request:
        :param lastSetConf:
        :return:
        """

        # 校验端口数量
        actualPortNum = request.POST.get("actualPortNum", None)
        if actualPortNum is not None and int(actualPortNum) > 36:
            raise ServiceException({"result": 2, "description": u"实际端口数量最大36"})

        powerPackage = request.POST.get("powerPackage", None)
        if powerPackage is not None:
            if len(powerPackage) > 6:
                raise ServiceException({"result": 2, "description": u"功率计费不得大于六档"})

        # 这个地方开始各种计费模式收费模式
        chargeType = request.POST.get("chargeType")

        if chargeType not in ["power", "time", "elec", "billAsService"]:
            raise ServiceException({"result": 2, "description": u"不支持的计费模式"})

        self.update_device_conf(request.POST)

    def start_device(self, package, openId, attachParas):
        """
        :param package:
        :param openId:
        :param attachParas:
        :return:
        """
        # 在此次改版的时候， 凡是 payAfterUse == True 的设备 都说明是使用了按功率付费的设备，这个地方做一个转换 为下一步切换做准备
        otherConf = self.device.get("otherConf", dict())
        if "chargeType" not in otherConf:
            if otherConf.get("payAfterUse", YueWanTong.DEFAULT_PAY_AFTER_USE):
                otherConf["chargeType"] = "power"
            else:
                otherConf["chargeType"] = "time"

            Device.objects.filter(devNo=self.device.devNo).update(otherConf=otherConf)
            Device.invalid_device_cache(self.device.devNo)

            # 由于参数重新更新过了 这个地方就在加载一次
            dev = Device.get_dev(self.device.devNo)
            self._device = dev

        # 从启动参数中获取相关的 参数 订单号 以及 充电端口等等
        portStr = attachParas.get("chargeIndex")
        orderNo = attachParas.get("orderNo")
        if portStr is None:
            raise ServiceException({'result': 2, 'description': u'未知端口'})

        lockPorts = self.device.otherConf.get("lockPorts") or list()
        if str(portStr) in lockPorts:
            raise ServiceException({"result": 2, "description": u"当前端口已被禁用"})

        # 计算充电时间 如果套餐是充满自停 则会在启动的时候设置为最大值
        unit = package.get("unit")
        needTime = package.get("time")
        coins = package.get("coins")
        needTime = self._transform_time(needTime, unit)

        # 获取当前的计费模式
        otherConf = self.device.get("otherConf", dict())
        chargeType = otherConf.get("chargeType")
        payAfterUse = otherConf.get("payAfterUse")

        if chargeType == "time" and not needTime:
            raise ServiceException({"result": 2, "description": u"时间套餐设置错误，请联系经销商解决"})

        # 发送指令
        result = self._start_device(orderNo=orderNo, port=portStr, chargeTime=needTime)

        portDict = {
            "status": Const.DEV_WORK_STATUS_WORKING,
            "vCardId": self._vcard_id,
            "isStart": True,
            "openId": openId,
            "orderNo": orderNo,
            "coins": coins,
            "startTime": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            "chargeType": chargeType,
            "payAfterUse": payAfterUse
        }
        if needTime:
            portDict["needTime"] = needTime

        Device.update_dev_control_cache(self._device["devNo"], {str(portStr): portDict})

        result["consumeOrderNo"] = orderNo
        return result

    def analyze_event_data(self, data):
        """
        解析设备上报的各种事件
        :param data:
        :return:
        """
        funcCode = data[6: 8]

        # 主板请求同步时间
        if funcCode == "A1":
            self._sync_device_time()
            return

        # 主板请求同步设备参数
        elif funcCode == "A2":
            self._sync_device_settings()
            return

        # 刷卡请求充电
        elif funcCode == "B0":
            ret = self._parse_card_start(data)
            ret.update({'cmdCode': 'B0'})
            return ret

        # 刷卡结束充电
        elif funcCode == "B1":
            ret = self._parse_card_stop(data)
            ret.update({'cmdCode': 'B1'})
            return ret

        # 设备上报充电结束
        elif funcCode == "C1":
            ret = self._parse_stop(data)
            ret.update({'cmdCode': 'C1'})
            return ret

        # 端口状态上报
        elif funcCode == "C0":
            ret = self._parse_report(data)
            ret.update({'cmdCode': 'C0'})
            return ret

        elif funcCode == "CA":
            ret = self._parse_all_report(data)
            ret.update({'cmdCode': 'CA'})
            return ret

        # 故障上报
        elif funcCode == "E0":
            ret = self._parse_fault(data)
            ret.update({'cmdCode': 'E0'})
            return ret

        else:
            logger.error("error event! funCode is {}".format(funcCode))

    def _get_time_use_money(self, reportRecord):    # type:(DevicePortReport) -> float
        """
        时间计费模式下 预付费的充电时间由 下发的参数进行控制 这个地方不再予以控制
        :param reportRecord:
        :return:
        """
        portCache = Device.get_port_control_cache(self.device.devNo, reportRecord.port)
        needTime = portCache.get("needTime")     # 单位分钟
        coins = portCache["coins"]
        
        # 时间模式下一定会有 needTime 如果没有needTime 一定是出错了 做个保护
        if not needTime:
            return coins

        return coins * float(reportRecord.chargeTime) / float(needTime)

    def _get_elec_use_money(self, reportRecord):    # type:(DevicePortReport) -> float
        """
        电量计费模式下 预付费模式下的已经使用的金额
        :param reportRecord:
        :return:
        """
        usedElec = reportRecord.elec
        elecPrice = self.device.get("otherConf", dict()).get("elecPrice", self.DEFAULT_ELEC_PRICE)

        return usedElec * elecPrice

    def _get_power_use_money(self, reportRecord):   # type:(DevicePortReport) -> float

        records = DevicePortReport.billing_records(reportRecord.orderNo)
        intervalMap = self._get_power_interval_map()
        consumeMoney = DevicePortReport.calculate(records, intervalMap)

        return consumeMoney

    def _get_billAsService_use_money(self, reportRecord):
        """
              服务费 + 电费模式
              :param reportRecord:
              :return:
              """
        usedElec = reportRecord.elec
        elecCharge = round(
            float(self.device.get("otherConf", dict()).get("elecCharge", self.DEFAULT_ELEC_CHARGE)) * usedElec, 2)
        serviceCharge = round(float(
            self.device.get("otherConf", dict()).get("serviceCharge", self.DEFAULT_SERVICE_CHARGE)) * usedElec, 2)

        return elecCharge, serviceCharge

    def _get_power_interval_map(self):
        """
        获取计费区间---单价映射
        :return:
        """
        if hasattr(self, "_interval_map"):
            return self._interval_map

        powerPackage = self.device.get(
            "otherConf", dict()
        ).get("powerPackage", self.DEFAULT_POWER_PACKAGE)

        powerPackage = self._suit_power_package(powerPackage)

        mapDict = dict()
        for package in powerPackage:
            lowLimit = package.get("lowLimit")
            upLimit = package.get("upLimit")
            price = package.get("price")
            _time = package.get("time")

            mapDict.update({
                Interval(int(lowLimit), int(upLimit), closed = "left"):
                    {
                        "unitPrice": float(price),
                        "time": 0
                    }
            })

        setattr(self, "_interval_map", mapDict)
        return mapDict

    def stop(self, port = None):
        portCache = Device.get_port_control_cache(self.device.devNo, str(port))
        orderNo = portCache.get('orderNo', 0)
        openId = portCache.get('openId', None)
        if orderNo == 0 or openId is None:
            raise ServiceException({'result': 2, 'description': u'未知订单无法停止，请稍后再试。'})
        result = self._stop_device(orderNo, str(port))
        event_data = self.__parse_B2(result)
        from apps.web.eventer.yuewantong import YueWanTongWorkerEvent
        ywt = YueWanTongWorkerEvent(self,event_data)
        ywt.do()

        ServiceProgress.update_progress_and_consume_rcd(
            self.device['ownerId'],
            {
                'open_id': openId, 'device_imei': self.device['devNo'],
                'port': int(port), 'isFinished': False
            },{})

        infoDict = dict()
        infoDict['remainder_time'] = 0
        return infoDict

    @property
    def isHaveStopEvent(self):
        return True

    def __parse_B2(self,data):
        data = data.get("data")
        dataDict = {
            "cmdCode" : data[6:8],
            "orderNoHex" : data[8:22],
            "orderNo" :str(int(reverse_hex(data[8:22]), 16)),
            "portHex" : data[22:24],
            "portStr" : str(int(reverse_hex(data[22:24]), 16)),
            "voltage" : str(int(reverse_hex(data[24:28]), 16)),
            "power" : str(int(reverse_hex(data[32:36]), 16)),
            "elec" : int(reverse_hex(data[36:44]), 16) / 1000.0,
            "chargeTime" : int(reverse_hex(data[44:48]), 16),
            "reason" : u"远程手动停止充电！"
        }
        return dataDict

    def lock_unlock_port(self, port, lock=True):
        """
        禁用端口
        主板不支持 禁用端口 只能服务器实现
        """
        otherConf = self.device.get("otherConf")
        lockPorts = otherConf.get("lockPorts", list())

        port = str(port)
        try:
            if lock:
                if port not in lockPorts:
                    lockPorts.append(port)
            else:
                lockPorts.remove(port)
        except Exception as e:
            logger.error(e)

        otherConf.update({"lockPorts": lockPorts})

        try:
            Device.objects(devNo=self.device.devNo).update(otherConf=otherConf)
            Device.invalid_device_cache(self.device.devNo)
        except Exception as e:
            logger.error("update device %s lockPorts error the reason is %s " % (self.device.devNo, e))
            raise ServiceException({'result': 2, 'description': u'操作失败，请重新试试'})