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

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

# 整个业务流程的 控制的最关键的三个函数 _open， _charge， _stop
# 粤万通 充电柜 基本的业务流程可以描述为
# 1. 扫码/刷卡  启动设备 此时调用 _open 函数，并创建相应的订单以及开锁密码 开锁密码在整个的充电过程中不能改变 用于设备离线时候直接从触控屏解锁
# 2. 门锁打开的时候 等候用户下一步操作（放入电池、关闭门锁）
# 3. 主板方检测到门锁关闭之后 上报门锁关闭信号 服务器接收到关锁信号之后  调用_charge 函数 ，注意此时仅仅充电不开锁 开启端口的充电
# 4. 在整个充电的过程中 主板会不断地上报 该端口的充电数据 C0指令，其中 power 为瞬时功率 chargeTime 为累计充电时间 stayTime 为累计占位时间
# 5. 在 到达最大充电时间 或者 主板检测电池充满 之后， 会上报充电结束的指令 C1，同时主板停止充电，开始进入 占位状态
# 6. 需要注意的是，在充电柜业务流程中，停止充电并不意味着 流程结束，也不代表可以对其进行 费用结算
# 7. 关于充电柜的业务结束一共有以下 3种情况：
#   7.1 用户再次扫码，并点击停止充电按钮，此时触发 stop 函数，服务器通过 _stop 发起对主板的开锁，主板接收到之后 开锁并同时上报最后一次数据状态
#   7.2 用户刷卡启动的设备，需要用户刷卡结束，用户第二次刷卡 后，主板上报刷卡请求充电指令，服务器接收到之后 通过 _stop 发起对于主板的开锁 同时上报最后一次充电状态
#   7.3 用户直接在主板上选择密码开锁， 输入密码（开启充电时候下发的密码），主板接收到之后，无条件开锁，同时上报最后一次充电状态。一般用于设备离线的时候使用
# 8. 用户以任何方式 结束充电柜业务之后，需要对其订单进行结算，并将整个过程中的费用记录到相应订单上

# 关于粤万通新式充电柜的计费
# 计费公式为： 总费用 = 充电费用 + 占位费用
# 对于占位费用，目前的计费方式就是 占位时间 ✖ 占位单价
# 对于充电费用，目前一共有 两种计费方式可供选择，以下
# 充电计费方式一：按时间计费：
#   本次粤万通计费将时间计费修改为按时段计费，例如
#   经销商设置8：00-9：00 单价为1小时1元；9：00-10：00 单价为1小时2元；默认单价为1小时0.5元
#   某用户从7：00充电一直到10：30 共四个小时
#   7：00-8：00时间段经销商没有设置单价， 则费用为默认单价0.5元
#   8：00-9：00时间段设置了单价，则费用为1元
#   9：00-10：00时间段设置了单价，则费用为2元
#   10：00-10：30 时间段没有设置单价，则费用为默认单价 0.5*0.5小时 为0.25元
#   此次按时间充电的费用为 0.5+1+2+0.25 = 3.75元
# 充电计费方式二：按功率计费，即经销商预设功率挡位以及相应单价 例如
#   经销商设置为100-200w 1小时1元；200-400w 1小时2元，默认单价为0.5元
#   用户充电过程中一共1小时，其中半小时功率为95w，半小时功率为 240w，则充电总费用为 1.5元
# 充电计费的注意事项：
#   1.按时间计费的时间是订单的初始时间-结束时间，也就是说只要最关键的报文结束报文 服务器能够接收到，就一定能计算出费用
#   2.按功率计费需要依赖每次的充电状态上报，即C0指令，C0指令主板会有ack机制（最新的修改已经将ack置于模块侧回复），但若某次没有收到，则以最近一次的功率为主计算该段的费用
#   3.计费有最低费用和最高费用，假设经销商设置的最低费用为1元，最高费用为10元，假设某次用户总费用为0.5元，则系统收费为1元；同理也不能超过最大费用


import binascii
import datetime
import logging
import os
import random
import time

import simplejson as json
from mongoengine import DoesNotExist

