manyi/apps/web/eventer/changyuan4.py

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

import datetime
import logging
import random
import time
import uuid

import simplejson as json
from bson import ObjectId

from apilib.monetary import Ratio, RMB, VirtualCoin
from apilib.utils_sys import memcache_lock
from apps.web.api.models import APIServiceStartRecord
from apps.web.common.models import TempValues
from apps.web.constant import Const, DEALER_CONSUMPTION_AGG_KIND
from apps.web.core.accounting import Accounting
from apps.web.core.device_define.changyuan import CYCardMixin, CYConstant
from apps.web.device.models import Group, Device
from apps.web.eventer import EventBuilder
from apps.web.eventer.base import FaultEvent, WorkEvent
from apps.web.report.utils import record_consumption_stats
from apps.web.south_intf.platform import handle_and_notify_event_to_north_cy4, handle_and_notify_event_to_north_cy4_new
from apps.web.user.models import RefundMoneyRecord
from apps.web.user.models import ServiceProgress, RechargeRecord, CardRechargeOrder, CardRechargeRecord, Card, MyUser, \
    ConsumeRecord
from apps.web.user.transaction_deprecated import refund_money, refund_cash

logger = logging.getLogger(__name__)


class builder(EventBuilder):
    def __getEvent__(self, device_event):
        event_data = self.deviceAdapter.analyze_event_data(device_event['data'])

        if event_data is None or 'cmdCode' not in event_data:
            return

        if event_data["cmdCode"] in ["D7"]:
            return ChargingCY4FaultEventer(self.deviceAdapter, event_data)

        if event_data['cmdCode'] in ['D8', 'D9', 'DA', 'D4', 'D3']:
            return ChargingCY4WorkEventer(self.deviceAdapter, event_data)

        return None


class ChargingCY4FaultEventer(FaultEvent):
    def do(self, **args):
        # 收到指令之后优先回复
        self.deviceAdapter.ack_event()

        group = Group.get_group(self.device["groupId"])

        warningData = {
            "warningStatus": 2,
            "warningDesc": "设备温度超限警告",
            "warningTime": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        }
        # 整机告警
        Device.update_dev_warning_cache(self.device.devNo, {"0": warningData})

        self.notify_dealer(
            templateName = "device_fault",
            title = "注意！设备火警预告！",
            device = u"{groupNumber}组-{logicalCode}".format(groupNumber = self.device["groupNumber"],
                                                            logicalCode = self.device["logicalCode"]),
            location = u"{address}-{groupName}".format(address = group["address"], groupName = group["groupName"]),
            fault = u"设备当前温度过高，可能发生了火警！",
            notifyTime = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        )


