# -*- coding: utf-8 -*- # !/usr/bin/env python import datetime import json import logging import time from arrow import Arrow from django.conf import settings from mongoengine import DoesNotExist from apilib.monetary import RMB, VirtualCoin, Ratio from apilib.systypes import StrEnum from apilib.utils_datetime import to_datetime from apilib.utils_string import make_title_from_dict from apps.web.agent.models import Agent from apps.web.constant import Const, DEALER_CONSUMPTION_AGG_KIND, APP_TYPE, DeviceCmdCode from apps.web.core.accounting import Accounting from apps.web.core.adapter.base import SmartBox from apps.web.core.adapter.hedong import ChargingHDBox from apps.web.core.device_define.jndz import CMD_CODE, SWIPE_CARD_PARAM_OP, SWIPE_CARD_RES from apps.web.core.exceptions import ServiceException from apps.web.core.networking import MessageSender from apps.web.dealer.models import Dealer from apps.web.device.models import Group, Device, DeviceDict, GroupDict from apps.web.eventer import EventBuilder from apps.web.eventer.base import FaultEvent, WorkEvent, ComNetPayAckEvent, AckEventProcessorIntf, \ IcStartAckEvent, IcRechargeAckEvent, CardRefundAckEvent, IdStartAckEvent, VirtualCardStartAckEvent from apps.web.eventer.errors import InvalidOption, NoCommandHandlerAvailable from apps.web.helpers import get_wechat_auth_bridge from apps.web.report.utils import record_consumption_stats from apps.web.south_intf.platform import notify_event_to_north from apps.web.south_intf.zhejiang_fire import send_event_to_zhejiang from apps.web.south_intf.zhongtian import report_zhongtian_service_complete, report_zhongtian_refund from apps.web.user.models import VCardConsumeRecord, ServiceProgress, CardRechargeOrder, MyUser, \ UserVirtualCard, Card, ConsumeRecord, RechargeRecord from apps.web.api.models import APIStartDeviceRecord from apps.web.user.utils import freeze_user_balance logger = logging.getLogger(__name__) class Cmd: # 刷卡类 SUCCESS_00 = 0 BALANCE_NOT_ENOUGH_01 = 1 INVALID_CARD_02 = 2 class CARD_TYPE(StrEnum): OFFLINE_CARD = "00" ONLINE_CARD = "01" MONTHLY_CARD = "02" FULL_CARD = "04" def is_server_refund(billingType, dev, dealer, agent): # type:(str, DeviceDict, Dealer, Agent)->bool if billingType != 'time': if 'jhCardElecRefund' in dealer.features: return False if dev.is_auto_refund: return True else: return False else: if 'huopo_card_time_refund' in agent.features: return True else: support_server_refund = dev.devType.get('features', {}).get( 'support_server_refund', False) if not support_server_refund: return False if dev.is_auto_refund: return True else: return False 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'] == 'ic_recharge': return MyIcRechargeAckEvent(self.deviceAdapter, device_event) elif device_event['order_type'] == 'ic_start': return MyIcStartAckEvent(self.deviceAdapter, device_event) elif device_event['order_type'] == 'id_start': return MyIdStartAckEvent(self.deviceAdapter, device_event) elif device_event['order_type'] == 'vir_start': return MyVirtualCardStartAckEvent(self.deviceAdapter, device_event) elif device_event['order_type'] == 'card_refund': return MyCardRefundAckEvent(self.deviceAdapter, device_event) else: pass elif 'event_type' in device_event: if device_event['event_type'] == 'card': return CardEvent(self.deviceAdapter, device_event) else: return None event_data = self.deviceAdapter.analyze_event_data(device_event['data']) if event_data is None or 'cmdCode' not in event_data: return None if 'duration' in device_event: event_data.update({'duration': device_event['duration']}) if event_data['cmdCode'] in ['06', '16', '20', '2D', '2C']: return ChargingJNDZWorkEvent(self.deviceAdapter, event_data) if event_data['cmdCode'] in [ CMD_CODE.DEVICE_SUBMIT_DEVICE_FAULT_0A, CMD_CODE.DEVICE_FAULT_TEMPERATURE, CMD_CODE.DEVICE_FAULT_POWER, CMD_CODE.DEVICE_FAULT_SMOKE, CMD_CODE.DEVICE_ELEC, CMD_CODE.DEVICE_FAULT_ALTER ]: return JNDZEventerFailure(self.deviceAdapter, event_data) #if event_data['cmdCode'] == '21': # return ChargingJNDZReportEvent(self.deviceAdapter, event_data) class CardEvent(WorkEvent): def do(self): if not self.deviceAdapter.get_device_configs(): # type:ChargingHDBox.get_device_configs() self.deviceAdapter.get_dev_setting() if self.event_data['funCode'] == '10': self._do_get_balance() def _do_get_balance(self): cardNo = str(int(self.event_data["cardNo"], 16)) logger.info('[_do_get_balance] receive cardNo = {}'.format(cardNo)) card = self.update_card_dealer_and_type(cardNo) if not card or not card.openId or card.frozen: logger.info('[_do_get_balance] receive cardNo = {}, card invalid!'.format(cardNo)) data = { 'funCode': '10', 'cardNo': self.event_data.get('cardNo'), 'result': Cmd.INVALID_CARD_02, 'balance': 0, } else: # 是否存在没有到账的余额 进行充值 card_recharge_order = CardRechargeOrder.get_last_to_do_one(str(card.id)) self.recharge_id_card( card=card, rechargeType='append', order=card_recharge_order ) card.reload() device_configs = self.deviceAdapter.get_device_configs() cst = RMB(device_configs.get('cst', 30) / 10.0) if card.balance >= RMB(0.1): pay = int(min(cst, card.balance) * 10) * 0.1 # 采用向下取整 rule = self.get_account_rule(pay) # 下发对应的额度 data = { 'funCode': '10', 'cardNo': self.event_data.get('cardNo'), 'result': Cmd.SUCCESS_00, 'balance': int(card.balance * 10.0), } data.update(rule) else: data = { 'funCode': '10', 'cardNo': self.event_data.get('cardNo'), 'result': Cmd.BALANCE_NOT_ENOUGH_01, 'balance': 0, } self.send_mqtt(data=data) def send_mqtt(self, data=None, cmd=DeviceCmdCode.OPERATE_DEV_SYNC, otherData=None): ''' 发送mqtt 指令默认210 返回data ''' result = MessageSender.send(self.device, cmd, data) if 'rst' in result and result['rst'] != 0: if result['rst'] == -1: raise ServiceException( {'result': 2, 'description': u'该设备正在玩命找网络,请您稍候再试', 'rst': -1}) elif result['rst'] == 1: raise ServiceException( {'result': 2, 'description': u'该设备忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能', 'rst': 1}) else: if cmd in [DeviceCmdCode.OPERATE_DEV_NO_RESPONSE, DeviceCmdCode.PASSTHROUGH_OPERATE_DEV_NO_RESPONSE]: return return result.get('data', 'ok') def get_account_rule(self, coins): device_configs = self.deviceAdapter.get_device_configs() cardMin = device_configs.get('cardMin', 240) cardElec = device_configs.get('cardElec', 10) # 秒 timeMax = int(coins * 60 * cardMin) # 度 > 瓦 elecMax = int(coins * 0.1 * 3600000 * cardElec) powerMax1 = device_configs.get('powerMax1', 200) power1Ti = device_configs.get('power1Ti', 100) powerMax2 = device_configs.get('powerMax2', 300) power2Ti = device_configs.get('power2Ti', 75) powerMax3 = device_configs.get('powerMax3', 400) power3Ti = device_configs.get('power3Ti', 50) powerMax4 = device_configs.get('powerMax4', 500) power4Ti = device_configs.get('power4Ti', 25) return { 'timeMax': timeMax, 'elecMax': elecMax, 'accountRule': { 'powerStep': [ {'max': powerMax1, 'ratio': power1Ti}, {'max': powerMax2, 'ratio': power2Ti}, {'max': powerMax3, 'ratio': power3Ti}, {'max': powerMax4, 'ratio': power4Ti}, ] } } class JNDZEventerFailure(FaultEvent): def do(self, **args): cmdCode = self.event_data.get('cmdCode') faultType = self.event_data.get(u'fault') desc = self.event_data.get('desc', '') # 保证原有的故障处理逻辑不变 if cmdCode == CMD_CODE.DEVICE_SUBMIT_DEVICE_FAULT_0A: if self.event_data.get('FaultCode') == 1: # 不准确的继电器粘连上报 pass else: super(JNDZEventerFailure, self).do() group = Group.get_group(self.device.groupId) titleList = [ {u'告警名称': faultType}, {u'地址名称': group['groupName']} ] title = make_title_from_dict(titleList) # 接下来的都是整机告警，这个地方需要通知到经销商 # TODO zjl 需要知道 这个告警标志位是否有具体含义 self.notify_dealer( 'device_fault', title = title, device = u' 号设备'.format(self.device.logicalCode), faultType = faultType, notifyTime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'), fault = '' ) # 记录错误故障 self.record( faultCode = cmdCode, description = desc, title = faultType, detail ={'faultType':faultType} ) class ChargingJNDZWorkEvent(WorkEvent): def do(self, **args): devNo = self.device['devNo'] logger.info('JingNengDianZi charging event detected, devNo=%s,curInfo=%s' % (devNo, self.event_data)) cmdCode = self.event_data['cmdCode'] #: 刷卡消费的，分为扣费和退费两种 if cmdCode == CMD_CODE.SWIPE_CARD_10: if self.device.support_reliable: return self.do_id_response_support_reliable(**args) cardNo = self.event_data['cardNo'] preFee = RMB(self.event_data['preFee']) #: 操作符，是充值还是减少 <- (00, 01) oper = self.event_data['oper'] card = self.update_card_dealer_and_type(cardNo) #: 经销商限制ID卡, 如果满足直接return if not card: self.response_use_card(SWIPE_CARD_RES.INVALID_CARD_02, 0) return self.event_data['openId'] = card.openId self.event_data['cardId'] = str(card.id) self.event_data['startTime'] = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') Device.update_dev_control_cache(devNo, self.event_data) #: 首先检查订单，并进行充值 #: 用户首先在手机客户端充值，需要这个时刻刷卡上报事件将充值的订单同步上来 card_recharge_order = CardRechargeOrder.get_last_to_do_one(str(card.id)) result = self.recharge_id_card(card = card, rechargeType = 'append', order = card_recharge_order) card.reload() logger.info('JingNengDianZi cmdNo(10) - cardNo=%s, openId=%s, result=%s, preFee=%s, curinfo=%s' % ( cardNo, card.openId, result, preFee, self.event_data)) # TODO 这个地方为了同时满足劲能电子和霍珀的需求 先使用特性 vCardNeedBind 后续需要统一规则 try: dealer = Dealer.get_dealer(card.dealerId) agent = Agent.objects.get(id = dealer.get('agentId')) features = agent.features except Exception as e: features = list() if 'vCardNeedBind' in features: virtual_card = card.bound_virtual_card else: virtual_card = card.related_virtual_card # 如果虚拟卡已经绑定，需要检查下今天是否可用，如果可用，有限使用虚拟卡 vCardCanUse = False package = {'coins': float(preFee), 'unit': u'分钟', 'time': 180} if virtual_card is not None and card.openId is not None: devObj = Device.objects.get(devNo = devNo) cardMin = devObj.otherConf.get('cardMin', None) if cardMin is not None: package = {'coins': float(preFee), 'unit': u'分钟', 'time': int(cardMin)} vCardCanUse = virtual_card.can_use_today(package) #: 扣费 if oper == SWIPE_CARD_PARAM_OP.DECR_00: if card.openId == '' or card.frozen: res = SWIPE_CARD_RES.INVALID_CARD_02 leftBalance = RMB(0) return self.response_use_card(res, leftBalance) # 如果虚拟卡可用，卡的费用不要扣掉，仅仅做记录，但是虚拟卡的额度需要扣掉 elif vCardCanUse: # 记录卡消费记录以及消费记录 orderNo, cardOrderNo = self.record_consume_for_card(card, money = RMB(0.0), desc = u'使用绑定的虚拟卡') group = Group.get_group(self.device['groupId']) consumeRcd = virtual_card.consume(openId = card.openId, group = group, dev = self.device, package = package, attachParas = {}, nickname = card.cardName) # 记录当前服务的progress.没有上报端口号，所以先用-1标记，表示端口未知。端口等消费的时候会报上来 ServiceProgress.register_card_service(self.device, -1, card, { 'orderNo': orderNo, 'money': self.event_data['preFee'], 'coin': self.event_data['preFee'], 'needTime': 0, 'cardOrderNo': cardOrderNo, 'consumeRcdId': str(consumeRcd.id) }) self.consume_money_for_card(card, money = RMB(0.0)) if consumeRcd is None: # 如果额度没有扣除成功，就用卡 pass else: self.response_use_card(SWIPE_CARD_RES.SUCCESS_00, leftBalance = 0) # 通知微信，已经扣费 # self.notify_balance_has_consume_for_card(card, preFee, desc = u'使用绑定的虚拟卡') return elif result['balance'] < preFee: res = SWIPE_CARD_RES.BALANCE_NOT_ENOUGH_01 leftBalance = result['balance'] return self.response_use_card(res, leftBalance) else: # 记录卡消费记录以及消费记录 orderNo, cardOrderNo = self.record_consume_for_card(card, preFee) # 记录当前服务的progress.没有上报端口号，所以先用-1标记，表示端口未知。端口等消费的时候会报上来 ServiceProgress.register_card_service(self.device, -1, card, { 'orderNo': orderNo, 'money': self.event_data['preFee'], 'coin': self.event_data['preFee'], 'needTime': 0, 'cardOrderNo': cardOrderNo }) res = SWIPE_CARD_RES.SUCCESS_00 leftBalance = result['balance'] self.consume_money_for_card(card, preFee) leftBalance -= preFee self.response_use_card(res, leftBalance) # 通知微信，已经扣费 self.notify_balance_has_consume_for_card(card, preFee) # 退费.卡的退费比较特殊：如果需要按照电量进行扣费退费，需要在设备管理后台，设置成按电量方式计费。然后把卡的余额回收关闭掉。 # 充电结束后，上报事件，然后把钱退到卡里。如果是按照时间计费（霍柏的特殊），完全由设备决定，设备告诉我退费，我就退。针对霍柏 # 绑定虚拟卡的情况下，按照时间退费，需要直接取消掉余额回收，靠结束事件触发结束 elif oper == SWIPE_CARD_PARAM_OP.INCR_01: if virtual_card: logger.debug('virtual card is not do device refund.') return dev = Device.objects.get(devNo = self.device['devNo']) dealer = self.device.owner if not dealer: logger.error('dealer is not found, dealerId=%s' % self.device.ownerId) return agent = Agent.objects(id = dealer.agentId).first() if not agent: logger.error('agent is not found, agentId=%s' % dealer.agentId) return res = SWIPE_CARD_RES.SUCCESS_00 device_refund = False billingType = dev.otherConf.get('billingType', 'time') if is_server_refund(billingType, self.device, dealer, agent): logger.debug('{} in {} has card refund by server refund.'.format(repr(card), repr(self.device))) return logger.debug('{} card refund by {}.'.format(repr(card), repr(self.device))) self.response_use_card(res, card.balance + preFee) self.refund_money_for_card(preFee, str(card.id)) self.notify_user(card.managerialOpenId, 'refund_coins', **{ 'title': u'退币完成！您的卡号是%s,卡别名:%s' % (card.cardNo, card.nickName), 'backCount': u'金币：%s' % preFee, 'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') }) else: raise InvalidOption('oper has be to 00 or 01, %s was given' % (oper,)) #: 结束的命令 elif cmdCode in [CMD_CODE.DEVICE_SUBMIT_CHARGE_FINISHED_06, CMD_CODE.DEVICE_SUBMIT_CHARGE_FINISHED_v2_16]: lineInfo = Device.update_port_control_cache(devNo, self.event_data) group = Group.get_group(self.device['groupId']) dealer = Dealer.objects(id = group['ownerId']).first() if not dealer: logger.error('dealer is not found, dealerId=%s' % group['ownerId']) return agent = Agent.objects(id = dealer.agentId).first() if not agent: logger.error('agent is not found, agentId=%s' % dealer.agentId) return if not lineInfo.has_key('coins'): logger.debug('port cache has no coins. no order in port {}'.format(lineInfo.get('port'))) return if 'duration' in self.event_data and self.event_data['duration'] > 0: usedTime = self.event_data['duration'] else: if (not lineInfo) or (not lineInfo.has_key('startTime')): return startTime = to_datetime(lineInfo['startTime']) nowTime = datetime.datetime.now() if startTime > nowTime: # 如果web服务器时间和事件监控服务器时间不一致，导致开始时间比事件时间还大 usedTime = 0 else: usedTime = int(round(((nowTime - startTime).total_seconds() / 60.0))) cardId = lineInfo.get('cardId', '') vCardId = lineInfo.get('vCardId', None) money = VirtualCoin(lineInfo['coins']) backCoins = VirtualCoin(0.0) price = RMB(lineInfo.get('price', 0.0)) refundRMB = RMB('0.0') leftTime = self.event_data['leftTime'] billingType = lineInfo.get('billingType', 'time') consumeType = lineInfo.get('consumeType', '') refundProtectionTime = lineInfo.get('refundProtectionTime', 5) isTempPackage = lineInfo.get('isTempPackage', False) needTime = 0 leftTimeStr = '' try: #: 刷卡或者万一缓存重启了，出现needElec为空的,作为1000度电吧，就会一定使用设备上报的电量 if lineInfo.get('elec', 0.0) < lineInfo.get('needElec', 0.0): spendElec = round(lineInfo['needElec'] - lineInfo['elec'], 2) backCoins_by_elec = round(self.event_data.get('elec',0) / lineInfo['needElec'] * float(money), 2) else: spendElec = 0.0 backCoins_by_elec = money if leftTime == 65535: actualNeedTime = 0 backCoins = money refundRMB = price usedTime = 0 spendElec = 0.0 else: actualNeedTime = usedTime + leftTime leftTimeStr = leftTime if 'alt_tech_refund_mode' in agent.features and billingType == 'time': needTime = lineInfo['needTime'] # 剩余时间不满 60 按照 0 算, 不满 120 按照 60 算... calcleftTime = (int(leftTime) // 60) * 60 backCoins = money * (float(calcleftTime) / float(actualNeedTime)) else: # TODO 整改退费 哪个时间电量取小的 needTime = lineInfo['needTime'] backCoins = money * (float(leftTime) / float(actualNeedTime)) # elif billingType == 'time': # needTime = lineInfo['needTime'] # backCoins = money * (float(leftTime) / float(actualNeedTime)) # else: # needElec, elec = Decimal(lineInfo.get('needElec', 1000)), Decimal(str(lineInfo.get('elec'))) # ratio = (needElec - elec) / needElec # backCoins = VirtualCoin(money.amount - money.amount * ratio) backCoins = VirtualCoin(min(float(backCoins), float(backCoins_by_elec))) isRefundProtection = False if usedTime < refundProtectionTime: backCoins = money isRefundProtection = True if backCoins > money: backCoins = money refundRMB = price * (float(backCoins) / float(money)) logger.debug( 'refund money is： {}； refund rmb is: {}'.format(str(backCoins.amount), str(refundRMB.amount))) #: 扫码的方式 if cardId == '' and vCardId is None and consumeType != 'coin': logger.info('finished with netPay') #: 这里需要考虑API调用的和普通使用场景 if 'extOrderNo' in lineInfo: record = APIStartDeviceRecord.get_api_record(self.device['logicalCode'], lineInfo['extOrderNo']) if not record: logger.debug('cannot find api start device record') return if record.postActionTriggered: logger.debug('api({}) post action has done.'.format(lineInfo['extOrderNo'])) return # 中天的结束状态匹配 reasonCode = self.event_data['reasonCode'] if reasonCode == '0B': reasonCode = '03' elif reasonCode == '03': reasonCode = '04' else: pass # 中天空载需要这样写 if leftTime == 65535: leftTime = lineInfo['needTime'] report_zhongtian_service_complete( event_code = '16', record = record, orderNo = lineInfo['extOrderNo'], deviceCode = self.device['logicalCode'], groupName = group['groupName'], address = group['address'], actualNeedTime = lineInfo['needTime'], leftTime = leftTime, finishedState = reasonCode ) record.update(servicedInfo = {'spendElec': str(spendElec), 'backCoins': '0'}) if self.device.is_auto_refund: coins = VirtualCoin(lineInfo['coins']) money = RMB(lineInfo['price']) backCoins = self.get_backCoins(coins = coins, leftTime = leftTime, actualNeedTime = lineInfo['needTime']) backMoney = self.get_backMoney(money = money, leftTime = leftTime, actualNeedTime = lineInfo['needTime']) report_zhongtian_refund( eventCode = '16', record = record, orderNo = lineInfo['extOrderNo'], deviceCode = self.device['logicalCode'], groupName = group['groupName'], address = group['address'], backMoney = str(backMoney), backCoins = str(backCoins), actualNeedTime = lineInfo['needTime'], leftTime = leftTime, finishedState = reasonCode ) record.update(servicedInfo = {'spendElec': str(spendElec), 'backCoins': str(backCoins)}) else: openId = lineInfo['openId'] user = MyUser.objects(openId = openId, groupId = self.device['groupId']).first() leftTimeStr = leftTime if leftTime != 65535 else u'空载' # todo 生成模板所需要的所有参数, 后续有客户自定义的话, 直接在这个字典里面添加, 不需要删掉之前的. # todo 这个变量仅仅用于下面generate_service_complete_title_by_devType()函数的参. 做成配置项更好, 下次不用改代码. templateMap = { 'reason': self.event_data['reason'], 'logicalCode': self.device['logicalCode'], 'port': self.event_data['port'], 'address': group['address'], 'actualNeedTime': actualNeedTime, 'leftTimeStr': leftTimeStr } # 先去获取devType上面的模板, 如果没有就走正常的流程 title = self.generate_service_complete_title_by_devType(self.device['devType']['id'], templateMap) if title == '': billingType = lineInfo.get('billingType', 'time') if billingType == 'time': title = u'\\n\\n结束原因：\\t\\t{reason}\\n\\n设备编号：\\t\\t{logicalCode}-{port}\\n\\n设备地址：\\t\\t{address}\\n\\n消费时间：\\t\\t动态功率计算{actualNeedTime}分钟\\n\\n剩余时间：\\t\\t{leftTimeStr}分钟'.format( reason = self.event_data['reason'], logicalCode = self.device['logicalCode'], port = self.event_data['port'], address = group['address'], actualNeedTime = actualNeedTime, leftTimeStr = leftTimeStr ) else: title = u'\\n\\n结束原因：\\t\\t{reason}\\n\\n设备编号：\\t\\t{logicalCode}-{port}\\n\\n设备地址：\\t\\t{address}\\n\\n购买电量：\\t\\t{needElec}\\n\\n消耗电量：\\t\\t{spendElec}'.format( reason = self.event_data['reason'], logicalCode = self.device['logicalCode'], port = self.event_data['port'], address = group['address'], needElec = lineInfo.get('needElec', 1000), spendElec = spendElec) self.notify_user( managerialOpenId = user.managerialOpenId if user else '', templateName = 'service_complete', title = title, service = u'充电服务', finishTime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'), remark = u'谢谢您的支持') consumeDict = { 'chargeIndex': lineInfo['port'], 'reason': lineInfo['reason'], 'actualNeedTime': u'动态功率计算为%s分钟' % actualNeedTime, 'duration': usedTime } if billingType == 'time': leftTimeStr = leftTime if leftTime != 65535 else lineInfo['needTime'] consumeDict.update( {'leftTime': leftTimeStr, 'needTime': u'扫码订购%s分钟' % lineInfo['needTime']}) consumeDict.update({'elec': spendElec}) else: consumeDict.update({'needElec': lineInfo['needElec']}) consumeDict.update({'elec': spendElec}) consumeDict.update({'elecFee': self.calc_elec_fee(spendElec)}) need_refund = False if not group.get('isFree', False): if isTempPackage is True: if isRefundProtection is True: need_refund = True else: pass elif self.device.is_auto_refund: need_refund = True elif isRefundProtection is True: need_refund = True else: pass if self.event_data['elec'] == 0 or self.event_data['leftTime'] == 0: need_refund = False else: pass if not need_refund: ServiceProgress.update_progress_and_consume_rcd( self.device['ownerId'], { 'open_id': openId, 'device_imei': self.device['devNo'], 'port': lineInfo['port'], 'isFinished': False }, consumeDict ) else: if isTempPackage: self.refund_net_pay(user, lineInfo, refundRMB, VirtualCoin(0), consumeDict, True) else: self.refund_net_pay(user, lineInfo, refundRMB, backCoins, consumeDict, ('refundRMB_device_event' in dealer.features)) ServiceProgress.update_progress_and_consume_rcd( self.device['ownerId'], { 'open_id': openId, 'device_imei': self.device['devNo'], 'port': lineInfo['port'], 'isFinished': False }, consumeDict) if DEALER_CONSUMPTION_AGG_KIND.REFUNDED_COINS in consumeDict: self.notify_user(user.managerialOpenId if user else '', 'refund_coins', **{ 'title': u'充电已经完成', 'backCount': u'%s(金币)' % str(consumeDict[DEALER_CONSUMPTION_AGG_KIND.REFUNDED_COINS]), 'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') }) elif DEALER_CONSUMPTION_AGG_KIND.REFUNDED_CASH in consumeDict: self.notify_user(user.managerialOpenId if user else '', 'refund_coins', **{ 'title': u'充电已经完成', 'backCount': u'%s(元)' % str(consumeDict[DEALER_CONSUMPTION_AGG_KIND.REFUNDED_CASH]), 'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') }) elif vCardId is not None: # 使用的是虚拟卡 logger.info('finished with vCard!') billingType = lineInfo.get('billingType', 'time') if billingType == 'time': leftTimeStr = leftTime if leftTime != 65535 else lineInfo['needTime'] title = u'\\n\\n结束原因：\\t\\t{reason}\\n\\n设备编号：\\t\\t{logicalCode}-{port}\\n\\n设备地址：\\t\\t{address}\\n\\n消费时间：\\t\\t动态功率计算{actualNeedTime}分钟\\n\\n剩余时间：\\t\\t{leftTimeStr}分钟'.format( reason = self.event_data['reason'], logicalCode = self.device['logicalCode'], port = self.event_data['port'], address = group['address'], actualNeedTime = actualNeedTime, leftTimeStr = leftTimeStr ) else: title = u'\\n\\n结束原因：\\t\\t{reason}\\n\\n设备编号：\\t\\t{logicalCode}-{port}\\n\\n设备地址：\\t\\t{address}\\n\\n购买电量：\\t\\t{needElec}\\n\\n消耗电量：\\t\\t{spendElec}'.format( reason = self.event_data['reason'], logicalCode = self.device['logicalCode'], port = self.event_data['port'], address = group['address'], needElec = lineInfo.get('needElec', 1000), spendElec = spendElec ) # 通知充电完成 try: vCard = UserVirtualCard.objects.get(id = vCardId) except DoesNotExist: logger.info('can not find the vCard id = %s' % vCardId) return self.notify_user( managerialOpenId = self.get_managerialOpenId_by_openId(lineInfo['openId']), templateName = 'service_complete', title = title, service = u'充电服务', finishTime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'), remark = u'谢谢您的支持' ) consumeDict = {'chargeIndex': lineInfo['port'], 'reason': lineInfo['reason'], 'actualNeedTime': u'动态功率计算为%s分钟' % actualNeedTime, 'duration': usedTime} consumeDict.update({'elec': spendElec}) if billingType != 'time': consumeDict.update({'elec': spendElec}) consumeDict.update({'elecFee': self.calc_elec_fee(spendElec)}) ServiceProgress.update_progress_and_consume_rcd( self.device['ownerId'], {'open_id': lineInfo['openId'], 'device_imei': self.device['devNo'], 'port': lineInfo['port'], 'isFinished': False}, consumeDict ) consumeRcdId = lineInfo.get('consumeRcdId', None) if consumeRcdId is None: logger.info('can not find consume rcd id') return # 尝试进行虚拟卡退费 try: vCardConsumeRcd = VCardConsumeRecord.objects.get(id = consumeRcdId) except DoesNotExist, e: logger.info('can not find the consume rcd id = %s' % consumeRcdId) else: vCard.refund_quota(vCardConsumeRcd, usedTime, spendElec, backCoins.mongo_amount) elif cardId != '': # 刷的实体卡 logger.info('finished with card') card = Card.objects.get(id = cardId) virtual_card = card.bound_virtual_card # type: UserVirtualCard if billingType == 'time': logger.info('billingType is time.') self.notify_user( managerialOpenId = card.managerialOpenId, templateName = 'service_complete', title = u'\\n\\n结束原因：\\t\\t{reason}\\n\\n设备编号：\\t\\t{logicalCode}-{port}\\n\\n设备地址：\\t\\t{address}\\n\\n消费卡号：\\t\\t{cardNo}\\n\\n持卡姓名：\\t\\t{cardName}\\n\\n消费时间：\\t\\t动态功率计算{actualNeedTime}分钟\\n\\n剩余时间：\\t\\t{leftTimeStr}分钟'.format( reason = self.event_data['reason'], logicalCode = self.device['logicalCode'], port = self.event_data['port'], address = group['address'], cardNo = card.cardNo, cardName = card.cardName, actualNeedTime = actualNeedTime, leftTimeStr = leftTimeStr ), service = u'充电服务', finishTime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'), remark = u'谢谢您的支持') consumeDict = { 'chargeIndex': lineInfo['port'], 'leftTime': leftTimeStr, 'needTime': u'刷卡订购%s分钟' % needTime if virtual_card is None else u'绑定虚拟卡订购%s分钟' % needTime, 'reason': lineInfo['reason'], 'duration': usedTime, 'actualNeedTime': u'动态功率计算为%s分钟' % actualNeedTime, 'elec': spendElec, 'elecFee': self.calc_elec_fee(spendElec) } if virtual_card: self.refund_virtual_card(backCoins, cardId, consumeDict, lineInfo, spendElec, usedTime, virtual_card) elif is_server_refund(billingType, self.device, dealer, agent): logger.info( 'ready to server refund money <{}> for user card <{}> in device<{}>'.format( backCoins, str(card.id), self.device.devNo)) consumeDict.update({DEALER_CONSUMPTION_AGG_KIND.REFUND_CARD: backCoins.mongo_amount}) ServiceProgress.update_progress_and_consume_rcd( self.device['ownerId'], { 'cardId': cardId, 'device_imei': self.device['devNo'], 'port': lineInfo['port'], 'isFinished': False }, consumeDict) self.refund_money_for_card(backCoins, str(card.id)) desc = u'您使用的%s号端口充电，共付款:%s元，充电预定时间为:%s分钟，使用:%s分钟,给您退款:%s元' % ( lineInfo['port'], money, actualNeedTime, usedTime, backCoins) self.notify_user(card.managerialOpenId if card else '', 'refund_coins', **{ 'title': desc, 'backCount': u'金币：%s' % backCoins, 'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}) else: ServiceProgress.update_progress_and_consume_rcd( self.device['ownerId'], { 'cardId': cardId, 'device_imei': self.device['devNo'], 'port': lineInfo['port'], 'isFinished': False }, consumeDict) else: logger.info('billingType is elec') self.notify_user( managerialOpenId = card.managerialOpenId, templateName = 'service_complete', title = u'\\n\\n结束原因：\\t\\t{reason}\\n\\n设备编号：\\t\\t{logicalCode}-{port}\\n\\n设备地址：\\t\\t{address}\\n\\n消费卡号：\\t\\t{cardNo}\\n\\n持卡姓名：\\t\\t{cardName}\\n\\n购买电量：\\t\\t{needElec}\\n\\n消耗电量：\\t\\t{spendElec}'.format( reason = self.event_data['reason'], logicalCode = self.device['logicalCode'], port = self.event_data['port'], address = group['address'], cardNo = card.cardNo, cardName = card.cardName, needElec = lineInfo.get('needElec'), spendElec = spendElec ), service = u'充电服务', finishTime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'), remark = u'谢谢您的支持') consumeDict = { 'chargeIndex': lineInfo['port'], 'leftTime': leftTimeStr, 'reason': lineInfo['reason'], 'elec': spendElec, 'elecFee': self.calc_elec_fee(spendElec), 'duration': usedTime, 'needElec': lineInfo['needElec'] } if virtual_card: self.refund_virtual_card(backCoins, cardId, consumeDict, lineInfo, spendElec, usedTime, virtual_card) elif is_server_refund(billingType, self.device, dealer, agent): logger.info( 'ready to server refund money <{}> for user card <{}> in device<{}>'.format( backCoins, str(card.id), self.device.devNo)) self.refund_money_for_card(backCoins, str(card.id)) consumeDict.update({DEALER_CONSUMPTION_AGG_KIND.REFUND_CARD: backCoins.mongo_amount}) desc = u'您使用的%s号端口充电，共付款:%s元，充电预定电量为:%s度，使用:%s度,给您退款:%s元' % ( lineInfo['port'], money, lineInfo.get('needElec', 0.0), spendElec, backCoins) self.notify_user(card.managerialOpenId if card else '', 'refund_coins', **{ 'title': desc, 'backCount': u'金币：%s' % backCoins, 'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') }) else: logger.info('device not open refund switch') ServiceProgress.update_progress_and_consume_rcd( self.device['ownerId'], {'cardId': cardId, 'device_imei': self.device['devNo'], 'port': lineInfo['port'], 'isFinished': False}, consumeDict ) elif consumeType == 'coin': #: 消费类型为金币，则 logger.info('finished with coin') CoinConsumeRcd = ConsumeRecord.objects.get(orderNo = lineInfo['consumeOrderNo']) # type: ConsumeRecord CoinConsumeRcd.servicedInfo['elec'] = spendElec CoinConsumeRcd.servicedInfo['actualNeedTime'] = u'动态功率计算为%s分钟' % actualNeedTime CoinConsumeRcd.servicedInfo['needTime'] = u'投币订购%s分钟' % needTime CoinConsumeRcd.servicedInfo['reason'] = lineInfo['reason'] CoinConsumeRcd.servicedInfo['chargeIndex'] = lineInfo['port'] CoinConsumeRcd.finishedTime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') CoinConsumeRcd.save() valueDict = {'duration': usedTime} valueDict = { DEALER_CONSUMPTION_AGG_KIND.ELEC: spendElec, DEALER_CONSUMPTION_AGG_KIND.ELECFEE: self.calc_elec_fee(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,)) except Exception as e: logger.exception('deal with jingneng devNo=%s event e=%s' % (devNo, e)) finally: Device.clear_port_control_cache(devNo, str(self.event_data['port'])) dataDict = {'backMoney': str(refundRMB.mongo_amount), 'backCoins': str(backCoins.mongo_amount)} if lineInfo.has_key('orderNo'): dataDict.update({'orderNo': lineInfo['orderNo']}) notify_event_to_north(self.dealer, self.device, level = Const.EVENT_NORMAL, desc = self.event_data['reason'], dataDict = dataDict) send_event_to_zhejiang(self.dealer, self.device, self.event_data) #: 启动了端口,主要记录下投币数据 elif cmdCode == CMD_CODE.DEVICE_SUBMIT_OFFLINE_COINS_20: consumeType = self.event_data['consumeType'] if consumeType == 'coin': self.event_data.update({'startTime': datetime.datetime.now().strftime(Const.DATETIME_FMT)}) # 记录该端口累计需要的时间和钱,cardId Device.update_port_control_cache(self.device['devNo'], self.event_data) Accounting.recordOfflineCoin(self.device, int(time.time()), int(self.event_data['coins'])) self.event_data.update({'needElec': self.event_data['elec']}) self.event_data.update({'consumeOrderNo': self.record_consume_for_coin(RMB(self.event_data['coins']))}) Device.update_port_control_cache(self.device['devNo'], self.event_data) elif consumeType == 'card': port = self.event_data['port'] consumeDict = {'chargeIndex': port, 'elec': self.event_data['elec'], 'money': self.event_data['coins'], 'needTime': u'刷卡订购%s分钟' % self.event_data['needTime']} queryDict = {'device_imei': self.device['devNo'], 'port': -1, 'isFinished': False, 'cardId': {'$ne': ''}, 'start_time': {'$gte': int(time.time()) - 3600}} progressDict = {'port': port} ServiceProgress.update_progress_and_consume_rcd(ownerId = self.device['ownerId'], queryDict = queryDict, consumeDict = consumeDict, updateConsume = True, progressDict = progressDict) # 找出对应的卡的ID记录到端口内存数据 queryDict.update(progressDict) rcds = ServiceProgress.get_collection().find(queryDict, {'cardId': 1, 'open_id': 1, 'consumeOrder': 1}, sort = [('start_time', -1)]) if rcds.count() == 0: return rcd = rcds[0] dev = Device.objects.get(devNo = self.device['devNo']) billingType = dev.otherConf.get('billingType', 'time') # 刷卡虚拟卡启动的时候，将consumeRcd 写入到缓存 退费的时候使用 consumeRcdId = rcd.get('consumeOrder', dict()).get('consumeRcdId') if consumeRcdId: self.event_data.update({'consumeRcdId': consumeRcdId}) self.event_data.update({'billingType': billingType}) self.event_data.update({'cardId': rcd['cardId']}) self.event_data.update({'openId': rcd['open_id']}) cInfo = Device.get_dev_control_cache(devNo) lastPortInfo = cInfo.get(str(port), {}) # 钱需要累计 lastCoins = lastPortInfo.get('coins', 0.0) self.event_data.update({'coins': self.event_data['coins'] + lastCoins}) # 电量需要累加 lastNeedElec = lastPortInfo.get('needElec', 0.0) self.event_data.update({'needElec': self.event_data['elec'] + lastNeedElec}) # 时间需要累加 lastNeedTime = lastPortInfo.get('needTime', 0.0) self.event_data.update({'needTime': self.event_data['needTime'] + lastNeedTime}) self.event_data.update({'startTime': datetime.datetime.now().strftime(Const.DATETIME_FMT)}) self.event_data.update({'isStart': True, 'status': Const.DEV_WORK_STATUS_WORKING}) #: 记录该端口累计需要的时间和钱,cardId Device.update_port_control_cache(self.device['devNo'], self.event_data) elif consumeType == 'server': port = self.event_data['port'] #: 记录该端口累计需要的时间和钱 Device.update_port_control_cache(self.device['devNo'], self.event_data) consumeDict = {'chargeIndex': self.event_data['port'], 'elec': self.event_data['elec'], 'needTime': u'订购%s分钟' % self.event_data['needTime']} queryDict = {'device_imei': self.device['devNo'], 'port': port, 'isFinished': False, 'start_time': {'$gte': int(time.time()) - 3600}} progressDict = {'port': self.event_data['port']} ServiceProgress.update_progress_and_consume_rcd(ownerId = self.device['ownerId'], queryDict = queryDict, consumeDict = consumeDict, updateConsume = True, progressDict = progressDict) # todo 功率过低告警还没做完 # openId = self.curDevInfo['openId'] # if openId is not None: # user = MyUser.objects(openId=openId, groupId = self.device['groupId']).first() # # report_to_user_low_power_wechat.delay(self.notify_low_power_to_user(user, 1, 20), 15) elif cmdCode == '2D': self._do_charge_consume() elif cmdCode == '2C': self._do_coin_finished() else: raise NoCommandHandlerAvailable( '[JNDZ]] no command handler for cmd %s, curDevInfo=%s' % (cmdCode, self.event_data)) def _do_charge_consume(self): if self.event_data.get("result", '00') == '00': logger.info("receive failure card charge data <{}>".format(self.event_data.get("sourceData", ''))) return # 回复主板是正常的2D指令 sessionId = self.event_data.get("sessionId") self.deviceAdapter._response_to_2D("{:0>10}".format(sessionId)) # 判断是否这个 sessionId 是否已经被执行 判断方式是该端口中是否有这个 sessionId portStr = self.event_data.get("portStr") if not portStr: logger.info("receive card charge data <{}> without port !".format(self.event_data.get("sourceData", ''))) return portCache = Device.get_dev_control_cache(self.device.devNo).get(portStr, dict()) if portCache.get("status", Const.DEV_WORK_STATUS_WORKING) == Const.DEV_WORK_STATUS_WORKING and portCache.get( "sessionId") == sessionId: logger.info( "receive card charge data <{}> has been handle, <{}>!".format(self.event_data.get("sourceData", ''), sessionId)) return # 接下来判断上传成功启动的类别 由硬币/卡类型决定 chargeType = self.event_data.get("chargeType") if chargeType == "00": self._charge_with_coin() elif chargeType == "01": self._charge_with_card() elif chargeType == "02": self._charge_with_remote() else: logger.info("card recharge type <{}> undefined! <{}>".format(chargeType, self.event_data.get("sourceData"))) def refund_virtual_card(self, backCoins, cardId, consumeDict, lineInfo, spendElec, usedTime, virtual_card): logger.debug('server refund for virtual card<{}> in device<{}>'.format( str(virtual_card.id), self.device.devNo)) ServiceProgress.update_progress_and_consume_rcd( self.device['ownerId'], { 'cardId': cardId, 'device_imei': self.device['devNo'], 'port': lineInfo['port'], 'isFinished': False }, consumeDict) consumeRcdId = lineInfo.get('consumeRcdId', None) # 不是虚拟卡启动的直接结束掉 if consumeRcdId: # 尝试进行虚拟卡退费 try: vCardConsumeRcd = VCardConsumeRecord.objects.get(id = consumeRcdId) except DoesNotExist, e: logger.info('can not find the consume rcd id = %s' % consumeRcdId) else: virtual_card.refund_quota(vCardConsumeRcd, usedTime, spendElec, backCoins.mongo_amount) else: logger.info('can not find consume rcd id') def response_use_card(self, res, leftBalance): # 启动失败需要把金币还回去 try: self.deviceAdapter.response_use_card(res, leftBalance) except ServiceException as e: logger.exception(e) def do_id_response_support_reliable(self, **args): # TODO 预扣请求和余额回收,此处进行验证,通过则下发可以开启设备 cardNo = self.event_data['cardNo'] cardHex = self.event_data['sourceData'][8:16] fee = self.event_data['preFee'] oper = self.event_data['oper'] logger.info('Check card can be used cardNo={} ,cardHex={} fee={} oper={}'.format(cardNo, cardHex, fee, oper)) # 进来的时候检查过卡是否存在这里校验卡的合法型 card = self.update_card_dealer_and_type(cardNo) if not card or not card.openId or card.frozen: self.deviceAdapter.response_card(2, 0, fee, oper, cardHex) return # 2.检查卡片充值订单是否存在 card_recharge_order = CardRechargeOrder.get_last_to_do_one(str(card.id)) result = self.recharge_id_card(card=card, rechargeType='append', order=card_recharge_order) card.reload() logger.info('JingNengDianZi cmdNo(10) - cardNo=%s, openId=%s, result=%s, preFee=%s, curinfo=%s' % ( cardNo, card.openId, result, fee, self.event_data)) virtual_card = self._get_virtual_card_by_card(card) # 3.检查当前操作为是否为扣费还是余额回收(00:扣费,01:充值) if oper == SWIPE_CARD_PARAM_OP.DECR_00: # 先检查虚拟卡是否能使用 leftCount = self._check_virtual_card_can_use_today(virtual_card, fee) if leftCount: return self.deviceAdapter.response_card(0, leftCount, fee, oper, cardHex, isVir=True , virtual_card_id=str(virtual_card.id)) # 校验实体卡能否使用 elif self._check_card_balance_can_use_today(card, fee): return self.deviceAdapter.response_card(0, card.balance, fee, oper, cardHex) else: return self.deviceAdapter.response_card(1, card.balance, fee, oper, cardHex) elif oper == SWIPE_CARD_PARAM_OP.INCR_01: if virtual_card: logger.debug('virtual card is not do device refund...') return dev = Device.objects.get(devNo=self.device['devNo']) dealer = self.device.owner if not dealer: logger.error('dealer is not found, dealerId=%s' % self.device.ownerId) return agent = Agent.objects(id=dealer.agentId).first() if not agent: logger.error('agent is not found, agentId=%s' % dealer.agentId) return res = SWIPE_CARD_RES.SUCCESS_00 billingType = dev.otherConf.get('billingType', 'time') if is_server_refund(billingType, self.device, dealer, agent): logger.debug('{} in {} has card refund by server refund.'.format(repr(card), repr(self.device))) return logger.debug('{} card refund by {}.'.format(repr(card), repr(self.device))) self.response_use_card(res, card.balance.mongo_amount + fee) self.refund_money_for_card(fee, str(card.id)) self.notify_user(card.managerialOpenId, 'refund_coins', **{ 'title': u'退币完成！！！您的卡号是%s,卡别名:%s' % (card.cardNo, card.nickName), 'backCount': u'金币：%s' % fee, 'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') }) def _get_virtual_card_by_card(self, card): if not card.openId or float(card.balance) != 0: return try: dealer = self.device.owner agent = Agent.objects.get(id=dealer.agentId) features = agent.features except Exception as e: features = [] return card.bound_virtual_card if 'vCardNeedBind' in features else card.related_virtual_card def _check_virtual_card_can_use_today(self, virtual_card, fee): # 如果虚拟卡已经绑定，需要检查下今天是否可用，如果可用，有限使用虚拟卡 if virtual_card: unit = self.device['washConfig'].get('1', {}).get('unit','分钟') if unit == '分钟': cardMin = self.device['otherConf'].get('cardMin', 180) package = {'coins': float(fee), 'unit': unit, 'time': int(cardMin)} elif unit == '度': cardMin = self.device['otherConf'].get('cardMin', 180) package = {'coins': float(fee), 'unit': unit, 'time': int(cardMin)} else: return 0 if virtual_card.can_use_today(package): dayKey = datetime.datetime.now().strftime('%Y-%m-%d') leftDayQuota = virtual_card.calc_left_day_quota(dayKey) left_count = virtual_card.find_match_unit_and_can_use_count(leftDayQuota, package) return left_count def _check_card_balance_can_use_today(self, card, fee): if float(card.balance) >= fee: return True else: return False def _charge_with_card(self): """ 充值卡 的充值 :return: """ cardType = self.event_data.get("cardType") if cardType == CARD_TYPE.OFFLINE_CARD: self._charge_with_offline_card() elif cardType == CARD_TYPE.ONLINE_CARD: self._charge_with_online_card() elif cardType == CARD_TYPE.MONTHLY_CARD: self._charge_with_monthly_card() elif cardType == CARD_TYPE.FULL_CARD: self._charge_with_full_card() else: logger.info( "card recharge card type <{}> undefined! <{}>".format(cardType, self.event_data.get("sourceData"))) def _charge_with_coin(self): """ 投币的上报 :return: """ port = self.event_data.get('portStr') ctrInfo = Device.get_dev_control_cache(self.device.devNo) lineInfo = ctrInfo.get(port, {}) if lineInfo.get('status', 0) == Const.DEV_WORK_STATUS_WORKING and lineInfo.get('consumeType') == 'coin': #续充 lineInfo['coins'] += self.event_data.get('coins', 0) lineInfo['needTime'] += self.event_data.get('time', 0) lineInfo['needElec'] += self.event_data.get('elec', 0) if 'sub_orderNo' in lineInfo: lineInfo['sub_orderNo'].append( self.record_consume_for_coin(RMB(self.event_data['coins']))) else: lineInfo['sub_orderNo'] = [self.record_consume_for_coin(RMB(self.event_data['coins'])),] else: lineInfo = { 'startTime': datetime.datetime.now().strftime(Const.DATETIME_FMT), 'port': port, 'coins': self.event_data.get('coins', 0), 'needTime': self.event_data.get('time', 0), 'needElec': self.event_data.get('elec', 0), 'consumeOrderNo': self.record_consume_for_coin(RMB(self.event_data['coins'])), 'consumeType': 'coin', 'isStart': True, 'status': Const.DEV_WORK_STATUS_WORKING, 'sessionId': self.event_data.get('sessionId'), } # 记录该端口累计需要的时间和钱,cardId Device.update_port_control_cache(self.device['devNo'], lineInfo) Accounting.recordOfflineCoin(self.device, int(time.time()), int(self.event_data.get('coins', 0))) def _charge_with_remote(self): logger.info("not supper charge type! {}".format(self.event_data)) def _charge_with_online_card(self): """ 在线卡启动充值 :return: """ portStr = self.event_data.get("portStr") needElec = self.event_data.get("elec", 0) cardNo = self.event_data.get("cardNo") cardCst = self.event_data.get("cardCst") card = self.update_card_dealer_and_type(cardNo) if not card or not card.openId or card.frozen: logger.warning("error card, cardNo is {}".format(cardNo)) return res, cardBalance = self.consume_money_for_card(card, RMB(cardCst)) if res != 1: logger.warning("consume error!!!, cardNo is {}".format(cardNo)) return consumeDict = { "chargeIndex": portStr, "needElec": needElec } orderNo, cardOrderNo = self.record_consume_for_card(card, RMB(cardCst), servicedInfo=consumeDict) portCache = { "isStart": True, "status": Const.DEV_WORK_STATUS_WORKING, "openId": card.openId, "price": cardCst, "coins": cardCst, "needElec": needElec, "startTime": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "startTimeStamp": int(time.time()), "consumeType": "card", } Device.update_dev_control_cache(self.device.devNo, {portStr: portCache}) ServiceProgress.register_card_service( self.device, int(portStr), card, consumeOrder={ "orderNo": orderNo, "cardOrderNo": cardOrderNo, } ) def _charge_with_offline_card(self): """ 离线卡启动充值 :return: """ pass def _charge_with_monthly_card(self): """ 包月在线卡启动 :return: """ logger.info("not supper card charge type! {}".format(self.event_data)) def _charge_with_full_card(self): """ 充满自停卡 :return: """ logger.info("not supper card charge type! {}".format(self.event_data)) def _do_coin_finished(self): port = str(self.event_data.get('port')) ctrInfo = Device.get_dev_control_cache(self.device.devNo) lineInfo = ctrInfo.get(port, {}) now = datetime.datetime.now() if lineInfo and lineInfo.get('consumeType') == 'coin': # 只处理投币结束 if 'consumeOrderNo' in lineInfo: order = ConsumeRecord.objects.filter(orderNo=lineInfo['consumeOrderNo']).first() if 'duration' in self.event_data and self.event_data['duration'] > 0: usedTime = self.event_data['duration'] else: startTime = to_datetime(lineInfo['startTime']) nowTime = datetime.datetime.now() if startTime > nowTime: # 如果web服务器时间和事件监控服务器时间不一致，导致开始时间比事件时间还大 usedTime = 0 else: usedTime = int(round(((nowTime - startTime).total_seconds() / 60.0))) actualNeedTime = usedTime + self.event_data.get('leftTime', 0) consumeDict = { 'chargeIndex': port, 'reason': self.event_data.get('reasonDesc', ''), 'totalCount': lineInfo.get('coins', 0), 'needTime': lineInfo.get('needTime', 0), 'leftTime': self.event_data.get('leftTime', 0), 'leftElec': self.event_data.get('leftElec', 0), 'actualNeedTime': actualNeedTime, } order.update_service_info(consumeDict) ConsumeRecord.objects.filter(orderNo=lineInfo['consumeOrderNo']).update(status='finished', finishedTime=now) if 'sub_orderNo' in lineInfo: subConsumeDict = { 'desc': '关联主单号：{}'.format(order.orderNo) } ConsumeRecord.objects.filter(orderNo__in=lineInfo['sub_orderNo']).update(status='finished', finishedTime=now, servicedInfo=subConsumeDict) Device.clear_port_control_cache(self.device.devNo, port) class ChargingJNDZReportEvent(WorkEvent): def do(self, **args): # if not self.device.get('otherConf', {}).get('need_save_upload_data', None): # logger.info('No need to record!!!') # return portNum = self.event_data.get('portNum') portInfo = self.event_data.get('portInfo') ctrInfo = Device.get_dev_control_cache(self.device.devNo) now = datetime.datetime.now() for port, one_info in portInfo.items(): if one_info.get('portStatus') == '02': lineInfo = ctrInfo.get(port, {}) orderNo = lineInfo.get('orderNo') if not orderNo: continue try: order = ConsumeRecord.objects.filter(orderNo=orderNo).first() if hasattr(order, 'upload_data'): upload_data = order.upload_data else: upload_data = [] one_info['upload_time'] = now.strftime('%Y-%m-%d %H:%M:%S') if not upload_data: one_info['duration'] = round((now - order.startTime).total_seconds() / 60.0, 1) one_info['total_time'] = one_info['duration'] else: one_info['duration'] = round((now - to_datetime(upload_data[-1]['upload_time'])).total_seconds() / 60.0, 1) one_info['total_time'] = round((now - order.startTime).total_seconds() / 60.0, 1) upload_data.append(one_info) order.upload_data = upload_data order.save() except Exception as e: logger.error(e) pass class StartAckEventPreProcessor(AckEventProcessorIntf): def analysis_reason(self, reason): FINISHED_CHARGE_REASON_MAP = { '00': u'为了防止过度充电，您的充电已超过最大设定充电时长。', '01': u'充电满了或者用户手动停止(拔插头,或是按了停止按钮)', '02': u'充电满了,自动停止', '03': u'超功率自停', '04': u'远程断电', '05': u'刷卡断电', '0B': u'设备或是端口出现问题,被迫停止', # 服务器定义的停止事件 '90': u'用户手动点击结束按钮结束充电', '91': u'检测到设备未在充电工作状态,结束本次充电', -2: u'检测到设备未在充电工作状态,结束本次充电', } return FINISHED_CHARGE_REASON_MAP.get(reason) def pre_processing(self, device, event_data): # type:(DeviceDict, dict)->dict source = json.dumps(event_data) event_data['source'] = source if 'duration' in event_data and event_data['duration'] != 0: duration = event_data.get('duration') event_data['duration'] = ((duration + 59) / 60) elif 'fts' in event_data and 'sts' in event_data: duration = event_data['fts'] - event_data['sts'] event_data['duration'] = ((duration + 59) / 60) else: event_data['duration'] = 0 if 'elec' in event_data: event_data['elec'] = round(event_data.pop('elec') / 3600000.0, 3) else: event_data['elec'] = 0 # 初始化分档时间 if 'time' in event_data: event_data['time'] = event_data['time'] / 60.0 else: event_data['time'] = 0.0 if 'timeMax' in event_data: event_data['needTime'] = event_data.pop('timeMax') / 60.0 if 'elecMax' in event_data: event_data['needElec'] = round(event_data.pop('elecMax') / 3600000.0, 3) if 'port' in event_data: pass if 'sub' in event_data: subs = event_data.get('sub', []) for item in subs: if 'card_cst' in item: item['fee'] = RMB(item['card_cst']) * Ratio('0.1') # event_data['fee'] += item['fee'] if 'balance' in item: item['balance'] = RMB(item['balance']) * Ratio('0.1') if 'timeMax' in event_data: event_data['needTime'] = event_data.pop('timeMax') if 'elecMax' in event_data: event_data['needElec'] = event_data.pop('elecMax') if event_data['order_type'] != 'com_start': package = {'coins': float(event_data['fee']), 'unit': 'time', 'time': 999} event_data['package'] = package if event_data['status'] == 'finished': if 'reason' in event_data: # 正常结束 event_data['reasonDesc'] = self.analysis_reason(event_data['reason']) else: event_data['reasonDesc'] = self.analysis_reason('91') # 由轮询订单出来的结果 if 'time' in event_data and 'needTime' in event_data: if event_data['time'] >= event_data['needTime']: event_data['time'] = event_data['needTime'] event_data['reasonDesc'] = '购买的充电时间用完,功率超过额定值时间会相应缩短。' if 'elec' in event_data and 'needElec' in event_data: if event_data['elec'] >= event_data['needElec']: event_data['elec'] = event_data['needElec'] event_data['reasonDesc'] = '根据您的动态功率计算, 您订购的电量已用完, 当前充电服务已结束, 谢谢您的使用!!' if 'cardType' in event_data: pass if 'cardNo' in event_data: event_data['cardNoHex'] = str(event_data.pop('cardNo')) event_data['cardNo'] = str(int(event_data['cardNoHex'], 16)) event_data['cardType'] = 'ID' if 'balance' in event_data: if event_data['order_type'] == 'com_start': event_data['fee'] = RMB(event_data.pop('balance')) * Ratio('0.1') elif event_data['order_type'] == 'id_start': cst = float(device['otherConf'].get("deviceConfigs", {}).get('cst', 30.0)) * 0.1 event_data['fee'] = RMB(cst) event_data['fee'] = min(RMB(cst), RMB(event_data.pop('balance')) * Ratio('0.1')) else: event_data['fee'] = RMB(0) if event_data['needTime'] == 0: event_data['timeFee'] = RMB(0) else: event_data['timeFee'] = event_data['fee'] * round(event_data['time'] / event_data['needTime'], 2) if event_data['needElec'] == 0: event_data['elecFee'] = RMB(0) else: event_data['elecFee'] = event_data['fee'] * round(event_data['elec'] / event_data['needElec'], 2) # if event_data.get('reason') in ['00']: # event_data['timeFee'] = event_data['fee'] # event_data['elecFee'] = event_data['fee'] if event_data['order_type'] != 'com_start': package = {'coins': float(event_data['fee']), 'unit': 'time', 'time': 999} event_data['package'] = package return event_data class MyComNetPayAckEvent(ComNetPayAckEvent): def __init__(self, smartBox, event_data): super(MyComNetPayAckEvent, self).__init__(smartBox, event_data, StartAckEventPreProcessor()) def post_after_start(self, order = None): pass def post_after_finish(self, order = None): # TODO 订单结束处理后付费 self.pay_order(order) def merge_order(self, master_order, sub_orders): # type:(ConsumeRecord, list)->dict if self.is_postpaid: # TODO 显示费用调整 portDict start_time = Arrow.fromdatetime(master_order.startTime, tzinfo=settings.TIME_ZONE) portDict = {'billingType': 'time'} portDict['coins'] = 0 portDict['needKind'] = 'needTime' portDict['needValue'] = 999 portDict['unit'] = u'分钟' portDict['estimatedTs'] = int(start_time.timestamp + 720 * 60 * 60) return portDict else: needTime, needElec= self.deviceAdapter._check_package(master_order.package) start_time = Arrow.fromdatetime(master_order.startTime, tzinfo = settings.TIME_ZONE) portDict = { } if master_order.paymentInfo['via'] == 'virtualCard': portDict.update({ 'vCardId': master_order.virtual_card_id }) all_coins = master_order.package['coins'] all_price = master_order.package['price'] all_consume_time_value = needTime all_consume_elec_value = needElec for sub_order in sub_orders: all_coins += sub_order.package['coins'] all_price += sub_order.package['price'] sub_needTime, sub_needElec = self.deviceAdapter._check_package(sub_order.package) all_consume_time_value += sub_needTime all_consume_elec_value += sub_needElec portDict['coins'] = str(all_coins) portDict['price'] = str(all_price) portDict['all_consume_time_value'] = str(all_consume_time_value) portDict['all_consume_elec_value'] = str(all_consume_elec_value) portDict['needKind'] = 'needTime' portDict['needValue'] = 999 #显示充满自停 portDict['unit'] = u'分钟' portDict['estimatedTs'] = int(start_time.timestamp + 720 * 60) portDict['consumeType'] = 'mobile' return portDict def do_finished_event(self, master_order, sub_orders, merge_order_info): # type: (ConsumeRecord, [ConsumeRecord], dict)->None self._do_finished(master_order, sub_orders, merge_order_info) # billing_type = merge_order_info['billingType'] # if billing_type == 'time': # if self.is_postpaid: # self.do_postpaid_time_finished(master_order, sub_orders, merge_order_info) # else: # self.do_time_finished(master_order, sub_orders, merge_order_info) # else: # self.do_elec_finished(master_order, sub_orders, merge_order_info) @SmartBox.check_device_features(device_features=['Postpaid']) def pay_order(self, order): order.status = 'running' order.save() order.s_to_e() @property @SmartBox.check_device_features(device_features=['Postpaid']) def is_postpaid(self): return True def do_postpaid_time_finished(self, master_order, sub_orders=None, merge_order_info=None): user = MyUser.objects(openId=master_order.openId, groupId=master_order.groupId).first() # type: MyUser if not user: logger.error( 'user is not exist. openId = {}, groupId = {}'.format(master_order.openId, master_order.groupId)) return left = self.event_data.get('leftTime', 0) duration = self.event_data.get('duration', 0) elec = self.event_data.get('elec', 0) consumeDict = { 'reason': self.event_data.get('reasonDesc'), 'leftTime': str(left), 'chargeIndex': str(master_order.used_port), 'duration': duration, 'elec': elec, 'elecFee': self.deviceAdapter.calc_elec_fee(elec) } logger.debug( 'orderNo = {}, orderType = isPostpaid, usedTime = {}, needPayMoney = {}'.format(master_order.orderNo, duration, master_order.coin)) extra = [] desc = r'(已使用账户余额自动结算此次消费)' if master_order.is_finished() else r'(您的账户余额已不足以抵扣此次消费，请前往账单中心进行支付)' self.event_data['reasonDesc'] += desc extra.append({u'消费金额': '{}(金币)'.format(master_order.money)} if master_order.is_finished() else { u'消费金额': '{}(元)'.format(master_order.money)}) master_order.update_service_info(consumeDict) auth_bridge = get_wechat_auth_bridge(source=self.device, app_type=APP_TYPE.WECHAT_USER_MANAGER) self.notify_user_service_complete( service_name='充电', openid=user.get_bound_pay_openid(auth_bridge.bound_openid_key), port=str(master_order.used_port), address=master_order.address, reason=self.event_data.get('reasonDesc'), finished_time=master_order.finishedTime.strftime('%Y-%m-%d %H:%M:%S'), extra=extra) def insert_vCard_consume_record(self, vCard, order, success, consumeTotal,consumeDay): try: if success and consumeDay['count'] > 0: record = VCardConsumeRecord( orderNo=VCardConsumeRecord.make_no(order.logicalCode), openId=order.openId, nickname=order.nickname, cardId=str(vCard.id), dealerId=vCard.dealerId, devNo=order.devNo, devTypeCode = order.devTypeCode, devTypeName = order.dev_type_name, logicalCode=order.logicalCode, groupId=order.groupId, address=order.address, groupNumber=order.groupNumber, groupName=order.groupName, attachParas=order.attachParas, consumeData=consumeTotal, consumeDayData=consumeDay ) record.save() except Exception, e: logger.exception(e) def _do_finished(self, order, sub_orders, merge_order_info): # type: (ConsumeRecord, list, dict)->None duration, elec = self.event_data.get('duration',0), self.event_data.get('elec',0) coins = VirtualCoin(merge_order_info['coins']) timeFee = VirtualCoin(self.event_data.get('timeFee', 0.0)) elecFee = VirtualCoin(self.event_data.get('elecFee', 0.0)) usedFee = max(timeFee, elecFee) auto_refund = self.device.is_auto_refund refundProtectionTime = self.device.get('otherConf', {}).get('refundProtectionTime', 5) user = MyUser.objects(openId=order.openId, groupId=order.groupId).first() # type: MyUser backCoins = VirtualCoin(0) if duration < refundProtectionTime: backCoins = coins usedFee = VirtualCoin(0) else: if auto_refund: backCoins = coins - usedFee else: usedFee = coins logger.debug('{} auto refund enable switch is {}, refund protect time = {} backMoney={}'.format( repr(self.device), str(auto_refund), refundProtectionTime, backCoins)) extra = [] extra.append({u'本次使用时长':u'{}(分钟)'.format(duration)}) if order.paymentInfo['via'] == 'free': extra.append({u'消费金额': u'当前设备免费使用'}) elif order.paymentInfo['via'] in ['netPay', 'coins', 'cash', 'coin']: all_money = RMB(0) all_refund_money = RMB(0) orders = [order] + sub_orders refundCash = 'refundRMB_device_event' in self.device.owner.features for _order in orders[::-1]: consumeDict = { 'reason': self.event_data.get('reasonDesc', None), 'chargeIndex': str(order.used_port), 'source': self.event_data.get('source', None) } need_back_coins, need_consume_coins, backCoins = self._calc_refund_info(backCoins, _order.coin) rechargeRcdId = _order.attachParas.get('linkedRechargeRecordId', '') if rechargeRcdId != '': rechargeRcd = RechargeRecord.objects.filter(id=rechargeRcdId, isQuickPay=True).first() else: rechargeRcd = None if refundCash and rechargeRcd: # 退现金特征 + 有充值订单 # 退现金部分 user.clear_frozen_balance(str(_order.id), _order.paymentInfo['deduct'], back_coins=VirtualCoin(0), consume_coins=VirtualCoin(_order.coin)) refundRMB = rechargeRcd.money * (float(need_back_coins) / float(_order.coin)) self.refund_net_pay(user, {'rechargeRcdId': rechargeRcdId, 'openId': user.openId}, refundRMB, VirtualCoin(0), consumeDict, True) all_money += RMB(rechargeRcd.money) all_refund_money += RMB(refundRMB) else: user.clear_frozen_balance(str(_order.id), _order.paymentInfo['deduct'], back_coins=need_back_coins, consume_coins=need_consume_coins) consumeDict.update({ DEALER_CONSUMPTION_AGG_KIND.COIN: _order.coin.mongo_amount, DEALER_CONSUMPTION_AGG_KIND.SPEND_MONEY: need_consume_coins.mongo_amount, DEALER_CONSUMPTION_AGG_KIND.REFUNDED_COINS: need_back_coins.mongo_amount}) if _order.orderNo == order.orderNo: consumeDict.update({ DEALER_CONSUMPTION_AGG_KIND.DURATION: duration, DEALER_CONSUMPTION_AGG_KIND.ELEC: elec, DEALER_CONSUMPTION_AGG_KIND.ELECFEE: self.deviceAdapter.calc_elec_fee(elec), }) _order.update_service_info(consumeDict) if refundCash: extra.append({u'消费金额': '{}元'.format(all_money - all_refund_money)}) if all_refund_money > RMB(0): extra.append({u'退款金额': '{}元'.format(all_refund_money)}) else: extra.append({u'消费金额': '{}金币'.format(usedFee)}) if backCoins > VirtualCoin(0): extra.append({u'退款金额': '{}金币(当充电金币数量大于或等于扫码充电金额时可抵现金，金币不可提现)'.format(backCoins)}) else: logger.error('not net pay rather user virtual card pay. something is wrong.') return auth_bridge = get_wechat_auth_bridge(source=self.device, app_type=APP_TYPE.WECHAT_USER_MANAGER) self.notify_user_service_complete( service_name='充电', openid=user.get_bound_pay_openid(auth_bridge.bound_openid_key), 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 _calc_refund_info(self, backCoins, orderCoin): if backCoins >= orderCoin: need_back_coins = orderCoin need_consume_coins = VirtualCoin(0) backCoins -= orderCoin else: need_back_coins = backCoins need_consume_coins = orderCoin - need_back_coins backCoins = VirtualCoin(0) return need_back_coins, need_consume_coins, backCoins class MyIcStartAckEvent(IcStartAckEvent): def __init__(self, smartBox, event_data): super(MyIcStartAckEvent, self).__init__(smartBox, event_data, StartAckEventPreProcessor()) def post_after_start(self, order = None): pass def post_after_finish(self, order = None): pass def merge_order(self, master_order, sub_orders): # type:(ConsumeRecord, list)->dict consumeModule = self.device.get('otherConf', dict()).get('consumeModule', 0) # 按时间计费 if consumeModule == 0: billingType = 'time' else: billingType = 'elec' start_time = Arrow.fromdatetime(master_order.startTime, tzinfo = settings.TIME_ZONE) portDict = { 'billingType': billingType } if master_order.paymentInfo['via'] == 'virtualCard': portDict.update({ 'vCardId': master_order.paymentInfo['itemId'] }) all_coins = master_order.coin all_money = master_order.money for sub_order in sub_orders: all_coins += sub_order.coin all_money += sub_order.money portDict['coins'] = str(all_coins) portDict['money'] = str(all_money) portDict['estimatedTs'] = int(start_time.timestamp + 12 * 60 * 60) return portDict def do_time_finished(self, card, order, merge_order_info): # type: (Card, ConsumeRecord, dict)->None duration, elec = self.event_data['duration'], self.event_data['elec'] coins = VirtualCoin(merge_order_info['coins']) left = self.event_data['left'] consumeDict = { 'reason': self.event_data['reason'], 'chargeIndex': str(order.used_port), 'duration': duration, 'elec': elec, 'elecFee': self.deviceAdapter.calc_elec_fee(elec) } # backMoney = VirtualCoin(self.event_data['backMoney']) group = self.device.group # type: GroupDict extra = [{ u'实体卡号': self.event_data['cardNo'] }] consumeDict.update({'balance': str(card.balance)}) order.update_service_info(consumeDict) self.notify_user_service_complete( service_name = '充电', openid = card.managerialOpenId if card else '', port = order.used_port, address = group.address, reason = self.event_data['reason'], finished_time = order.finishedTime.strftime('%Y-%m-%d %H:%M:%S'), extra = extra) def do_elec_finished(self, card, order, merge_order_info): # type:(Card, ConsumeRecord, dict)->None ''' 电川的板子 按电量退费 :return: ''' leftElec = self.event_data.get('left', 0) / 100.0 duration, elec = self.event_data['duration'], self.event_data['elec'] try: consumeDict = { 'reason': self.event_data['reasonDesc'], 'chargeIndex': order.used_port, 'duration': duration, 'elec': elec, 'elecFee': self.deviceAdapter.calc_elec_fee(elec) } # backMoney = self.event_data.get('backMoney') extra = [{u'实体卡号': self.event_data['cardNo']}] # if self.event_data['cardType'] == 'ID': # if backMoney > 0: # self.refund_money_for_card(RMB(backMoney), card.id) # extra.append({ # u'退款金额': u'{}(金币)'.format(backMoney) # }) # # consumeDict.update({'balance': str(card.balance + VirtualCoin(self.event_data['backMoney']))}) # else: consumeDict.update({'balance': str(card.balance)}) order.update_service_info(consumeDict) self.notify_user_service_complete( service_name = '充电', openid = self.get_managerialOpenId_by_openId(order.openId), port = order.used_port, address = self.device.group.address, reason = self.event_data['reason'], finished_time = order.finishedTime.strftime('%Y-%m-%d %H:%M:%S'), extra = extra) except Exception as e: logger.exception(e) def do_finished_event(self, card, order, merge_order_info): # type:(Card, ConsumeRecord, dict)->None if 'backMoney' in self.event_data and self.event_data['backMoney'] > RMB(0): refund_order = RechargeRecord.objects(orderNo = self.event_data['order_id']).first() if not refund_order: self.refund_money_for_card(RMB(self.event_data['backMoney']), card.id, self.event_data['order_id']) billing_type = merge_order_info['billingType'] if billing_type == 'time': self.do_time_finished(card, order, merge_order_info) else: self.do_elec_finished(card, order, merge_order_info) class MyIcRechargeAckEvent(IcRechargeAckEvent): def __init__(self, smartBox, event_data): super(MyIcRechargeAckEvent, self).__init__(smartBox, event_data, StartAckEventPreProcessor()) class MyCardRefundAckEvent(CardRefundAckEvent): def __init__(self, smartBox, event_data): super(MyCardRefundAckEvent, self).__init__(smartBox, event_data, CardRefundAckEventPreProcessor()) class CardRefundAckEventPreProcessor(AckEventProcessorIntf): def pre_processing(self, device, event_data): # type:(DeviceDict, dict)->dict if 'cardType' in event_data: if event_data['cardType'] == 'AA33': event_data['cardType'] = 'ID' else: event_data['cardType'] = 'IC' if 'cardNo' in event_data: event_data['cardNo'] = str(event_data['cardNo']) event_data['backMoney'] = (int(event_data['backMoney']) / 10.0) return event_data class MyIdStartAckEvent(IdStartAckEvent): def __init__(self, smartBox, event_data): super(MyIdStartAckEvent, self).__init__(smartBox, event_data, StartAckEventPreProcessor()) def post_after_start(self, order=None): pass def post_after_finish(self, order=None): pass def merge_order(self, master_order, sub_orders): # type:(ConsumeRecord, list)->dict billingType = self.device.get('otherConf', dict()).get('billingType', 'time') start_time = Arrow.fromdatetime(master_order.startTime, tzinfo = settings.TIME_ZONE) portDict = { 'billingType': billingType } all_coins = master_order.coin all_money = master_order.money all_consume_time = self.event_data.get('needTime', 0) all_consume_elec = self.event_data.get('needElec', 0) for sub_order in sub_orders: all_coins += sub_order.coin all_money += sub_order.money if self.event_data.get('sub', []): for _ in self.event_data['sub']: all_consume_time += _.get('needTime', 0) all_consume_elec += _.get('needElec', 0) portDict['coins'] = str(all_coins) portDict['money'] = str(all_money) portDict['all_consume_time_value'] = all_consume_time portDict['all_consume_elec_value'] = all_consume_elec # 直接显示充满自停 portDict['needValue'] = 999 portDict['needKind'] = 'needTime' portDict['unit'] = u'分钟' portDict['estimatedTs'] = int(start_time.timestamp + portDict['needValue'] * 60) return portDict def _do_finished(self, order, merge_order_info): # type: (ConsumeRecord, dict)->None duration, elec = self.event_data.get('duration', 0), self.event_data.get('elec', 0) coins = VirtualCoin(merge_order_info['coins']) timeFee = VirtualCoin(self.event_data.get('timeFee', 0.0)) elecFee = VirtualCoin(self.event_data.get('elecFee', 0.0)) usedFee = max(timeFee, elecFee) consumeDict = { 'reason': self.event_data.get('reasonDesc', None), 'chargeIndex': str(order.used_port), 'duration': duration, 'elec': elec, 'cardNo': self.event_data['cardNo'], 'elecFee': self.deviceAdapter.calc_elec_fee(elec), DEALER_CONSUMPTION_AGG_KIND.CONSUME_CARD: coins.mongo_amount, 'source': self.event_data.get('source', None) } refundProtectionTime = int(self.device.get('otherConf', {}).get('refundProtectionTime', 5)) logger.info('[HDV3]{} refund protect time = {} duration={} coins={} usedFee={}'.format( repr(self.device), refundProtectionTime, duration, coins, usedFee)) if duration <= refundProtectionTime: backMoney = coins usedFee = VirtualCoin(0) else: backMoney = coins - usedFee logger.info('{} refund protect time = {} backMoney={}'.format( repr(self.device), refundProtectionTime, backMoney)) self.card.clear_frozen_balance(str(order.id), backMoney) self.card.reload() extra = [] extra.append({u'实体卡': '{}--No:{}'.format(self.card.cardName, self.card.cardNo)}) extra.append({u'本次使用时长': '{}(分钟)'.format(duration)}) extra.append({u'本次消费金额': '{}(金币)'.format(usedFee)}) extra.append({u'卡片当前余额': '{}(金币)'.format(self.card.balance.mongo_amount)}) if backMoney > VirtualCoin(0): self.record_refund_money_for_card(backMoney, str(self.card.id), orderNo=order.orderNo) consumeDict.update({ DEALER_CONSUMPTION_AGG_KIND.CONSUME_CARD: usedFee.mongo_amount, DEALER_CONSUMPTION_AGG_KIND.REFUNDED_COINS: backMoney.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 do_finished_event(self, order, merge_order_info): # type:(ConsumeRecord, dict)->None self._do_finished(order, merge_order_info) def checkout_order(self, order): fee = VirtualCoin(order.coin) self.card.freeze_balance(transaction_id=str(order.id), fee=fee) class MyVirtualCardStartAckEvent(VirtualCardStartAckEvent): def __init__(self, smartBox, event_data): super(MyVirtualCardStartAckEvent, self).__init__(smartBox, event_data, StartAckEventPreProcessor()) def post_after_start(self, order = None, card = None): pass def post_after_finish(self, order = None): pass def checkout_order(self, order): group = Group.get_group(self.device.groupId) # type:GroupDict freeze_user_balance(self.device, group, order, self.virtualCard) def merge_order(self, master_order, sub_orders): # type:(ConsumeRecord, list)->dict billingType = self.device.get('otherConf', dict()).get('billingType', 'time') start_time = Arrow.fromdatetime(master_order.startTime, tzinfo = settings.TIME_ZONE) portDict = { 'billingType': billingType } all_coins = master_order.coin all_money = master_order.money all_consume_time = self.event_data.get('needTime', 0) all_consume_elec = self.event_data.get('needElec', 0) if self.event_data.get('sub', []): for _ in self.event_data['sub']: all_consume_time += _.get('needTime', 0) all_consume_elec += _.get('needElec', 0) portDict['coins'] = str(all_coins) portDict['money'] = str(all_money) if billingType == 'time': portDict['needKind'] = 'needTime' portDict['needValue'] = all_consume_time portDict['unit'] = u'分钟' portDict['estimatedTs'] = int(start_time.timestamp + all_consume_time * 60) elif billingType == 'elec': portDict['needKind'] = 'needElec' portDict['needValue'] = round(all_consume_elec / 100.0, 2) portDict['unit'] = u'度' portDict['estimatedTs'] = int(start_time.timestamp + 12 * 60 * 60) else: pass return portDict def do_time_finished(self, card, order, sub_orders, merge_order_info): # type: (Card, ConsumeRecord, list, dict)->None duration, elec = self.event_data['duration'], self.event_data['elec'] consumeDict = { 'reason': self.event_data['reasonDesc'], 'chargeIndex': str(order.used_port), 'duration': duration, 'elec': elec, 'cardNo': self.event_data['cardNo'], 'elecFee': self.deviceAdapter.calc_elec_fee(elec) } auto_refund = self.device.is_auto_refund refundProtection = self.device.get('otherConf', {}).get('refundProtection', 0) refundProtectionTime = self.device.get('otherConf', {}).get('refundProtectionTime', 5) logger.debug('{} auto refund enable switch is {}. refund protect = {}, refund protect time = {}'.format( repr(self.device), str(auto_refund), refundProtection, refundProtectionTime)) if auto_refund: order_need_time = order.package.get('time') if order_need_time >= duration: usedTime = duration duration = 0 else: usedTime = order_need_time duration -= order_need_time success, consumeTotal, consumeDay = self.virtualCard.clear_frozen_quota(transaction_id=str(order.id), usedTime=usedTime, spendElec=0, backCoins=VirtualCoin(0).mongo_amount) self.insert_vCard_consume_record(self.virtualCard, order, success, consumeTotal, consumeDay) for sub_order in sub_orders: order_need_time = sub_order.package.get('time') if order_need_time >= duration: usedTime = duration duration = 0 else: usedTime = order_need_time duration -= order_need_time success, consumeTotal, consumeDay = self.virtualCard.clear_frozen_quota(transaction_id=str(sub_order.id), usedTime=usedTime, spendElec=0, backCoins=VirtualCoin(0).mongo_amount) self.insert_vCard_consume_record(self.virtualCard, sub_order, success, consumeTotal, consumeDay) else: order_need_time = order.package.get('time') success, consumeTotal, consumeDay = self.virtualCard.clear_frozen_quota(transaction_id=str(order.id), usedTime=order_need_time, spendElec=0, backCoins=VirtualCoin( 0).mongo_amount) self.insert_vCard_consume_record(self.virtualCard, order, success, consumeTotal, consumeDay) for sub_order in sub_orders: order_need_time = sub_order.package.get('time') success, consumeTotal, consumeDay = self.virtualCard.clear_frozen_quota( transaction_id=str(sub_order.id), usedTime=order_need_time, spendElec=0, backCoins=VirtualCoin(0).mongo_amount) self.insert_vCard_consume_record(self.virtualCard, sub_order, success, consumeTotal, consumeDay) group = self.device.group # type: GroupDict extra = [{ u'虚拟卡号': self.virtualCard.cardNo }] order.update_service_info(consumeDict) self.notify_user_service_complete( service_name = '充电', openid = card.managerialOpenId if card else '', port = order.used_port, address = group.address, reason = self.event_data['reasonDesc'], finished_time = order.finishedTime.strftime('%Y-%m-%d %H:%M:%S'), extra = extra) def do_elec_finished(self, card, order, sub_orders, merge_order_info): # type:(Card, ConsumeRecord, list, dict)->None duration, elec = self.event_data['duration'], self.event_data['elec'] consumeDict = { 'reason': self.event_data['reasonDesc'], 'chargeIndex': str(order.used_port), 'duration': duration, 'elec': elec, 'cardNo': self.event_data['cardNo'], 'elecFee': self.deviceAdapter.calc_elec_fee(elec), } auto_refund = self.device.is_auto_refund refundProtection = self.device.get('otherConf', {}).get('refundProtection', 0) refundProtectionTime = self.device.get('otherConf', {}).get('refundProtectionTime', 5) logger.debug('{} auto refund enable switch is {}. refund protect = {}, refund protect time = {}'.format( repr(self.device), str(auto_refund), refundProtection, refundProtectionTime)) if auto_refund: order_need_time = order.package.get('time') if order_need_time >= elec: usedTime = duration duration = 0 else: usedTime = order_need_time elec -= order_need_time success, consumeTotal, consumeDay = self.virtualCard.clear_frozen_quota(transaction_id=str(order.id), usedTime=usedTime, spendElec=0, backCoins=VirtualCoin( 0).mongo_amount) self.insert_vCard_consume_record(self.virtualCard, order, success, consumeTotal, consumeDay) for sub_order in sub_orders: order_need_time = order.package.get('time') if order_need_time >= duration: usedTime = duration duration = 0 else: usedTime = order_need_time duration -= order_need_time success, consumeTotal, consumeDay = self.virtualCard.clear_frozen_quota( transaction_id=str(sub_order.id), usedTime=usedTime, spendElec=0, backCoins=VirtualCoin(0).mongo_amount) self.insert_vCard_consume_record(self.virtualCard, sub_order, success, consumeTotal, consumeDay) else: order_need_time = order.package.get('time') success, consumeTotal, consumeDay = self.virtualCard.clear_frozen_quota( transaction_id=str(order.id), usedTime=order_need_time, spendElec=0, backCoins=VirtualCoin( 0).mongo_amount) self.insert_vCard_consume_record(self.virtualCard, order, success, consumeTotal, consumeDay) for sub_order in sub_orders: order_need_time = sub_order.package.get('time') success, consumeTotal, consumeDay = self.virtualCard.clear_frozen_quota( transaction_id=str(sub_order.id), usedTime=order_need_time, spendElec=0, backCoins=VirtualCoin(0).mongo_amount) self.insert_vCard_consume_record(self.virtualCard, sub_order, success, consumeTotal, consumeDay) extra = [{ u'虚拟卡号': self.virtualCard.cardNo }] order.update_service_info(consumeDict) self.notify_user_service_complete( service_name = '充电', openid = self.get_managerialOpenId_by_openId(order.openId), port = order.used_port, address = self.device.group.address, reason = self.event_data['reason'], finished_time = order.finishedTime.strftime('%Y-%m-%d %H:%M:%S'), extra = extra) def do_finished_event(self, card, order, sub_orders, merge_order_info): # type:(Card, ConsumeRecord, list, dict)->None billing_type = merge_order_info['billingType'] if billing_type == 'time': self.do_time_finished(card, order, sub_orders,merge_order_info) else: self.do_elec_finished(card, order, sub_orders,merge_order_info) def insert_vCard_consume_record(self, vCard, order, success, consumeTotal, consumeDay): try: if success and consumeDay['count'] > 0: record = VCardConsumeRecord( orderNo=VCardConsumeRecord.make_no(order.logicalCode), openId=order.openId, nickname=order.nickname, cardId=str(vCard.id), dealerId=vCard.dealerId, devNo=order.devNo, devTypeCode = order.devTypeCode, devTypeName = order.dev_type_name, logicalCode=order.logicalCode, groupId=order.groupId, address=order.address, groupNumber=order.groupNumber, groupName=order.groupName, attachParas=order.attachParas, consumeData=consumeTotal, consumeDayData=consumeDay ) record.save() except Exception, e: logger.exception(e)