from apilib.monetary import VirtualCoin, RMB
from apilib.utils_string import make_title_from_dict
from apps.web.common.proxy import ClientConsumeModelProxy
from apps.web.constant import DeviceCmdCode, Const, MQTT_TIMEOUT
from apps.web.core.adapter.base import SmartBox, reverse_hex, fill_2_hexByte
from apps.web.core.exceptions import ServiceException
from apps.web.core.networking import MessageSender
from apps.web.device.models import Group, Device, DevicePortLastReport, DeviceType
from apps.web.user.models import ConsumeRecord, ServiceProgress, MyUser
from apps.web.core.device_define.ywt_chongdiangui_new import DefaultParams, Calculater
from apps.web.utils import concat_user_login_entry_url
from taskmanager.mediator import task_caller

logger = logging.getLogger(__name__)


class ChargeCabinet(SmartBox):

    def __init__(self, *args, **kwargs):
        super(ChargeCabinet, self).__init__(*args, **kwargs)
        # 主要用于计算费用
        self.devNo = self.device.devNo

    @property
    def is_support_auto_charge(self):
        """
        是否支持自动供电
        主板的新特性 发送新的指令不需要发送充电 关门后直接启动充电
        兼容之前的设备特性和现在的设备类型特性
        """
        # 先找设备
        if self.device.support_dev_type_features("support_auto_charge_after_close_door"):
            return True

        return False

    @property
    def password(self):
        return random.randint(0x2710, 0xFFFF)

    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'系统错误'})

    @staticmethod
    def _to_str(data):
        return binascii.unhexlify(data)

    @staticmethod
    def _to_ascii(data):
        return binascii.hexlify(data)

    @staticmethod
    def _suit_power_package(package):
        """适配之前的 功率计费规则"""
        if not package or "lowLimit" not in package[0].keys():
            return package

        newPackage = list()
        for _item in package:
            newPackage.append({"max": _item["upLimit"], "min": _item["lowLimit"], "price": _item["price"] * 60 / _item["time"]})

        newPackage.append({"max": "default", "min": "default", "price": 0})
        return newPackage

    @staticmethod
    def _suit_time_package(package):
        """适配之前的 时间计费规则"""
        if not package or not isinstance(package, (int, str)):
            return package

        return [{"max": "default", "min": "default", "price": int(package)}]

    def _notify_user_service_over(self, managerialOpenId, extra, isPaid=True):

        title = make_title_from_dict(extra)

        notifyData = {
            "title": title,
            "service": u"已使用账户余额自动结算此次消费" if isPaid else u"您的账户余额已不足以抵扣此次消费，请前往账单中心进行支付",
            "finishTime": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            "remark": u'谢谢您的支持'
        }

        task_caller(
            func_name='report_to_user_via_wechat',
            openId=managerialOpenId,
            dealerId=self.device.get("ownerId"),
            templateName="service_complete",
            **notifyData
        )

    @staticmethod
    def _parse_event_A1(data):
        return dict()

    @staticmethod
    def _parse_event_A2(data):
        return dict()

    @staticmethod
    def _parse_event_B0(data):
        cardPre = ChargeCabinet._to_str(data[8: 16])
        cardNo = ChargeCabinet._to_str(data[16: 32])
        portStr = str(int(data[32: 34], 16))
        return {
            "cardPre": cardPre,
            "cardNo": cardNo,
            "cardNoHex": data[8: 32],       # zjl 16->8
            "portStr": portStr,
            "portHex": data[32: 34]   # zjl new
        }

    @staticmethod
    def _parse_event_B1(data):
        cardPre = ChargeCabinet._to_str(data[8: 16])
        cardNo = ChargeCabinet._to_str(data[16: 32])
        portStr = str(int(data[32: 34], 16))
        orderNoHex = data[34: 48]
        orderNo = str(int(reverse_hex(orderNoHex), 16))
        return {
            "cardPre": cardPre,
            "cardNo": cardNo,
            "cardNoHex": data[8: 32],       # zjl 16->8
            "portStr": portStr,
            "portHex": data[32:34],         # zjl
            "orderNoHex": orderNoHex,
            "orderNo": orderNo
        }

    @staticmethod
    def _parse_event_C0(data):
        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)
        stayTime = int(reverse_hex(data[48:52]), 16)
        temperature = int(reverse_hex(data[52: 56]), 16)
        status = DefaultParams.STATUS_MAP.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,
            "stayTime": stayTime
        }

    @staticmethod
    def _parse_event_E0(data):
        portStr = str(int(data[8: 10], 16))
        faultHex = data[10: 14]
        fault = str(int(faultHex[2:4]+faultHex[:2], 16))

        faultReason = DefaultParams.FAULT_MAP.get(fault)

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

    @staticmethod
    def _parse_event_C1(data):
        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)
        stayTime = int(reverse_hex(data[48:52]), 16)
        temperature = int(reverse_hex(data[52: 56]), 16)

        reasonCode = data[56: 58]
        reason = DefaultParams.STOP_REASON_MAP.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,
            "stayTime": stayTime
        }

    @staticmethod
    def _parse_event_C3(data):
        portStr = str(int(data[8:10], 16))
        doorStatus = data[10: 12]

        return {
            "portStr": portStr,
            "doorStatus": doorStatus
        }

    @staticmethod
    def _parse_result_B2(data):
        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)
        stayTime = int(reverse_hex(data[48:52]), 16)

        return {
            "orderNoHex": orderNoHex,
            "orderNo": orderNo,
            "portHex": portHex,
            "portStr": portStr,
            "voltage": voltage,
            "power": power,
            "elec": elec,
            "chargeTime": chargeTime,
            "stayTime": stayTime
        }

    @staticmethod
    def _parse_event_CA(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)
            stayTime = int(reverse_hex(data[40: 44]), 16)
            temperature = int(reverse_hex(data[44: 48]), 16)
            status = DefaultParams.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,
                "stayTime": stayTime
            })

        return {"subChargeList": result}

