修改未关泵补卡逻辑

zuoxiao

2024-08-13 3673328730251736f9614793d9a75630c17b28f6

 qiheonlinelibrary/src/main/java/com/dayu/qiheonlinelibrary/card/ManagerToUserCard.java

@@ -1,9 +1,13 @@
package com.dayu.qiheonlinelibrary.card;

import com.dayu.baselibrary.tools.BcdUtil;
import com.dayu.baselibrary.tools.HexUtil;
import com.dayu.qiheonlinelibrary.utils.CardCommon;
import com.tencent.bugly.crashreport.CrashReport;

import java.io.Serializable;
import java.util.Calendar;
import java.util.List;

/**
 * Created by Android Studio.
@@ -18,13 +22,83 @@

    public int arerNumber;//区域号(底位在前高位在后)

    public int deviceNumberl;//设备编号(底位在前高位在后)
    public short rechargeTimes;//充值次数
    public String oldCardNumber;//旧卡卡号

    public int totalWater;//用户总用水量  底位在前，高位在后2位小数点  含两个小数点的整数
    public int cardWriteState;//管理卡返写机制 00:中心写01:控制器返写

    public int totalElectric;//总用电量位 底位在前，高位在后  1位小数点  含1位小数点的整数
    public int cardState;//现场卡状态  00:旧卡 01:新卡

    public int balance;//剩余金额 底位在前  2位小数点，单位分

    public int surplusElecticity;//剩余电量 底位在前  2位小数点　单位立方米 (跟价格一样先乘以100)

    public int totalMorny;//累计充值金额

    public Calendar rechargeDate;// 购水时间 BCD

    public Float electricPrice;//电单价，保留三位小数

    /**
     * 通过byte转bean
     *
     * @param data
     */
    public static ManagerToUserCard getBean(List<byte[]> data) {
        try {
            ManagerToUserCard userCard = new ManagerToUserCard();
            //第0块解析
            byte[] zero = data.get(0);
            userCard.cardType = HexUtil.byteToHex(zero[0]);

            byte[] arerNumberByte = new byte[4];
            System.arraycopy(zero, 1, arerNumberByte, 0, arerNumberByte.length);
            userCard.arerNumber = HexUtil.get16To10LowHightByBytes(arerNumberByte);

            byte[] oldCardNumberByte = new byte[4];
            System.arraycopy(zero, 5, oldCardNumberByte, 0, oldCardNumberByte.length);
            userCard.oldCardNumber = HexUtil.bytesToHex(oldCardNumberByte);

            byte[] cardWriteState = new byte[1];
            System.arraycopy(zero, 13, cardWriteState, 0, cardWriteState.length);
            userCard.cardWriteState = HexUtil.get16To10LowHightByBytes(cardWriteState);
            byte[] cardState = new byte[1];
            System.arraycopy(zero, 14, cardState, 0, cardState.length);
            userCard.cardState = HexUtil.get16To10LowHightByBytes(cardState);
            //第1块解析
            byte[] one = data.get(1);
            byte[] balanceByte = new byte[4];
            System.arraycopy(one, 0, balanceByte, 0, balanceByte.length);
            userCard.balance = HexUtil.get16To10LowHightByBytes(balanceByte);
            byte[] surplusWaterByte = new byte[4];
            System.arraycopy(one, 4, surplusWaterByte, 0, surplusWaterByte.length);
            userCard.surplusElecticity = HexUtil.get16To10LowHightByBytes(surplusWaterByte);

            byte[] totalMorny = new byte[4];
            System.arraycopy(one, 8, totalMorny, 0, totalMorny.length);
            userCard.totalMorny = HexUtil.get16To10LowHightByBytes(totalMorny);

            byte[] rechargeDateByte = new byte[3];
            System.arraycopy(one, 12, rechargeDateByte, 0, rechargeDateByte.length);
            int year = HexUtil.getBcdToInt(one[12]);
            int month = HexUtil.getBcdToInt(one[13]);
            int day = HexUtil.getBcdToInt(one[14]);
            Calendar calendar = Calendar.getInstance();
            calendar.set(2000 + year, month, day, 0, 0, 0);
            userCard.rechargeDate = calendar;

            byte[] two = data.get(2);
            byte[] electricPriceByte = new byte[4];
            System.arraycopy(two, 8, electricPriceByte, 0, electricPriceByte.length);
            userCard.electricPrice = HexUtil.hexToFloatLowHigh(electricPriceByte);

            return userCard;

        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }

    }


    /**
@@ -36,37 +110,29 @@
                byte[] data = new byte[16];
                data[0] = HexUtil.hexToByte(cardType);
                //区域号
                byte[] arerNumberBytes = new byte[2];
                byte[] arerNumberBytes = new byte[4];
                byte[] arerNumberDatas = HexUtil.hexToByteArray(HexUtil.get10To16LowHigh(arerNumber));
                System.arraycopy(arerNumberDatas, 0, arerNumberBytes, 0, arerNumberDatas.length);
                if (arerNumberBytes != null) {
                    System.arraycopy(arerNumberBytes, 0, data, 1, arerNumberBytes.length);
                }
                //设备编号
                byte[] deviceNumberlBytes = new byte[2];
                byte[] deviceNumberlDatas = HexUtil.hexToByteArray(HexUtil.get10To16LowHigh(deviceNumberl));
                System.arraycopy(deviceNumberlDatas, 0, deviceNumberlBytes, 0, deviceNumberlDatas.length);
                if (deviceNumberlBytes != null) {
                    System.arraycopy(deviceNumberlBytes, 0, data, 3, deviceNumberlBytes.length);
                //管理卡返写机制 00:中心写01:控制器返写
                byte[] cardWriteStateBytes = new byte[1];
                byte[] cardWriteStateDatas = HexUtil.hexToByteArray(HexUtil.get10To16LowHigh(cardWriteState));
                System.arraycopy(cardWriteStateDatas, 0, cardWriteStateBytes, 0, cardWriteStateDatas.length);
                if (cardWriteStateBytes != null) {
                    System.arraycopy(cardWriteStateBytes, 0, data, 13, cardWriteStateBytes.length);
                }
                //充值次数
                byte rechargeTimesByte = HexUtil.hexToByte(HexUtil.get10to16(rechargeTimes));
                data[5] = rechargeTimesByte;

                //用户总用水量
                byte[] totalWaterBytes = new byte[4];
                byte[] totalWaterDatas = HexUtil.hexToByteArray(HexUtil.get10To16LowHigh(totalWater));
                System.arraycopy(totalWaterDatas, 0, totalWaterBytes, 0, totalWaterDatas.length);
                if (totalWaterBytes != null) {
                    System.arraycopy(totalWaterBytes, 0, data, 6, totalWaterBytes.length);
                //管理卡返写机制 00:中心写01:控制器返写
                byte[] cardStateBytes = new byte[1];
                byte[] cardStateDatas = HexUtil.hexToByteArray(HexUtil.get10To16LowHigh(cardState));
                System.arraycopy(cardStateDatas, 0, cardStateBytes, 0, cardStateDatas.length);
                if (cardStateBytes != null) {
                    System.arraycopy(cardStateBytes, 0, data, 14, cardStateBytes.length);
                }
                //总用电量位
                byte[] totalElectricBytes = new byte[4];
                byte[] totalElectricDatas = HexUtil.hexToByteArray(HexUtil.get10To16LowHigh(totalElectric));
                System.arraycopy(totalElectricDatas, 0, totalElectricBytes, 0, totalElectricDatas.length);
                if (totalElectricBytes != null) {
                    System.arraycopy(totalElectricBytes, 0, data, 10, totalElectricBytes.length);
                }


                data[15] = getByteSum(data);
                return data;
            } catch (Exception e) {
@@ -78,27 +144,208 @@

    }

    /**
     * 用户卡1块
     */
    public class One extends BaseCard {

        public byte[] toBytes() {
            byte[] data = new byte[16];


            try {
                byte[] balanceBytes = new byte[4];
                byte[] balanceDatas = HexUtil.hexToByteArray(HexUtil.get10To16LowHigh(balance));
                System.arraycopy(balanceDatas, 0, balanceBytes, 0, balanceDatas.length);
                if (balanceBytes != null) {
                    System.arraycopy(balanceBytes, 0, data, 0, balanceBytes.length);
                }

                byte[] surplusElecticityBytes = new byte[4];
                byte[] surplusElecticityDatas = HexUtil.hexToByteArray(HexUtil.get10To16LowHigh(surplusElecticity));
                System.arraycopy(surplusElecticityDatas, 0, surplusElecticityBytes, 0, surplusElecticityDatas.length);
                if (surplusElecticityBytes != null) {
                    System.arraycopy(surplusElecticityBytes, 0, data, 4, surplusElecticityBytes.length);
                }
                byte[] totalMornyBytes = new byte[4];
                byte[] totalMornyDatas = HexUtil.hexToByteArray(HexUtil.get10To16LowHigh(totalMorny));
                System.arraycopy(totalMornyDatas, 0, totalMornyBytes, 0, totalMornyDatas.length);
                if (totalMornyBytes != null) {
                    System.arraycopy(totalMornyBytes, 0, data, 8, totalMornyBytes.length);
                }

                if (rechargeDate != null) {
                    // 获取年、月、日、时、分、秒
                    int year = (rechargeDate.get(Calendar.YEAR)) % 1000;
                    int month = rechargeDate.get(Calendar.MONTH) + 1; // 月份从0开始，所以需要加1
                    int day = rechargeDate.get(Calendar.DAY_OF_MONTH);
                    byte bcdYear = HexUtil.getIntToBCD(year)[0];
                    byte bcdMonth = HexUtil.getIntToBCD(month)[0];
                    byte bcdDay = HexUtil.getIntToBCD(day)[0];
                    data[12] = bcdYear;
                    data[13] = bcdMonth;
                    data[14] = bcdDay;
                }

                data[15] = getByteSum(data);
            } catch (Exception e) {
                e.printStackTrace();
                CrashReport.postCatchedException(e);
            }
            return data;
        }


    }

    /**
     * 用户卡2块
     */
    public class Two extends BaseCard {
        public byte[] toBytes() {
            byte[] data = new byte[16];


            try {
                byte[] balanceBytes = new byte[4];
                byte[] balanceDatas = HexUtil.hexToByteArray(HexUtil.get10To16LowHigh(balance));
                System.arraycopy(balanceDatas, 0, balanceBytes, 0, balanceDatas.length);
                if (balanceBytes != null) {
                    System.arraycopy(balanceBytes, 0, data, 0, balanceBytes.length);
                }

                byte[] surplusElecticityBytes = new byte[4];
                byte[] surplusElecticityDatas = HexUtil.hexToByteArray(HexUtil.get10To16LowHigh(surplusElecticity));
                System.arraycopy(surplusElecticityDatas, 0, surplusElecticityBytes, 0, surplusElecticityDatas.length);
                if (surplusElecticityBytes != null) {
                    System.arraycopy(surplusElecticityBytes, 0, data, 4, surplusElecticityBytes.length);
                }

                byte[] electricPriceBytes = new byte[4];
                byte[] electricPriceDatas = HexUtil.hexToByteArray(HexUtil.floatToHexLowHigh(electricPrice));
                System.arraycopy(electricPriceDatas, 0, electricPriceBytes, 0, electricPriceDatas.length);
                if (electricPriceBytes != null) {
                    System.arraycopy(electricPriceBytes, 0, data, 8, electricPriceBytes.length);
                }

                if (rechargeDate != null) {
                    // 获取年、月、日、时、分、秒
                    int year = (rechargeDate.get(Calendar.YEAR)) % 1000;
                    int month = rechargeDate.get(Calendar.MONTH) + 1; // 月份从0开始，所以需要加1
                    int day = rechargeDate.get(Calendar.DAY_OF_MONTH);
                    byte bcdYear = HexUtil.getIntToBCD(year)[0];
                    byte bcdMonth = HexUtil.getIntToBCD(month)[0];
                    byte bcdDay = HexUtil.getIntToBCD(day)[0];
                    data[12] = bcdYear;
                    data[13] = bcdMonth;
                    data[14] = bcdDay;
                }


                data[15] = getByteSum(data);
            } catch (Exception e) {
                e.printStackTrace();
                CrashReport.postCatchedException(e);
            }
            return data;
        }
    }

    public byte[] getZeroBytes() {
        ManagerToUserCard.Zero zero = new ManagerToUserCard.Zero();
        return zero.toByte();
    }

    public byte[] getOneBytes() {
        ManagerToUserCard.One zero = new ManagerToUserCard.One();
        return zero.toBytes();
    }

    public byte[] getTwoBytes() {
        ManagerToUserCard.Two zero = new ManagerToUserCard.Two();
        return zero.toBytes();
    }


    public String getCardType() {
        return cardType;
    }

    public void setCardType(String cardType) {
        this.cardType = cardType;
    }

    public int getArerNumber() {
        return arerNumber;
    }

    public void setArerNumber(int arerNumber) {
        this.arerNumber = arerNumber;
    }

    public void setDeviceNumberl(int deviceNumberl) {
        this.deviceNumberl = deviceNumberl;


    public int getCardWriteState() {
        return cardWriteState;
    }

    public void setRechargeTimes(short rechargeTimes) {
        this.rechargeTimes = rechargeTimes;
    public void setCardWriteState(int cardWriteState) {
        this.cardWriteState = cardWriteState;
    }

    public void setTotalWater(int totalWater) {
        this.totalWater = totalWater;
    public int getCardState() {
        return cardState;
    }

    public void setTotalElectric(int totalElectric) {
        this.totalElectric = totalElectric;
    public void setCardState(int cardState) {
        this.cardState = cardState;
    }
    public byte[] getZeroBytes() {
        Zero zero = new Zero();
        return zero.toByte();

    public int getBalance() {
        return balance;
    }

    public void setBalance(int balance) {
        this.balance = balance;
    }

    public int getSurplusElecticity() {
        return surplusElecticity;
    }

    public void setSurplusElecticity(int surplusElecticity) {
        this.surplusElecticity = surplusElecticity;
    }

    public int getTotalMorny() {
        return totalMorny;
    }

    public void setTotalMorny(int totalMorny) {
        this.totalMorny = totalMorny;
    }

    public Calendar getRechargeDate() {
        return rechargeDate;
    }

    public void setRechargeDate(Calendar rechargeDate) {
        this.rechargeDate = rechargeDate;
    }

    public Float getElectricPrice() {
        return electricPrice;
    }

    public void setElectricPrice(Float electricPrice) {
        this.electricPrice = electricPrice;
    }

    public String getOldCardNumber() {
        return oldCardNumber;
    }

    public void setOldCardNumber(String oldCardNumber) {
        this.oldCardNumber = oldCardNumber;
    }
}