manyi/apps/web/eventer/changyuanFive.py

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

import datetime
import logging
import random
import time

import simplejson as json
from bson import ObjectId
from mongoengine import DoesNotExist

from apilib.monetary import RMB, VirtualCoin, Ratio
from apilib.utils_datetime import to_datetime
from apilib.utils_sys import memcache_lock
from apps import serviceCache
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
from apps.web.core.accounting import Accounting
from apps.web.core.device_define.changyuan import CYCardMixin, CYConstant
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.user.models import CardRechargeOrder, Card, RechargeRecord, CardRechargeRecord, ServiceProgress, \
    ConsumeRecord, CardConsumeRecord, MyUser, UserVirtualCard


logger = logging.getLogger(__name__)


class PayTypeEnum(object):
    COUNT_CARD = '00'
    NET_PAY = '01'
    OFFLINE_COIN = '02'
    PREPAID_CARD = '03'
    ONLINE_CARD = '04'


class builder(EventBuilder):
    def __getEvent__(self, device_event):
        if 'data' not in device_event:
            return None
        eventData = self.deviceAdapter.analyze_event_data(device_event.get('data'))

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

        if "ack_id" in device_event:
            eventData["ack_id"] = device_event["ack_id"]

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

        else:
            return ChangYuanWorkEventer(self.deviceAdapter, eventData)