# -----------------------------------------------将开门、充电以及停止充电区分开--------------------------------------------------------

    def _open(self, port, orderNo, pw):
        """
        打开柜门 不启动充电 为用户使用的第一步
        :param port: 端口号
        :param orderNo: 订单编号
        :param pw: 开锁密码
        :return:
        """
        operHex = "03"
        chargeTimeHex = "0000"
        orderNoHex = fill_2_hexByte(hex(int(orderNo)), 14, reverse=True)
        portHex = fill_2_hexByte(hex(int(port)), 2, reverse=True)
        pwHex = fill_2_hexByte(hex(int(pw)), 4, reverse=True)

        data = orderNoHex+portHex+chargeTimeHex+operHex+pwHex

        return self._send_data("B2", data, timeout=15)

    def _charge(self, port, orderNo, pw, door=False, chargeTime=0x0258):
        """
        直接下发的充电指令 不打开柜门
        :param port:  端口号
        :param orderNo: 订单编号
        :param pw: 开锁密码
        :param door: true 表示开锁 false 表示不开所
        :param chargeTime: 充电时间 最大充电时间为600分钟
        :return:
        """
        operHex = "01" if not door else "02"
        orderNoHex = fill_2_hexByte(hex(int(orderNo)), 14, reverse=True)
        portHex = fill_2_hexByte(hex(int(port)), 2, reverse=True)
        pwHex = fill_2_hexByte(hex(int(pw)), 4, reverse=True)
        chargeTimeHex = fill_2_hexByte(hex(int(chargeTime)), 4, reverse=True)

        data = orderNoHex+portHex+chargeTimeHex+operHex+pwHex

        return self._send_data("B2", data, timeout=15)

    def _new_charge(self,port, orderNo, pw, chargeTime=0x0258):
        operHex = "02"
        orderNoHex = fill_2_hexByte(hex(int(orderNo)), 14, reverse=True)
        portHex = fill_2_hexByte(hex(int(port)), 2, reverse=True)
        pwHex = fill_2_hexByte(hex(int(pw)), 4, reverse=True)
        chargeTimeHex = fill_2_hexByte(hex(int(chargeTime)), 4, reverse=True)

        data = orderNoHex + portHex + chargeTimeHex + operHex + pwHex

        return self._send_data("B2", data, timeout=15)

    def _stop(self, port, orderNo, pw, door=False):
        """
        终止设备运行
        :param port: 端口号
        :param orderNo: 订单编号
        :param pw: 开锁密码
        :param door: true表示断电的同时开锁  false 表示仅仅断电
        :return:
        """
        operHex = "11" if not door else "12"

        orderNoHex = fill_2_hexByte(hex(int(orderNo or 0)), 14, reverse=True)
        portHex = fill_2_hexByte(hex(int(port)), 2, reverse=True)
        pwHex = fill_2_hexByte(hex(int(pw)), 4, reverse=True)

        data = orderNoHex+portHex+"0000"+operHex+pwHex
        return self._send_data("B2", data)

