manyi/apps/web/eventer/kehang.py

# coding=utf-8
import datetime
import logging

from arrow import Arrow
from django.conf import settings
from typing import TYPE_CHECKING, Iterable

from apilib.monetary import VirtualCoin, RMB
from apps.web.common.models import TempValues
from apps.web.constant import START_DEVICE_STATUS, DEALER_CONSUMPTION_AGG_KIND, Const
from apps.web.core.device_define.kehang import BillingType, REASON_MAP, CARD_STATUS, CARD_OPT
from apps.web.device.models import Device, Group
from apps.web.eventer import EventBuilder
from apps.web.eventer.base import ComNetPayAckEvent, IdStartAckEvent, AckEventProcessorIntf, WorkEvent
from apps.web.user.models import Card, ServiceProgress, CardRechargeOrder, CardRechargeRecord
from apps.web.user.utils import clear_frozen_user_balance
from apps.web.utils import set_start_key_status

if TYPE_CHECKING:
    from apps.web.user.models import ConsumeRecord

logger = logging.getLogger(__name__)


class builder(EventBuilder):

    def __getEvent__(self, device_event):

        if 'order_id' in device_event:
            if device_event["order_type"] == "com_start":
                return MyComNetPayAckEvent(self.deviceAdapter, device_event)
            elif device_event["order_type"] == "id_start":
                return IDPayAckEvent(self.deviceAdapter, device_event)

        event_data = self.deviceAdapter.analyze_event_data(device_event['data'])

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

        if event_data["cmdCode"] in ["22", "11", "12", "16"]:
            return KeHangWorkEvent(self.deviceAdapter, event_data)


class KeHangWorkEvent(WorkEvent):

    def _do_query_card(self):
        logger.info("device <{}> do query id card balance, event = {}".format(self.device.devNo, self.event_data))
        cardNo = self.event_data["cardNo"]
        card = self.update_card_dealer_and_type(cardNo) # type: Card

        # 非法卡 （经销商绑卡会有 openId = any......）
        if not card or not card.openId:
            logger.info("device <{}> receive query card, error card = <{}>".format(self.device.devNo, cardNo))
            return self.deviceAdapter._response_card(int(cardNo), CARD_STATUS.ILLEGAL, float(VirtualCoin(0)), openId="")

        # 冻结卡
        if card.frozen:
            logger.info("device <{}> receive query card, frozen card = <{}>".format(self.device.devNo, cardNo))
            return self.deviceAdapter._response_card(int(cardNo), CARD_STATUS.FROZEN, float(VirtualCoin(card.balance)) * 10, openId=str(card.id))

        # 正常的卡余额回复  不需要管余额是否足够 交由模块判断
        logger.info("device <{}> receive query card success, card = <{}>, balance = <{}>".format(self.device.devNo, cardNo, card.balance))
        return self.deviceAdapter._response_card(int(cardNo), CARD_STATUS.SUCCESS, float(VirtualCoin(card.balance)) * 10, openId=str(card.id))

    def _do_ic_card(self):
        logger.info("device <{}> do card start event, event = {}".format(self.device.devNo, self.event_data))
        cardNo = self.event_data["cardNo"]
        card = self.update_card_dealer_and_type(cardNo, "IC")
        # 卡不存在的地方 直接退出
        if not card:
            return

        # 卡存在的情况下 分为退费 和 扣费两种
        if self.event_data["opt"] == CARD_OPT.DEDUCT:
            orderNo, cardOrderNo = self.record_consume_for_card(card, RMB(self.event_data["cost"]), desc=u"离线卡启动")

            consumeDict = {
                "orderNo": "orderNo",
                "cardOrderNo": cardOrderNo
            }

            ServiceProgress.register_card_service(
                self.device,
                int(self.event_data["port"]),
                card,
                consumeDict
            )

            Device.update_dev_control_cache(self.device.devNo, {str(self.event_data["port"]): {"status": Const.DEV_WORK_STATUS_WORKING}})

        else:
            self.record_refund_money_for_card(RMB(self.event_data["cost"]), str(card.id))
            Device.clear_port_control_cache(self.device.devNo, str(self.event_data["port"]))

    def _do_ic_card_sync_balance(self):
        logger.info("device <{}> do ic card sync balance, event = {}".format(self.device.devNo, self.event_data))
        cardNo = self.event_data["cardNo"]
        cardType = self.event_data["type"]

        card = self.update_card_dealer_and_type(cardNo, "IC")
        if not card:
            logger.info("device <{}> do ic card <{}> sync balance, card not find".format(self.device.devNo, cardNo))
            return

        money, coins, orderNos, cardOrderNos = CardRechargeOrder.get_to_do_list(str(card.id))
        if not orderNos:
            logger.info("device <{}> do ic card <{}> sync balance, charge orders not find".format(self.device.devNo, cardNo))
            return

        # 订单号保存到缓存里
        TempValues.set('%s-%s' % (self.device.devNo, cardNo), value=cardOrderNos)
        asyncMoney = (RMB(self.event_data["balance"]) + RMB(coins)) * 10

        try:
            CardRechargeOrder.update_card_order_has_finished(str(card.id))
        except Exception as e:
            logger.exception('%s' % e)
        else:
            self.deviceAdapter._response_sync_card_balance(cardNo, asyncMoney)

    def _do_ic_card_sync_response(self):
        logger.info("device <{}> do ic card sync balance response, event = {}".format(self.device.devNo, self.event_data))
        cardNo = self.event_data["cardNo"]
        card = self.update_card_dealer_and_type(cardNo, "IC")
        balance = self.event_data["balance"]
        success = self.event_data["success"]

        if not success:
            logger.info("device <{}> do ic card sync balance response not success, event = {}".format(self.device.devNo, self.event_data))
            return

        cardOrderNos = TempValues.get('%s-%s' % (self.device.devNo, cardNo))
        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
            )

        self.update_card_balance(card, RMB(balance))

        TempValues.remove('%s-%s' % (self.device.devNo, cardNo))

    def do(self, **args):
        if self.event_data["cmdCode"] == "22":
            return self._do_query_card()

        if self.event_data["cmdCode"] == "11":
            return self._do_ic_card()

        if self.event_data["cmdCode"] == "12":
            return self._do_ic_card_sync_balance()

        if self.event_data["cmdCode"] == "16":
            return self._do_ic_card_sync_response()