class ChangYuanFaultEventer(FaultEvent):

    def do(self, **args):
        if "ack_id" in self.event_data:
            self.deviceAdapter._ack(self.event_data["ack_id"])

        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(CYCardMixin, WorkEvent):
    def do(self, **args):
        if "ack_id" in self.event_data:
            self.deviceAdapter._ack(self.event_data["ack_id"])

        cmdCode = self.event_data.get('cmdCode')

        if cmdCode == 'D8':
            return self._do_report_device_status()

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

                elif cmdCode == 'D4':
                    self._do_recharge_card()

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

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

                elif cmdCode == 'DE':
                    self._do_card_refund()
                elif cmdCode == 'F0':
                    self._do_prepare_online_card_start()

            else:
                logger.warning(
                    'cyp_event is doing!, dev is <{}>, cacheKey is <{}>, cmd is <{}>, data is <{}>'.format(
                        self.device.devNo,
                        cacheKey,
                        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, "01")
        if not card:
            return

        # 查看返费前的金额是否是相等的
        if VirtualCoin(card.balance) != VirtualCoin(beforeRefund):
            logger.info(
                'beforeRefund is not 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 or "",
            'refund_coins',
            **{
                'title': u'预付卡充电桩返费',
                'backCount': u'%s' % refund,
                'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
            }
        )

    @staticmethod
    def _do_update_ConsumeRecord_CardConsumeRecord_service_progress(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)
            card_order = CardConsumeRecord.objects.get(orderNo=cardOrderNo)
            service_pogress = ServiceProgress.objects(__raw__={'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('%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, billing_method=cardType)
        if not card:
            return

        if card.cardType == "ID":
            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('result')
        answerSid = self.event_data.get('sid')
        cardBalance = self.event_data.get('cardBalance')
        cardNo = str(self.event_data.get('cardNo'))
        cardType = self.event_data.get('cardType')

        # 先找卡 卡都不存在的话 直接推掉
        card = self._update_card_dealer_and_type(cardNo, cardType)
        if not card:
            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')
        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['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(
            'do_start_charge() is run!!   event_data:{}'.format(json.dumps(self.event_data, ensure_ascii=False)))

        portStr = str(self.event_data.get('port'))

        ctrInfo = Device.get_dev_control_cache(self.device.devNo)
        lineInfo = ctrInfo.get(portStr, {'port': portStr})

        payType = self.event_data.get('payType')
        if payType == PayTypeEnum.NET_PAY:  # 线上支付
            if lineInfo.get('status', Const.DEV_WORK_STATUS_IDLE) == Const.DEV_WORK_STATUS_IDLE:
                lineInfo['power'] = self.event_data.get('power')
                lineInfo['payType'] = self.event_data.get('payType')
                lineInfo['needTime'] = self.event_data.get('needTime')
                logger.info("NET_PAY is ok!!")
            else:
                lineInfo['power'] = self.event_data.get('power')
                lineInfo['needTime'] = self.event_data.get('needTime')
                logger.info("NET_PAY is ok!!")

            Device.update_port_control_cache(self.device.devNo, lineInfo)

            return

        elif payType == PayTypeEnum.OFFLINE_COIN:
            Accounting.recordOfflineCoin(self.device,
                                         int(time.time()),
                                         int(self.event_data['coins']))

            orderNo = self.record_consume_for_coin(RMB(self.event_data["coins"]))

            Device.update_port_control_cache(
                self.device["devNo"],
                {'port':portStr,
                        "isStart": True,
                        "coins": self.event_data["coins"],
                        "needTime": self.event_data["needTime"],
                        "power": self.event_data["power"],
                        "payType": self.event_data["payType"],
                        "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:
            cardNo = self.event_data.get('cardNo')
            if cardNo == '00000000':
                return
            cardBalance = RMB(self.event_data.get('cardBalance'))
            coins = self.event_data.get('coins')
            needTime = self.event_data.get('needTime')

            # 判断卡
            card = self._update_card_dealer_and_type(cardNo, billing_method=self.event_data["cardType"])

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

            if payType == PayTypeEnum.ONLINE_CARD:
                oldBalance = card.balance
                newBalance = oldBalance - RMB(coins)
                self.update_card_balance(card, newBalance)
            else:
                # 离线卡 以设备上报过来的数据为准
                self.update_card_balance(card, RMB(cardBalance))

            if lineInfo.get('status', Const.DEV_WORK_STATUS_IDLE) != Const.DEV_WORK_STATUS_IDLE and cardNo == lineInfo.get('cardNo'):
                logger.info('Card<{}> Swipe to pay again!!'.format(cardNo))
                orderNo = lineInfo.get('orderNo')
                cardOrderNo = lineInfo.get('cardOrderNo')
        
                lineInfo['coins'] += coins
                lineInfo['payCount'] += 1

        
                if not needTime:
                    needTime = 0

                lineInfo['needTime'] = needTime

                ConsumeRecord.objects.filter(orderNo=orderNo).update_one(inc__coin=coins, inc__money=coins)

                CardConsumeRecord.objects.filter(orderNo=cardOrderNo).update_one(inc__money=coins, dec__balance=coins)

                ServiceProgress.objects.filter(device_imei=self.device.devNo, port=int(portStr),
                                               consumeOrder__orderNo=orderNo, isFinished=False).update_one(
                    inc__consumeOrder__coin=coins, inc__finished_time=(time.time()+needTime * 60))

            # 第一次刷卡
            else:
                logger.info('Card<{}> start charge the once!!'.format(cardNo))
                # 记录ID卡的消费
                attachParas = {
                    'chargeIndex': portStr
                }

                servicedInfo = {
                    'cardNo': cardNo,
                    'chargeIndex': portStr
                }
                needTime = self.event_data.get('needTime')
                
                orderNo, cardOrderNo = self.record_consume_for_card(card, RMB(coins), servicedInfo=servicedInfo, attachParas=attachParas)

                # 记录缓存信息 可以在个人中心以及经销商的端口管理显示
                lineInfo = {
                    'port': portStr,
                    'cardNo': cardNo,
                    'openId': card.openId,
                    'payCount': 1,
                    'coins': coins,
                    'status': Const.DEV_WORK_STATUS_WORKING,
                    'startTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                    'orderNo': orderNo,
                    'cardOrderNo': cardOrderNo,
                    'payType': payType,
                    'consumeType': 'card',
                    'needTime':needTime,
                }

                finishedTime = None
                if needTime:
                    finishedTime = int(time.time()) + needTime * 60
                    # lineInfo['needTime'] = needTime

                ServiceProgress.register_card_service(
                    self.device,
                    int(portStr),
                    card,
                    {
                        'orderNo': orderNo,
                        'coin': VirtualCoin(coins).mongo_amount,
                        'cardOrderNo': cardOrderNo
                    },
                    finishedTime)

                logger.info('port:{} is running, order:{} cardOrder:{}'.format(portStr, orderNo, cardOrderNo))
            # 更新端口缓存
            Device.update_port_control_cache(self.device.devNo, lineInfo)

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

    def _do_finish(self):
        '''
        充电结束的指令
        :return:
        '''

        portStr = str(self.event_data.get('port'))

        FINISHED_COUNT_KEY = 'device_port_finish_{}_{}'.format(self.device.devNo, portStr)
        count = serviceCache.get(FINISHED_COUNT_KEY, 0)

        ctrInfo = Device.get_dev_control_cache(self.device.devNo)
        lineInfo = ctrInfo.get(portStr)
        if not lineInfo or lineInfo.get('payType') is None:
            logger.info('cache is missing ,DA is over')
            return

        if "startTime" in lineInfo:
            duration = ((datetime.datetime.now() - to_datetime(lineInfo.get('startTime'))).total_seconds() + 59) // 60
            if duration < 3:
                count += 1
                serviceCache.set(FINISHED_COUNT_KEY, count, 60 * 60 * 24)

            if count >= 3:
                self.notify_fault_to_dealer()
                serviceCache.delete(FINISHED_COUNT_KEY)

        payType = lineInfo.get('payType')
        try:
            if payType == PayTypeEnum.NET_PAY:
                self._do_netpay_finish(portStr, lineInfo)
            elif payType == PayTypeEnum.OFFLINE_COIN:
                self._do_offline_coin_finish(portStr, lineInfo)
            else:
                self._do_card_finish(portStr, lineInfo)
        except Exception as e:
            logger.error('DA is over error:{}'.format(e))

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

    def _do_card_finish(self, portStr, lineInfo):
        logger.info('do card finished lineInfo={} ||| event_data={}'.format(lineInfo, self.event_data))

        extra = []
        coins = lineInfo.get('coins')
        cardNo = lineInfo.get('cardNo')
        card = self.update_card_dealer_and_type(cardNo, cardType='IC')
        if not card:
            logger.debug('server no find card!!! cardNo=<{}>'.format(cardNo))
            return

        extra.append({u'使用卡片': u'{}--{}'.format(card.cardName, cardNo)})

        consumeDict = {
            'port': portStr,
            'cardNo': cardNo,
            'elec': self.event_data.get('usedElec'),
            'reason': self.event_data.get('reason'),
        }

        payType = lineInfo.get('payType')
        if payType == PayTypeEnum.COUNT_CARD:
            leftTime = self.event_data.get('left')
            now = datetime.datetime.now()
            consumeDict['leftTime'] = leftTime
            consumeDict['duration'] = ((now - to_datetime(lineInfo.get('startTime'))).total_seconds() + 59) // 60
            consumeDict['actualNeedTime'] = '动态计算时间为{}分钟'.format(consumeDict['duration'] + leftTime)
            extra.append({u"使用详情": u"本次使用{}分钟,剩余{}分钟".format(consumeDict['duration'], consumeDict['leftTime'])})

        elif payType == PayTypeEnum.PREPAID_CARD:
            leftMoney = self.event_data.get('left') * 0.01
            if leftMoney:
                if leftMoney > coins:
                    leftMoney = coins
                refundedMoney = round(leftMoney, 2)
                consumeDict['spendMoney'] = round(coins - leftMoney, 2)
                extra.append(
                    {u"消费明细": u"消费{}金币,剩余{}金币(等待靠卡退费)".format(consumeDict['spendMoney'], refundedMoney)})
            else:
                consumeDict['spendMoney'] = round(coins, 2)
                extra.append(
                    {u"消费明细": u"消费{}金币".format(coins)})
        elif payType == PayTypeEnum.ONLINE_CARD:
            usedElec = self.event_data.get('usedElec')
            reason = self.event_data.get('reason')
            leftTime = self.event_data.get('left')

            extra = []

            openId = lineInfo.get('openId')
            coins = VirtualCoin(lineInfo.get('coins', 0))
            money = RMB(lineInfo.get('price', 0))
            payInfo = lineInfo.get('payInfo')
            vCardId = lineInfo.get('vCardId')

            needTime = lineInfo.get('needTime')
            duration = needTime - leftTime

            backCoins = coins * Ratio(float(leftTime) / float(needTime))
            refundMoney = money * Ratio(float(leftTime) / float(needTime))

            if duration <= CYConstant.REFUND_PRODUCTION_TIME:
                refundMoney = money
                backCoins = coins

            # 如果没有openId则为经销商远程上分
            if not openId:
                logger.info('Remote activation by dealer')
                return
            else:
                user = MyUser.objects.filter(openId=openId, groupId=self.device['groupId']).first()

            consumeDict = {
                'port': portStr,
                'elec': usedElec,
                'duration': duration,
                'reason': reason,
                'needTime': needTime,
            }

            logger.info(
                'ChangYuanPower net pay finish and start to notify user! {}-{}'.format(self.device['devNo'], portStr))
            logger.info(
                'ChangYuanPower net pay finish refund data {}-backCoins:{}-refundMoney:{}'.format(self.device['devNo'],
                                                                                                  str(backCoins),
                                                                                                  str(refundMoney)))

            if duration > 5:
                extra.append({u'充电时长': u'{}分钟'.format(duration)})
            else:
                extra.append({u'充电时长': u'0分钟'})

            if self.device.is_auto_refund or duration <= 5:
                if payInfo:
                    # 现金退款
                    self.refund_money_for_card(refundMoney, str(card.id))
                    extra.append({u'消费明细': u'支付{}元,退款{}元'.format(money, refundMoney)})

                elif vCardId:
                    try:
                        vCard = UserVirtualCard.objects.get(id=vCardId)
                        extra.append({u'虚拟卡券': u'{}--{}'.format(vCard.cardName, vCard.cardNo)})
                    except DoesNotExist:
                        logger.info('can not find the vCard id = %s' % vCardId)
                        pass

                    pass

                else:
                    self.refund_money_for_card(backCoins, str(card.id))
                    extra.append({u'消费明细': u'消费{}金币,退款{}金币'.format(coins-backCoins, backCoins)})
                    consumeDict['spendMoney'] = round(coins-backCoins, 2)
            else:
                extra.append({u'消费明细': u'消费{}金币'.format(coins)})
                consumeDict['spendMoney'] = round(coins, 2)
                if payInfo:
                    for item in payInfo:
                        self.do_ledger(item['rechargeRcdId'])

        ServiceProgress.update_progress_and_consume_rcd(
            self.device['ownerId'],
            {
                'device_imei': self.device['devNo'],
                'cardId': str(card.id),
                'port': int(portStr),
                'isFinished': False
            },
            consumeDict
        )
        
        self.notify_to_user(card.managerialOpenId, extra)
        
        logger.info('do_card_finish is finished!!')

    def _do_netpay_finish(self, portStr, lineInfo):
        logger.info('[ChangYuanWorkEventer _do_netpay_finish] devNo = {}, event data = {}'.format(self.device.devNo, self.event_data))

        usedElec = self.event_data.get('usedElec')
        reason = self.event_data.get('reason')
        leftTime = self.event_data.get('left')

        openId = lineInfo.get('openId')
        coins = VirtualCoin(lineInfo.get('coins', 0))
        money = RMB(lineInfo.get('price', 0))
        payInfo = lineInfo.get('payInfo')
        vCardId = lineInfo.get('vCardId')
        needTime = lineInfo.get("needTime", leftTime)

        # 如果没有openId则为经销商远程上分
        if not openId:
            logger.info('[ChangYuanWorkEventer _do_netpay_finish] Remote activation by dealer, devNo = {}, lineInfo = {}'.format(self.device.devNo, lineInfo))
            return

        user = MyUser.objects.filter(openId=openId).first()
        now = datetime.datetime.now()
        usedTime = needTime - leftTime
        duration = (now - to_datetime(lineInfo.get('startTime'))).total_seconds() // 60
        actualNeedTime = duration + leftTime

        backCoins = coins * Ratio(leftTime / actualNeedTime)
        refundMoney = money * Ratio(leftTime / actualNeedTime)

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

        consumeDict = {
            'port': portStr,
            'elec': usedElec,
            'duration': usedTime,
            'reason': reason,
            'needTime': needTime,
            'actualNeedTime': u'动态功率计算为%s分钟' % actualNeedTime,
        }

        # 大于充电保护时长
        if usedTime <= CYConstant.REFUND_PRODUCTION_TIME:
            usedTime = 0
            backCoins = coins
            refundMoney = money
            self.event_data.update({"reason": u"异常结束，如非自己停止，可能是插头松动"})

        if usedTime < 0:
            usedTime = 0
            backCoins = VirtualCoin(0)
            refundMoney = RMB(0)

        if (self.device.is_auto_refund and self.event_data.get(
                "reasonCode") in CYConstant.NEED_REFUND) or usedTime <= CYConstant.REFUND_PRODUCTION_TIME:
            if payInfo:
                # 先做现金分账
                for item in payInfo:
                    self.do_ledger(item['rechargeRcdId'])
                
                # 现金退款
                self.refund_net_pay(user, lineInfo, refundedMoney=refundMoney, refundCoins=VirtualCoin(0),
                                    consumeDict=consumeDict, is_cash=True)
                extra.append({u'消费明细': u'支付{}元,退款{}元'.format(money, refundMoney)})

            elif vCardId:
                try:
                    vCard = UserVirtualCard.objects.get(id=vCardId)
                    extra.append({u'虚拟卡券': u'{}--{}'.format(vCard.cardName, vCard.cardNo)})
                except DoesNotExist:
                    logger.error('can not find the vCard id = %s' % vCardId)
            else:
                self.refund_net_pay(user, lineInfo, refundedMoney=RMB(0), refundCoins=backCoins,
                                    consumeDict=consumeDict, is_cash=False)
                extra.append({u'消费明细': u'支付{}金币,退款{}金币'.format(coins, backCoins)})
        else:
            if payInfo:
                for item in payInfo:
                    self.do_ledger(item['rechargeRcdId'])

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

        self.notify_to_user(openId=user.managerialOpenId, extra=extra)

    def _update_card_dealer_and_type(self, cardNo, billing_method):
        """
        昌原的都是IC卡 并且需要标注卡类型
        :param cardNo:  卡号
        :param billing_method:   卡类型
        :return:
        """
        if billing_method in ['0A','02']:
            card = self.update_card_dealer_and_type(cardNo, "ID")

            card_recharge_order = CardRechargeOrder.get_last_to_do_one(str(card.id))
            if card_recharge_order:
                self.recharge_id_card(card = card, rechargeType = 'append', order = card_recharge_order)
                card.reload()
        else:
            card = self.update_card_dealer_and_type(cardNo, "IC")  # type: Card

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

        # 没有卡的计费类型的 说明是经销商新添加的卡 添加上计费类型 有了卡计费类型的 需要比较卡计费类型是否正确 如果不正确的 说明卡不正确
        # if not card.billing_method:
        #     card.billing_method = billing_method
        # 只要检测到卡上报的卡类型和服务器存储的卡类型不同，则以上报的卡类型为主
        card.billing_method = billing_method

        if not card.billing_method_equal(billing_method):
            logger.error("card <{}> billing_method not equal!, event is <{}>".format(cardNo, self.event_data))
            return None

        return card

    def update_card_dealer_and_type(self, cardNo, cardType='ID', 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.filter(cardNo=cardNo, agentId=dealer.agentId).first()

            if not card:
                return None

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

            return card

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

    def notify_to_user(self, openId, extra):

        group = Group.get_group(self.device['groupId'])
        self.notify_user_service_complete(
            service_name='充电',
            openid=openId,
            port=self.event_data['port'],
            address=group['address'],
            reason=self.event_data.get('reason'),
            finished_time=datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
            extra=extra)

    def _do_offline_coin_finish(self, portStr, lineInfo):

        CoinConsumeRcd = ConsumeRecord.objects.get(orderNo=lineInfo.get('consumeOrderNo'))
        startTime = lineInfo.get('startTime')
        startTime = to_datetime(startTime)
        nowTime = datetime.datetime.now()
        if startTime > nowTime:
            usedTime = 0
        else:
            usedTime = int(round(((nowTime - startTime).total_seconds() / 60.0)))

        consumeDict = {
            'chargeIndex': portStr,
            'reason': self.event_data.get('reason'),
            'leftTime': self.event_data.get('left', 0),
            'actualNeedTime': usedTime + self.event_data.get('left', 0),
            DEALER_CONSUMPTION_AGG_KIND.DURATION: usedTime,
            DEALER_CONSUMPTION_AGG_KIND.ELEC: self.event_data.get('usedElec'),
            DEALER_CONSUMPTION_AGG_KIND.TOTAL_COUNT: lineInfo.get('coins'),
        }

        CoinConsumeRcd.update_service_info(consumeDict)
        CoinConsumeRcd.update(status='finished',finishedTime=nowTime)

    def notify_fault_to_dealer(self):
        group = self.device.group

        self.notify_dealer(
            templateName='device_fault',
            title=u'端口连续停止超过三次',
            device=u'{groupNumber}组-{logicalCode}-端口{port}'.format(groupNumber=self.device['groupNumber'],
                                                          logicalCode=self.device['logicalCode'],port=self.event_data.get('port')),
            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 anonymous_user_start(self, lineInfo):
    
        coins = self.event_data.get('coins')
        cardNo = self.event_data.get('cardNo')
        port = self.event_data.get('port')
        needTime = self.event_data.get('needTime')
        cardBalance = self.event_data.get('cardBalance')
        payType = self.event_data.get('payType')
        
        if lineInfo.get('status', Const.DEV_WORK_STATUS_IDLE) != Const.DEV_WORK_STATUS_IDLE and cardNo == lineInfo.get(
                'cardNo'):
            logger.info('anonymous_user card<{}> Swipe to pay again!!'.format(cardNo))
            orderNo = lineInfo.get('orderNo')
            cardOrderNo = lineInfo.get('cardOrderNo')
        
            lineInfo['coins'] += coins
            lineInfo['payCount'] += 1
        
            if not needTime:
                needTime = 0
            #     lineInfo['needTime'] = needTime
        
            ConsumeRecord.objects.filter(orderNo=orderNo).update_one(inc__coin=coins, inc__money=coins)
        
            CardConsumeRecord.objects.filter(orderNo=cardOrderNo).update_one(inc__money=coins, dec__balance=coins)
        
            ServiceProgress.objects.filter(device_imei=self.device.devNo, port=port,
                                           consumeOrder__orderNo=orderNo, isFinished=False).update_one(
                inc__consumeOrder__coin=coins, inc__finished_time=(time.time() + needTime * 60))
        
            # 第一次刷卡
        else:
            logger.info('anonymous_user card<{}> start charge the once!!'.format(cardNo))
            
            card = Card(
                cardNo=cardNo,
                dealerId=self.device.ownerId,
                agentId=self.device.owner.agentId,
                groupId=self.device.groupId,
                openId=Const.DEFAULT_CARD_OPENID,
                balance=RMB(cardBalance),
            ).save()
            
            
            # 记录ID卡的消费
            attachParas = {
                'chargeIndex': port
            }
            servicedInfo = {
                'cardNo': cardNo,
                'chargeIndex': port,
            }
            orderNo, cardOrderNo = self.record_consume_for_card(card, RMB(coins), servicedInfo=servicedInfo, attachParas=attachParas)
        
            # 记录缓存信息 可以在个人中心以及经销商的端口管理显示
            lineInfo = {
                'port': port,
                'cardNo': cardNo,
                'openId': card.openId,
                'payCount': 1,
                'coins': coins,
                'status': Const.DEV_WORK_STATUS_WORKING,
                'startTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                'orderNo': orderNo,
                'cardOrderNo': cardOrderNo,
                'payType': payType,
                'consumeType': 'card',
            }
        
            finishedTime = None
            if needTime:
                finishedTime = int(time.time()) + (needTime+5) * 60
                # lineInfo['needTime'] = needTime
        
            ServiceProgress.register_card_service(
                self.device,
                port,
                card,
                {
                    'orderNo': orderNo,
                    'coin': VirtualCoin(coins).mongo_amount,
                    'cardOrderNo': cardOrderNo
                },
                finishedTime)
        
            logger.info('port:{} is running, order:{} cardOrder:{}'.format(port, orderNo, cardOrderNo))
            # 更新端口缓存
        Device.update_port_control_cache(self.device.devNo, lineInfo)

    def _do_prepare_online_card_start(self):
        cardType = self.event_data['cardType']
        cardNo = self.event_data['cardNo']
        # card = Card.objects.get(cardNo=cardNo)
        card = self._update_card_dealer_and_type(cardNo,cardType) # type:Card
        balance = card.balance
        port = self.event_data['port']
        self.deviceAdapter._response_F0(cardType,cardNo,port,balance)