# -*- coding: utf-8 -*- # !/usr/bin/env python import datetime import logging import re import time from decimal import Decimal from typing import TYPE_CHECKING from apilib.monetary import RMB, VirtualCoin from apilib.utils import is_number from apilib.utils_datetime import to_datetime from apps import serviceCache from apps.web.constant import Const, DeviceCmdCode, CONSUMETYPE from apps.web.core.adapter.base import SmartBox from apps.web.core.exceptions import ServiceException, InvalidParameter from apps.web.core.networking import MessageSender from apps.web.device.models import Device, Group from apps.web.user.models import Card, CardRechargeOrder, ConsumeRecord, MyUser logger = logging.getLogger(__name__) if TYPE_CHECKING: pass class ChargingZhongShanBox(SmartBox): def __init__(self, device): super(ChargingZhongShanBox, self).__init__(device) # 解析获取设备信息的返回报文 def analyze_event_data(self, device_data): uart_data = device_data.get("data") if not uart_data: return data = str(uart_data) if data[:2] != "CC": return consumeModule = self.device["otherConf"].get("deviceConfigs", {}).get("consumeModule") if consumeModule is None: consumeModule = self.get_function_switch().get("consumeModule") self.get_consumption_rules() self._device = Device.get_dev(self.device.devNo) if self.device.devTypeCode == Const.DEVICE_TYPE_CODE_CHARGE_ZHONGSHAN_BILLASSERVICE: billingType = "billAsService" if consumeModule == 1 else "elec" else: billingType = "time" if consumeModule == 1 else "elec" cmd = data[4:6] if cmd == "99": return {"cmd":cmd} if cmd == "04": port = self.decode_str(data[18:20]) cardNo = "{:0>10}".format(self.decode_str(data[20:28])) eventCode = data[28:30] fee = self.decode_str(data[30:32], ratio=0.1, base=10) cardType = "IC" if data[32:34] == "02" else "ID" cardBalance = self.decode_str(data[34:38], ratio=0.1, base=10) return {"cmd": cmd, "cardNo": cardNo, "port": port, "eventCode": eventCode, "fee": fee, "cardType": cardType, "cardBalance": cardBalance, "billingType": billingType, "uart_data": uart_data} elif cmd == "05": reasonDict = { "01": "购买的充电时间、电量用完了", "02": "用户手动停止（拔插头，或是按了停止按钮）", "03": "您的爱车充满电了", "04": "设备或是端口出现问题，被迫停止", "05": "因充电器功率超过充电站的单路最大输出功率，切断输出", "06": "超高温（达到75度）", "07": "烟雾报警", "08": "漏电报警", "09": "负载电流过大（短路）", "0A": "开始充电未接充电器", "0B": "端口远程停止", } consumeTypeDict = { "01": "投币消费", "02": "离线卡消费", "03": "在线卡消费", "04": "扫码消费", "05": "远程开启", } port = self.decode_str(data[18:20]) reasonCode = data[24:26] reason = reasonDict.get(reasonCode) backMoney = self.decode_str(data[34:38], ratio=0.01, base=10) consumeTypeCode = data[38:40] consumeType = consumeTypeDict.get(consumeTypeCode) result = {"cmd": cmd, "port": port, "reasonCode": reasonCode, "reason": reason, "backMoney": backMoney, "consumeTypeCode": consumeTypeCode, "consumeType": consumeType, "billingType": billingType, "uart_data": uart_data } if "ack_event_id" in device_data: result["ack_event_id"] = device_data["ack_event_id"] if billingType == "time": leftTime = self.decode_str(data[20:24]) result["leftTime"] = leftTime elif billingType == "billAsService": serviceFee = self.decode_str(data[20:24], ratio=0.01) result["serviceFee"] = serviceFee else: leftElec = self.decode_str(data[20:24], ratio=0.01) result["leftElec"] = leftElec if consumeTypeCode == "02": # 离线卡 cardNo = "{:0>10}".format(self.decode_str(data[26:34])) result["cardNo"] = cardNo elif consumeTypeCode == "03": # 扫码 cardNo = "{:0>10}".format(self.decode_str(data[26:34])) result["cardNo"] = cardNo elif consumeTypeCode == "01": # 线下投币 try: rechargeCode = self.decode_long_hex_to_list(data[26:34]) rechargeCode = "".join(rechargeCode[:3]) result["rechargeCode"] = rechargeCode except Exception: result["rechargeCode"] = "000" else: pass return result elif cmd == "09": errorDict = { "01": "端口输出故障", "02": "机器整机功率过大", "03": "电源故障", "04": "机箱超温（高于80摄氏度）", "05": "烟雾警告", "06": "漏电", "07": "端口故障", "08": "其他", } port = data[18:20] if data[18:20] != "FF" else None FaultCode = data[20:22] fault = errorDict.get(FaultCode) return {"status": Const.DEV_WORK_STATUS_FAULT, "statusInfo": fault, "cmdCode": cmd, "port": port, "FaultCode": FaultCode, "billingType": billingType, "uart_data": uart_data} elif cmd == "1D": cardNo = "{:0>10}".format(self.decode_str(data[18:26])) cardType = "IC" if data[26:28] == "02" else "ID" cardBalance = self.decode_str(data[28:32], ratio=0.1, base=10) return {"cmd": cmd, "cardNo": cardNo, "cardType": cardType, "cardBalance": cardBalance, "billingType": billingType, "uart_data": uart_data} elif cmd == "1F": cardNo = "{:0>10}".format(self.decode_str(data[18:26])) cardType = "IC" if data[26:28] == "02" else "ID" ayscMoney = self.decode_str(data[28:32], ratio=0.1, base=10) cardBalance = self.decode_str(data[32:36], ratio=0.1, base=10) status = data[36:38] return {"cmd": cmd, "cardNo": cardNo, "cardType": cardType, "ayscMoney": ayscMoney, "cardBalance": cardBalance, "status": status, "billingType": billingType, "uart_data": uart_data} elif cmd == "03": port = self.decode_str(data[18:20]) coins = self.decode_str(data[20:22], ratio=0.1, base=10) return {"cmd": cmd, "port": port, "coins": coins, "billingType": billingType, "uart_data": uart_data} elif cmd == "F1": # 主板心跳 data = self.decode_str(data[18:20]) return {"cmd": cmd, "billingType": billingType, "data": data, "uart_data": uart_data} else: pass def _check_package(self, package): """ 获取设备启动的发送数据 根据设备的当前模式以及套餐获取 :param package: :return: """ consumeModule = self.device.get("otherConf", dict()).get("deviceConfigs", dict()).get("consumeModule",None) if consumeModule is None: consumeModule = int(self.get_function_switch().get("consumeModule")) self.get_consumption_rules() self._device = Device.get_dev(self.device.devNo) unit = package.get("unit", u"分钟") _time = float(package.get("time", 0)) if self.device.devTypeCode == Const.DEVICE_TYPE_CODE_CHARGE_ZHONGSHAN_BILLASSERVICE: if consumeModule == 1: billingType = "billAsService" else: billingType = "elec" if unit != u"度": raise ServiceException({"result": 2, "description": u"套餐单位错误，请联系经销商"}) else: _time = _time else: # 按时间计费 if consumeModule == 1: billingType = "time" if unit == u"小时": _time = _time * 60 elif unit == u"天": _time = _time * 24 * 60 elif unit == u"秒": _time = _time / 60 elif unit == u"分钟": _time = _time else: raise ServiceException({"result": 2, "description": u"套餐单位错误，请联系经销商"}) # 按电量计费 else: billingType = "elec" if unit != u"度": raise ServiceException({"result": 2, "description": u"套餐单位错误，请联系经销商"}) else: _time = _time return _time, unit, billingType def disable_app_device(self, switch=True): # type:(bool) -> None otherConf = self.device.get("otherConf", {}) otherConf["disableDevice"] = switch Device.objects.filter(devNo=self.device["devNo"]).update(otherConf=otherConf) Device.invalid_device_cache(self.device["devNo"]) @staticmethod def encode_str(data, length=2, ratio=1.0, base=16): # type:(str,int,float,int) -> str if not isinstance(data, Decimal): data = Decimal(data) if not isinstance(length, str): length = str(length) if not isinstance(ratio, Decimal): ratio = Decimal(ratio) end = "X" if base == 16 else "d" encodeStr = "%." + length + end encodeStr = encodeStr % (data * ratio) return encodeStr @staticmethod def decode_str(data, ratio=1.0, base=16): # type:(str,float,int) -> str """ ratio:比率单位转换 """ if not isinstance(data, str): data = str(data) return "%.10g" % (int(data, base) * ratio) @staticmethod def reverse_hex(data): # type:(str) -> str if not isinstance(data, str): raise TypeError return "".join(list(reversed(re.findall(r".{2}", data)))) def decode_long_hex_to_list(self, data, split=2, ratio=1.0, base=16): # type:(str,int,float,int) -> list """ return: list """ if len(data) % split != 0: raise Exception("Invalid data") pattern = r".{%s}" % split hex_list = re.findall(pattern, data) hex_list = map(lambda x: self.decode_str(x, ratio=ratio, base=base), hex_list) return hex_list @staticmethod def check_params_range(params, minData=None, maxData=None, desc=""): # type:(str,float,float,str) -> str """ 检查参数,返回字符串参数 """ if params is None: raise ServiceException({"result": 2, "description": u"参数错误."}) if not isinstance(params, Decimal): params = Decimal(params) if not minData and maxData: if not isinstance(maxData, Decimal): maxData = Decimal(maxData) if params <= maxData: return "%g" % params else: raise ServiceException({"result": 2, "description": u"%s超出可选范围,可选最大值为%g" % (desc, maxData)}) if not maxData and minData: if not isinstance(minData, Decimal): minData = Decimal(minData) if minData <= params: return "%g" % params else: raise ServiceException({"result": 2, "description": u"%s超出可选范围,可选最小值为%g" % (desc, minData)}) if not minData and not maxData: return "%g" % params else: if not isinstance(minData, Decimal): minData = Decimal(minData) if not isinstance(maxData, Decimal): maxData = Decimal(maxData) if minData <= params <= maxData: return "%g" % params else: raise ServiceException( {"result": 2, "description": u"%s参数超出可选范围,可取范围为%g-%g" % (desc, minData, maxData)}) def send_mqtt(self, funCode, data, cmd=DeviceCmdCode.OPERATE_DEV_SYNC): """ 发送mqtt 指令210 返回data """ if not isinstance(funCode, str): funCode = str(funCode) if not isinstance(data, str): data = str(data) result = MessageSender.send(self.device, cmd, {"IMEI": self.device["devNo"], "funCode": funCode, "data": 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 if result.get("data") == "00": raise ServiceException({"result": 2, "description": u"设备操作失败.请重试"}) else: return str(result["data"][18:-2]) @staticmethod def port_is_busy(port_dict): if not port_dict: return False if "billingType" not in port_dict: return False if "status" not in port_dict: return False if "coins" not in port_dict: return False if port_dict["billingType"] not in ["time", "elec"]: return False if port_dict["billingType"] == "time": if "needTime" not in port_dict: return False else: if "needElec" not in port_dict: return False if port_dict["status"] == Const.DEV_WORK_STATUS_WORKING: return True else: return False def ack_05_event(self, ack_event_id): try: MessageSender.send(device=self.device, cmd=DeviceCmdCode.OPERATE_DEV_SYNC, payload={ "IMEI": self.device.devNo, "data": "00", "cmd": DeviceCmdCode.OPERATE_DEV_SYNC, "ack_event_id": ack_event_id, "funCode": "CA"}) except Exception: pass def send_F1_heartbeat(self): self.send_mqtt(funCode="F1", data="00") def do_update_configs(self, updateDict): dev = Device.objects.get(devNo=self.device.devNo) deviceConfigs = dev.otherConf.get("deviceConfigs", {}) deviceConfigs.update(updateDict) dev.otherConf['deviceConfigs'] = deviceConfigs dev.save() Device.invalid_device_cache(self.device.devNo) def start_device(self, package, openId, attachParas): # type: (...)-> dict if attachParas is None: raise ServiceException({"result": 2, "description": u"请您选择合适的充电线路、电池类型信息"}) if "chargeIndex" not in attachParas: raise ServiceException({"result": 2, "description": u"请您选择合适的充电线路"}) dev = Device.objects.get(devNo=self.device["devNo"]) refundProtection = dev.otherConf.get("refundProtection", 0) refundProtectionTime = dev.otherConf.get("refundProtectionTime", 5) port = attachParas["chargeIndex"] portHex = self.encode_str(port, 2) _time, unit, billingType = self._check_package(package) coins = float(package.get("coins", 0)) coinsHex = self.encode_str(coins, length=4, ratio=10, base=10) unitHex = self.encode_str(_time, length=4) unit = package["unit"] price = float(package['price']) if unit == "度": unitHex = self.encode_str(_time, length=4, ratio=100) orderNo = attachParas.get("orderNo") data = portHex + coinsHex + unitHex logger.info("lz_start_device devNo:{}, cmd:220 funcCode:02 uart_send:{}".format(self.device["devNo"], data)) devInfo = MessageSender.send( device=self.device, cmd=DeviceCmdCode.OPERATE_DEV_SYNC, payload={ "IMEI": self.device["devNo"], "funCode": "02", "data": data }, timeout=120 ) if "rst" in devInfo and devInfo["rst"] != 0: if devInfo["rst"] == -1: raise ServiceException( {"result": 2, "description": u"充电桩正在玩命找网络，您的金币还在，重试不需要重新付款，建议您试试旁边其他设备，或者稍后再试哦"}) elif devInfo["rst"] == 1: self.check_serial_port_for_startcmd(attachParas["chargeIndex"]) # 收到回应报文后，需要ack响应报文。 logger.info("lz_start_device devNo:{}, funcCode:02 uart_rece:{}".format(self.device["devNo"], devInfo)) data = devInfo["data"][18::] usePort = int(attachParas["chargeIndex"]) result = data[2:4] if result == "01": # 成功 pass elif result == "02": newValue = {str(usePort): {"status": Const.DEV_WORK_STATUS_FAULT, "statusInfo": u"充电站故障"}} Device.update_dev_control_cache(self.device["devNo"], newValue) raise ServiceException({"result": 2, "description": u"充电站故障"}) elif result == "03": newValue = {str(usePort): {"status": Const.DEV_WORK_STATUS_WORKING, "statusInfo": u""}} Device.update_dev_control_cache(self.device["devNo"], newValue) raise ServiceException({"result": 2, "description": u"该端口正在使用中"}) portDict = { "startTime": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "status": Const.DEV_WORK_STATUS_WORKING, "billingType": billingType, "isStart": True, "openId": openId, "refunded": False, "refundProtection": refundProtection, "refundProtectionTime": refundProtectionTime, "doPowerLevel": False, "consumeType": "mobile", "orderNo": orderNo, "port": usePort } servicedInfo = {"chargeIndex":usePort} ConsumeRecord.objects.filter(orderNo = orderNo).update(servicedInfo=servicedInfo,remarks='扫码启动') ctrInfo = Device.get_dev_control_cache(self.device["devNo"]) lastPortInfo = ctrInfo.get(str(usePort), {}) if (lastPortInfo is not None) and \ lastPortInfo.get('status', '') == Const.DEV_WORK_STATUS_WORKING and \ lastPortInfo.get('openId') == openId and \ lastPortInfo.get('billingType') == billingType: is_continus = True else: is_continus = False if 'linkedRechargeRecordId' in attachParas: portDict['rechargeRcdId'] = str(attachParas['linkedRechargeRecordId']) if billingType == "time": if is_continus: portDict["coins"] = float(coins) + lastPortInfo["coins"] portDict["price"] = float(price) + lastPortInfo["price"] portDict["needTime"] = _time + lastPortInfo["needTime"] else: portDict["coins"] = float(coins) portDict["price"] = float(price) portDict.update({"needTime": _time}) finishedTime = int(time.time()) + int(portDict["needTime"] * 60) elif billingType == "elec": if is_continus: portDict["coins"] = float(coins) + lastPortInfo["coins"] portDict["needElec"] = _time + lastPortInfo["needElec"] else: portDict["coins"] = float(coins) portDict.update({"needElec": _time}) finishedTime = int(time.time()) + 60 * 60 * 12 else: if is_continus: portDict["coins"] = float(coins) + lastPortInfo["coins"] else: portDict["coins"] = float(coins) finishedTime = int(time.time()) + 60 * 60 * 12 portDict.update({"finishedTime": finishedTime}) if "orderNo" in attachParas: portDict.update({"orderNo": attachParas["orderNo"]}) Device.update_port_control_cache(self.device["devNo"], portDict) devInfo["finishedTime"] = finishedTime return devInfo def get_device_ID(self): # type:() -> dict """ 获取设备唯一ID funcCode : 55 """ result = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC, {"IMEI": self.device["devNo"], "funCode": "55", "data": "00"}) 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 result.get("data") == "00": raise ServiceException({"result": 2, "description": u"设备操作失败.请重试"}) else: data = result.get("data") data_list = self.decode_long_hex_to_list(data[6:-2], base=10) return {"deviceId": "".join(data_list)} def get_default_port_nums(self): allPorts = self.device["otherConf"].get("deviceConfigs", {}).get("allPorts") if not allPorts: data = self.send_mqtt(funCode="01", data="00") allPorts = int(data[:2], 16) self.do_update_configs({"allPorts": allPorts}) return allPorts def get_mcu_version(self): devInfo = MessageSender.send(self.device, DeviceCmdCode.OPERATE_DEV_SYNC, {"IMEI": self.device["devNo"], "funCode": "25", "data": "00"}) if "rst" in devInfo and devInfo["rst"] != 0: if devInfo["rst"] == -1: raise ServiceException( {"result": 2, "description": u"充电桩正在玩命找网络,请您稍候再试"}) elif devInfo["rst"] == 1: raise ServiceException( {"result": 2, "description": u"充电桩忙,无响应,请您稍候再试。也可能是您的设备版本过低，暂时不支持此功能"}) confData = devInfo["data"][18::] mcuVersion = int(confData[0:4], 16) return {"mcuVersion": mcuVersion} def get_port_status(self, force=False): if force: return self.get_all_port_status() ctrInfo = Device.get_dev_control_cache(self.device.devNo) if "allPorts" in ctrInfo and ctrInfo["allPorts"] > 0: allPorts = ctrInfo["allPorts"] else: allPorts = self.get_default_port_nums() statusDict = {} for ii in range(allPorts): tempDict = ctrInfo.get(str(ii + 1), {}) if "status" in tempDict: statusDict[str(ii + 1)] = {"status": tempDict.get("status")} elif "isStart" in tempDict: if tempDict["isStart"]: statusDict[str(ii + 1)] = {"status": Const.DEV_WORK_STATUS_WORKING} else: statusDict[str(ii + 1)] = {"status": Const.DEV_WORK_STATUS_IDLE} else: statusDict[str(ii + 1)] = {"status": Const.DEV_WORK_STATUS_IDLE} return statusDict def get_port_info(self, port): # type:(str) -> dict """ 获取单个端口状态 funcCode : 06 发送:CC09060009090909090107 返回:AA0D06000909090909 01 0054 0364 30 """ data = self.encode_str(port, 2) data = self.send_mqtt(funCode="06", data=data) if self.device.bill_as_service_feature.on: billingType = "billAsService" if self.device["otherConf"].get("deviceConfigs", dict()).get("consumeModule", 0) == 1 else "elec" else: billingType = "time" if self.device["otherConf"].get("deviceConfigs", dict()).get("consumeModule", 0) == 1 else "elec" port = self.decode_str(data[:2]) if billingType == "time": leftTime = int(self.decode_str(data[2:6])) else: if self.device.bill_as_service_feature.on: if billingType == 'billAsService': serviceFee = float(self.decode_str(data[2:6], ratio=0.01)) else: leftElec = float(self.decode_str(data[2:6], ratio=0.01)) leftTime = int(self.decode_str(data[10:14])) else: leftElec = float(self.decode_str(data[2:6], ratio=0.01)) leftTime = int(self.decode_str(data[10:14])) power = self.decode_str(data[6:10], ratio=0.1, base=10) leftBalance = self.decode_str(data[14:18], ratio=0.01, base=10) result = locals() result.pop("self") return result def get_all_port_status(self): # type:() -> dict """ 获取所有端口的状态 空闲,使用,禁用,故障 funcCode : 01 发送:CC09010009090909090001 返回:AA1301000909090909 0A 1000 00 00 00 00 00 00 00 00 01 """ data = self.send_mqtt(funCode="01", data="00") result = {} allPorts = int(data[:2], 16) usedPorts = 0 portData = re.findall(r"..", data[2:]) for i, statusTemp in enumerate(portData[:allPorts]): if statusTemp == "00": status = {"status": Const.DEV_WORK_STATUS_IDLE} elif statusTemp == "01": status = {"status": Const.DEV_WORK_STATUS_WORKING} usedPorts += 1 elif statusTemp == "02": status = {"status": Const.DEV_WORK_STATUS_FORBIDDEN} usedPorts += 1 elif statusTemp == "03": status = {"status": Const.DEV_WORK_STATUS_FAULT} usedPorts += 1 else: status = {"status": Const.DEV_WORK_STATUS_FAULT} usedPorts += 1 result[str(i + 1)] = status usePorts = allPorts - usedPorts # 这里存在多线程更新缓存的场景，可能性比较低，但是必须先取出来，然后逐个更新状态，然后再记录缓存 ctrInfo = Device.get_dev_control_cache(self.device["devNo"]) for strPort, info in result.items(): if strPort in ctrInfo: ctrInfo[strPort].update({"status": info["status"]}) else: ctrInfo[strPort] = info ctrInfo.update({ "allPorts": allPorts, "usedPorts": usedPorts, "usePorts": usePorts }) Device.update_dev_control_cache(self.device.devNo, ctrInfo) # 01指令读不到非法充电的充电状态，所以需要从缓存中查找是否有非法充电的端口 cacheInfo = Device.get_dev_control_cache(self.device.devNo) for k,v in cacheInfo.items(): if type(k) == unicode: k = k.encode('gbk') if str.isdigit(k): if v.get('statusErrorInfo') == '非法充电': if result[k]["status"] == Const.DEV_WORK_STATUS_IDLE: result[k] = {"status": Const.DEV_WORK_STATUS_WORKING,"errorInfo":True} return result def get_all_port_info(self): # type:() -> dict """ 获取全部端口的信息 funcCode : 07 发送:CC09070009090909090007 返回:AA330700000000000100081D00000000000000000000000000000000000519840011006000000000000000000000000000000000C9 """ if self.device.devTypeCode == Const.DEVICE_TYPE_CODE_CHARGE_ZHONGSHAN_BILLASSERVICE: billingType = "billAsservice" if self.device["otherConf"].get("deviceConfigs", dict()).get("consumeModule", 0) == 1 else "elec" else: billingType = "time" if self.device["otherConf"].get("deviceConfigs", dict()).get("consumeModule", 0) == 1 else "elec" data = self.send_mqtt(funCode="07", data="00") totalAmpere = self.decode_str(data[:4], ratio=0.1, base=10) temperature = self.decode_str(data[4:6]) data = data[6:] lis = [] for i in xrange(0, 80, 16): lis.append(data[i:i + 16]) allPorts = self.get_default_port_nums() if allPorts > 5: data = self.send_mqtt(funCode="30", data="00") for i in xrange(0, 80, 16): lis.append(data[i:i + 16]) result = {} if billingType == "time": for index, item in enumerate(lis): result[str(index + 1)] = { "leftTime": int(self.decode_str(item[:4])), "power": self.decode_str(item[4:8], ratio=0.1, base=10), "leftBalance": self.decode_str(item[12:], ratio=0.01, base=10) } elif billingType == "elec": for index, item in enumerate(lis): result[str(index + 1)] = { "leftElec": float(self.decode_str(item[:4], ratio=0.01)), "power": self.decode_str(item[4:8], ratio=0.1, base=10), "leftTime": int(self.decode_str(item[8:12])), "leftBalance": self.decode_str(item[12:], ratio=0.01, base=10) } elif billingType == "billAsservice": # 新增电费+服务费模式 for index, item in enumerate(lis): result[str(index + 1)] = { "serviceFee": float(self.decode_str(item[:4],ratio=0.01)), "power": self.decode_str(item[4:8], ratio=0.1, base=10), "leftTime": int(self.decode_str(item[8:12])), "leftBalance": self.decode_str(item[12:], ratio=0.01, base=10) } result.update({"totalAmpere": totalAmpere, "temperature": temperature, "billingType": billingType}) return result def get_port_status_from_dev(self): all_port_status = self.get_all_port_status() # 做一个兼容，不是所有主板都支持06指令，支持06指令的主板优先是由06指令查询到的数据 try: all_port_detail = dict() for port, status in all_port_status.items(): if status['status'] != 0: port_detail = self.get_port_info(port) if float(port_detail['power']) <= 5 and status['errorInfo']: Device.clear_port_control_cache(self.device.devNo, port) all_port_detail.update({port: port_detail}) except: all_port_detail = self.get_all_port_info() cacheInfo = Device.get_dev_control_cache(self.device.devNo) parse_status_code = { "0": u"端口空闲", "1": u"端口正在使用", "2": u"端口禁用", "3": u"端口故障", } lis = [] for port, info in all_port_status.items(): lineInfo = cacheInfo.get(port, {}) if info["status"] == 0: item = {"index": port, "status": "idle", "desc": parse_status_code.get(str(info["status"]))} elif info["status"] == 1: if not lineInfo.get("startTime"): # 端口启动 没有任何订单消息 最直接的原因就经销商直接换了模块 服务器没有任何信息 item = {"index": port, "status": "busy", "desc": parse_status_code.get(str(info["status"])), "leftElec": all_port_detail.get(port, {}).get("leftElec"), "leftMoney": all_port_detail.get(port, {}).get("leftBalance"), "leftTime": all_port_detail.get(port, {}).get("leftTime"), "power": all_port_detail.get(port, {}).get("power"), } else: nowTime = datetime.datetime.now() startTime = to_datetime(lineInfo["startTime"]) usedTime = int(round((((nowTime - startTime).total_seconds() + 59) / 60.0))) if self.device.devTypeCode == Const.DEVICE_TYPE_CODE_CHARGE_ZHONGSHAN_BILLASSERVICE: billingType = lineInfo.get("billingType") if billingType == "elec": item = { "startTime": lineInfo.get("startTime", '')[2:], "index": port, "status": "busy", "usedTime": usedTime, "power": all_port_detail.get(port, {}).get("power"), "desc": parse_status_code.get(str(info["status"])), "leftMoney": all_port_detail.get(port, {}).get("leftBalance"), "consumeMoney": round(float(lineInfo.get("coins")) - float(all_port_detail.get(port, {}).get("leftBalance")),2), "coins": str(lineInfo.get("coins")) + "币", "consumeType": lineInfo.get("consumeType"), "leftElec":all_port_detail.get(port, {}).get("leftElec"), "needElec":lineInfo['needElec'], "usedElec":round(float(lineInfo['needElec']) - float(all_port_detail.get(port, {}).get("leftElec")), 2), "leftTime":all_port_detail.get(port, {}).get("leftTime") } # 记录非法充电的功率，非法充电时功率只能通过06指令查到 elif billingType == "faultCharge": # data = self.encode_str(port, 2) # res = self.send_mqtt(funCode='06',data=data) item = { "startTime": lineInfo.get("startTime", '')[2:], "index": port, "status": "busy", "usedTime": usedTime, "power": all_port_detail.get(port, {}).get("power"), "statusErrorInfo": lineInfo.get('statusErrorInfo') } else: item = { "startTime": lineInfo.get("startTime", '')[2:], "index": port, "status": "busy", "usedTime": usedTime, "power": all_port_detail.get(port, {}).get("power"), "desc": parse_status_code.get(str(info["status"])), "leftMoney": all_port_detail.get(port, {}).get("leftBalance"), "consumeMoney": round( float(lineInfo.get("coins")) - float( all_port_detail.get(port, {}).get("leftBalance")), 2), "coins": str(lineInfo.get("coins")) + "币", "consumeType": lineInfo.get("consumeType"), "serviceFee" : all_port_detail.get(port, {}).get("serviceFee"), "elecFee" : round(float(lineInfo.get("coins")) - float(all_port_detail.get(port, {}).get("leftBalance")) - float(all_port_detail.get(port, {}).get("serviceFee")),2), } else: billingType = lineInfo.get("billingType") if billingType == "faultCharge": item = { "startTime": lineInfo.get("startTime", '')[2:], "index": port, "status": "busy", "usedTime": usedTime, "power": all_port_detail.get(port, {}).get("power"), "statusErrorInfo": lineInfo.get('statusErrorInfo') } else: item = { "startTime": lineInfo.get("startTime", '')[2:], "index": port, "status": "busy", "leftTime": all_port_detail.get(port, {}).get("leftTime"), "usedTime": usedTime, "actualNeedTime": usedTime + int(all_port_detail.get(port, {}).get("leftTime")), "leftElec": all_port_detail.get(port, {}).get("leftElec"), "power": all_port_detail.get(port, {}).get("power"), "desc": parse_status_code.get(str(info["status"])), "leftMoney": all_port_detail.get(port, {}).get("leftBalance"), "consumeMoney": round(float(lineInfo.get("coins")) - float(all_port_detail.get(port, {}).get("leftBalance")),2), "coins": str(lineInfo.get("coins")) + "币", "consumeType": lineInfo.get("consumeType"), } if 'needElec' in lineInfo: item['needElec'] = lineInfo['needElec'] item['usedElec'] = round(float(lineInfo['needElec']) - float(item['leftElec']), 2) if lineInfo.get("cardNo") and lineInfo.get("cardNo") != "0000000000": item.update({"cardNo": lineInfo.get("cardNo")}) if lineInfo.get("openId"): user = MyUser.objects.filter(openId=lineInfo.get("openId"), groupId=self.device["groupId"]).first() if user: item.update({"nickName": user.nickname}) if 'rechargeRcdId' in lineInfo: item['coins'] = str(lineInfo.get("coins")) + "元" if 'needTime' in lineInfo: item['needTime'] = lineInfo['needTime'] elif info["status"] == 2: item = {"index": port, "status": "ban", "desc": parse_status_code.get(str(info["status"]))} elif info["status"] == 3: item = {"index": port, "status": "fault", "desc": parse_status_code.get(str(info["status"]))} else: pass lis.append(item) lis = sorted(lis, key=lambda x: int(x["index"])) return lis @property def isHaveStopEvent(self): return True def test(self, port="1", coins="1", time="100", elec="0"): # type:(...) -> dict """ 启动某个端口 funcCode : 02 """ portHex = self.encode_str(port, 2) coinsHex = self.encode_str(coins, 4, ratio=10) if elec: unitHex = self.encode_str(int(elec) * 100, 4) else: unitHex = self.encode_str(int(time), 4) data = portHex + coinsHex + unitHex result = self.send_mqtt(funCode="02", data=data) if result: port = result[:2] status = "Charging success" if result[2:4] == "01" else "Charging failed" return {"port": port, "status": status} def remote_device(self, port, mode="start"): # type:(str,str) -> dict """ 远程操作某个端口 funCode: 08 发送:CC0A08000909090909020009 返回:AA0B0800090909090902021913" """ port = self.encode_str(port) if mode == "start": data = port + "01" elif mode == "stop": data = port + "00" else: return {} data = self.send_mqtt(funCode="08", data=data) # TODO parse dataHex port = self.decode_str(data[:2]) result = self.decode_str(data[4:], base=16) if self.device.devTypeCode == Const.DEVICE_TYPE_CODE_CHARGE_ZHONGSHAN_BILLASSERVICE: billingType = self.device["otherConf"].get("deviceConfigs", dict()).get("consumeModule", "elec") if billingType == "serviceFee": return {"port": port, "serviceFee": result} else: return {"port": port, "leftElec": result} else: return {"port": port, "leftTime": result} def set_consumption_rules(self, configDict): # type:(dict) -> None """ 设置单次刷卡，投币，远程 用户获取量(时间：分钟 ，电量: 度) funCode: 0A """ if self.device.devTypeCode == Const.DEVICE_TYPE_CODE_CHARGE_ZHONGSHAN_BILLASSERVICE: remoteElec = self.check_params_range(params=configDict.get("remoteElec"), minData=0, maxData=5.00, desc="扫码计费标准") serviceCharge = self.check_params_range(params=configDict.get("serviceFee"), minData=0, maxData=5.00, desc="服务费计费标准") time = self.check_params_range(params=configDict.get("time"), minData=0, maxData=600, desc="消费1元充电时间上限") coinElec = self.check_params_range(params=configDict.get("coinElec"), minData=0, maxData=5.00, desc="投币计费标准") cardElec = self.check_params_range(params=configDict.get("cardElec"), minData=0, maxData=5.00, desc="刷卡计费标准") data = self.encode_str(time, length=4, ratio=1) data += self.encode_str(coinElec, length=4, ratio=100) data += self.encode_str(cardElec, length=4, ratio=100) data += self.encode_str(remoteElec, length=4, ratio=100) data += self.encode_str(serviceCharge, length=4, ratio=100) self.send_mqtt(funCode="0A", data=data) self.device.update_device_obj(**{ 'devType.features.billAsService.serviceCharge': serviceCharge, 'devType.features.billAsService.elecCharge': remoteElec, }) else: coinTime = self.check_params_range(params=configDict.get("coinTime"), minData=0, maxData=600, desc="投币一个的充电时间") coinElec = self.check_params_range(params=configDict.get("coinElec"), minData=0, maxData=5.00, desc="投币一个的充电电量") cardTime = self.check_params_range(params=configDict.get("cardTime"), minData=0, maxData=600, desc="刷卡一次的充电时间") cardElec = self.check_params_range(params=configDict.get("cardElec"), minData=0, maxData=5.00, desc="刷卡一次的充电电量") remoteTime = self.check_params_range(params=configDict.get("remoteTime"), minData=0, maxData=600, desc="扫码一元的充电时间") remoteElec = self.check_params_range(params=configDict.get("remoteElec"), minData=0, maxData=5.00, desc="扫码一元的充电电量") data = self.encode_str(coinTime, length=4, ratio=1) data += self.encode_str(coinElec, length=4, ratio=100) data += self.encode_str(cardTime, length=4, ratio=1) data += self.encode_str(cardElec, length=4, ratio=100) data += self.encode_str(remoteTime, length=4, ratio=1) data += self.encode_str(remoteElec, length=4, ratio=100) self.send_mqtt(funCode="0A", data=data) def get_consumption_rules(self): # type:() -> dict """ 获取单次刷卡，投币，远程 用户获取量(时间：分钟 ，电量: 度) funCode: 0B """ data = self.send_mqtt(funCode="0B", data="00") if self.device.devTypeCode == Const.DEVICE_TYPE_CODE_CHARGE_ZHONGSHAN_BILLASSERVICE: time = self.decode_str(data[:4], ratio=1) coinElec = self.decode_str(data[4:8], ratio=0.01) cardElec = self.decode_str(data[8:12], ratio=0.01) remoteElec = self.decode_str(data[12:16], ratio=0.01) serviceCharge = self.decode_str(data[16:20], ratio=0.01) result = {"time": time, "coinElec": coinElec, "cardElec": cardElec, "remoteElec": remoteElec, "serviceFee": serviceCharge} self.do_update_configs(result) self.device.update_device_obj(**{ 'devType.features.billAsService.serviceCharge': serviceCharge, 'devType.features.billAsService.elecCharge': remoteElec, }) return result coinTime = self.decode_str(data[:4], ratio=1) coinElec = self.decode_str(data[4:8], ratio=0.01) cardTime = self.decode_str(data[8:12], ratio=1) cardElec = self.decode_str(data[12:16], ratio=0.01) remoteTime = self.decode_str(data[16:20], ratio=1) remoteElec = self.decode_str(data[20:24], ratio=0.01) result = {"coinTime": coinTime, "coinElec": coinElec, "cardTime": cardTime, "cardElec": cardElec, "remoteTime": remoteTime, "remoteElec": remoteElec} self.do_update_configs(result) return result def set_function_switch(self, configDict): # type:(dict) -> None """ 设置功能开关: ic卡(00关闭,01可用),刷卡退费(00关闭,01可用),充满自停(00关闭,01可用),免费充电(00关闭,01可用),消费模式(00电量,01时间) funCode: 0C """ coinSwitch = configDict.get("coinSwitch") cardSwitch = configDict.get("cardSwitch") cardRefund = configDict.get("cardRefund") autoStop = configDict.get("autoStop") chargeFree = configDict.get("chargeFree") consumeModule = configDict.get("consumeModule") data = self.encode_str(coinSwitch) data += self.encode_str(cardSwitch) data += self.encode_str(cardRefund) data += self.encode_str(autoStop) data += self.encode_str(chargeFree) data += self.encode_str(consumeModule) self.send_mqtt(funCode="0C", data=data) updateConfigs = { "coinSwitch": int(coinSwitch), "cardSwitch": int(cardSwitch), "cardRefund": int(cardRefund), "autoStop": int(autoStop), "chargeFree": int(chargeFree), "consumeModule": int(consumeModule) } self.do_update_configs(updateConfigs) if self.device.devTypeCode == Const.DEVICE_TYPE_CODE_CHARGE_ZHONGSHAN_BILLASSERVICE: billAsServiceSwitch = True if consumeModule == "1" else False self.device.update_device_obj(**{ 'devType.features.billAsService.on': billAsServiceSwitch, 'otherConf.deviceConfigs.consumeModule' : 1 if consumeModule == "1" else 0 }) def get_function_switch(self): # type:() -> dict """ 设置功能开关: ic卡(00关闭,01可用),刷卡退费(00关闭,01可用),充满自停(00关闭,01可用),免费充电(00关闭,01可用),消费模式(00电量,01时间) funCode: 0D """ data = self.send_mqtt(funCode="0D", data="00") result_list = self.decode_long_hex_to_list(data) # 给前台做兼容 结果的值转为数字 result_list = map(lambda x: int(x), result_list) name_list = ["coinSwitch", "cardSwitch", "cardRefund", "autoStop", "chargeFree", "consumeModule"] retult = dict(zip(name_list, result_list)) self.do_update_configs(retult) return retult def set_icMoney_maxPower_floatingCharge(self, configDict): # type:(dict) -> None """ 设置 刷卡金额 最大功率 浮充功率 浮充时间 funCode: 0E """ icMoney = self.check_params_range(params=configDict.get("icMoney"), minData=1, maxData=99, desc="单次刷卡需要消耗的金额") # TODO 单位角 maxPower = self.check_params_range(params=configDict.get("maxPower"), minData=1, maxData=999, desc="最大功率") floatingPower = self.check_params_range(params=configDict.get("floatingPower"), minData=1, maxData=99, desc="浮充功率") floatingTime = self.check_params_range(params=configDict.get("floatingTime"), minData=1, maxData=120, desc="浮充时间") data = self.encode_str(icMoney, length=2, base=10) # TODO 文档中是十进制待验证! data += self.encode_str(maxPower, length=4) data += self.encode_str(floatingPower, length=2) data += self.encode_str(floatingTime, length=2) result = self.send_mqtt(funCode="0E", data=data) def get_icMoney_maxPower_floatingCharge(self): # type:() -> dict """ 获取 刷卡金额 最大功率 浮充功率 浮充时间 funCode: 0F """ data = self.send_mqtt(funCode="0F", data="00") icMoney = self.decode_str(data[:2], base=10) maxPower = self.decode_str(data[2:6]) floatingPower = self.decode_str(data[6:8]) floatingTime = self.decode_str(data[8:10]) return {"icMoney": icMoney, "maxPower": maxPower, "floatingPower": floatingPower, "floatingTime": floatingTime} def set_noloadTime_volume(self, configDict): # type:(dict) -> None """ 设置 空载时间(noloadTime) 喇叭音量(volume) funCode: 10 """ noloadTime = self.check_params_range(params=configDict.get("noloadTime"), minData=1, maxData=180, desc="空载检测时间") volume = self.check_params_range(params=configDict.get("volume"), minData=0, maxData=15, desc="喇叭音量") data = self.encode_str(noloadTime) data += self.encode_str(volume) result = self.send_mqtt(funCode="10", data=data) def get_noloadTime_volume(self): # type:() -> dict """ 读取 空载时间(noloadTime) 喇叭音量(volume) funCode: 11 """ data = self.send_mqtt(funCode="11", data="00") noloadTime = self.decode_str(data[:2]) volume = self.decode_str(data[2:4]) return {"noloadTime": noloadTime, "volume": volume} def set_powerPs(self, configDict): # type:(dict) -> None """ 设置 修正系数(powerPs)[20B] 如0x0100表示1.00 funCode: 12 """ data = "" for i in xrange(1, 11): powerPs = self.check_params_range(params=configDict.get("powerPs{}".format(i)), minData=0, maxData=9.99, desc="修正系数") data += self.encode_str(powerPs, length=4, ratio=100, base=10) # TODO 文档中是十进制待验证! result = self.send_mqtt(funCode="12", data=data) def get_powerPs(self): # type:() -> dict """ 获取 修正系数(powerPs)[20B] 如0x0100表示1.00 funCode: 13 """ data = self.send_mqtt(funCode="13", data="00") data_list = self.decode_long_hex_to_list(data, split=4, ratio=0.01, base=10) result = {} for i in xrange(1, len(data_list) + 1): result["powerPs{}".format(i)] = data_list[i - 1] return result def reset_device(self): # type:() -> None """ 复位设备 funCode: 14 下发:CC09140009090909090001 返回:AA09140009090909090115 """ self.send_mqtt(funCode="14", data="00") def set_dev_fault(self, fault): # type:(dict) -> None """ 开启禁用设备 (01：开启设备 00：禁用设备) funCode: 15 """ if fault == True: data = "00" self.send_mqtt(funCode="15", data=data) self.disable_app_device(True) elif fault == False: data = "01" self.send_mqtt(funCode="15", data=data) self.disable_app_device(False) else: raise ServiceException({"result": 2, "description": u"设备操作故障!"}) def reset_factory_Mode(self): # type:() -> None """ 恢复工厂模式: funCode: 16 """ self.send_mqtt(funCode="16", data="00") def get_total_consumption(self): # type:() -> dict """ 获取消费总额 totalCoins[4B] + totalCard[4B] + totalRemote[4B] + totalAll[4B] + totalElec[4B] funCode: 17 """ data = self.send_mqtt(funCode="17", data="00") data_list = self.decode_long_hex_to_list(data, split=8, ratio=0.1, base=10) name_list = ["totalCoins", "totalCard", "totalRemote", "totalAll", "totalElec"] return dict(zip(name_list, data_list)) def get_total_refund(self): # type:() -> dict """ 获取退费总额度 totalRefundCoins[4B] + totalRefundCard[4B] + totalRefundRemote[4B] funCode: 18 """ data = self.send_mqtt(funCode="18", data="00") data_list = self.decode_long_hex_to_list(data, split=8, ratio=0.1, base=10) name_list = ["totalRefundCoins", "totalRefundCard", "totalRefundRemote"] return dict(zip(name_list, data_list)) def lock_unlock_port(self, ports, switch=True): # type:(str,str) -> None """ 远程禁用某个或多个端口 port[10B] 0x00：禁用 0x01：开启 funCode: 19 """ if isinstance(ports, list) or isinstance(ports, tuple): ports = map(lambda x: str(x), ports) elif isinstance(ports, dict): ports = map(lambda x: str(x), ports.keys()) else: ports = [str(ports)] # 防止下面1判断成10 if switch: switchStr1 = "00" switchStr2 = "01" else: switchStr1 = "01" switchStr2 = "01" data = "" for port in xrange(1, 11): if str(port) in ports: data += switchStr1 else: data += switchStr2 self.send_mqtt(funCode="19", data=data) def set_device_time(self, configDict): # type:(dict) -> None """ 设置设备系统时间 year + month + date + day + hour + minute + second funCode: 1A """ year = self.check_params_range(configDict.get("year"), minData=0, maxData=99, desc="年份") month = self.check_params_range(configDict.get("month"), minData=1, maxData=12, desc="月份") date = self.check_params_range(configDict.get("date"), minData=1, maxData=31, desc="日份") day = self.check_params_range(configDict.get("day"), minData=1, maxData=7, desc="星期") hour = self.check_params_range(configDict.get("hour"), minData=1, maxData=23, desc="时") minute = self.check_params_range(configDict.get("minute"), minData=1, maxData=59, desc="分") second = self.check_params_range(configDict.get("second"), minData=1, maxData=59, desc="秒") data = self.encode_str(year) data += self.encode_str(month) data += self.encode_str(date) data += self.encode_str(day) data += self.encode_str(hour) data += self.encode_str(minute) data += self.encode_str(second) self.send_mqtt(funCode="1A", data=data) def get_device_time(self): # type:() -> dict """ 获取设备系统时间 funCode: 1B """ data = self.send_mqtt(funCode="1B", data="00") data_list = self.decode_long_hex_to_list(data) name_list = ["year", "month", "date", "day", "hour", "minute", "second"] return dict(zip(name_list, data_list)) def get_charging_record(self, date): # type:(str) -> None """ 获取某天的充电纪录,连续返回,连续返回,连续返回!!! funCode: 1C example:201109 20年11月9日 """ year = date[:2] month = date[2:4] day = date[4:] data = self.encode_str(year) data += self.encode_str(month) data += self.encode_str(day) self.send_mqtt(funCode="1C", data=data) # TODO 收到指令后进行解析 def parse_reson(self, code): # type:(str) -> str """ code 传入解码的字符串 """ if not isinstance(code, str): code = str(code) infoDict = { "1": "购买的充电时间、电量用完了", "2": "用户手动停止(拔插头，或是按了停止按钮)", "3": "充电满了，自动停止", "4": "设备或是端口出现问题，被迫停止", "5": "因充电器功率超过充电站的单路最大输出功率，切断输出", "6": "超高温(达到75度)", "7": "烟雾报警", "8": "漏电报警", "9": "负载电流过大(短路)", "0A": "开始充电未接充电器", "0B": "端口远程停止", } return infoDict.get(code) def read_charging_record(self, data): # type:(str) -> dict """ 接上一条,连续发送后收到解析 """ year = self.decode_str(data[:2]) month = self.decode_str(data[2:4]) date = self.decode_str(data[4:6]) day = self.decode_str(data[6:8]) hour = self.decode_str(data[8:10]) minute = self.decode_str(data[10:12]) second = self.decode_str(data[12:14]) dateNum = self.decode_str(data[14:16]) port = self.decode_str(data[16:18]) consumeType = self.decode_str(data[18:20]) chargeStatus = self.decode_str(data[20:22]) reason = self.parse_reson(data[22:24]) payMoney = self.decode_str(data[24:28], ratio=0.1, base=10) leftMoney = self.decode_str(data[28:32], ratio=0.1, base=10) leftTime = self.decode_str(data[32:36], ratio=0.1, base=10) cardNo = "{:0>10}".format(self.decode_str(data[36:44])) randomCode = self.decode_str(data[44:48]) usedElec = self.decode_str(data[48:52], ratio=0.01, base=10) cardBalance = self.decode_str(data[52:56], ratio=0.1, base=10) TotalRecordSum = self.decode_str(data[56:60]) return locals() def recharge_ic_card(self, cardNo, coin): # type:(str,str)->None """ 下发充电指令 funcCode: 1E """ cardNo = self.encode_str(cardNo) cardType = "02" money = self.encode_str(coin, length=4, ratio=10, base=10) data = cardNo + cardType + money self.send_mqtt(funCode="1E", data=data, cmd=DeviceCmdCode.OPERATE_DEV_NO_RESPONSE) def stop(self, port="1"): # type: (str) -> None self.remote_device(port, "stop") time.sleep(1) def response_card_status(self, cardNo, cardBalance, cardType, result): # type: (str,RMB,str,str) -> None """ 刷卡上报后回复设备,在上报事件里面报 funCode: 04 """ data = self.encode_str(cardNo) data += self.encode_str(str(cardBalance), length=4, ratio=10, base=10) data += self.encode_str(cardType) data += self.encode_str(result) self.send_mqtt(funCode="04", data=data) def get_dev_setting(self): # type: () -> dict result = {} data = self.get_device_ID() result.update(data) data = self.get_function_switch() result.update(data) data = self.get_consumption_rules() result.update(data) data = self.get_powerPs() result.update(data) data = self.get_icMoney_maxPower_floatingCharge() result.update(data) data = self.get_noloadTime_volume() result.update(data) time = self.get_device_time() result.update(time) totalRecords = self.get_total_consumption() result.update(totalRecords) refundProtection = self.device.get("otherConf", {}).get("refundProtection", 1) refundProtectionTime = self.device.get("otherConf", {}).get("refundProtectionTime", "5") consumeModule = result.get("consumeModule") result.update({"refundProtection": refundProtection, "refundProtectionTime": refundProtectionTime, "consumeModule": consumeModule}) return result def set_refundProtection_params(self, configDict): refundProtection = configDict.get("refundProtection", 1) # TODO给前端做兼容 refundProtection = int(refundProtection) refundProtectionTime = configDict.get("refundProtectionTime", "5") otherConf = self.device["otherConf"] otherConf.update({"refundProtection": refundProtection, "refundProtectionTime": refundProtectionTime}) Device.objects.filter(devNo=self.device["devNo"]).update(otherConf=otherConf) Device.invalid_device_cache(self.device.devNo) def set_device_function(self, request, lastSetConf): updateSet = set(request.POST.keys()) nameSet = {"coinSwitch", "cardSwitch", "cardRefund", "autoStop", "chargeFree"} if len(updateSet & nameSet): lastSetConf.update(request.POST) self.set_function_switch(lastSetConf) nameSet = {"refundProtection"} if len(updateSet & nameSet): lastSetConf.update(request.POST) self.set_refundProtection_params(lastSetConf) nameSet = {"reset"} if len(updateSet & nameSet): self.reset_factory_Mode() nameSet = {"reboot"} if len(updateSet & nameSet): self.reset_device() def set_device_function_param(self, request, lastSetConf): update = request.POST.copy() lastSetConf = lastSetConf.copy() if "logicalCode" in update: update.pop("logicalCode", None) if "logicalCode" in lastSetConf: lastSetConf.pop("logicalCode", None) update = dict(set(update.items()) - set(lastSetConf.items())) updateSet = set(update.keys()) if not updateSet: return nameSet = {"cardTime", "cardElec", "coinElec", "remoteElec", "coinTime", "remoteTime","time","serviceFee"} if len(updateSet & nameSet): lastSetConf.update(update) self.set_consumption_rules(lastSetConf) nameSet = {"powerPs1", "powerPs2", "powerPs3", "powerPs4", "powerPs5", "powerPs6", "powerPs7", "powerPs8", "powerPs9", "powerPs10", } if len(updateSet & nameSet): lastSetConf.update(update) self.set_powerPs(lastSetConf) nameSet = {"icMoney", "maxPower", "floatingPower", "floatingTime"} if len(updateSet & nameSet): lastSetConf.update(update) self.set_icMoney_maxPower_floatingCharge(lastSetConf) nameSet = {"noloadTime", "volume"} if len(updateSet & nameSet): lastSetConf.update(update) self.set_noloadTime_volume(lastSetConf) nameSet = {"refundProtectionTime"} if len(updateSet & nameSet): lastSetConf.update(update) self.set_refundProtection_params(lastSetConf) nameSet = {"consumeModule"} if len(updateSet & nameSet): lastSetConf.update(update) self.set_function_switch(lastSetConf) nameSet = {"hour", "day", "month", "second", "year", "date", "minute"} if len(updateSet & nameSet): lastSetConf.update(update) self.set_device_time(lastSetConf) def active_deactive_port(self, port, active): if active == False: self.stop(port) def updata_no_balance_list(self, devNo, card, mode="update"): # type: (str,Card,str) -> None key = "100255_no_balance_list_%s" % (devNo) if not serviceCache.get(key): no_balance_list = [] else: no_balance_list = serviceCache.get(key) if mode == "update": cardModel = { "cardId": card.id, "cardNo": card.cardNo, "balance": card.balance, } if card.cardNo: cardModel.update({"cardName": card.cardName}) if card.phone: cardModel.update({"phone": card.phone}) for item in no_balance_list: if card.cardNo == item["cardNo"]: no_balance_list.remove(item) if len(no_balance_list) > 49: no_balance_list = no_balance_list[:49] no_balance_list.insert(0, cardModel) elif mode == "remove": for item in no_balance_list: if card.cardNo == item["cardNo"]: no_balance_list.remove(item) serviceCache.set(key, no_balance_list) def get_no_balance_list(self, devNo): key = "100255_no_balance_list_%s" % (devNo) if not serviceCache.get(key): no_balance_list = [] else: no_balance_list = serviceCache.get(key) return no_balance_list def remote_charge_ic_card_by_dealer(self, cardIds, amount): """ 经销商远程充值接口 """ cards = Card.objects.filter(id__in=cardIds) for card in cards: openId = None cardId = card.id cardNo = card.cardNo money = 0 coins = VirtualCoin(amount) group = Group.get_group(self.device["groupId"]) rechangeOrder = None cardRechangeOrder = CardRechargeOrder.new_one(openId, cardId, cardNo, money, coins, group, rechangeOrder, rechargeType="offline") cardRechangeOrder.update(remarks="经销商线下充卡") self.recharge_ic_card(card.cardNo, amount) cardRechangeOrder.update(status="finished") self.updata_no_balance_list(self.device.devNo, card, mode="remove") def set_service_fee_info(self, payload): # 显示展示给用户信息部分 if payload.get('displaySwitchs'): displaySwitchs = payload.get('displaySwitchs') else: displaySwitchs = {'displayCoinsSwitch': False, 'displayTimeSwitch': True, 'displayPriceSwitch': True, 'setPulseAble': False, 'setBasePriceAble': False} # 套餐部分 packages = payload.get('packages') # 调整SN套餐顺序 for i, item in enumerate(packages): item['sn'] = i # 套餐id 去重 existIds = list(map(lambda _: _.get('id'), packages)) washConfig = {} for rule in packages: if 'price' in rule: if not is_number(rule['price'] and is_number(rule.get('time', 0))): raise InvalidParameter(u'金币数目或者时间或者价格必须是数字') if RMB(rule['price']) >= self.device.owner.maxPackagePrice: raise InvalidParameter(u'套餐金额超限') if len(rule['name']) > 20: raise InvalidParameter(u'套餐名字只能取1-20位') if 'id' in rule: ruleId = rule['id'] else: ruleId = list(set(range(1, 71)) - set([int(ruleId) for ruleId in washConfig.keys()]) - set(existIds))[0] washConfig[str(ruleId)] = { 'billingMethod': CONSUMETYPE.BILL_AS_SERVICE, 'name': rule['name'], 'coins': float(rule['price']), 'price': float(rule['price']), 'time': float(rule.get('time', 0)), 'description': rule.get('description', ''), 'imgList': rule.get('imgList', []), 'unit': rule.get('unit', u'分钟'), 'switch': rule.get('switch', True), 'sn': rule.get('sn') } self.device.update_device_obj(**{ 'washConfig': washConfig, 'otherConf.displaySwitchs': displaySwitchs, }) dealer = self.device.owner dealer.defaultWashConfig[self.device.devTypeId] = self.device['washConfig'].values() dealer.save() def get_service_fee_info(self): ruleList = [] billAsService = self.device.bill_as_service_feature billAsService['on'] = billAsService.on billAsService['elecCharge'] = billAsService.elec_charge billAsService['serviceCharge'] = billAsService.service_charge method = "电费+服务费计费" if billAsService.on else "电量计费" for packageId, rule in self.device['washConfig'].items(): item = { 'id': packageId, 'name': rule['name'], 'coins': rule['coins'], 'price': rule.get('price', rule['coins']), 'time': rule.get('time', 20), 'description': rule.get('description', ''), 'imgList': rule.get('imgList', []), 'unit': rule.get('unit', u'分钟'), 'switch': rule.get('switch', True) } if 'sn' in rule: item['sn'] = rule['sn'] ruleList.append(item) devData = { 'id': self.device.devNo, 'isManager': True, 'groupName': self.device.group['groupName'], 'groupNumber': self.device['groupNumber'], 'devNo': self.device.devNo, 'devTypeName': self.device.devTypeName, 'devTypeCode': self.device.devTypeCode } if "displaySwitchs" in self.device.my_obj.otherConf: displaySwitchs = self.device.my_obj.otherConf.get('displaySwitchs') else: displaySwitchs = { 'displayCoinsSwitch': True, 'displayTimeSwitch': True, 'displayPriceSwitch': True, "setPulseAble": False, "setBasePriceAble": False } ruleList = sorted(ruleList, key=lambda x: (x.get('sn'), x.get('id'))) return { 'ruleList': ruleList, 'billAsService': billAsService, 'devData': devData, 'displaySwitchs': displaySwitchs, 'method': method } def format_upload_power(self, power): return float(power / 10)