# -*- coding: utf-8 -*- # !/usr/bin/env python import json import logging import datetime import time from mongoengine import DoesNotExist 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, ErrorCode, DEALER_CONSUMPTION_AGG_KIND from apps.web.dealer.models import Dealer from apps.web.device.models import Group, Device from apps.web.eventer import EventBuilder from apps.web.eventer.base import WorkEvent from apps.web.eventer.weifuleCommon import WeiFuLeStatusEvent, WeiFuLeCommonEvent from apps.web.user.models import ServiceProgress, UserVirtualCard, VCardConsumeRecord, \ ConsumeRecord, Card, CardConsumeRecord, CardRechargeOrder, MyUser, CardRechargeRecord, RechargeRecord logger = logging.getLogger(__name__) created_order_32 = 32 exec_order_33 = 33 finished_order_34 = 34 id_card_request_35 = 35 card_recharge_order_36 = 36 status_change_event_44 = 44 ic_consume_event_48 = 48 # ic卡花钱的时候，会上报此事件 part_sn_event = 49 # 组件上报相关信息 card_is_normal = 1 card_not_in_db = 2 card_is_forzen = 3 card_has_not_order = 4 # IC卡适用 card_less_balance = 5 # ID卡适用 card_type_is_ic = 6 # IC卡不允许当做ID卡使用 no_load_code = 7 class builder(EventBuilder): def __getEvent__(self, device_event): event_data = self.deviceAdapter.analyze_event_data(device_event['data']) if event_data is None: return None if event_data['fun_code'] in [created_order_32, exec_order_33, finished_order_34, id_card_request_35, card_recharge_order_36]: return ChargingSocketWorkEvent(self.deviceAdapter, event_data) if event_data['fun_code'] in [status_change_event_44]: return WeiFuLeStatusEvent(self.deviceAdapter, device_event) class ChargingSocketWorkEvent(WorkEvent, WeiFuLeCommonEvent): def analyse_need_from_package(self, order): needKind, needValue, unit = 'needElec', 0, u'度' if order['chrmt'] == 'TIME': needKind = 'needTime' needValue = order['amount_time'] / 60 unit = u'分钟' else: needValue = order['amount_elec'] / 1000000.0 return needKind, needValue, unit def create_progress_for_socket_order(self, consumeRcd, order): try: port = int(order['port']) progress = ServiceProgress.objects.filter(device_imei=self.device.devNo, port=port).first() if not progress: progress = ServiceProgress(device_imei=self.device.devNo, port=port) progress.start_time = order['create_time'] progress.finished_time = order['create_time'] + order.get('amount_time', 60 * 60 * 12) progress.isFinished = False else: if order['id'] in progress.consumes: return if progress.isFinished == False: progress.finished_time = progress.finished_time + order.get('amount_time', 60 * 60 * 12) else: progress.consumes = [] progress.start_time = order['create_time'] progress.finished_time = order['create_time'] + order.get('amount_time', 60 * 60 * 12) progress.isFinished = False progress.open_id = consumeRcd.openId progress.consumes.append(order['id']) progress.status = 'running' progress.save() except Exception as e: logger.exception(e) def do(self, **args): devNo = self.device['devNo'] funCode = self.event_data.get('fun_code') order = self.event_data.get('order', {}) logger.info('weifule charging event detected, devNo=%s' % (devNo,)) with memcache_lock(key = '%s-%s-%s-finished' % (devNo, order.get('id'), funCode), value = '1', expire = 120) as acquired: if acquired: self._do_ack_order(order) try: if funCode == created_order_32: self._do_created_order_32(order) elif funCode == exec_order_33: self._do_exec_order_33(order) elif funCode == finished_order_34 and order['order_type'] != 'card_charge': self._do_finished_order_34(order) elif funCode == finished_order_34 and order['order_type'] == 'card_charge': self.update_card_recharge_for_success_event(order['id'], RMB(order['balance'] / 100.0)) elif funCode == id_card_request_35: self.response_id_card() elif funCode == card_recharge_order_36: # 如果是卡充值，直接回复订单 self.deal_with_ic_charge_event() except Exception: import traceback logger.warn(traceback.format_exc()) logger.info('deal order is finished < funCode: {} order: {} >'.format(funCode, order.get('id'))) else: logger.info('weifule charging event is doing !!!, devNo=%s' % (devNo,)) def update_balance_for_IC_card(self, card, balance): card.balance = balance try: card.save() except Exception, e: pass def __translate_reason(self, cause, chrmt): if cause == 1: if chrmt == 'TIME': return u'订购时间已经用完。' else: return u'订购电量已经用完。' elif cause == 2: return u'用户远程停止。' elif cause == 3: return u'管理员操作停止。' elif cause == 4: return u'经销商远程停止。' elif cause == 5: return u'用户拔掉充电器，或者插座脱落。' elif cause == 6: return u'端口功率过载，系统为了安全，关闭此充电端口。' elif cause == 7: return u'整机电压过载，系统为了安全，关闭所有充电端口。' elif cause == 8: return u'端口电流过载，系统为了安全，关闭此充电端口。' elif cause == 9: return u'整机功率超限，系统为了安全，关闭所有充电端口。' elif cause == 10: return u'检测到温度超限，系统为了安全，关闭所有充电端口。' elif cause == 11: return u'充满自停' elif cause == 20: return u'端口功率过小。可能是电池已经充满，也可能是所接负载功率太小' return u'充电结束。' def record_consume_for_card(self, card, money, orderNo): group = Group.get_group(self.device['groupId']) address = group['address'] group_number = self.device['groupNumber'] now = datetime.datetime.now() new_record = { 'orderNo': orderNo, 'time': now.strftime('%Y-%m-%d %H:%M:%S'), 'dateTimeAdded': now, 'openId': card.openId, 'ownerId': self.device['ownerId'], 'coin': money.mongo_amount, 'money': money.mongo_amount, 'devNo': self.device['devNo'], 'logicalCode': self.device['logicalCode'], 'groupId': self.device['groupId'], 'address': address, 'groupNumber': group_number, 'groupName': group['groupName'], 'devTypeCode': self.device.devTypeCode, 'devTypeName': self.device.devTypeName, 'isNormal': True, 'status': ConsumeRecord.Status.RUNNING, 'remarks': u'刷卡消费', 'errorDesc': '', 'sequanceNo': '', 'desc': '', 'attachParas': {}, 'servicedInfo': {} } ConsumeRecord.get_collection().insert_one(new_record) # 刷卡消费也记录一条数据 new_card_record = { 'orderNo': orderNo, 'openId': card.openId, 'cardId': str(card.id), 'money': money.mongo_amount, 'balance': card.balance.mongo_amount, 'devNo': self.device['devNo'], 'devType': self.device['devType']['name'], 'logicalCode': self.device['logicalCode'], 'groupId': self.device['groupId'], 'address': address, 'groupNumber': group_number, 'groupName': group['groupName'], 'result': 'success', 'remarks': u'刷卡消费', 'sequanceNo': '', 'dateTimeAdded': datetime.datetime.now(), 'desc': '', 'servicedInfo': {}, 'linkedConsumeRcdOrderNo': str(new_record['orderNo']) } CardConsumeRecord.get_collection().insert(new_card_record) return new_record['orderNo'], new_card_record['orderNo'] def _do_ack_order(self, order): funCode = self.event_data['fun_code'] if funCode in [created_order_32, finished_order_34]: try: self.deviceAdapter.ack_event(order['id'], funCode) except Exception, e: logger.info('ack event devNo=%s err=%s' % (self.device.devNo, e)) pass def _do_created_order_32(self, order): if order['order_type'] == 'apps_start': # 扫码 self.pay_apps_start_by_32(order) consumeRcd = ConsumeRecord.objects.filter(orderNo=order['id']).first() if consumeRcd is None: return self.create_progress_for_socket_order(consumeRcd, order) elif order['order_type'] == 'card_start': cardNo = order['card_no'] # 登记下卡相关信息 if order['card_type'] == 'IC': card = self.update_card_dealer_and_type(cardNo, 'IC') if card: self.update_balance_for_IC_card(card, RMB(order['balance'] / 100.0)) else: return # 如果卡冻结了，马上把端口关闭 if card.frozen: logger.info('this card=%s is frozen,so shut down the port which opened by the card' % cardNo) self.deviceAdapter.stop_charging_port(order['port']) else: card = self.update_card_dealer_and_type(cardNo, 'ID') if not card: logger.info('no find card=<{}>'.format(cardNo)) return balance = card.balance - RMB(order['amount'] / 100.0) card.balance = balance # 卡的显示余额同步下 card.showBalance = balance card.save() fee = RMB(order['amount'] / 100.0) # 记录卡消费记录以及消费记录 orderNo, cardOrderNo = self.record_consume_for_card(card, fee, order['id']) consumeRcd = ConsumeRecord.objects.filter(orderNo=orderNo).first() self.create_progress_for_socket_order(consumeRcd, order) # 通知用户，已经扣费 title = make_title_from_dict([ {u'设备地址': u'{}'.format(self.device.group.address)}, {u'设备编号': u'{}'.format(self.device['logicalCode'])}, {u'实体卡': u'{}--No:{}'.format(card.cardName or card.nickName, card.cardNo)}, {u'本次消费': u'{} 元'.format(fee)}, {u'卡余额': u'{} 元'.format(RMB(order['balance'] / 100.0))}, ]) start_time_stamp = order.get('create_time') start_time = datetime.datetime.fromtimestamp(start_time_stamp) self.notify_user( card.managerialOpenId, 'dev_start', **{ 'title': title, 'things': u'刷卡消费', 'remark': u'感谢您的支持!', 'time': start_time.strftime(Const.DATETIME_FMT) } ) # 缓存切换 ctrInfo = Device.get_dev_control_cache(self.device.devNo) lineInfo = ctrInfo.get(str(order['port']), {}) if not lineInfo or lineInfo.get('status') == Const.DEV_WORK_STATUS_IDLE: lineInfo = { 'port': str(order['port']), 'status': Const.DEV_WORK_STATUS_WORKING, 'order_type': 'card_start', 'startTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'), 'orderNo': orderNo, } Device.update_port_control_cache(self.device.devNo, lineInfo) else: pass def _do_exec_order_33(self, order): now = datetime.datetime.fromtimestamp(order['exec_time']) consumeRcd = ConsumeRecord.objects.filter(orderNo=order['id']).first() if not consumeRcd: logger.info('no this order <{}> '.format(order['id'])) return consumeRcd.startTime = now consumeRcd.save() ctrInfo = Device.get_dev_control_cache(self.device.devNo) lineInfo = ctrInfo.get(str(order['port']), {}) if lineInfo.get('status') == Const.DEV_WORK_STATUS_WORKING and lineInfo.get('orderNo') == order['id']: lineInfo.update({'chrmt': order['chrmt']}) if 'card_no' in order: lineInfo.update({'cardType': order.get('card_type'),'cardNo': order.get('card_no')}) Device.update_port_control_cache(self.device.devNo, lineInfo) logger.info('now to exec order <{}>'.format(lineInfo.get('orderNo'))) return consumeRcd = ConsumeRecord.objects.filter(orderNo=order['id']).first() lineInfo = { 'port': str(order['port']), 'status': Const.DEV_WORK_STATUS_WORKING, 'order_type': order['order_type'], 'startTime': now.strftime('%Y-%m-%d %H:%M:%S'), 'orderNo': consumeRcd.orderNo, 'chrmt': order['chrmt'] } if 'card_no' in order: lineInfo.update({'cardType': order.get('card_type'), 'cardNo': order.get('card_no')}) Device.update_port_control_cache(self.device.devNo, lineInfo) logger.info('now to exec next order <{}>'.format(lineInfo.get('orderNo'))) def _do_finished_order_34(self, order): # 如果是离线卡的余额回收，修改下余额，然后直接返回即可 if order['order_type'] == 'card_refund': return self.update_card_dealer_and_type(cardNo=order['card_no'], cardType='IC', balance=RMB(order['balance'] / 100.0)) consumeRcd = ConsumeRecord.objects.filter(orderNo=order['id'], status__ne='finished').first() # type: ConsumeRecord if not consumeRcd: logger.info('Repeat processing!! orderNo<{}>'.format(order['id'])) return progress = ServiceProgress.objects.filter(device_imei=self.device.devNo, port=int(order['port']), consumes__contains=order['id']).first() if progress is None: pass else: progress.consumes.remove(order['id']) if len(progress.consumes) > 0: # 还有其他的单未处理完成 progress.save() else: progress.status = 'finished' # 此时为本次服务的最后一单 progress.isFinished = True progress.save() try: order['reason'] = self.__translate_reason(order['cause'], order['chrmt']) group = Group.get_group(self.device['groupId']) consumeDict = { 'reason': order['reason'], 'chargeIndex': order['port'], 'duration': round(order['time'] / 60.0, 1), 'elec': round(order['elec'] / 1000000.0, 2) } notifyDict = { 'service': u'充电服务完成', 'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'), 'remark': u'谢谢您的支持' } refundDict = { 'finishTime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') } refundProtection = self.device['otherConf'].get('refundProtection', 5) package = consumeRcd.package if package.get('name') == '充满自停' and package.get('coins') == 0 and package.get('price') == 0: # 后付费 usedFee = VirtualCoin(order['money'] * 0.01) usedTime = order['time'] / 60 cause = int(order.get(u'cause', 0)) if cause == no_load_code or usedTime <= refundProtection: usedFee = VirtualCoin(0) consumeDict.update({ DEALER_CONSUMPTION_AGG_KIND.SPEND_MONEY: usedFee.mongo_amount }) user = MyUser.objects(openId=consumeRcd.openId, groupId=self.device['groupId']).first() if not user: return try: user.pay(usedFee) consumeRcd.update(coin=usedFee.mongo_amount, status='finished') except Exception: pass notifyDict.update( {'title': make_title_from_dict([ {u'设备编号': self.device['logicalCode']}, {u'端口': order['port']}, {u'地址': group['address']}, {u'结束原因': order['reason']}, {u'充电时间': u'%s分钟' % round(usedTime, 1)}, {u'本次服务费用': u'%s币' % usedFee}, ])}) # 通知服务结束 notifyOpenId = user.managerialOpenId if user else '' self.notify_user(notifyOpenId, 'service_complete', **notifyDict) consumeRcd.update_service_info(consumeDict) consumeRcd.update(status='finished', finishedTime=datetime.datetime.now(), servicedInfo__source=json.dumps(order)) logger.info('orderNo<{}> finished!!'.format(consumeRcd.orderNo)) return else: coins = consumeRcd.coin backCoins = RMB(0) if order['chrmt'] == 'TIME': # 按照时间计费 needTime = round(order['amount_time'] / 60.0, 1) usedTime = round(order['time'] / 60.0, 1) leftTime = round(order['left_time'] / 60 if order['left_time'] > 0 else 0, 1) leftTimeStr = leftTime actualNeedTime = round(usedTime + leftTime, 1) consumeDict.update({ 'needTime': needTime, 'leftTime': leftTimeStr, 'actualNeedTime': u'动态功率计算为%s分钟' % actualNeedTime, }) notifyDict.update({'title': make_title_from_dict([ {u'设备编号': self.device['logicalCode']}, {u'端口': order['port']}, {u'地址': group['address']}, {u'结束原因': order['reason']}, {u'订购时间': u'%s分钟' % needTime}, {u'应充时间': u'%s分钟' % actualNeedTime}, {u'充电时间': u'%s分钟' % usedTime}, {u'剩余时间': u'%s分钟' % leftTimeStr} ])}) refundTitleDictList = [ {u'设备编号': self.device['logicalCode']}, {u'端口': order['port']}, {u'付款': u'%s元' % coins}, {u'预定时间': u'%s分钟' % needTime}, {u'应充时间': u'%s分钟' % actualNeedTime}, {u'充电时间': u'%s分钟' % usedTime}, {u'剩余时间': u'%s分钟' % leftTimeStr}, ] else: needElec = round(order['amount_elec'] / 1000000.0, 2) usedTime = round(order['time'] / 60.0, 1) usedElec = round(order['elec'] / 1000000.0, 2) leftElec = round(needElec - usedElec if needElec > usedElec else 0.0, 2) consumeDict.update({ 'needElec': needElec, 'leftElec': leftElec, }) notifyDict.update({'title': make_title_from_dict([ {u'设备编号': self.device['logicalCode']}, {u'端口': order['port']}, {u'结束原因': order['reason']}, {u'充电时间': u'%s分钟' % usedTime}, {u'订购电量': u'%s度' % needElec}, {u'消耗电量': u'%s度' % usedElec}, {u'剩余电量': u'%s度' % leftElec}, ])}) refundTitleDictList = [ {u'设备编号': self.device['logicalCode']}, {u'端口': order['port']}, {u'结束原因': order['reason']}, {u'充电时间': u'%s分钟' % usedTime}, {u'订购电量': u'%s度' % needElec}, {u'消耗电量': u'%s度' % usedElec}, {u'剩余电量': u'%s度' % leftElec}, ] if usedTime <= refundProtection: backCoins = coins else: if self.device.is_auto_refund: backCoins = coins * (float(order['left_money']) / float(order['amount'])) refundDict.update({ 'title': make_title_from_dict(refundTitleDictList), 'backCount': u'金币：%s' % backCoins }) logger.info( 'REFUND STATUS orderNo=<{}>, refundSwitch={}, refundProtectionTime=<{}>, backCoins=<{}>'.format( consumeRcd.orderNo, self.device.is_auto_refund, refundProtection, backCoins.mongo_amount )) if u'虚拟卡' in consumeRcd.remarks: # 退额度 try: vRcd = VCardConsumeRecord.objects.get(orderNo=order['id']) vCard = UserVirtualCard.objects.get(id=vRcd.cardId) except DoesNotExist, e: logger.info('can not find the vCard id = %s' % vRcd.cardId) return # 通知服务结束 notifyOpenId = self.get_managerialOpenId_by_openId(vRcd.openId) if vCard else '' self.notify_user(notifyOpenId, 'service_complete', **notifyDict) # 不需要退款，直接返回，不通知 if self.device.is_auto_refund and backCoins > RMB(0): if order['chrmt'] == 'TIME': vCard.refund_quota(vRcd, usedTime, 0.0, backCoins.mongo_amount) else: vCard.refund_quota(vRcd, 0.0, usedElec, backCoins.mongo_amount) # 刷卡的方式 elif order['order_type'] == 'card_start' and order['card_no']: dealer = Dealer.get_dealer(ownerId=self.device['ownerId']) card = Card.objects.filter(agentId=dealer['agentId'], cardNo=order['card_no']).first() if card is None: # 离线卡没有绑定或者在线卡被解绑了 return # 先通知 notifyOpenId = card.managerialOpenId if card else '' self.notify_user(notifyOpenId, 'service_complete', **notifyDict) # 不需要退款，直接返回.在线卡需要退费，离线卡只登记使用记录就OK if backCoins > RMB(0) and card.cardType == 'ID' and backCoins > RMB(0): card = self.refund_money_for_card(RMB(backCoins), card.id) card.showBalance = card.balance card.save() consumeDict.update({'refundedMoney': str(backCoins)}) self.notify_user(notifyOpenId, 'refund_coins', **refundDict) else: # 扫码的 user = MyUser.objects(openId=consumeRcd.openId, groupId=self.device['groupId']).first() if not user: return # 通知服务结束 notifyOpenId = user.managerialOpenId if user else '' self.notify_user(notifyOpenId, 'service_complete', **notifyDict) # 如果需要退款，计算退款数据. if backCoins > RMB(0): refundCash = 'refundRMB_device_event' in self.device.owner.features rechargeRcdId = consumeRcd.recharge_record_id if rechargeRcdId: rechargeRcd = RechargeRecord.objects.filter(id=rechargeRcdId, isQuickPay=True).first() else: rechargeRcd = None if refundCash is True and rechargeRcd is not None: # 退现金特征 + 有充值订单 refundRMB = rechargeRcd.money * (backCoins.amount / coins.amount) self.refund_net_pay(user, {'rechargeRcdId': rechargeRcdId, 'openId': user.openId}, refundRMB, VirtualCoin(0), consumeDict, True) refundDict.update({'backCount': u'金额：%s' % refundRMB}) self.notify_user(notifyOpenId, 'refund_coins', **refundDict) else: self.refund_net_pay(user, {'openId': user.openId}, RMB(0), backCoins, consumeDict, False) self.notify_user(notifyOpenId, 'refund_coins', **refundDict) consumeRcd.update_service_info(consumeDict) consumeRcd.update(status='finished', finishedTime=datetime.datetime.now(),servicedInfo__source=json.dumps(order)) except Exception as e: logger.exception('some exception happed,devNo=%s,e=%s' % (self.device.devNo, e)) finally: ctrInfo = Device.get_dev_control_cache(self.device.devNo) lineInfo = ctrInfo.get(str(order['port']), {}) # 如果缓存中要结束的端口是本单的 就清空缓存 否则不处理 if order['id'] == lineInfo.get('orderNo'): Device.clear_port_control_cache(self.device.devNo, order['port']) # 这里采用更新端口 不操作缓存 self.deviceAdapter.get_port_status_from_dev() def deal_with_ic_charge_event(self): cardNo = self.event_data['card_no'] card = self.update_card_dealer_and_type(cardNo, 'IC') if not card: return self.deviceAdapter.response_card_charge_result(self.event_data['card_no'], card_not_in_db) elif card.frozen: return self.deviceAdapter.response_card_charge_result(self.event_data['card_no'], card_is_forzen) preBalance = card.balance rechargeOrder = CardRechargeOrder.get_last_to_do_one(str(card.id)) if rechargeOrder: self.recharge_ic_card(card=card, preBalance=preBalance, rechargeType='append', order=rechargeOrder, need_verify=False) else: return self.deviceAdapter.response_card_charge_result(self.event_data['card_no'], card_has_not_order) def recharge_ic_card(self, card, preBalance, rechargeType, order, need_verify=True): # type:(Card, RMB, str, CardRechargeOrder, bool)->bool """ # rechargeType有两种，一种是用直接覆写overwrite的方式，一种是append追加钱的方式。 # 不同的的设备，充值的方式还不一样.注意：money是实际用户付的钱，coins是给用户充值的钱，比如付10块（money），充15（coins）。 :param card: :param preBalance: :param rechargeType: :param order: :return: """ if not order or order.coins == RMB(0): return False status = Card.get_card_status(str(card.id)) if status == 'busy': return False Card.set_card_status(str(card.id), 'busy') try: # IC卡需要下发到设备，设备写卡，把余额打入卡中 if rechargeType == 'overwrite': sendMoney = preBalance + order.coins else: sendMoney = order.coins # 先判断order最近一次充值是否OK. 满足三个条件才认为上次充值成功: # 1、操作时间已经超过三天 # 2、操作结果是串口超时, 即result == 1 # 3、当前余额大于最后一次充值操作的充值前余额 if need_verify and len(order.operationLog) > 0: log = order.operationLog[-1] result = log['result'] time_delta = (datetime.datetime.now() - log['time']).total_seconds() last_pre_balance = RMB(log['preBalance']) if (result == ErrorCode.DEVICE_CONN_FAIL or result == ErrorCode.BOARD_UART_TIMEOUT) \ and (time_delta > 3 * 24 * 3600 or preBalance > last_pre_balance): logger.debug('{} recharge verify result is finished.'.format(repr(card))) order.update_after_recharge_ic_card(device=self.device, sendMoney=sendMoney, preBalance=preBalance, result=ErrorCode.SUCCESS, description=u'充值校验结束') CardRechargeRecord.add_record( card=card, group=Group.get_group(order.groupId), order=order, device=self.device) return False try: operation_result, balance = self.deviceAdapter.recharge_card(card.cardNo, sendMoney, orderNo=str(order.id)) order.update_after_recharge_ic_card(device=self.device, sendMoney=sendMoney, preBalance=preBalance, syncBalance=balance, result=operation_result['result'], description=operation_result['description']) if operation_result['result'] != ErrorCode.SUCCESS: return False if not balance: balance = preBalance + order.coins CardRechargeRecord.add_record( card=card, group=Group.get_group(order.groupId), order=order, device=self.device) # 刷新卡里面的余额 card.balance = balance card.lastMaxBalance = balance card.save() return True except Exception as e: order.update_after_recharge_ic_card(device=self.device, sendMoney=sendMoney, preBalance=preBalance, syncBalance=balance, result=ErrorCode.EXCEPTION, description=e.message) return False except Exception as e: logger.exception(e) return False finally: Card.set_card_status(str(card.id), 'idle') def response_id_card(self): cardNo = self.event_data['card_no'] Card.record_dev_card_no(self.device['devNo'], cardNo) card = Card.objects.filter(cardNo=cardNo, agentId=self.device.owner.agentId).first() # 如果没有卡，直接返回 if card is None: return self.deviceAdapter.response_card_balance(cardNo=cardNo, balance=0, result=card_not_in_db, amount=0) if card.cardType == '': card.update(cardType='ID') elif card.cardType != 'ID': # 如果以前是离线卡，只能用于离线卡，需要提醒用户 return self.deviceAdapter.response_card_balance(cardNo=cardNo, balance=0, result=card_type_is_ic, amount=0) if card.frozen: return self.deviceAdapter.response_card_balance(cardNo=cardNo, balance=0, result=card_is_forzen, amount=0) card_recharge_order = CardRechargeOrder.get_last_to_do_one(str(card.id)) if card_recharge_order: result = self.recharge_id_card(card=card, rechargeType='append', order=card_recharge_order) card.reload() oper = self.event_data.get('reduce') fee = RMB(self.device['otherConf'].get('id_card_oncefee', 1)) if oper: if card.balance >= fee: result = card_is_normal balance = card.balance - fee # balance = card.showBalance * 100 else: result = card_less_balance # balance = card.showBalance * 100 balance = card.balance self.deviceAdapter.response_card_balance(cardNo, fee, balance, result) # 返回的cardNo为16进制 else: self.deviceAdapter.response_card_balance(cardNo, fee, card.balance, card_is_normal)