# -*- coding: utf-8 -*- # !/usr/bin/env python import logging import datetime from apilib.monetary import RMB, VirtualCoin from apilib.utils_string import make_title_from_dict from apilib.utils_sys import memcache_lock from apps.web.constant import Const, DeviceCmdCode, DEALER_CONSUMPTION_AGG_KIND from apps.web.core.exceptions import ServiceException from apps.web.device.models import Group, Device, DevicePortReport, DeviceType from apps.web.eventer import EventBuilder, powerRecorder from apps.web.eventer.base import WorkEvent, FaultEvent from apps.web.user.models import ServiceProgress, MyUser, ConsumeRecord, CardConsumeRecord, CardRechargeOrder, \ UserVirtualCard, VCardConsumeRecord from apps.web.user.transaction_deprecated import refund_money from apps.web.user.utils import vCard_pay_coin logger = logging.getLogger(__name__) def reverse_hex(s): if len(s) == 0: return "" return s[-2:] + reverse_hex(s[:-2]) class builder(EventBuilder): def __getEvent__(self, device_event): event_data = self.deviceAdapter.analyze_event_data(device_event['data']) if not event_data: return event_data['raw_msg'] = device_event # 粤万通的版本比较复杂 没有一个统一的版本 这次力争升级到一个统一的版本 # TODO 补丁 if "ack_id" in device_event and self.device.driverVersion not in [ "v1.0.0", "v1.0.1", "v1.0.2", "v3.0.1", "v3.0.2", "v3.0.3", "v4.0.0", "v4.0.1" ]: self.deviceAdapter._ack(device_event["ack_id"]) funCode = event_data.get("cmdCode") if funCode == "E0": return YueWanTongFaultEvent(self.deviceAdapter, event_data) else: return YueWanTongWorkerEvent(self.deviceAdapter, event_data) class YueWanTongFaultEvent(FaultEvent): def do(self, **args): group = Group.get_group(self.device["groupId"]) if self.is_notify_dealer(): self.notify_dealer( "device_fault", title = u"注意注意您的设备发生故障", device = u"组号：{}，二维码编号：{}".format(self.device["groupNumber"], self.device["logicalCode"]), location = u"组名称：{}，地址：{}".format(group["groupName"], group["address"]), fault = self.event_data["statusInfo"], notifyTime = str(datetime.datetime.now())[:19] ) warningData = { "warningStatus": 2, "warningDesc": self.event_data["statusInfo"], "warningTime": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") } # 整机告警 part = self.event_data.get("portStr", "0") Device.update_dev_warning_cache(self.device.devNo, {part: warningData}) try: faultRecord = self.record(faultCode=self.event_data.get("faultCode", ""), detail={"errorCode": self.event_data["faultCode"]}) self.north_to_liangxi(faultRecord) except Exception as e: logger.error(e) finally: sendData = self.event_data.get("portHex") + "01" self.deviceAdapter._send_data("E0", sendData = sendData, cmd = DeviceCmdCode.OPERATE_DEV_NO_RESPONSE) class YueWanTongWorkerEvent(WorkEvent): @staticmethod def _get_cache_key(devNo, port, cmd): return "{}-{}-{}".format(devNo, port, cmd) def _card_start_repeat(self, _type, portStr, cardCode, balance = None, orderNo = None, chargeTime = None, virtualCardLeftDays=None, cardType=None): """ 卡启动的回复 :param _type: 正常卡 非法卡 余额不足卡 :param portStr: 端口号 :param cardCode: 带ICSetupCode的卡号 :param balance: 卡上余额 :param orderNo: 卡启动的订单号 :param chargeTime: 充电的时间 :return: """ if balance is None: balance = "00000000" else: balance = reverse_hex("{:0>8X}".format(int(balance * 100) & 0xFFFFFFFF)) if orderNo is None: orderNo = "00000000000000" else: orderNo = reverse_hex("{:0>14X}".format(int(orderNo))) if chargeTime is None: chargeTime = "0000" else: chargeTime = reverse_hex("{:0>4X}".format(int(chargeTime))) if virtualCardLeftDays is None: leftDays = "0000" else: leftDays = reverse_hex("{:0>4X}".format(int(virtualCardLeftDays))) if cardType is None: cardType = "01" # 随机开锁密码无用 pw = "0000" sendData = cardCode + portStr + _type + balance + cardType + leftDays + orderNo + chargeTime + pw self.deviceAdapter._send_data(funCode = "B0", sendData = sendData, cmd = DeviceCmdCode.OPERATE_DEV_NO_RESPONSE) def _get_port_charge_status(self, port): """ 获取端口的详细信息，向设备请求 :param port: :return: """ result = self.deviceAdapter._read_port_charge_status() portChargeStatus = result.get(str(port), dict()) return portChargeStatus def _card_stop_repeat(self, _type, portStr, cardCode, balance = None, money = None, virtualCardLeftDays=None, cardType=None): """ 刷卡结束充电请求回复， 回复设备后， 设备会将该端口的该单号的充电记录清零 重新记录 :param _type: 回复设备的状态 :param portStr: 端口号 16进制 :param cardCode: 卡号带前缀 ascii :param balance: 余额 可能为负数 :param money: 消费金额 :return: """ if balance is None: balance = "00000000" else: balance = reverse_hex("{:0>8X}".format(int(balance * 100) & 0xFFFFFFFF)) if money is None: money = "00000000" else: money = reverse_hex("{:0>8X}".format(int(money * 100))) if virtualCardLeftDays is None: leftDays = "0000" else: leftDays = reverse_hex("{:0>4X}".format(int(virtualCardLeftDays))) if cardType is None: cardType = "01" sendData = cardCode + portStr + _type + balance + cardType + leftDays + money self.deviceAdapter._send_data(funCode = "B1", sendData = sendData, cmd = DeviceCmdCode.OPERATE_DEV_NO_RESPONSE) def _stop_repeat(self, orderHex, portHex): """ 充电结束回复设备 格式固定 :param orderHex: :param portHex: :return: """ # TODO 补丁 if self.device.driverVersion not in ["v1.0.0", "v1.0.1", "v1.0.2", "v3.0.1", "v3.0.2", "v3.0.3", "v4.0.0", "v4.0.1"]: return sendData = orderHex + portHex + "01" self.deviceAdapter._send_data(funCode = "C1", sendData = sendData, cmd = DeviceCmdCode.OPERATE_DEV_NO_RESPONSE) def _handle_card_stop(self, cardOrderNo, orderNo, totalConsume, chargeTime, elec, card, portStr, reason=None): """ 结束充电事件和刷卡请求结束充电都有这一部分代码 抽出来 :param cardOrderNo: :param orderNo: :param totalConsume: :param chargeTime: :param elec: :param card: :param portStr: :param reason: :return: """ logger.info("[_handle_card_stop] cardOrderNo={}, orderNo={}, totalConsume={}, chargeTime={}, port={}".format(cardOrderNo, orderNo, totalConsume, chargeTime, portStr)) consumeOrder = ConsumeRecord.objects.get(orderNo = orderNo) # 虚拟卡没有支付的情况下 if not consumeOrder.virtual_card_id: consumeOrder.coin = totalConsume.mongo_amount consumeOrder.money = totalConsume.mongo_amount try: consumeOrder.save() except Exception as e: logger.error(e) cardConsumeRecord = CardConsumeRecord.objects.get(orderNo = cardOrderNo) cardConsumeRecord.money = RMB(totalConsume) cardConsumeRecord.balance = card.balance - RMB(totalConsume) try: cardConsumeRecord.save() except Exception as e: logger.error(e) # 更新此次卡的余额 self.update_card_balance(card, card.balance - RMB(totalConsume)) # 结束服务，同时更新cardRecord和consumeRecord的serviceInfo， 以及聚合信息 if reason is None: reason = "刷卡结束充电" consumeDict = { 'chargeIndex': portStr, 'reason': reason, 'actualNeedTime': chargeTime, 'duration': chargeTime, 'elec': elec, 'elecFee': self.calc_elec_fee(float(elec)), DEALER_CONSUMPTION_AGG_KIND.CONSUME_CARD: RMB(totalConsume).mongo_amount } self._finished_service(portStr, card.openId, consumeDict) def _handle_min_consume(self, totalConsume, chargeTime=None): """ 检测支付值和最小支付值 :param totalConsume: :return: """ if not chargeTime: chargeTime = self.event_data["chargeTime"] otherConf = self.device.get("otherConf", dict()) minConsume = VirtualCoin(int(otherConf.get("minConsume", self.deviceAdapter.DEFAULT_MIN_CONSUME))) refundProtectTime = int(otherConf.get("refundProtectTime", self.deviceAdapter.DEFAULT_MIN_CHARGE_TIME)) if int(chargeTime) < int(refundProtectTime): return VirtualCoin(0) return max(VirtualCoin(minConsume), VirtualCoin(totalConsume)) def _finished_service(self, portStr, openId, consumeInfo): ServiceProgress.update_progress_and_consume_rcd( self.device["ownerId"], { "open_id": openId, "device_imei": self.device.devNo, "port": int(portStr), "isFinished": False }, consumeInfo ) # 清空端口信息 Device.clear_port_control_cache(self.device["devNo"], portStr) def _notify_user_finished(self, user, extra): """ 通知用户 服务结束 :return: """ title = make_title_from_dict(extra) self.notify_user( managerialOpenId=user.managerialOpenId if user else "", templateName="service_complete", title=title, service=u"充电桩充电服务", finishTime=str(datetime.datetime.now())[: 19], remark=u'谢谢您的支持' ) def do(self, **args): cmd = self.event_data['cmdCode'] portStr = self.event_data.get("portStr") cacheKey = self._get_cache_key(self.device["devNo"], portStr, cmd) with memcache_lock(cacheKey, value = '1', expire = 5) as required: if required: if cmd == "B0": self.do_card_start() elif cmd == "B1": self.do_card_stop() elif cmd == "C1": self.do_stop() elif cmd == "B2": self.do_stop() elif cmd == "C0": self.do_report() # 自定义 elif cmd == "CA": self.do_all_report() else: logger.error("error cmd, cmd is {}".format(cmd)) def do_card_start(self): """ 刷卡启动，刷卡的时候设备上报命令，等待设备回复后成功启动 由于是后付费，这个地方仅仅做卡启动记录，费用在结束的时候结算 但是还是需要校验 卡上的钱是否是小于0，负数卡不予启动 :return: """ cardNo = self.event_data.get("cardNo") portStr = self.event_data.get("portStr") portStrHex = self.event_data['portStrHex'] cardCode = self.event_data['cardCode'] lockPorts = self.device.otherConf.get("lockPorts") or list() if portStr in lockPorts: self._card_start_repeat(_type = "03", portStr = portStrHex, cardCode = cardCode) return card = self.update_card_dealer_and_type(cardNo) if not card or not card.openId: self._card_start_repeat(_type = "03", portStr = portStrHex, cardCode = cardCode) logger.info("bad card, cardNo is %s, cannot start port!" % cardNo) return 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() # 这个地方处理包月卡的问题 package = {"unit": u"次", "count": 1} virtualCardCanUse = False virtualCard = card.bound_virtual_card # 虚拟卡使用的四个条件 绑定虚拟卡没有过期、绑定虚拟卡设备组允许、绑定虚拟卡设备种类允许、绑定虚拟卡额度足够使用 if virtualCard and (self.device.get("groupId") in virtualCard.groupIds or "*" in virtualCard.groupIds) and DeviceType.objects.filter(code=self.device.devType.get("code"), id__in=virtualCard.devTypeList) and virtualCard.can_use_today(package): virtualCardCanUse = True # 包月卡不可用并且余额不足的时候 if not virtualCardCanUse and float(card.balance) <= 0: self._card_start_repeat(_type = "02", portStr = portStrHex, cardCode = cardCode, balance = card.balance) self.deviceAdapter._stop_device("00000000000000", portStr) logger.info("negative card, card No is %s, card balance is %s" % (cardNo, card.balance)) return # 可以启动的情况下 优先将卡消费订单创建出来，获取单号， 消费先是0，结束的时候再算 try: orderNo, cardOrderNo = self.record_consume_for_card(card, RMB(0), desc="包月卡消费" if virtualCardCanUse else u"刷卡消费", attachParas={"chargeIndex": portStr}) except Exception as e: logger.error("record to database error!".format(e)) return # 虚拟卡可用的情况下 直接扣费吧 virtualCardPaid = False if virtualCardCanUse: order = ConsumeRecord.objects.get(orderNo=orderNo) # type: ConsumeRecord group = Group.get_group(self.device.groupId) try: vCard_pay_coin(order, virtualCard, self.device, group, package, {}) except ServiceException: # 支付失败的情况况下 重新将虚拟卡支付标记为 否 结算的时候从卡上扣除相应的金额 order.desc = u"虚拟卡支付失败" order.save() else: virtualCardPaid = True # 发送报文回应设备，启动, 刷卡启动时候余额单位为分，充电模式为充满自停，所以时间为最大值 chargeTime = 2 ** 32 - 1 virtualCardLeftDays = (virtualCard.expiredTime - datetime.datetime.now()).days if virtualCardPaid else None cardType = "02" if virtualCardPaid else "01" self._card_start_repeat("01", portStrHex, cardCode=cardCode, balance=card.balance, orderNo=orderNo, chargeTime=chargeTime, virtualCardLeftDays=virtualCardLeftDays, cardType=cardType) logger.info("card start ok! event has been report!") # 启动设备之后，注册服务，并更新端口缓存值 serviceDict = { "orderNo": orderNo, "cardOrderNo": cardOrderNo } if virtualCardPaid: serviceDict.update({"vCardId": str(virtualCard.id)}) ServiceProgress.register_card_service( self.device, int(portStr), card, serviceDict ) portDict = { "status": Const.DEV_WORK_STATUS_WORKING, "isStart": True, "orderNo": orderNo, # 订单号码 "cardOrderNo": cardOrderNo, "cardNo": cardNo, # 卡号 0-99999999 "openId": card.openId, "startTime": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), # 刷卡启动的初始时间 "vCardId": str(virtualCard.id) if virtualCardPaid else None, "chargeType": "power", # 刷卡的只能是按功率收费, 并且是后付费 "payAfterUse": True } self.notify_user( managerialOpenId=card.managerialOpenId, templateName="consume_notify", title=u"您正在刷卡启动充电桩业务", money=u"使用结束后计算费用", serviceType=u"刷卡消费, 当前启动为: {}端口".format(portStr), finishTime=datetime.datetime.now().strftime(Const.DATETIME_FMT) ) Device.update_dev_control_cache(self.device["devNo"], {portStr: portDict}) @powerRecorder() def do_report(self): """ 处理端口上报消息的事件 :return: """ # 获取原始参数 orderNo = self.event_data.get("orderNo") orderNoHex = self.event_data.get("orderNoHex") portStr = self.event_data.get("portStr") voltage = self.event_data.get("voltage") power = self.event_data.get("power") elec = self.event_data.get("elec") chargeTime = self.event_data.get("chargeTime") temperature = self.event_data.get("temperature") # 获取端口缓存 devCache = Device.get_dev_control_cache(self.device["devNo"]) portCache = devCache.get(portStr, dict()) # 回复设备报文 新版本的设备已经在驱动侧回复，但是可能存在部分老设备 此段回复代码首先保留 迭代几个版本之后可以删除 if self.device.driverVersion in ["v1.0.0", "v1.0.1"]: sendData = orderNoHex + "{:0>2X}".format(int(portStr)) + "01" self.deviceAdapter._send_data(funCode = "C0", sendData = sendData, cmd = DeviceCmdCode.OPERATE_DEV_NO_RESPONSE) # 筛选无效报文 if orderNo != portCache.get("orderNo"): logger.info("port report event, not equal orderNo, useless info! event={} portCache = {}".format(self.event_data, portCache)) return # 更新端口缓存 portCache.update({"voltage": voltage, "elec": elec, "temperature": temperature, "power": power}) Device.update_dev_control_cache(self.device["devNo"], {portStr: portCache}) # 获取计费模式以及消费模式 chargeType = portCache.get("chargeType", self.deviceAdapter.DEFAULT_CHARGE_TYPE) payAfterUse = portCache.get("payAfterUse", self.deviceAdapter.DEFAULT_PAY_AFTER_USE) # 保存上报的心跳数据到日志数据库 reportRecord = DevicePortReport.create( devNo = self.device["devNo"], port = portStr, orderNo = orderNo, openId = portCache["openId"], voltage = voltage, power = power, elec = elec, chargeTime = chargeTime ) if not reportRecord: logger.info("port report event, save db error!") return # 后付费的 一律不处理 因为后付费的费用结算是在使用完毕之后 if payAfterUse: return # 计算各个模式下面 到目前为止使用的金钱 if chargeType == "time": useMoney = self.deviceAdapter._get_time_use_money(reportRecord) elif chargeType == "elec": useMoney = self.deviceAdapter._get_elec_use_money(reportRecord) elif chargeType == "billAsService": elecCharge, serviceCharge = self.deviceAdapter._get_billAsService_use_money(reportRecord) useMoney = round(sum(elecCharge, serviceCharge), 2) else: useMoney = self.deviceAdapter._get_power_use_money(reportRecord) # 当预付费模式下 使用的金钱大于 预付的金钱 立即下发停止指令 if VirtualCoin(useMoney) >= VirtualCoin(portCache["coins"]): result = self.deviceAdapter._stop_device(orderNo, portStr) data = result.get("data") stopData = self.deviceAdapter._parse_device_stop(data) # 能走到这个地方说明钱已经花完了 不需要处理退费 但是需要对用户进行通知 以及清除响应的端口状态 reason = u"动态功率计算，服务已经结束" # 推送通知信息组织 extra = [ {u'结束原因': u'{}'.format(reason)}, {u'设备编号': u'{}-{}'.format(self.device.logicalCode, portStr)}, {u'服务地址': u'{}'.format(self.device.group["address"])}, {u'充电时间': u'{}分钟'.format(chargeTime)}, ] consumeDict = { "chargeIndex": portStr, "reason": reason, 'actualNeedTime': stopData.get("chargeTime"), 'duration': stopData.get("chargeTime"), 'elec': stopData.get("elec"), 'elecFee': self.calc_elec_fee(stopData.get("elec")), } if chargeType == "billAsService": consumeDict.update({ 'elecCharge': elecCharge, 'serviceCharge': serviceCharge, }) extra.extend([ {u'电量费用': u'{}'.format(elecCharge)}, {u'服务费用': u'{}'.format(serviceCharge)}, ]) user = MyUser.objects.filter(openId=portCache["openId"], groupId=self.device.groupId).first() self._notify_user_finished(user, extra) openId = portCache.get("openId") self._finished_service(portStr, openId, consumeDict) @powerRecorder(stop=True) def do_card_stop(self): """ 刷卡结束的充电行为 累计充电的总时长 总时长小于5分钟不予扣费，剩下的正常扣除费用 费用的扣除需要分段累加进行 因为是后付费行为，所以不会存在退费 :return: """ portStr = self.event_data.get("portStr") orderNo = self.event_data.get("orderNo") cardNo = self.event_data.get("cardNo") devCache = Device.get_dev_control_cache(self.device["devNo"]) portCache = devCache.get(portStr, dict()) portStrHex = self.event_data['portStrHex'] cardCode = self.event_data['cardCode'] # 检查订单号 if portCache.get("orderNo") != orderNo or cardNo != portCache.get("cardNo"): # TODO ZJL 这个地方会有可能出现吗？需要回应设备确认么 logger.info("card stop event, orderNo or carNo not equal!, event = {}".format(self.event_data)) return card = self.update_card_dealer_and_type(cardNo) # 向设备发送报文，获取该端口充电的信息，时间是累加值 portChargeStatus = self._get_port_charge_status(portStr) # 检查充电的累计时长， 小于一定的值不予扣费 chargeTime = int(portChargeStatus.get("chargeTime", 0)) if chargeTime < self.deviceAdapter.DEFAULT_MIN_CHARGE_TIME: logger.info("card stop event, chargeTime lt min charge time!") self._card_stop_repeat( _type = "01", portStr = portStrHex, cardCode = cardCode, balance = card.balance, money = 0) extra = [{u"消费金额": u"{}元".format(0),"余额": "{}元".format(RMB(card.balance))}] self.notify_user_service_complete( service_name='充电', openid=card.managerialOpenId, port=portStr, address=self.device.group['address'], reason=self.event_data.get('reasonDesc'), finished_time=datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'), extra=extra) # 不扣费的情况下也属于正常结束 端口状态需要清空 Device.clear_port_control_cache(self.device["devNo"], portStr) return # 计算该次刷卡的累计消费 totalConsume = DevicePortReport.calculate_consume( orderNo = orderNo, allChargeTime = chargeTime, lastPower = portChargeStatus.get("power"), interval_map = self.deviceAdapter._get_power_interval_map(), devNo = self.device["devNo"], port = portStr, openId = card.openId, voltage = portChargeStatus.get("voltage"), elec = portChargeStatus.get("elec") ) totalConsume = self._handle_min_consume(totalConsume, chargeTime) # 最后回复设备表示已经接收到刷卡请求结束充电的信息，以便主板清空端口累计信息 orderNo = portCache.get("orderNo") consumeOrder = ConsumeRecord.objects.get(orderNo=orderNo) virtualCard = None virtualCardLeftDays = None if consumeOrder.virtual_card_id: vConsumeRecord = VCardConsumeRecord.objects.filter(id=consumeOrder.virtual_card_id).first() virtualCard = UserVirtualCard.objects.filter(id=vConsumeRecord.cardId).first() virtualCardLeftDays = (virtualCard.expiredTime - datetime.datetime.now()).days if virtualCard: _type = "01" balance = card.balance elif int(card.balance-totalConsume) < 0: _type = "02" balance = card.balance - totalConsume else: _type = "01" balance = card.balance - totalConsume self._card_stop_repeat( _type = _type, portStr = portStrHex, cardCode = cardCode, balance = balance, money = float(totalConsume), virtualCardLeftDays=virtualCardLeftDays, cardType="02" if virtualCard else "01" ) self._handle_card_stop( cardOrderNo = portCache.get("cardOrderNo"), orderNo = portCache.get("orderNo"), totalConsume = totalConsume, chargeTime = chargeTime, elec = portChargeStatus.get("elec"), card = card, portStr = portStr ) extra = [{u"消费金额": "{}元".format(totalConsume),"余额": "{}元".format(RMB(card.balance))}] self.notify_user_service_complete( service_name='充电', openid=card.managerialOpenId, port=portStr, address=self.device.group['address'], reason=self.event_data.get('reasonDesc'), finished_time=datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'), extra=extra) @powerRecorder(stop=True) def do_stop(self): """ 处理充电结束上报 充电结束上报和刷卡请求结束充电的区别在于： 充电结束表示主板在该次充电服务已经结束，端口信息已经清空，信息做最后上报 刷卡请求结束充电，主板端口信息未清空，但是端口服务已经停止，需要请求最后一次数据 处理流程与 刷卡请求结束充电 基本类似 :return: """ # 获取原始参数 orderNo = self.event_data.get("orderNo") orderNoHex = self.event_data.get("orderNoHex") portStr = self.event_data.get("portStr") portHex = self.event_data.get("portHex") voltage = self.event_data.get("voltage") power = self.event_data.get("power") elec = self.event_data.get("elec") chargeTime = self.event_data.get("chargeTime") reason = self.event_data.get("reason") portCache = Device.get_port_control_cache(self.device.devNo, portStr) try: self._stop_repeat(orderNoHex, portHex) except Exception as e: logger.exception("devNo is <{}>, orderNoHex is <{}> port is <{}>, error is {}".format(self.device.devNo, orderNoHex, portHex, e)) # 检查订单号 if portCache.get("orderNo") != orderNo: logger.info("stop event, orderNo not equal! event = {} portCache = {}".format(self.event_data, portCache)) return # 将最后一次的充电信息存储 reportRecord = DevicePortReport.create( devNo = self.device["devNo"], port = portStr, orderNo = orderNo, openId = portCache["openId"], voltage = voltage, power = power, elec = elec, chargeTime = chargeTime ) # 推送通知信息组织 extra = [ {u'结束原因': u'{}'.format(reason)}, {u'设备编号': u'{}-{}'.format(self.device.logicalCode, portStr)}, {u'服务地址': u'{}'.format(self.device.group["address"])}, {u'充电时间': u'{}分钟'.format(chargeTime)}, ] # 订单信息组织 consumeDict = { "chargeIndex": portStr, "reason": self.event_data.get("reason"), 'actualNeedTime': chargeTime, 'duration': chargeTime, 'elec': self.event_data.get("elec"), 'elecFee': self.calc_elec_fee(self.event_data.get("elec")), } # 获取计费模式以及消费模式 chargeType = portCache.get("chargeType", self.deviceAdapter.DEFAULT_CHARGE_TYPE) payAfterUse = portCache.get("payAfterUse", self.deviceAdapter.DEFAULT_PAY_AFTER_USE) # 计算各个模式下面 到目前为止使用的金钱 if chargeType == "time": useMoney = self.deviceAdapter._get_time_use_money(reportRecord) elif chargeType == "elec": useMoney = self.deviceAdapter._get_elec_use_money(reportRecord) elif chargeType == "billAsService": elecCharge, serviceCharge = self.deviceAdapter._get_billAsService_use_money(reportRecord) useMoney = elecCharge + serviceCharge extra.extend([ {u'电量费用': u'{}'.format(elecCharge)}, {u'服务费用': u'{}'.format(serviceCharge)}, ]) consumeDict.update({ 'elecCharge': elecCharge, 'serviceCharge': serviceCharge, }) else: useMoney = self.deviceAdapter._get_power_use_money(reportRecord) # 根据用户使用的时间 以及经销商所设置的最小使用金额等等信息 判定最终所需支付的金额 usedCoins = self._handle_min_consume(useMoney) consumeDict.update({ DEALER_CONSUMPTION_AGG_KIND.COIN: usedCoins.mongo_amount }) # 刷卡的单独走 if portCache.get("cardNo"): card = self.update_card_dealer_and_type(portCache.get("cardNo")) self._handle_card_stop( cardOrderNo = portCache.get("cardOrderNo"), orderNo = portCache.get("orderNo"), totalConsume = usedCoins, chargeTime = chargeTime, elec = self.event_data.get("elec"), card = card, portStr = portStr, reason = self.event_data.get("reason") ) return user = MyUser.objects.filter(openId=portCache["openId"], groupId=self.device.groupId).first() # type: MyUser self._notify_user_finished(user, extra) # 对金钱的处理 先付费 如果自动退款打开并且存在退款金额 if not payAfterUse: backCoins = VirtualCoin(portCache["coins"]) - VirtualCoin(usedCoins) refundProtectTime = int(self.device.get("otherConf", dict()).get("refundProtectTime", self.deviceAdapter.DEFAULT_MIN_CHARGE_TIME)) if int(chargeTime) < int(refundProtectTime): refund_money(self.device, backCoins, portCache.get("openId")) self._notify_user_refund(user, backCoins, orderNo) consumeDict.update({DEALER_CONSUMPTION_AGG_KIND.REFUNDED_COINS: backCoins.mongo_amount}) elif self.device.is_auto_refund and backCoins > VirtualCoin(0): refund_money(self.device, backCoins, portCache.get("openId")) self._notify_user_refund(user, backCoins, orderNo) consumeDict.update({DEALER_CONSUMPTION_AGG_KIND.REFUNDED_COINS: backCoins.mongo_amount}) else: logger.info("device not refund, devNo = {}, refund coins = {}, autoRefund = {}, chargeTime= {}".format(self.device.devNo, backCoins, self.device.is_auto_refund, chargeTime)) # 后付费 修改订单的金额 并对用户的个人账户进行扣款 else: consumeOrder = ConsumeRecord.objects.get(orderNo=orderNo) consumeOrder.money = usedCoins.mongo_amount consumeOrder.coin = usedCoins.mongo_amount try: consumeOrder.save() except Exception as e: logger.error(e) # 对于个人账户的金币减去 相应的消费值 try: user.total_consumed = user.total_consumed + usedCoins user.balance = user.balance - usedCoins user.save() except Exception as e: logger.error(e) self._finished_service(portStr, user.openId, consumeDict) def do_all_report(self): """ 自定义的指令 将主板的主动上报修改为 模块侧轮询然后组装 """ subChargeList = self.event_data["subChargeList"] for _sub in subChargeList: self.__class__(self.deviceAdapter, _sub).do_report() def _notify_user_refund(self, user, coins, orderNo, refundType=u"金币退款"): """ 通知用户金币退回 :return: """ group = Group.get_group(self.device.groupId) self.notify_user( managerialOpenId=user.managerialOpenId if user else "", templateName="refund_coins", title=u"\\n\\n退款方式：\\t\\t{refundType}\\n\\n退款地址：\\t\\t{group}\\n\\n退款设备：\\t\\t{logicalCode}\\n\\n消费单号：\\t\\t{orderNo}".format( refundType=refundType, group=group["address"], logicalCode=self.device.logicalCode, orderNo=orderNo ), backCount="{:.2f}".format(float(coins)), finishTime=datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") )