manyi/apps/web/eventer/changyuanPower.py

# coding=utf-8
import datetime
import logging
import random
import time

import simplejson as json
import typing
from bson import ObjectId
from mongoengine import DoesNotExist, ValidationError

from apilib.monetary import RMB, VirtualCoin, Ratio
from apilib.utils_sys import memcache_lock
from apps.web.agent.models import Agent
from apps.web.common.models import TempValues
from apps.web.constant import FAULT_CODE, FAULT_LEVEL, Const, DEALER_CONSUMPTION_AGG_KIND, USER_RECHARGE_TYPE
from apps.web.core.device_define.changyuan import CYCardMixin
from apps.web.core.payment import WithdrawGateway
from apps.web.dealer.models import Dealer
from apps.web.device.models import Group, Device
from apps.web.eventer import EventBuilder
from apps.web.eventer.base import WorkEvent, FaultEvent
from apps.web.report.ledger import Ledger
from apps.web.user.models import CardRechargeOrder, Card, RechargeRecord, CardRechargeRecord, ServiceProgress, \
    ConsumeRecord, CardConsumeRecord, MyUser
from apps.web.user.models import RefundMoneyRecord
from apps.web.user.transaction_deprecated import refund_money, refund_cash

if typing.TYPE_CHECKING:
    from apps.web.device.models import GroupDict

logger = logging.getLogger(__name__)


class builder(EventBuilder):
    def __getEvent__(self, device_event):
        eventData = self.deviceAdapter.analyze_event_data(device_event.get("data"))

        if device_event.get('daid'):
            eventData['daid'] = device_event.get('daid')

        if eventData is None or "cmdCode" not in eventData:
            return None

        if eventData["cmdCode"] == "D7":
            return ChangYuanFaultEventer(self.deviceAdapter, eventData)

        else:
            return ChangYuanWorkEventer(self.deviceAdapter, eventData)


class ChangYuanFaultEventer(FaultEvent):

    def do(self, **args):
        self.event_data.update({
            "faultName": u"设备火灾预警",
            "faultCode": FAULT_CODE.FIRE_ALARM,
            "level": FAULT_LEVEL.CRITICAL,
            "desc": u"主板上报设备火警"
        })

        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})

        super(ChangYuanFaultEventer, self).do(**args)