class MyComNetPayAckEvent(ComNetPayAckEvent):

    def do_running_order(self, order, result):      # type: (ConsumeRecord, dict) -> None
        """
        处理运行订单
        :param order: 用户服务器订单
        :param result: device_event 设备侧订单
        :return:
        """
        # 订单消息已经被回复过
        if order.status in ["running", "finished"]:
            logger.debug('order<{}> no need to deal. this has done.'.format(repr(order)))
            return

        # 启动设备的时候 设备实际启动成功 但是订单串口超时 不知道订单的明确状态 后面启动时间又重新上报
        if order.status == "unknown":
            errorDesc = u"设备信号恢复，订单正常运行"
            logger.info("order <{}> timeout  to running")
        # 正常运行的订单
        else:
            errorDesc = u""

        if 'master' in result:
            order.association = {
                'master': result['master']
            }
            order.servicedInfo.update({'masterOrderNo': result['master']})

        order.errorDesc = errorDesc
        order.isNormal = True
        order.status = 'running'
        order.startTime = datetime.datetime.fromtimestamp(result['sts'])
        order.save()

        set_start_key_status(start_key=order.startKey, state=START_DEVICE_STATUS.FINISHED, order_id=str(order.id))

    def do_finished_order(self, order, result):     # type: (ConsumeRecord, dict) -> None
        """
        处理结束运行订单
        :param order: 用户服务器订单
        :param result: device_event 设备侧订单
        :return:
        """
        portCache = Device.get_port_control_cache(self.device.devNo, str(order.used_port))
        self.event_data["portCache"] = portCache
        # 子单归并主单
        if 'sub' in result:
            order.association = {
                'sub': [item['order_id'] for item in self.event_data['sub']]
            }
            order.servicedInfo.update(
                {'subOrderNo': '{}'.format(', '.join([item['order_id'] for item in self.event_data['sub']]))})

        # 主单归并自身
        elif 'master' in result:
            order.association = {
                'master': result['master']
            }
            order.servicedInfo.update({'masterOrderNo': result['master']})

        # 此时理论上服务器订单状态有三种可能（finished在上层已经被排除）
        # 正常的状态 相当于订单由运行状态 即将切换为finished状态
        if order.status == "running":
            order.isNormal = True
            order.status = "finished"
            order.errorDesc = u""
            order.finishedTime = datetime.datetime.fromtimestamp(result['fts'])

        # 非正常状态 相当于订单最开始串口超时 然后直接变为结束
        elif order.status == "unknown":
            order.isNormal = True
            order.status = "finished"
            order.errorDesc = u"设备信号恢复，订单正常结束(0001)"
            order.startTime = datetime.datetime.fromtimestamp(result['sts'])
            order.finishedTime = datetime.datetime.fromtimestamp(result['fts'])

        # 正常状态 相当于订单启动失败或者是中间running单没有上来
        elif order.status == "created":
            order.isNormal = True
            order.status = "finished"
            order.errorDesc = u"设备信号恢复，订单正常结束(0002)"
            order.startTime = datetime.datetime.fromtimestamp(result['sts'])
            order.finishedTime = datetime.datetime.fromtimestamp(result['fts'])

        else:
            logger.warning('order<{}> status = <{}> to finished. no deal with'.format(repr(order), order.status))


        order.save()
        set_start_key_status(start_key=order.startKey, state=START_DEVICE_STATUS.FINISHED, order_id=str(order.id))

    def do_finished_event(self, order, sub_orders, merge_order_info):   # type:(ConsumeRecord, list, dict) -> None
        """
        订单的状态已经完成 进一步事件 扣费等等
        :param order: 处理完毕的订单（主订单）
        :param sub_orders: 子订单
        :param merge_order_info: 合并单的信息
        :return:
        """
        order.reload()

        # 解析event的参数 这个left是转换后的时间
        """
        比如1元240分钟，充电后变为120分钟，一分钟后119，然后，过一会进入下一档，80分钟，这时候如果停止，我会把80分钟转换为230多分钟给你
        """
        left = self.event_data["left"]

        # 获取端口的缓存
        portCache = self.event_data["portCache"]
        need = portCache["needValue"]
        coins = portCache["coins"]
        billingType = portCache["billingType"]

        # need 和 left 单位始终相同 所以不会造成退费金额出错
        backCoins = VirtualCoin(coins) * ((left * 1.0) / need)
        if not self.device.is_auto_refund:
            backCoins = VirtualCoin(0)
        else:
            backCoins = min(VirtualCoin(coins), backCoins)

        # 算电量 算时间
        if billingType == BillingType.TIME:
            duration = need - left
            spendElec = 0
            extra = [
                {u"本次订购时长": "{}分钟".format(need)},
                {u"本次实际使用时长": "{}分钟".format(need-left)},
                {u"消费金额": "{}（金币）".format((VirtualCoin(coins) - VirtualCoin(backCoins)).amount)}
            ]
        else:
            # 电量模式下 时间有可能不太准 考虑断电的情况
            duration = (self.event_data["fts"] - self.event_data["sts"]) / 60
            spendElec = (need - left) / 100.0
            extra = [
                {u"本次订购电量": "{} 度".format(need/100.0)},
                {u"消费金额": "{}（金币）".format((VirtualCoin(coins) - VirtualCoin(backCoins)).amount)}
            ]

        clear_frozen_user_balance(self.device, order, duration, spendElec=spendElec, backCoins=backCoins, user=order.user)

        # 组织消费信息
        consumeDict = {
            "reason": self._get_finish_reason(),
            "billingType": u"时间计费" if billingType == BillingType.TIME else u"电量计费",
            "leftTime": left,
            DEALER_CONSUMPTION_AGG_KIND.DURATION: duration,
            DEALER_CONSUMPTION_AGG_KIND.SPEND_MONEY: (VirtualCoin(coins) - VirtualCoin(backCoins)).mongo_amount,
            DEALER_CONSUMPTION_AGG_KIND.REFUNDED_COINS: str(backCoins)
        }

        spendElec and consumeDict.update({DEALER_CONSUMPTION_AGG_KIND.ELEC: spendElec})
        spendElec and consumeDict.update({DEALER_CONSUMPTION_AGG_KIND.ELECFEE: self.calc_elec_fee(spendElec)})

        order.update_service_info(consumeDict)

        self.notify_user_service_complete(
            service_name='充电',
            openid=order.user.managerialOpenId,
            port=str(order.used_port),
            address=order.address,
            reason=consumeDict["reason"],
            finished_time=order.finishedTime.strftime('%Y-%m-%d %H:%M:%S'),
            extra=extra
        )

    def merge_order(self, master_order, sub_orders):  # type:(ConsumeRecord, list)->dict
        """
        主板暂时不支持续充 如果续充的话 时间不准
        :param master_order:
        :param sub_orders:
        :return:
        """
        start_time = Arrow.fromdatetime(master_order.startTime, tzinfo=settings.TIME_ZONE)

        need = self.event_data["charge_param"]
        billingType = self.event_data.get("billing_type", BillingType.TIME)
        coins = master_order.package["coins"]
        price = master_order.package["price"]

        portCache = {
            "openId": master_order.openId,
            "consumeType": "mobile",
            "needKind": "needTime" if billingType == BillingType.TIME else "needElec",
            "estimatedTs": int(start_time.timestamp + 720 * 60 * 60),
            "needValue": need,
            "billingType": billingType
        }

        for _sub in sub_orders:
            coins += _sub.package["coins"]
            price += _sub.package["price"]

        portCache["coins"] = coins
        portCache["price"] = price

        if billingType == BillingType.TIME:
            master_order.update_service_info({'needTime': need})
        else:
            master_order.update_service_info({'needElec': need})

        return portCache

    def _get_finish_reason(self):
        if "reason" in self.event_data:
            return REASON_MAP.get(self.event_data["reason"], u"未知原因")

        return u"未知原因"