# ----------------------------------------------------------------------------------------------------------------------

    def _get_door_status(self):
        try:
            result = self._send_data("BD", "00", timeout=5)
        except ServiceException:
            return dict()
        data = result.get("data", "")[8: -4]
        doorStatus = dict()
        port = 0
        while data:
            port = port + 1
            _door = u"打开" if data[: 2] == "01" else u"关闭"
            doorStatus[str(port)] = _door

            data = data[2:]

        return doorStatus

    def _get_port_status(self):
        result = self._send_data("B3", "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 = DefaultParams.STATUS_MAP.get(data[2:4]) if tempPort not in lockPorts else Const.DEV_WORK_STATUS_FORBIDDEN

            portInfo.update({tempPort: tempStatus})

            data = data[4: ]

        return portInfo

    def _get_port_status_detail(self):
        result = self._send_data("B4", "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)
            tempAmpere = int(reverse_hex(data[6:10]), 16) / 1000.0
            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)
            tempOccTime = int(reverse_hex(data[26:30]), 16)
            tempTemper = int(reverse_hex(data[30: 34]), 16)
            tempStatus = DefaultParams.STATUS_MAP.get(data[34:36]) if tempPort not in lockPorts else Const.DEV_WORK_STATUS_FORBIDDEN

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

            data = data[36: ]

        return portInfo

    def _reboot_device(self):
        return self._send_data("B5", "00")

    def _lock_device(self):
        operateHex = "01"
        return self._send_data("B6", operateHex)

    def _unlock_device(self):
        operateHex = "00"
        return self._send_data("B6", operateHex)

    def _sync_device_time(self):
        nowTime = datetime.datetime.now()
        yearHex = fill_2_hexByte(hex(nowTime.year), 4, reverse=True)
        monthHex = fill_2_hexByte(hex(nowTime.month), 2)
        dayHex = fill_2_hexByte(hex(nowTime.day), 2)
        hourHex = fill_2_hexByte(hex(nowTime.hour), 2)
        minuteHex = fill_2_hexByte(hex(nowTime.minute), 2)
        secondHex = fill_2_hexByte(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):
        domain = os.environ.get("MY_DOMAIN")
        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", DefaultParams.DEFAULT_MIN_POWER)
        maxPower = otherConf.get("maxPower", DefaultParams.DEFAULT_MAX_POWER)
        floatTime = otherConf.get("floatTime", DefaultParams.DEFAULT_FLOAT_TIME)
        ICSetupCode = otherConf.get("ICSetupCode", DefaultParams.DEFAULT_IC_CODE)

        qrCodeLenHex = fill_2_hexByte(hex(len(qr_code_url)), 2)
        minPowerHex = fill_2_hexByte(hex(int(minPower)), 4, reverse=True)
        maxPowerHex = fill_2_hexByte(hex(int(maxPower)), 4, reverse=True)
        floatTimeHex = fill_2_hexByte(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)

        # 添加特性 去掉前台的金额显示按钮
        otherConf.update({"payAfterUse": True})
        Device.objects.filter(devNo=self.device.devNo).update(otherConf=otherConf)
        Device.invalid_device_cache(self.device.devNo)

    def _update_device_conf(self, data):
        minPower = data.get("minPower", DefaultParams.DEFAULT_MIN_POWER)
        maxPower = data.get("maxPower", DefaultParams.DEFAULT_MAX_POWER)
        floatTime = data.get("floatTime", DefaultParams.DEFAULT_FLOAT_TIME)
        ICSetupCode = data.get("ICSetupCode", DefaultParams.DEFAULT_IC_CODE)
        actualPortNum = data.get("actualPortNum", DefaultParams.DEFAULT_PORT_NUM)

        chargeType = data.get("chargeType", DefaultParams.DEFAULT_CHARGE_TYPE)
        minAfterStartCoins = data.get("minAfterStartCoins", DefaultParams.DEFAULT_MIN_START_COINS)
        stayTimeUnitPrice = data.get("stayTimeUnitPrice", DefaultParams.DEFAULT_STAY_TIME_UNIT_PRICE)
        freeStayTime = data.get("freeStayTime", DefaultParams.DEFAULT_FREE_STAY_TIME)
        minConsume = data.get("minConsume", DefaultParams.DEFAULT_MIN_CONSUME)
        maxConsume = data.get("maxConsume", DefaultParams.DEFAULT_MAX_CONSUME)

        powerPackage = data.get("powerPackage", DefaultParams.DEFAULT_POWER_PACKAGE)
        timePricePackage = data.get("timePricePackage", DefaultParams.DEFAULT_TIME_PACKAGE)
        timeUnitPrice = data.get("timePrice", DefaultParams.DEFAULT_TIME_UNIT_PRICE)
        powerUnitPrice = data.get("powerPrice", DefaultParams.DEFAULT_POWER_UNIT_PRICE)

        elecCharge = data.get("elecCharge", DefaultParams.DEFAULT_ELEC_CHARGE)
        serviceCharge = data.get("serviceCharge", DefaultParams.DEFAULT_SERVICE_CHARGE)



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

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

            "chargeType": chargeType,

            "stayTimeUnitPrice": float(stayTimeUnitPrice),
            "freeStayTime": float(freeStayTime),
            "minConsume": float(minConsume),
            "maxConsume": float(maxConsume),

            "timeUnitPrice": float(timeUnitPrice),
            "powerUnitPrice": float(powerUnitPrice),
            "powerPackage": powerPackage,
            "timePricePackage": timePricePackage,

            "elecCharge": float(elecCharge),
            "serviceCharge": float(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 _dealer_start_device(self, package, attachParas):
        """
        如果 是经销商启动 就当是取消当前端口的订单
        :param package:
        :param attachParas:
        :return:
        """
        portStr = attachParas.get("chargeIndex")
        if not portStr:
            raise ServiceException({"result": "2", "description": u"请选择插座号！"})

        devCache = Device.get_dev_control_cache(self.devNo)
        portCache = devCache.get(portStr, dict())
        orderNo = portCache.get("orderNo", 0xFFFFFFFFFFFFFF)
        pw = portCache.get("pw", 0)

        self._stop(portStr, orderNo, pw, door=True)

        # 清空端口的缓存
        Device.clear_port_control_cache(self.devNo, portStr)

        # 然后将订单直接取消
        try:
            consumeRecord = ConsumeRecord.objects.get(orderNo=orderNo, isNormal=True)
        except DoesNotExist:
            return

        consumeRecord.isNormal = False
        consumeRecord.status = "finished"
        consumeRecord.errorDesc = u"经销商关闭订单"
        consumeRecord.finishedTime = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        consumeRecord.save()

        sp = ServiceProgress.objects.filter(
            **{"device_imei": self.devNo, "isFinished": False, "open_id": consumeRecord.openId, "port": int(portStr)}
        ).first()
        if not sp:
            return
        sp.isFinished = True
        sp.finished_time = int(time.time())
        sp.status = "finished"
        sp.save()

    def _stage_billing(self, devNo, port, orderNo, **kwargs):
        try:
            order = ConsumeRecord.objects.get(orderNo=orderNo)
        except DoesNotExist:
            logger.warning("[{}._stage_billing] not find order, devNo = {}, orderNo = {}".format(self.__class__.__name__, devNo, orderNo))
            return

        lastReport = DevicePortLastReport.get_last(devNo=devNo, port=port, orderNo=orderNo)
        newReport = DevicePortLastReport.save_last(devNo=devNo, port=port, orderNo=orderNo, **kwargs)

        cal = Calculater(device=self.device, order=order)
        chargeConsume, stayConsume = cal.stage_billing(lastReport, newReport)
        newReport.update_consume(chargeConsume, stayConsume)

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

    def check_order_state(self, openId):
        """
        通过 openId 以及设备来鉴别 订单
        :param openId:
        :return:
        """
        dealerId = self.device.ownerId
        devTypeCode = self.device.devType.get("code")
        return ClientConsumeModelProxy.get_not_finished_record(ownerId = dealerId,
                                                               openId = openId,
                                                               devTypeCode = devTypeCode)

    def analyze_event_data(self, data):
        cmdCode = data[6:8]

        funcName = "_parse_event_{}".format(cmdCode.upper())
        func = getattr(ChargeCabinet, funcName, None)
        if func and callable(func):
            eventData = func(data)
            eventData.update({"cmdCode": cmdCode})
            return eventData

        else:
            logger.warning("<{}> device receive an undefined cmd <{}>, data is <{}>".format(self.devNo, cmdCode, data))

    def get_dev_setting(self):
        otherConf = self._device.get("otherConf", {})
        return {
            "minPower": otherConf.get("minPower", DefaultParams.DEFAULT_MIN_POWER),
            "maxPower": otherConf.get("maxPower", DefaultParams.DEFAULT_MAX_POWER),
            "floatTime": otherConf.get("floatTime", DefaultParams.DEFAULT_FLOAT_TIME),
            "ICSetupCode": otherConf.get("ICSetupCode", DefaultParams.DEFAULT_IC_CODE),
            "actualPortNum": otherConf.get("actualPortNum", DefaultParams.DEFAULT_PORT_NUM),

            "minAfterStartCoins": otherConf.get("minAfterStartCoins", DefaultParams.DEFAULT_MIN_START_COINS),
            "stayTimeUnitPrice": otherConf.get("stayTimeUnitPrice", DefaultParams.DEFAULT_STAY_TIME_UNIT_PRICE),
            "freeStayTime": otherConf.get("freeStayTime", DefaultParams.DEFAULT_FREE_STAY_TIME),
            "minConsume": otherConf.get("minConsume", DefaultParams.DEFAULT_MIN_CONSUME),
            "maxConsume": otherConf.get("maxConsume", DefaultParams.DEFAULT_MAX_CONSUME),
            "chargeType": otherConf.get("chargeType", DefaultParams.DEFAULT_CHARGE_TYPE),

            "powerPackage": otherConf.get("powerPackage", DefaultParams.DEFAULT_POWER_PACKAGE),
            "timePricePackage": otherConf.get("timePricePackage", DefaultParams.DEFAULT_TIME_PACKAGE),
            "timePricePackageDefaultPrice": otherConf.get("powerUnitPrice", DefaultParams.DEFAULT_POWER_UNIT_PRICE),
            "powerPackageDefaultPrice": otherConf.get("timeUnitPrice", DefaultParams.DEFAULT_TIME_UNIT_PRICE),

            # 服务费 + 电量
            "elecCharge": otherConf.get("elecCharge", DefaultParams.DEFAULT_ELEC_CHARGE),
            "serviceCharge": otherConf.get("serviceCharge", DefaultParams.DEFAULT_SERVICE_CHARGE),

        }

    def set_device_function_param(self, request, lastSetConf):
        actualPortNum = request.POST.get("actualPortNum", None)
        if actualPortNum is not None and int(actualPortNum) > 30:
            raise ServiceException({"result": 2, "description": u"实际端口数量最大30"})
        chargeType = request.POST.get("chargeType")

        if chargeType not in ("time",  "power", "elec"):
            raise ServiceException({"result": 2, "description": u"暂不支持此消费模式"})

        # 校验计费套餐
        maxConsume = request.POST.get("maxConsume")
        minConsume = request.POST.get("minConsume")
        if float(minConsume) < 0 or float(maxConsume) < 0:
            raise ServiceException({"result": 2, "description": u"最低消费金额和最高消费金额不能小于0"})
        if float(minConsume) > float(maxConsume):
            raise ServiceException({"result": 2, "description": u"最低消费金额不得大于最高消费金额"})

        # 时间计费规则校验
        timePricePackage = request.POST.get("timePricePackage")
        for _index, _package in enumerate(timePricePackage):
            if int(_package["max"]) <= int(_package["min"]):
                raise ServiceException({"result": 2, "description": u"第 {} 阶段 时间开始 {} 小于 时间结束 {}".format(_index+1, _package["max"], _package["min"])})

        powerPackage = request.POST.get("powerPackage")
        for _index, _package in enumerate(powerPackage):
            if int(_package["max"]) <= int(_package["min"]):
                raise ServiceException({"result": 2, "description": u"第 {} 阶段 功率开始 {} 小于 功率结束 {}".format(_index+1, _package["max"], _package["min"])})

        self._update_device_conf(request.POST)

    def set_device_function(self, request, lastSetConf):
        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_device() if lockDevice else self._unlock_device()
            return

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

    def get_port_status(self, force=False):
        if force:
            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", DefaultParams.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_status_from_dev(self):
        portInfo = self._get_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 start_device(self, package, openId, attachParas):

        if not openId:
            return self._dealer_start_device(package, attachParas)

        portStr = attachParas.get("chargeIndex")
        orderNo = attachParas.get("orderNo")
        pw = self.password

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

        devCache = Device.get_dev_control_cache(self.device.devNo) or dict()
        if devCache.get(portStr, dict()).get("status") == Const.DEV_WORK_STATUS_WORKING:
            raise ServiceException({"result": 2, "description": u"当前端口已被占用"})

        if portStr is None:
            raise ServiceException({'result': 2, 'description': u'请选择充电端口'})
        if orderNo is None:
            return ServiceException({'result': 2, "description": u"订单创建失败，请重新尝试"})

        # 支持发送关门自动断电的 发送新指令
        if self.is_support_auto_charge:
            result = self._new_charge(orderNo=orderNo, port=portStr, pw=pw)
        # 否则由服务器控制充电
        else:
            result = self._open(orderNo=orderNo, port=portStr, pw=pw)

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

        Device.update_dev_control_cache(self._device["devNo"], {str(portStr): portDict})
        otherConf = self.device.get("otherConf") or dict()
        result["consumeOrderNo"] = orderNo
        result["servicedInfo"] = {"pw": pw, "chargeType": otherConf.get("chargeType", DefaultParams.DEFAULT_CHARGE_TYPE)}
        result["finishedTime"] = int(time.time()) + 7 * 24 * 60 * 60
        return result

    def stop(self, port=None):
        """
        端口停止功能 用户主动停止了该端口
        对于充电柜的业务来说 结束充电就意味着 需要打开柜门 同时结算订单
        收到停止指令之后
        服务器首先下发B2-12指令
        然后根据返还的信息进行扣费处理
        最后结存订单
        :param port:
        :return:
        """
        portStr = str(port)
        devCache = Device.get_dev_control_cache(self.device.devNo)
        portCache = devCache.get(portStr, dict())

        # 校验订单状态 非正在运行的订单不能结束 考虑 是否 加锁
        if not portCache:
            return

        if portCache.get("cardNo"):
            raise ServiceException({"result": 2, "description": u"刷卡启动的设备请使用刷卡结束"})

        orderNo = portCache.get("orderNo", "")
        consumeOrder = ConsumeRecord.objects.filter(orderNo=orderNo).first()
        if consumeOrder is None or not consumeOrder.is_running():
            return

        logger.info("device stop order, device = {}, orderNo = {}".format(self.device.devNo, orderNo))

        pw = portCache.get("pw")
        try:
            result = self._stop(port, orderNo, pw, True)

            # 然后去读取主板的的最后一次的数据
            data = result.get("data")
            curInfo = ChargeCabinet._parse_result_B2(data)
            curInfo.update({"orderNo": orderNo})

            # 记录最后一次的上报 然后获取订单的金额
            self._stage_billing(self.devNo, portStr, **curInfo)
        except ServiceException:
            # 保证一定能够结单 当真正门锁未开的时候，直接找经销商上分即可
            logger.error("device open door error! devNo = {}, orderNo = {}".format(self.device.devNo, orderNo))
            order = DevicePortLastReport.get_last_by_order(orderNo)
            curInfo = {
                "chargeTime": order.chargeTime,
                "elec": 0,
                "stayTime": order.stayTime,
            }

        consumeMoney = Calculater.get_consume_by_order(self.device, orderNo)

        consumeOrder.update(money=RMB(consumeMoney).mongo_amount, coin=VirtualCoin(consumeMoney).mongo_amount)
        consumeOrder.reload()
        consumeOrder.s_to_e()

        consumeDict = {
            "chargeIndex": portStr,
            'actualNeedTime': curInfo.get("chargeTime"),
            'elec': curInfo.get("elec"),
            'stayTime': curInfo.get("stayTime"),
            'chargeTime': curInfo.get("chargeTime")
        }
        if consumeOrder.servicedInfo and isinstance(consumeOrder.servicedInfo, dict):
            consumeDict.update(consumeOrder.servicedInfo)

        if consumeOrder.servicedInfo.get('chargeType') == 'elec':
            elec_charge, service_charge = self.calc_elecFee_and_serviceFee(consumeMoney)
            consumeDict.update({
                'elecCharge': elec_charge.mongo_amount,
                'serviceCharge': service_charge.mongo_amount,
            })

        ServiceProgress.update_progress_and_consume_rcd(
            self._device["ownerId"],
            {
                "open_id": consumeOrder.openId,
                "device_imei": self.device["devNo"],
                "port": int(portStr),
                "isFinished": False
            },
            consumeDict
        )

        # 通知用户充电柜业务结束 如果订单并没有使用余额结算 还需要通知用户及时去付款
        try:
            openId = portCache.get("openId")
            user = MyUser.objects.filter(openId=openId, groupId=self.device.get("groupId")).first()

            extra = [
                {u"设备编号": u"{}-{}".format(self.device["logicalCode"], port)},
                {u"服务地址": u"{}".format(self.device.group["address"])},
                {u"使用时长": u"{}分钟".format(curInfo.get("chargeTime"))},
                {u"占位时长": u"{}分钟".format(curInfo.get("stayTime"))},
            ]

            if consumeOrder.servicedInfo.get('chargeType') == 'elec':
                elec_charge, service_charge = self.calc_elecFee_and_serviceFee(consumeMoney)

                extra.extend([
                    {u"使用电量": u"{}度".format(consumeDict['elec'])},
                    {u"电量费用": u"{}".format(elec_charge)},
                    {u"服务费用": u"{}".format(service_charge)},
                ])

            else:
                extra.append({u"本单消费": u"{}".format(consumeMoney)})

            self._notify_user_service_over(
                user.managerialOpenId,
                extra,
                consumeOrder.is_finished()
            )
        except Exception as e:
            logger.exception(e)

        Device.clear_port_control_cache(self.device.devNo, portStr)
        return

    def calc_elecFee_and_serviceFee(self, consumeMoney):
        elecCharge = float(self.device.otherConf.get("elecCharge", DefaultParams.DEFAULT_ELEC_CHARGE))
        serviceCharge = float(self.device.otherConf.get("serviceCharge", DefaultParams.DEFAULT_SERVICE_CHARGE))
        elec_charge = RMB(consumeMoney * (elecCharge / (elecCharge + serviceCharge)))
        service_charge = RMB(consumeMoney) - elec_charge
        return elec_charge, service_charge

    @property
    def isHaveStopEvent(self):
        return True

    def dealer_get_port_status(self):
        showPortNum = self._device.get("otherConf", {}).get("actualPortNum", DefaultParams.DEFAULT_PORT_NUM)
        showStatusDict = dict()
        portInfo = self._get_port_status_detail()
        devCache = Device.get_dev_control_cache(self.device.devNo)

        for port, item in portInfo.items():
            if int(port) > showPortNum:
                continue

            # 始终以 设备的状态为准
            portCache = devCache.get(port, dict())
            portCache.update(item)

            if portCache.get("status", Const.DEV_WORK_STATUS_IDLE) in (Const.DEV_WORK_STATUS_WORKING, Const.DEV_WORK_STATUS_OCCUPY):
                portCache["status"] = Const.DEV_WORK_STATUS_WORKING
                portCache["usedTime"] = portCache.get("chargeTime")

                # 如果是电量 + 服务费模式: 添加用户昵称, 添加电费金额 添加服务费金额
                try:
                    order = ConsumeRecord.objects.get(orderNo=portCache['orderNo'])
                    portCache['nickName'] = order.nickname
                    portCache['startTime'] = portCache['startTime'][-14:]

                    if order.servicedInfo.get('chargeType') == 'elec':  # 电量 + 服务费模式
                        consumeMoney = Calculater.get_consume_by_order(self.device, order.orderNo)
                        portCache['elecFee'], portCache['serviceFee'] = self.calc_elecFee_and_serviceFee(consumeMoney)
                except:
                    pass

                showStatusDict[port] = portCache
            else:
                showStatusDict[port] = {"status": portCache["status"]}

        return showStatusDict

    def get_current_use(self, order):   # type: (ConsumeRecord) -> dict
        group = Group.get_group(order.groupId)

        item = ServiceProgress.objects.filter(
            device_imei=order.devNo,
            open_id=order.openId,
            attachParas__orderNo=order.orderNo,
            isFinished=False
        ).first()

        if not item:
            return dict()

        data = {
            'startTime': time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(item.start_time)),
            'order': item.consumeOrder,
            'address': group.get('address', ''),
            'groupName': group.get('groupName', ''),
            'devType': self.device['devType'].get('name'),
            'devTypeCode': self.device['devType'].get('code'),
            'logicalCode': self.device['logicalCode'],
            'status': Const.DEV_WORK_STATUS_WORKING,
            'devNo': self.devNo,
            "port": item.port
        }
        data.update(DeviceType.get_services_button(self.device['devType']['id']))

        devCache = Device.get_dev_control_cache(self.devNo)
        portCache = devCache.get(str(item.port)) or dict()
        data.update(portCache)
        return data

    def active_deactive_port(self, port, active):
        if not active:
            devCache = Device.get_dev_control_cache(self.devNo)
            portCache = devCache.get(str(port))
            orderNo = portCache.get("orderNo") or 0
            pw = portCache.get("pw") or 0

            self._stop(port, orderNo, pw)

    @property
    def support_monthly_package(self):
        return True

    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'操作失败，请重新试试'})