class ChangYuanWorkEventer(WorkEvent, CYCardMixin):

    def do(self, **args):
        cmdCode = self.event_data.get("cmdCode")

        cacheKey = "{}-{}-event".format(self.device.devNo, cmdCode)
        with memcache_lock(key = cacheKey, value = '1', expire = 300) as acquired:
            if acquired:
                if cmdCode == "F3":
                    self._do_recharge_card_result()

                elif cmdCode == "F4":
                    self._do_recharge_card()

                elif cmdCode == "D8":
                    self._do_report_device_status()

                elif cmdCode == "D9":
                    self._do_start_charge()

                elif cmdCode == "DA":
                    self._do_finish()

                elif cmdCode == "DF":
                    self._do_card_refund()

            else:
                logger.warning(
                    "cyp_event is doing!, dev is <{}>, cmd is <{}>, data is <{}>".format(self.device.devNo, cmdCode,
                                                                                         self.event_data))

    def _do_card_refund(self):
        beforeRefund = self.event_data.get("beforeRefund")
        refund = self.event_data.get("refund")
        afterRefund = self.event_data.get("afterRefund")
        cardNo = str(self.event_data.get("cardNo"))

        if VirtualCoin(beforeRefund) + VirtualCoin(refund) != VirtualCoin(afterRefund):
            logger.info("bad refund event, beforeRefund is {}, refund is {} afterRefund is {}".format(
                beforeRefund, refund, afterRefund
            ))
            return

        card = self.update_card_dealer_and_type(cardNo, cardType = "IC")
        if not card:
            logger.info("cyp_ No cardNo cardNo is {}".format(cardNo))
            return

        if VirtualCoin(card.balance) != VirtualCoin(beforeRefund):
            logger.info(
                "beforeRefund isn't equal card balance, cardNo is {}, beforeRefund is {}, card balance is {}".format(
                    cardNo, beforeRefund, card.balance
                ))
            return

        self.refund_money_for_card(RMB(refund), str(card.id))
        self.notify_user(
            card.managerialOpenId,
            'refund_coins',
            **{
                'title': u"充电桩返费",
                'backCount': u'%s' % refund,
                'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
            }
        )

    def _do_over_ack_clear_port(self, daid, port, overServiceProgress = False):
        res = self.deviceAdapter._ack_finished_massage(daid)
        if res['rst'] == 0:
            if overServiceProgress:
                sp = ServiceProgress.objects.filter(device_imei = self.device.devNo, port = port,
                                                    isFinished = False).first()
                if sp:
                    sp.update(isFinished = True, finished_time = time.time(),
                              expireAt = datetime.datetime.now())
            Device.clear_port_control_cache(self.device["devNo"], port)
            logger.info('cyp_do_over_ack_clear_port() is over !!')

    def _do_update_ConsumeRecord_CardConsumeRecord_service_progress(self, portCache, updateMoney):
        portCache["payCount"] = portCache.get('payCount') + 1
        portCache["allPayMoney"] = updateMoney
        portCache["coins"] = updateMoney

        orderNo = portCache.get('orderNo')
        cardOrderNo = portCache.get("cardOrderNo")
        try:
            order = ConsumeRecord.objects.get(orderNo = orderNo)  # type: ConsumeRecord
            card_order = CardConsumeRecord.objects.get(orderNo = cardOrderNo)
            service_pogress = ServiceProgress.objects(
                __raw__ = {'device_imei': order.devNo, 'consumeOrder.orderNo': orderNo}).first()
            order.coin = updateMoney
            order.money = updateMoney
            card_order.money = updateMoney
            service_pogress.consumeOrder['money'] = updateMoney
            service_pogress.consumeOrder['coin'] = updateMoney
            order.save()
            card_order.save()
            service_pogress.save()
        except Exception as e:
            logger.debug('cyp_%s' % e)
        finally:
            pass

    def _do_recharge_card(self):
        """
        同步卡的请求
        :return:
        """
        cardNo = self.event_data.get("cardNo")
        cardBalance = self.event_data.get("cardBalance")
        cardType = self.event_data.get("cardType")

        card = self.update_card_dealer_and_type(cardNo)
        if not card:
            logger.error("not card exist, can not async card balance <{}>".format(cardNo))
            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._async_card_balance(cardType, cardNo, asyncMoney)

    def _do_recharge_card_result(self):
        """
        确认卡的同步结果
        :return:
        """
        asyncStatus = self.event_data.get("asyncStatus")
        answerSid = self.event_data.get("sid")
        cardBalance = self.event_data.get("cardBalance")
        cardNo = self.event_data.get("cardNo")

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

        sid = TempValues.get('{}-{}'.format(self.device.devNo, cardNo))
        if sid != answerSid:
            logger.error('answer sid is not equal sid <{}>-<{}>'.format(sid, answerSid))
            return

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

        # 明确接收到了主板同步失败的情况下 直接退出 不在转换充值订单的问题 防止出错
        if not asyncStatus:
            logger.error("card async not success! event data is <{}>".format(self.event_data))
            return

        # 下面的都不会更改订单的状态 最多走售后
        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 _do_report_device_status(self):
        """
        同步设备状态
        :return:
        """
        portInfo = self.event_data.get("portInfo")
        voltage = self.event_data.get("voltage")
        temperature = self.event_data.get("temperature")

        # 首先依据上报的状态获取已使用未使用端口数量
        allPorts, usedPorts, usePorts = self.deviceAdapter.get_port_static_info(portInfo)

        # 端口信息更新
        devCache = Device.get_dev_control_cache(self.device.devNo) or dict()
        for portStr, value in devCache.items():
            if not portStr.isdigit() or not isinstance(value, dict):
                continue

            # 更新每个端口的信息
            tempPortInfo = portInfo.get(portStr, dict())
            value.update(tempPortInfo)
            devCache[portStr] = value

        devCache["voltage"] = voltage
        devCache["temperature"] = temperature
        devCache["allPorts"] = allPorts
        devCache["usedPorts"] = usedPorts
        devCache["usePorts"] = usePorts
        Device.update_dev_control_cache(self.device.devNo, devCache)

    def _do_start_charge(self):
        """
        充电开始指令, 主要是更新各种缓存等等,
        对于扫码的启动基本在adapter缓存已经处理完成，主要需要处理的是刷卡的启动
        根据 需求方要求 刷卡的可以做合单处理
        :return:
        """
        logger.info(
            'cyp_do_start_charge() is run!!   event_data:{}'.format(json.dumps(self.event_data, ensure_ascii = False)))

        portStr = self.event_data.get("portStr")
        cardBalance = self.event_data.get("cardBalance")
        allPayMoney = self.event_data.get("allPayMoney")
        payMoney = self.event_data.get("payMoney")

        cardNo = str(self.event_data.get("cardNo"))
        if cardNo == '00000000':
            return

        card = self.update_card_dealer_and_type(cardNo)

        if not self.check_card_can_use(card):
            logger.info(
                "[ChangYuanWorkEventer _do_start_charge] check card not can use devNo = {}".format(self.device.devNo))
            self.notify_invalid_card_to_dealer(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

        devCache = Device.get_dev_control_cache(self.device.devNo)
        portCache = devCache.get(portStr) or dict()

        # 离线卡 以设备上报过来的数据为准
        self.update_card_balance(card, RMB(cardBalance))
        if portCache.get("status", Const.DEV_WORK_STATUS_IDLE) != Const.DEV_WORK_STATUS_IDLE:
            # TODO 续充时候的处理
            logger.info('cyp_do_card_start_charge again!!')
            self._do_update_ConsumeRecord_CardConsumeRecord_service_progress(portCache, allPayMoney)

        # 不是续充，第一次刷卡
        else:
            logger.info('cyp_do_card_start_charge the once!!')
            # 记录ID卡的消费
            attachParas = {
                "chargeIndex": portStr
            }

            servicedInfo = {
                'cardNo': cardNo,
                'chargeIndex': portStr
            }

            orderNo, cardOrderNo = self.record_consume_for_card(card, RMB(payMoney), servicedInfo = servicedInfo,
                                                                attachParas = attachParas)

            # 记录缓存信息 可以在个人中心以及经销商的端口管理显示
            portCache = {
                "cardNo": cardNo,
                "openId": card.openId,
                "allPayMoney": allPayMoney,
                "lastPayMoney": payMoney,
                "payCount": 1,
                "coins": allPayMoney,
                "status": Const.DEV_WORK_STATUS_WORKING,
                "startTime": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                "orderNo": orderNo,
                "cardOrderNo": cardOrderNo,
                "consumeType": "card",
                "cardBalance": cardBalance
            }
            ServiceProgress.register_card_service(
                self.device,
                int(portStr),
                card,
                {
                    "orderNo": orderNo,
                    "money": RMB(allPayMoney).mongo_amount,
                    "coin": RMB(allPayMoney).mongo_amount,
                    "cardOrderNo": cardOrderNo
                }
            )

        # 更新端口缓存
        Device.update_dev_control_cache(self.device.devNo, {portStr: portCache})

        # 通知消费
        self.notify_balance_has_consume_for_card(card, payMoney)

    def _do_finish(self):
        """
        充电结束的指令
        :return:
        """
        # if self.event_data.get('reasonCode') == u'E8':
        #     #远程手工停止
        #     logger.info('cyp_Remote shut-off !!   event_data:{}'.format(json.dumps(self.event_data,ensure_ascii=False)))

        cardNo = str(self.event_data.get("cardNo"))
        if cardNo == "00000000":
            self._do_netpay_finish()
        else:
            self._do_card_finish()

    def _do_card_finish(self):

        logger.info(
            'cyp_do_card_finish() is run !!   event_data:{}'.format(json.dumps(self.event_data, ensure_ascii = False)))

        cardNo = str(self.event_data.get("cardNo"))
        leftBalance = self.event_data.get('leftBalance')
        usedtime = self.event_data.get('usedTime')
        usedElec = self.event_data.get("usedElec")
        desc = self.event_data.get('desc')
        port = self.event_data['portStr']
        daid = self.event_data['daid']

        card = self.update_card_dealer_and_type(cardNo, cardType = "IC")
        if not card:
            logger.debug("cyp_server no find card!!!")
            self._do_over_ack_clear_port(daid, port, overServiceProgress = True)
            return
        dev_control_cache = Device.get_dev_control_cache(self.device.devNo)

        try:
            port_cache = dev_control_cache[port]
            if not port_cache or port_cache == {'status': 0}:
                raise
        except Exception:
            logger.debug('cyp_the device no cache!!!    dev_control_cache:{}'.format(
                json.dumps(dev_control_cache, ensure_ascii = False)))

            self._do_over_ack_clear_port(daid, port, overServiceProgress = True)
            return
        # port_cache ={'status': 1, 'openId': u'o-VzzwAfpdglJY38Kj7yMvVWlIgw', 'cardNo': u'828CA649', 'price': 5.0, 'coins': 5.0, 'cardOrderNo': '1600314329724498', 'startTime': '2020-09-17 11:45:29', 'orderNo': '1600314329469873'}

        if cardNo != port_cache.get('cardNo'):
            # 该端口开始时候记录的卡号与结束上报的时候的卡号不相同，可能缓存纪录有问题，基本不可能！！
            logger.info('cyp_the device no cardNo cache,do ack,clear port cache!!!  port_cache:{}'.format(
                json.dumps(port_cache, ensure_ascii = False)))
            self._do_over_ack_clear_port(daid, port, overServiceProgress = True)
            return

        servicedInfo = {
            "port": port,
            "elec": usedElec,
            "usedTime": usedtime,
            "reason": desc,
            "finishedTime": datetime.datetime.strftime(datetime.datetime.now(), "%Y-%m-%d %H:%M:%S")
        }

        servicedInfo.update(port_cache)
        servicedInfo["leftBalance"] = leftBalance
        servicedInfo['spendMoney'] = str(RMB(servicedInfo["allPayMoney"]) - RMB(leftBalance))

        logger.info('cyp_servicedInfo:{}'.format(json.dumps(servicedInfo, ensure_ascii = False)))

        # card.balance = card.balance + RMB(leftBalance)
        #
        # try:
        #     # card.save()
        # except Exception as e:
        #     logger.debug('cyp_update_card_balance ie error %s' % e)
        try:
            group = Group.get_group(self.device["groupId"])
            self.notify_user(
                managerialOpenId = card.managerialOpenId,
                templateName = "service_complete",
                title = u"\\n\\n结束原因：\\t\\t{reason}\\n\\n设备编号：\\t\\t{logicalCode}\\n\\n服务地址：\\t\\t{group}\\n\\n使用时长：\\t\\t{duration}分钟\\n\\n付款金额：\\t\\t{coin}\\n\\n待返费：\\t\\t{refund}".format(
                    reason = u"充电结束",
                    logicalCode = self.device["logicalCode"],
                    group = group.get("address", ""),
                    duration = usedtime,
                    coin = u"%s" % servicedInfo['allPayMoney'],
                    refund = u"%s 请将卡片贴近充电桩进行返费" % leftBalance
                ),
                service = u"本次充电结束，请将充电卡放在桩的刷卡区域返费，保持静止5秒以上，直到听到 返费成功 语音后，再把卡移开！",
                finishTime = datetime.datetime.strftime(datetime.datetime.now(), "%Y-%m-%d %H:%M:%S"),
                remark = u'谢谢您的支持'
            )
        finally:
            newServicedInfo = {
                "cardNo": servicedInfo["cardNo"],
                "reason": servicedInfo["reason"],
                "port": servicedInfo["port"],
                "elec": servicedInfo["elec"],
                "finishedTime": servicedInfo["finishedTime"],
                "coin": servicedInfo["coins"]
            }

            ServiceProgress.update_progress_and_consume_rcd(
                self.device["ownerId"],
                {
                    "device_imei": self.device["devNo"],
                    "cardId": str(card.id),
                    "port": int(port),
                    "isFinished": False,
                    "consumeOrder.orderNo": servicedInfo.get('orderNo'),
                },
                newServicedInfo
            )

            self._do_over_ack_clear_port(daid, port)
            logger.info('cyp_do_card_finish() is over!!')

    def _do_netpay_finish(self):
        logger.info('cyp_do_netpay_finish() is run !!    event_data:{}'.format(
            json.dumps(self.event_data, ensure_ascii = False)))

        cardNo = str(self.event_data.get("cardNo"))
        leftBalance = self.event_data.get('leftBalance')
        usedtime = self.event_data.get('usedTime')
        usedElec = self.event_data.get("usedElec")
        desc = self.event_data.get('desc')
        port = self.event_data['portStr']
        daid = self.event_data['daid']

        dev_control_cache = Device.get_dev_control_cache(self.device.devNo)

        try:
            port_cache = dev_control_cache[port]
            if not port_cache or port_cache == {'status': 0}:
                raise
        except Exception:
            logger.info('cyp_the device no port_cache,do ack,clear port cache!!!    dev_control_cache:{}'.format(
                dev_control_cache))
            self._do_over_ack_clear_port(daid, port, overServiceProgress = True)
            return

        try:
            servicedInfo = {
                "port": port,
                "elec": usedElec,
                "usedTime": usedtime,
                "reason": desc,
                "finishedTime": datetime.datetime.strftime(datetime.datetime.now(), "%Y-%m-%d %H:%M:%S")
            }

            servicedInfo.update(port_cache)
            servicedInfo["leftBalance"] = leftBalance
            payType = servicedInfo['payType']
            openId = servicedInfo['openId']
            coins = servicedInfo['coins']
            price = servicedInfo['allPayMoney']
            vCardId = servicedInfo.get('vCardId')
            rechargeRcdId = servicedInfo.get('rechargeRcdId')

            # 尝试进行分账
            rechargeRecord = self.do_ledger(rechargeRcdId)

            # 如果没有openId则为经销商远程上分
            if not openId and cardNo == '00000000':
                logger.info('cyp_Remote activation by dealer')
                return

            if payType == 'coin':
                servicedInfo['spendCoin'] = str(VirtualCoin(servicedInfo['coins']) - VirtualCoin(leftBalance))
            elif payType == 'cash':
                servicedInfo['spendMoney'] = str(RMB(servicedInfo['coins']) - RMB(leftBalance))

            logger.info('cyp_servicedInfo:{}'.format(json.dumps(servicedInfo, ensure_ascii = False)))

            group = Group.get_group(self.device["groupId"])
            user = MyUser.objects.filter(openId = openId, groupId = self.device["groupId"]).first()

            logger.info("cyp_ChangYuanPower net pay finish and start to notify user! {}".format(self.device["devNo"]))

            self.notify_user(
                managerialOpenId = user.managerialOpenId if user else "",
                templateName = "service_complete",
                title = u"\\n\\n结束原因：\\t\\t{reason}\\n\\n设备编号：\\t\\t{logicalCode}\\n\\n服务地址：\\t\\t{group}\\n\\n使用时长：\\t\\t{duration}分钟\\n\\n付款金额：\\t\\t{coin}".format(
                    reason = u"充电结束",
                    logicalCode = self.device["logicalCode"],
                    group = group.get("address", ""),
                    duration = usedtime,
                    coin = u"%s金币" % coins if payType == 'coin' else u"%s元" % price
                ),
                service = u"自助充电服务",
                finishTime = datetime.datetime.strftime(datetime.datetime.now(), "%Y-%m-%d %H:%M:%S"),
                remark = u'谢谢您的支持')

            if RMB(leftBalance) > RMB(0):
                if payType == "cash":
                    if not self.device.is_auto_refund:
                        return

                    refundMoney = RMB(rechargeRecord.money) * Ratio(float(leftBalance) / float(coins))
                    refund_order = refund_cash(
                        rechargeRecord, refundMoney, VirtualCoin(0),
                        user = user, minus_total_consume = VirtualCoin(rechargeRecord.coins))  # type: RefundMoneyRecord

                    if refund_order:
                        logger.info("refund cash apply success!")

                        servicedInfo.update({DEALER_CONSUMPTION_AGG_KIND.REFUNDED_CASH: refundMoney.mongo_amount})
                        self.notify_user(user.managerialOpenId if user else '', 'refund_coins', **{
                            'title': u"退款（退款金额将于1-5个工作日内返还）",
                            'backCount': u'%s 元' % refundMoney,
                            'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
                        })

                # 金币支付并且 设备金币退款的开关打开
                elif payType == "coin":
                    if not self.device.is_auto_refund:
                        return

                    refundMoney = VirtualCoin(leftBalance)
                    servicedInfo.update({DEALER_CONSUMPTION_AGG_KIND.REFUNDED_COINS: refundMoney.mongo_amount})
                    refund_money(self.device, refundMoney, openId)

                # 虚拟卡支付的情况
                else:
                    logger.info("pay type need not to refund!")

            newServicedInfo = {
                "reason": servicedInfo["reason"],
                "port": servicedInfo["port"],
                "coin": servicedInfo["coins"],
                "elec": servicedInfo["elec"],
            }

            if DEALER_CONSUMPTION_AGG_KIND.REFUNDED_COINS in servicedInfo:
                refunded_coins = servicedInfo[DEALER_CONSUMPTION_AGG_KIND.REFUNDED_COINS]
                newServicedInfo.update(
                    {
                        DEALER_CONSUMPTION_AGG_KIND.SPEND_MONEY: (VirtualCoin(coins) - refunded_coins).mongo_amount,
                        DEALER_CONSUMPTION_AGG_KIND.REFUNDED_COINS: refunded_coins
                    })
            elif DEALER_CONSUMPTION_AGG_KIND.REFUNDED_CASH in servicedInfo:
                refunded_cash = servicedInfo[DEALER_CONSUMPTION_AGG_KIND.REFUNDED_CASH]
                newServicedInfo.update(
                    {
                        DEALER_CONSUMPTION_AGG_KIND.REFUNDED_CASH: refunded_cash
                    })

            ServiceProgress.update_progress_and_consume_rcd(
                self.device["ownerId"],
                {
                    "open_id": openId,
                    "device_imei": self.device["devNo"],
                    "port": int(port),
                    "isFinished": False,
                    "consumeOrder.orderNo": servicedInfo.get('orderNo'),
                },
                newServicedInfo
            )

            logger.info('cyp_do_netpay_finish() is over !!')
        finally:
            self._do_over_ack_clear_port(daid, port)

    def update_card_dealer_and_type(self, cardNo, cardType = 'IC', isHaveBalance = True, balance = None):
        """
        更新卡的状态 重写目的 如果卡不存在 立即下发停止充电指令 而不是新建一张卡
        :param cardNo:
        :param cardType:
        :param isHaveBalance:
        :param balance:
        :return:
        """
        dealer = Dealer.objects.get(id = self.device["ownerId"])
        agent = Agent.objects.get(id = dealer.agentId)

        if not agent:
            logger.error('agent is not found, agentId=%s' % dealer.agentId)
            return

        try:
            card = Card.objects.get(cardNo = cardNo, agentId = dealer.agentId)

            # 如果卡没有被绑定，这个时候检查下绑定关系。如果卡已经被某个经销商认领了，就不要刷新，不要动了
            if card.cardType and card.dealerId and card.devNo and (card.dealerId == self.device['ownerId']):
                return card

            card.dealerId = self.device['ownerId']
            card.devNo = self.device['devNo']
            card.cardType = cardType
            card.devTypeCode = self.device['devType']['code']
            card.isHaveBalance = isHaveBalance

            return card.save()

        except DoesNotExist:
            return
        except Exception as e:
            logger.exception(e)
            return

    def notify_invalid_card_to_dealer(self, cardNo, card):
        logger.info('Illegal card <{}>, charging is about to stop'.format(cardNo))
        group = Group.get_group(self.device['groupId'])
        self.notify_dealer(
            'device_fault',
            title = u'注意！注意！您当前的设备已被非法卡使用！',
            device = u'组号：:%s, 二维码编号:%s' % (self.device['groupNumber'], self.device['logicalCode']),
            location = u'组名称：%s, 地址:%s' % (group['groupName'], group['address']),
            fault = u'在%s编号为%s的设备被非法卡卡启动，启动卡号为：%s 卡联系人 %s 卡联系电话 %s' % (
                group['address'], self.device['logicalCode'], card.cardNo if card else '',
                card.phone if card else '', card.cardName if card else ''),
            notifyTime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        )