class IDPayProcessor(AckEventProcessorIntf):
    def pre_processing(self, device, event_data):
        event_data["cardNo"] = str(event_data.pop("card", ""))
        event_data["fee"] = event_data["cost"] / 10.0

        if "sub" in event_data and isinstance(event_data["sub"], list):
            new_sub = list()
            for _item in event_data["sub"]:
                _item["cardNo"] = _item.pop("card")
                _item["fee"] = _item["cost"] / 10.0

                new_sub.append(_item)

            event_data["sub"] = new_sub
        return event_data


class IDPayAckEvent(IdStartAckEvent):
    """
    端口
    查询卡
    """
    def __init__(self, smartBox, event_data, pre_processor=None):
        super(IDPayAckEvent, self).__init__(smartBox, event_data, IDPayProcessor())

    def _get_finish_reason(self):
        if "reason" in self.event_data:
            return REASON_MAP.get(self.event_data["reason"], u"未知原因")

        return u"未知原因"

    def post_after_start(self, order=None):
        pass

    def post_after_finish(self, order=None):
        pass

    def checkout_order(self, order):
        fee = VirtualCoin(order.coin)
        self.card.freeze_balance(transaction_id=str(order.id), fee=fee)

    def do_finished_event(self, order, merge_order_info):  # type:(ConsumeRecord, dict)->None
        left = self.event_data["left"]
        billingType = self.event_data["billing_type"]

        if self.device.is_auto_refund:
            backCoins = min(VirtualCoin(self.event_data["refund"]), VirtualCoin(merge_order_info["coins"]))
        else:
            backCoins = VirtualCoin(0)

        consumeCoins = VirtualCoin(merge_order_info["coins"]) - backCoins

        self.card.clear_frozen_balance(str(order.id), backCoins)
        self.card.reload()

        extra = [
            {u"消费金额": "{}（金币）".format(consumeCoins.amount)},
            {u"卡内余额": "{} (金币)".format(self.card.balance.mongo_amount)}
        ]

        consumeDict = {
            'reason': self._get_finish_reason(),
            'chargeIndex': str(order.used_port),
            'cardNo': self.event_data['cardNo'],
            "left": left,
            "billingType": billingType
        }

        if backCoins > VirtualCoin(0):
            self.record_refund_money_for_card(backCoins, str(self.card.id), orderNo=order.orderNo)
            consumeDict.update({
                DEALER_CONSUMPTION_AGG_KIND.REFUNDED_COINS: backCoins.mongo_amount
            })

        order.update_service_info(consumeDict)

        self.notify_user_service_complete(
            service_name='充电',
            openid=self.card.managerialOpenId,
            port=str(order.used_port),
            address=order.address,
            reason=self.event_data.get('reasonDesc'),
            finished_time=order.finishedTime.strftime('%Y-%m-%d %H:%M:%S'),
            extra=extra
        )

    def merge_order(self, master_order, sub_orders):  # type:(ConsumeRecord, Iterable[ConsumeRecord])->dict
        """
        刷卡的退费是由主板决定的 金币以及钱只是为了展示
        """
        start_time = Arrow.fromdatetime(master_order.startTime, tzinfo=settings.TIME_ZONE)

        billingType = self.event_data.get("billing_type", BillingType.TIME)
        coins = master_order.coin
        price = master_order.money

        portCache = {
            "openId": master_order.openId,
            "consumeType": "card",
            "estimatedTs": int(start_time.timestamp + 720 * 60 * 60),
            "billingType": billingType
        }

        for _sub in sub_orders:
            coins += _sub.coin
            price += _sub.money

        portCache["coins"] = str(coins)
        portCache["price"] = str(price)

        return portCache