class ChargingCY4WorkEventer(CYCardMixin, WorkEvent):

    def do(self, **args):
        devNo = self.device['devNo']
        logger.info('ChangYuan4 charging event detected, devNo=%s,curInfo=%s' % (devNo, self.event_data))

        cmdCode = self.event_data['cmdCode']
        with memcache_lock(key = "{devNo}.{cmdCode}.event".format(devNo = devNo, cmdCode = cmdCode), expire=10, value = '1') as acquired:
            if acquired:
                # 收到某系指令之后先回复确认
                if self.event_data.get("cmdCode") in ["D3", "D9", "DA"]:
                    self.deviceAdapter.ack_event()

                # 设备状态由主板主动上报，上报之后需要和之前的端口信息做对比，如果之前端口处于工作状态的，而现在出于空闲状态的，需要结束服务
                if cmdCode == 'D8':
                    devCache = Device.get_dev_control_cache(devNo)
                    portInfo = self.event_data.get("portInfo")

                    newDevCache = self.compare_port_cache(portInfo, devCache)

                    self.temperature_check(self.event_data.get("temperature"))

                    self.main_board_check(portInfo)

                    newDevCache.update({"temperature": self.event_data.get("temperature")})
                    Device.update_dev_control_cache(self.device["devNo"], newDevCache)

                    if "cy4EventApi" in self.dealer.features:
                        for port, portData in newDevCache.items():
                            if port.isdigit():
                                orderNo = portData["consumeType"] + str(uuid.uuid4())

                                dataDict = {"deviceCode":self.device.logicalCode,
                                            "port":port,
                                            "notifyType": "portInfo",
                                            "status":portData["status"],
                                            "portInfo":{}}
                                if portData["status"] == Const.DEV_WORK_STATUS_WORKING:
                                    portDict = {
                                        "deviceCode": self.device.logicalCode,
                                        "status": Const.DEV_WORK_STATUS_WORKING,
                                        "power" : portData.get('power',0),
                                        "leftTime": portData.get('leftTime',None),
                                        "startTime":portData["startTime"],
                                        "consumeType":portData["consumeType"],
                                        "orderNo":orderNo,
                                        "isAPI":portData.get("isAPI",False),
                                        "port":port,
                                        "extOrderNo":portData.get("extOrderNo",""),

                                    }
                                    dataDict["portInfo"] = portDict
                                handle_and_notify_event_to_north_cy4_new(self.device,portDict)
                # 开始充电 状态上报 启动方式分为 刷卡 扫码 投币 对于刷卡需要创建相应的消费记录 其余的更新端口状态
                elif cmdCode == 'D9':
                    self.do_event_start()

                elif cmdCode == 'DA':  # 充电停止
                    self.do_event_finish()

                elif cmdCode == 'D4':  # 卡充值
                    self.do_event_recharge_card()
                    return  # D4充值，直接已经回应了报文，不需要再次回应报文。

                elif cmdCode == 'D3':  # 卡充值的回执
                    self.do_event_recharge_card_result()

    def compare_port_cache(self, portInfo, devCache):
        """
        主板要求 对比 上报上来的端口信息 和 缓存中的端口信息 如果端口的信息由工作变为空闲 ，则处理该端口停止
        同时更新端口缓存信息
        :param portInfo:  主板上报的信息
        :param devCache:  服务器记录的信息
        :return:
        """
        newDevCache = dict()
        for portStr, portData in portInfo.items():

            # 首先读取 服务器的缓存信息 如果存在等待D9的标记 则此次上报的数据不对 该端口信息产生任何影响
            portCache = devCache.get(portStr) or dict()
            if portCache.get("waitD9"):
                newDevCache[portStr] = portCache
                continue

            # 存在剩余时间以及使用时间
            if portData.get("leftTime", 0) and portCache.get("needTime", 0):
                portData["usedTime"] = portCache.get("needTime") - portData.get("leftTime")

                portCache.update(portData)
                newDevCache[portStr] = portCache

            # 非正常情况 清掉缓存
            if portData.get("status") == Const.DEV_WORK_STATUS_IDLE and portCache.get("status") == Const.DEV_WORK_STATUS_WORKING:
                Device.update_dev_control_cache(self.device.devNo, {portStr: {'status': Const.DEV_WORK_STATUS_IDLE}})

        return newDevCache

    def stop_port(self, portStr):
        """
        停止端口 状态
        :param portStr:
        :return:
        """
        self.deviceAdapter.stop(portStr)

    def do_event_start(self):
        """
        处理 D9 充电开始指令事件
        :return:
        """
        cardNo = self.event_data["cardNo"]
        portStr = self.event_data["port"]

        if not self.event_data["result"]:
            logger.info("start charging device reply error! devNo is %s, port is %s" % (self.device["devNo"], portStr))
            return

        if self.event_data["consumeType"] == "card":
            card = self.update_card_dealer_and_type(cardNo)


            if "cy4EventApi" not in self.dealer.features:
                if not self.check_card_can_use(card):
                    logger.info("[ChargingCY4WorkEventer do_event_start] check card not can use devNo = {}".format(self.device.devNo))
                    self.notify_invalid_card_to_dealer(self.event_data["cardNo"], card)
                    return self.deviceAdapter.stop_charging_port(portStr)

                # 判断卡是否存在 如果不存在 直接更新缓存信息即可
                if not card:
                    Device.update_dev_control_cache(self.device.devNo, {portStr: self.event_data})
                    return

                # 更新卡的余额
                self.update_card_balance(card, RMB(self.event_data["balance"]))

                # 记录卡的消费
                attachParas = {"chargeIndex": portStr}
                servicedInfo = {"cardNo": cardNo, "chargeIndex": portStr}
                orderNo, cardOrderNo = self.record_consume_for_card(card, RMB(self.event_data["coins"]), servicedInfo=servicedInfo, attachParas=attachParas)

                # 记录当前的卡消费的 progress
                fee = RMB(self.event_data["coins"])
                ServiceProgress.register_card_service(
                    self.device,
                    int(portStr),
                    card,
                    {
                        "orderNo": orderNo,
                        "money": fee.mongo_amount,
                        "coin": fee.mongo_amount,
                        "needTime": self.event_data["needTime"],
                        "cardOrderNo": cardOrderNo
                    }
                )

                # 通知卡消费成功
                self.notify_balance_has_consume_for_card(card, fee)

                cacheDict = {
                    "isStart": True,
                    "status": Const.DEV_WORK_STATUS_WORKING,
                    "coins": float(fee),
                    "price": float(fee),
                    "startTime": datetime.datetime.now().strftime(Const.DATETIME_FMT),
                    "openId": card.openId,
                    "needTime": self.event_data.get("needTime"),
                    "power": self.event_data.get("power"),
                    "consumeType": "card",
                    "payInfo": [{
                        "needTime": self.event_data.get("needTime"),
                        "coins": float(fee),
                        "price": float(fee),
                        "cardId": str(card.id),
                        "cardNo": self.event_data.get("cardNo")
                    }]
                }

                Device.update_dev_control_cache(self.device['devNo'], {portStr: cacheDict})  # 记录该端口累计需要的时间和钱
            else:
                # dataDict = {
                #     'orderNo': orderNo,
                #     'port': portStr,
                #     'devNo': self.device['devNo'],
                #     'logicalCode': self.device['logicalCode'],
                #     'money': float(fee),
                #     'startTime': datetime.datetime.now().strftime(Const.DATETIME_FMT),
                #     'openId': card.openId,
                #     'cardNo': cardNo,
                #     'needTime': self.event_data.get('needTime'),
                #     'consumeType': 'card',
                #     'status': 'PENDING',
                # }
                dataDict = {
                    "data": self.event_data.get('data'),
                    "logicalCode":self.device['logicalCode'],
                    "notifyType":"swipCard"
                }
                handle_and_notify_event_to_north_cy4_new(self.device, dataDict)

        elif self.event_data["consumeType"] == "mobile":
            # 如果是扫码启动的设备 可能会存在续充问题 payInfo needTime 需要特殊处理
            devCache = Device.get_dev_control_cache(self.device["devNo"])
            portCache = devCache.get(portStr, {})

            if portCache.get('isAPI', False) is False:

                # 没有 等待D9 的标记 说明已经处理过D9了 不需要再次处理
                if not portCache.get("waitD9"):
                    return

                # 如果是虚拟卡消费，在service处理消费记录的时候一定会写入到端口缓存中
                consumeRcdId = portCache.pop("consumeRcdId", None)

                # 获取本阶段的充电时间
                needTime = self.get_need_time(portCache, self.event_data.get("needTime"))

                payInfo = portCache.get("payInfo")
                payInfo[-1].update({
                    "needTime": needTime,
                })
                if consumeRcdId:
                    payInfo[-1].update({"consumeRcdId": consumeRcdId})

                portCache.update({
                    "needTime": portCache.get("needTime", 0) + needTime,
                    "power": self.event_data["power"],
                    "waitD9": False
                })
                Device.update_dev_control_cache(self.device["devNo"], {portStr: portCache})
            else:
                portCache.update({
                    "needTime": self.event_data["needTime"] if self.event_data["needTime"] != 0 else 1,
                    "power": self.event_data["power"],
                    "waitD9": False
                })

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

                dataDict = {
                    'orderNo': portCache.get('orderNo'),
                    'port': portStr,
                    'devNo': self.device.get("devNo"),
                    'logicalCode': self.device.get('logicalCode'),
                    'money': portCache.get('price'),
                    'startTime': datetime.datetime.now().strftime(Const.DATETIME_FMT),
                    'needTime': int(self.event_data.get('needTime', 0)),
                    'consumeType': 'mobile',
                    'status': 'PENDING',
                    'extOrderNo': portCache.get('extOrderNo')
                }
                handle_and_notify_event_to_north_cy4(self.device, dataDict)
                dataDict.update({"notifyType": "start"})
                handle_and_notify_event_to_north_cy4_new(self.device, dataDict)


        # 投币的暂时只是更新一下端口缓存
        elif self.event_data["consumeType"] == "coin":
            nowTime = datetime.datetime.now().strftime(Const.DATETIME_FMT)

            Accounting.recordOfflineCoin(
                self.device,
                int(time.time()),
                int(self.event_data["coins"]),
                port = portStr)
            orderNo = self.record_consume_for_coin(RMB(self.event_data["coins"]))

            Device.update_dev_control_cache(
                self.device["devNo"],
                {
                    portStr: {
                        "isStart": True,
                        "coins": self.event_data["coins"],
                        "needTime": self.event_data["needTime"],
                        "power": self.event_data["power"],
                        "consumeType": self.event_data["consumeType"],
                        "startTime": datetime.datetime.now().strftime(Const.DATETIME_FMT),
                        "status": Const.DEV_WORK_STATUS_WORKING,
                        "consumeOrderNo": orderNo,
                        "payInfo": [{
                            "coins": float(self.event_data["coins"]),
                            "price": float(self.event_data["coins"]),
                            "needTIme": self.event_data["needTime"],
                            "consumeOrderNo": orderNo
                        }]
                    }
                }
            )
        else:
            logger.error("error consumeType %s" % self.event_data["consumeType"])

    def do_event_finish(self):
        """
        充电结束事件上报
        :return:
        """
        portStr = self.event_data["port"]
        leftTime = self.event_data["leftTime"]

        devCache = Device.get_dev_control_cache(self.device.devNo)
        portCache = devCache.get(portStr, {})

        if not portCache:
            logger.error("[ChargingCY4WorkEventer do_event_finish] portCache is None, device = {}, port = {}".format(self.device.devNo, portStr))
            return

        group = self.device.group
        dealer = self.device.owner
        if not dealer or not group:
            logger.error('[ChargingCY4WorkEventer do_event_finish] dealer is not found, dealerId = {}'.format(self.device.ownerId))
            return

        if "coins" not in portCache:
            logger.error("[ChargingCY4WorkEventer do_event_finish] no coins info, device = {}, event data = {}".format(self.device.devNo, self.event_data))
            return

        nowTime = datetime.datetime.now()
        openId = portCache.get("openId", None)
        consumeType = portCache.get("consumeType", None)

        if consumeType == "mobile":
            if portCache.get('isAPI', False) is False:
                if not openId:
                    # 没有OPENID的情况下 仅仅是 清空端口缓存就OK
                    Device.clear_port_control_cache(self.device.devNo, portStr)
                    logger.info("[ChargingCY4WorkEventer do_event_finish] mobile consumeType finish but no openId, devNo = {}, port = {}".format(self.device.devNo, portStr))
                    return

                user = MyUser.objects(openId=openId, groupId=self.device.groupId).first()
                consumeDict = {
                    'chargeIndex': portStr,
                    'reason': self.event_data["reason"],
                    'actualNeedTime': portCache.get("needTime"),
                    'duration': int(portCache.get("needTime", 0)) - int(leftTime),
                    'elec': self.event_data["spendElec"],
                    'elecFee': self.calc_elec_fee(self.event_data["spendElec"]),
                    'leftTime': leftTime,
                    'needTime': u'扫码订购%s分钟' % portCache.get("needTime"),
                    DEALER_CONSUMPTION_AGG_KIND.COIN: VirtualCoin(portCache.get("coins")).mongo_amount
                }

                # 扫码退费的情况处理
                payInfo = portCache.get("payInfo", list())
                allNeedTime = portCache.get("needTime", 0)
                usedTime = allNeedTime - leftTime

                extra = [
                    {u"订购时长": u"{} 分钟".format(allNeedTime)},
                    {u"使用时长": u"{} 分钟".format(usedTime)}
                ]

                # 剩余时间比总订购时间还要长 则证明没有使用
                if usedTime <= 0:
                    usedTime = 0
                if usedTime <= CYConstant.REFUND_PRODUCTION_TIME:
                    usedTime = 0
                    self.event_data.update({"reason": u"异常结束，如非自己停止，可能是插头松动"})

                self.notify_user_service_complete(
                    service_name=u"充电",
                    openid=user.managerialOpenId if user else "",
                    port=self.event_data['port'],
                    address=group.address,
                    reason=self.event_data["reason"],
                    finished_time=nowTime.strftime("%Y-%m-%d %H:%M:%S"),
                    extra=extra
                )

                # 如果设备开启了退费并且结束原因在退费原因之列 或者时间不满5分钟
                if (self.device.is_auto_refund and self.event_data.get(
                        "reasonCode") in CYConstant.NEED_REFUND) or usedTime <= CYConstant.REFUND_PRODUCTION_TIME:

                    # 总的退还
                    allRefundMoney = VirtualCoin(0)

                    # 针对每一笔的支付信息不同进行退款
                    for item in payInfo:
                        usedTime, refundMoney = self.refund_user(item, usedTime, openId)
                        allRefundMoney += refundMoney

                    if allRefundMoney > VirtualCoin(0):
                        consumeDict.update({
                            DEALER_CONSUMPTION_AGG_KIND.REFUNDED_COINS: allRefundMoney.mongo_amount,
                            DEALER_CONSUMPTION_AGG_KIND.COIN: (
                                    VirtualCoin(portCache.get("coins")) - allRefundMoney).mongo_amount
                        })

                        refundTitle = u'您使用的%s号端口充电，共付款:%s元，充电预定时间为:%s分钟，剩余时间:%s分钟,给您退款:%s元（退款金额将于1-5个工作日内返还）' % (
                            portStr, portCache.get("coins"), portCache.get('needTime'), leftTime, allRefundMoney)
                        #
                        self.notify_user(user.managerialOpenId if user else '', 'refund_coins', **{
                            'title': refundTitle,
                            'backCount': u'%s' % allRefundMoney.amount,
                            'finishTime': datetime.datetime.strftime(nowTime, "%Y-%m-%d %H:%M:%S")
                        })

                # 没有退费的情况下 需要对经销商进行分账
                else:
                    for item in payInfo:
                        rechargeRcdId = item.get("rechargeRcdId")
                        self.do_ledger(rechargeRcdId)

                ServiceProgress.update_progress_and_consume_rcd(
                    self.device["ownerId"],
                    {
                        "open_id": openId,
                        "device_imei": self.device["devNo"],
                        "port": int(portStr),
                        "isFinished": False
                    },
                    consumeDict
                )
            else:
                try:
                    asr = APIServiceStartRecord.objects(orderNo=portCache['orderNo']).first()
                    needTime = asr.needTime
                    dataDict = {
                        'port': portStr,
                        'devNo': self.device['devNo'],
                        'logicalCode': self.device['logicalCode'],
                        'finishReason': self.event_data["reason"],
                        'duration': int(needTime) - int(leftTime),
                        'spendElec': self.event_data["spendElec"],
                        'leftTime': int(leftTime),
                        'status': 'FINISHED',
                        'consumeType': 'mobile',
                        'endTime': datetime.datetime.now().strftime(Const.DATETIME_FMT),
                        'extOrderNo': asr.extOrderNo
                    }
                    handle_and_notify_event_to_north_cy4(self.device, dataDict)
                    dataDict.update({"notifyType": "finished"})
                    handle_and_notify_event_to_north_cy4_new(self.device, dataDict)
                except Exception as e:
                    logger.error('changyuan4 api finish error! e={}'.format(e))
                    Device.clear_port_control_cache(self.device['devNo'], portStr)

        elif consumeType == "card":

            cardId = portCache.get("payInfo")[0].get("cardId")
            if not cardId:
                logger.info("[ChargingCY4WorkEventer do_event_finish] card consumeType finish but no cardId, devNo = {}, port = {}".format(self.device.devNo, portStr))
            else:
                card = Card.objects.get(id = cardId)
                extra = [
                    {u"刷卡卡号": "{}".format(card.cardNo)},
                    {u"订购时长": u"{} 分钟".format(portCache.get("needTime", 0))},
                    {u"使用时长": u"{} 分钟".format(int(portCache.get("needTime", 0)) - int(leftTime))}
                ]
                self.notify_user_service_complete(
                    service_name=u"充电",
                    openid=card.managerialOpenId,
                    port=self.event_data['port'],
                    address=group.address,
                    reason=self.event_data["reason"],
                    finished_time=nowTime.strftime("%Y-%m-%d %H:%M:%S"),
                    extra=extra
                )

                consumeDict = {
                    'chargeIndex': portStr,
                    'reason': self.event_data["reason"],
                    'actualNeedTime': portCache.get("needTime"),
                    'duration': int(portCache.get("needTime")) - int(leftTime),
                    'elec': self.event_data["spendElec"],
                    'elecFee': self.calc_elec_fee(self.event_data["spendElec"]),
                    'leftTime': leftTime,
                    'needTime': u'刷卡订购%s分钟' % portCache.get("needTime")
                }

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

                dataDict = {
                    'port': portStr,
                    'cardNo': card.cardNo,
                    'devNo': self.device['devNo'],
                    'logicalCode': self.device['logicalCode'],
                    'finishReason': self.event_data["reason"],
                    'duration': int(portCache.get("needTime")) - int(leftTime),
                    'spendElec': self.event_data["spendElec"],
                    'leftTime': int(leftTime),
                    'status': 'FINISHED',
                    'consumeType': 'card',
                    'endTime': datetime.datetime.now().strftime(Const.DATETIME_FMT),
                }
                handle_and_notify_event_to_north_cy4(self.device, dataDict)
                dataDict.update({"notifyType": "finished"})
                handle_and_notify_event_to_north_cy4_new(self.device, dataDict)

        elif consumeType == "coin":
            CoinConsumeRcd = ConsumeRecord.objects.get(orderNo = portCache.get('consumeOrderNo')) # type: ConsumeRecord
            CoinConsumeRcd.servicedInfo['elec'] = portCache.get("spendElec")
            CoinConsumeRcd.servicedInfo['actualNeedTime'] = u'动态功率计算为%s分钟' % str(
                int(portCache.get("needTime")) - int(leftTime))
            CoinConsumeRcd.servicedInfo['needTime'] = u'投币订购%s分钟' % portCache.get("needTime")
            CoinConsumeRcd.servicedInfo['reason'] = self.event_data.get("reason")
            CoinConsumeRcd.servicedInfo['chargeIndex'] = portStr
            CoinConsumeRcd.finishedTime = datetime.datetime.strftime(nowTime, '%Y-%m-%d %H:%M:%S')
            CoinConsumeRcd.save()

            valueDict = {
                DEALER_CONSUMPTION_AGG_KIND.ELEC: portCache.get("spendElec"),
                DEALER_CONSUMPTION_AGG_KIND.ELECFEE: self.calc_elec_fee(portCache.get("spendElec"))
            }

            status = CoinConsumeRcd.update_agg_info(valueDict)
            if status:
                record_consumption_stats(CoinConsumeRcd)
            else:
                logger.error(
                    '[update_progress_and_consume_rcd] failed to update_agg_info record=%r' % (CoinConsumeRcd,))

        else:
            logger.error("error consumeType! devNo is %s, port is %s" % (self.device["devNo"], portStr))

        # 事件结束之后清空端口的信息 更新设备的服务信息
        Device.clear_port_control_cache(self.device["devNo"], portStr)

    def do_event_recharge_card(self):
        """
        主板发起 卡金额同步指令
        服务器对照 相应卡的 余额 状态 充值记录等等进行相应的操作
        :return:
        """
        cardNo = self.event_data["cardNo"]
        cardBalance = self.event_data["balance"]

        card = self.update_card_dealer_and_type(cardNo)
        if not card:
            logger.error("no card exist, can not async card balance")
            return

        # 更新卡的余额 以设备侧的为准
        if RMB(cardBalance) != card.balance:
            logger.info('Card<{}> balance<{}> needs to be sync !!!'.format(cardNo, card.balance))
            card.balance = RMB(cardBalance)
            card = card.save()

        # orderNos 表示充值的订单 cardOrderNos 表示卡充值的订单
        money, coins, orderNos, cardOrderNos = CardRechargeOrder.get_to_do_list(str(card.id))

        # 一旦卡被冻结 立即下发 创建一张为 负数的金额订单 将卡的余额清空
        if card.frozen:
            group = Group.get_group(card.groupId)
            CardRechargeOrder.new_one(
                openId=card.openId,
                cardId=str(card.id),
                cardNo=card.cardNo,
                money=RMB(0),
                coins=VirtualCoin(0) - VirtualCoin(coins) - VirtualCoin(card.balance),
                group=group,
                rechargeId=ObjectId(),
                rechargeType=u"sendCoin"
            )
            money, coins, orderNos, cardOrderNos = CardRechargeOrder.get_to_do_list(str(card.id))

        # 没有需要同步的订单的情况下 直接退出
        if not orderNos:
            logger.info('Not card recharge record!, card is <{}>'.format(cardNo))
            # self._do_offline_recharge_by_dealer(cardNo, card, cardType)
            return

        orderNos = [str(item) for item in orderNos]
        sid = str(random.randint(0, 0xFFFF))

        TempValues.set('%s-%s' % (self.device.devNo, sid), value=json.dumps(orderNos))
        TempValues.set('%s-%s-%s' % (self.device.devNo, sid, cardNo), value=json.dumps(cardOrderNos))
        TempValues.set('%s-%s' % (self.device.devNo, cardNo), value=str(sid))

        # 计算总的需要同步的金额
        asyncMoney = RMB(cardBalance) + RMB(coins)
        logger.info('ready to recharge card, card is <{}>, money is <{}>'.format(cardNo, coins))


        # 已经下发金额后，先将订单的状态改为结束。如果主板上报失败，再将订单状态迁移回来否则就不再变化订单状态了
        try:
            CardRechargeOrder.update_card_order_has_finished(str(card.id))
        except Exception as e:
            logger.debug('%s' % e)
        else:
            self.deviceAdapter.recharge_card(cardNo, asyncMoney)

    def do_event_recharge_card_result(self):
        """
        同步卡余额 D3指令的应答指令 表示主板已经确认卡的余额已经被更新
        :return:
        """
        result = self.event_data["result"]
        if not result:
            logger.error("async card balance error, device reply error")
            return

        answerSid = self.event_data["sid"]
        cardNo = self.event_data["cardNo"]
        cardBalance = self.event_data["balance"]

        sid = TempValues.get("%s-%s" % (self.device["devNo"], cardNo))
        if sid != answerSid:
            logger.error("answer sid is not equal sid! %s\t%s" % (answerSid, sid))

        card = self.update_card_dealer_and_type(cardNo)
        if not card:
            logger.error("not found card, event is <{}>".format(self.event_data))
            return

        # 根据sid 以及卡号 查询出此次充值的所有的订单
        orderNos = TempValues.get('{}-{}'.format(self.device.devNo, sid))
        cardOrderNos = TempValues.get('{}-{}-{}'.format(self.device.devNo, sid, cardNo))

        # 下面的都不会更改订单的状态 最多走售后
        money, coins = RMB(0), VirtualCoin(0)

        # 校验金额是否是相等的
        orderNos = [ObjectId(item) for item in orderNos]
        rds = RechargeRecord.objects.filter(ownerId=card.dealerId, id__in=orderNos)
        for item in rds:
            money += item.money
            coins += item.coins

        # 这个地方就是异常值处理了
        if VirtualCoin(coins + card.balance) != VirtualCoin(cardBalance):
            logger.error('card pre balance not equal now balance! event is <{}>'.format(self.event_data))
            return

        # 依次更改卡充值的订单 并创建充值订单
        cardOrders = CardRechargeOrder.objects.filter(orderNo__in=cardOrderNos)
        for _order in cardOrders:   # type: CardRechargeOrder

            _order.update_after_recharge_ic_card(
                device=self.device,
                sendMoney=RMB(_order.coins),
                preBalance=card.balance
            )

            preBalance = card.balance
            card.balance = card.balance + _order.coins

            # 创建充值记录
            CardRechargeRecord.add_record(
                card=card,
                group=Group.get_group(_order.groupId),
                order=_order,
                device=self.device
            )

        # 保存
        card.save()

        # 完成之后将TempValue 的key value 清空
        TempValues.remove('%s-%s' % (self.device['devNo'], sid))
        TempValues.remove('%s-%s' % (self.device['devNo'], cardNo))
        TempValues.remove("%s-%s-%s" % (self.device["devNo"], sid, cardNo))

    def temperature_check(self, temperature):
        """
        温度监测
        :param temperature
        :return:
        """
        # 黑龙江温度 -19 度 昌原让屏蔽低温告警
        if temperature > self.deviceAdapter.MAX_TEMPERATURE:
            group = Group.get_group(self.device["groupId"])
            # self.notify_dealer(
            #     'device_fault',
            #     **{
            #         'title': u'注意！注意！设备温度不正常',
            #         'device': u'组号：:%s, 二维码编号: %s, 当前温度: %s' % (self.device['groupNumber'], self.device['logicalCode'], temperature),
            #         'location': u'组名称：%s, 地址:%s' % (group['groupName'], group['address']),
            #         'fault': u"设备温度超限",
            #         'notifyTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
            #     }
            # )

            self.notify_dealer(
                templateName = "device_fault",
                title = "注意！设备当前温度过高",
                device = u"{groupNumber}组-{logicalCode}".format(groupNumber = self.device["groupNumber"],
                                                                logicalCode = self.device["logicalCode"]),
                location = u"{address}-{groupName}".format(address = group["address"], groupName = group["groupName"]),
                fault = u"设备当前温度过高，请小心火警发生！",
                notifyTime = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            )

    def main_board_check(self, portInfo):
        """
        继电器粘连 监测
        :param portInfo:
        :return:
        """
        group = Group.get_group(self.device["groupId"])

        for portStr, portData in portInfo.items():
            if portData.get("status") == Const.DEV_WORK_STATUS_FAULT_RELAY_CONNECT:
                # self.notify_dealer(
                #     'device_fault',
                #     **{
                #         'title': u'注意！注意！您的设备发生继电器粘连',
                #         'device': u'组号：:%s, 二维码编号: %s, 端口号: %s' % (self.device['groupNumber'], self.device['logicalCode'], portStr),
                #         'location': u'组名称：%s, 地址:%s' % (group['groupName'], group['address']),
                #         'fault': u"设备端口发生继电器粘连",
                #         'notifyTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
                #     }
                # )
                self.notify_dealer(
                    templateName = "device_fault",
                    title = "注意！设备继电器发生粘连！",
                    device = u"{groupNumber}组-{logicalCode}-{port}".format(groupNumber = self.device["groupNumber"],
                                                                           logicalCode = self.device["logicalCode"],
                                                                           port = portStr),
                    location = u"{address}-{groupName}".format(address = group["address"],
                                                               groupName = group["groupName"]),
                    fault = u"设备继电器粘连，端口将一直处于供电状态！",
                    notifyTime = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
                )

    @staticmethod
    def get_need_time(portCache, allLeftTime):
        """
        获取此次支付的 needTime 协议中上报的NeedTime的理解：第一次支付获得了300分钟，使用了100分钟，第二次支付又获得了300分钟 然后上传过来的needTime是500分钟
        :param portCache: 端口缓存值
        :param allLeftTime: 上报过来的needTime
        :return:
        """
        leftTime = portCache.get("leftTime", 0)
        needTime = portCache.get("needTime")

        # 如果端口缓存中不存在剩余时间 说明是第一次支付
        # 绝大多数是这种情况
        if not leftTime and not needTime:
            return allLeftTime

        # 如果存在剩余时间 则可以说明此次获得的消费时间 = 上传的总剩余时间-之前的剩余时间（可能会有误差 已经和主板沟通）
        # 充电了一段时间之后的续充
        if leftTime and needTime:
            return allLeftTime - leftTime

        # 如果不存在剩余时间 但是端口缓存中已经存在了总的消费时间 说明是在1-5分钟之内续充 也就是D8指令还没有上来 连续续充 D9, D9
        # 连续续充 连续两次D9
        if not leftTime and needTime:
            return allLeftTime - needTime

        # 这种情况应该是不可能发生的，但是还是以防万一，出现的情况可能是 设备启动后，定时上传指令 比 上传充电指令更早到
        # D8 先 D9后 通过标记应该已经解决
        if leftTime and not needTime:
            return allLeftTime - leftTime

    def refund_user(self, payInfo, usedTime, openId):
        """
        退钱给用户 每一笔退还 如果不是虚拟卡支付 则说明是金币或者现金启动 后分账方式都需要对经销商进行分账
        :param payInfo: 单笔支付的信息
        :param usedTime: 使用的时间
        :param openId:
        :return: usedTime 退还此笔消费之后还剩余的使用时间 refundMoney 此笔退款退还的钱（币种可能不同 后续需要统一设计）
        """
        needTime = payInfo.get("needTime", 0)
        rechargeRcdId = payInfo.get("rechargeRcdId")
        vCardId = payInfo.get("vCardId")
        coins = payInfo.get("coins")

        # 进入退款后，还是优先分账 分完帐再说
        rechargeRecord = self.do_ledger(rechargeRcdId)

        # 接下来 计算退款率
        leftTime = needTime - usedTime

        # 情况一： 计算出来的剩余时间小于等于0 说明本单使用完毕 无需退款 但有可能下一单还需要退
        if leftTime <= 0:
            return usedTime - needTime, VirtualCoin(0)

        # 情况二：虚拟卡的直接本单不退 由于虚拟卡算1次 所以这一单直接不处理
        if vCardId:
            return 0, VirtualCoin(0)

        # 计算退款率 所需的退款即退款全额 * 退款率
        refundRate = Ratio(float(leftTime) / float(needTime))

        if rechargeRecord and rechargeRecord.isQuickPay:
            # 情况三： 现金退费
            refundMoney = refundRate * RMB(rechargeRecord.money)
            refund_cash(
                rechargeRecord, RMB(refundMoney), VirtualCoin(0),
                minus_total_consume = VirtualCoin(rechargeRecord.coins))  # type: RefundMoneyRecord

            return 0, refundMoney
        else:
            # 情况四：金币退费
            refundMoney = refundRate * VirtualCoin(coins)
            refund_money(self.device, refundMoney, openId)

            return 0, refundMoney