Merge branch 'master' of http://8.140.179.55:20000/r/pipIrr-SV

liurunyu

4 天以前 5fefff8c747cbf5d526f6108a215bd813ac36034

 pipIrr-platform/pipIrr-web/pipIrr-web-terminal/src/main/java/com/dy/pipIrrTerminal/card/CardSv.java

@@ -2,16 +2,14 @@

import com.dy.common.webUtil.BaseResponseUtils;
import com.dy.pipIrrGlobal.daoPr.PrWaterPriceMapper;
import com.dy.pipIrrGlobal.daoSe.SeCardOperateMapper;
import com.dy.pipIrrGlobal.daoSe.SeClientCardMapper;
import com.dy.pipIrrGlobal.daoSe.SeClientMapper;
import com.dy.pipIrrGlobal.daoSe.SeRechargeHistoryMapper;
import com.dy.pipIrrGlobal.daoSe.*;
import com.dy.pipIrrGlobal.pojoSe.SeCardOperate;
import com.dy.pipIrrGlobal.pojoSe.SeClientCard;
import com.dy.pipIrrGlobal.pojoSe.SeRechargeHistory;
import com.dy.pipIrrGlobal.voSe.VoAfterRecharge;
import com.dy.pipIrrGlobal.voSe.VoTermActiveCard;
import com.dy.pipIrrGlobal.voSe.VoTermRecharge;
import com.dy.pipIrrGlobal.voSe.VoTermCard;
import com.dy.pipIrrGlobal.voSe.VoTermCommon;
import com.dy.pipIrrTerminal.card.dto.*;
import com.dy.pipIrrTerminal.card.enums.CardStateENUM;
import com.dy.pipIrrTerminal.card.enums.LastOperateENUM;
@@ -23,7 +21,6 @@
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.Duration;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
@@ -52,6 +49,9 @@

    @Autowired
    private SeRechargeHistoryMapper seRechargeHistoryMapper;

    @Autowired
    private SeManagerCardMapper seManagerCardMapper;

    @Value("${project.projectNo}")
    private Integer projectNo;
@@ -134,6 +134,39 @@
    }

    /**
     * 根据水卡编号判断该卡是否可以解锁
     * @param po
     * @return
     */
    public Map canUnlock(DtoUnlock po) {
        Map map = new HashMap<>();
        map.put("success", false);
        map.put("content", null);

        Long cardNum = po.getCardNum();
        // 判断当前水卡是否为挂失状态且未补卡，仅已经挂失其未补卡的可以解锁
        if (!isLostAndUnreplaced(cardNum)) {
            map.put("msg", "水卡状态不支持当前操作");
            return map;
        }

        /**
         * 依据水卡编号获取水卡表主键及农户编号
         */
        Map map_card = Optional.ofNullable(seClientCardMapper.getCardIdAndClientNum(cardNum)).orElse(new HashMap());
        if (map_card == null || map_card.size() <= 0) {
            map.put("msg", "卡号错误，该卡不存在");
            return map;
        }
        CardSimple card = new CardSimple();
        card.setCardId(Long.parseLong(map_card.get("cardId").toString()));
        card.setClientId(Long.parseLong(map_card.get("clientId").toString()));

        map.put("success", true);
        map.put("content", card);
        return map;
    }
    /**
     * 根据水卡编号判断该卡是否可以补卡
     * @param po
     * @return true:可以补卡
@@ -170,6 +203,40 @@
        card.setCardId(Long.parseLong(map_card.get("cardId").toString()));
        card.setClientId(Long.parseLong(map_card.get("clientId").toString()));
        card.setProtocol(map_card.get("protocol").toString());

        map.put("success", true);
        map.put("content", card);
        return map;
    }

    /**
     * 根据水卡编号判断该卡是否可以注销
     * @param po
     * @return
     */
    public Map canCancel(DtoCancel po) {
        Map map = new HashMap<>();
        map.put("success", false);
        map.put("content", null);

        Long cardNum = po.getCardNum();
        String stateName = seClientCardMapper.getCardStateByCardNum(cardNum);
        if(stateName == null || stateName.equals("") || !stateName.equals("正常")) {
            map.put("msg", stateName + ", " + "水卡状态不支持当前操作");
            return map;
        }

        /**
         * 依据水卡编号获取水卡表主键及农户编号
         */
        Map map_card = Optional.ofNullable(seClientCardMapper.getCardIdAndClientNum(cardNum)).orElse(new HashMap());
        if (map_card == null || map_card.size() <= 0) {
            map.put("msg", "卡号错误，该卡不存在");
            return map;
        }
        CardSimple card = new CardSimple();
        card.setCardId(Long.parseLong(map_card.get("cardId").toString()));
        card.setClientId(Long.parseLong(map_card.get("clientId").toString()));

        map.put("success", true);
        map.put("content", card);
@@ -467,7 +534,7 @@
            return map;
        }

        VoTermRecharge voTermRecharge = new VoTermRecharge();
        VoTermCommon voTermRecharge = new VoTermCommon();
        voTermRecharge.setProjectNo(projectNo);
        voTermRecharge.setCardNum(po.getCardNum());
        voTermRecharge.setOrderNo(orderNo);
@@ -522,6 +589,11 @@
        return map;
    }

    /**
     * 挂失
     * @param po
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public Map reportLoss(DtoLoss po) {
        Map map = new HashMap<>();
@@ -575,6 +647,116 @@
    }

    /**
     * 解锁
     * @param po
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public Map unlock(DtoUnlock po) {
        Map map = new HashMap<>();
        map.put("success", false);
        map.put("content", null);

        Map map_canUnlock = canUnlock(po);
        if(map_canUnlock.get("success").equals(false)) {
            map.put("msg", map_canUnlock.get("msg").toString());
            return map;
        }
        CardSimple card = (CardSimple) map_canUnlock.get("content");
        Long cardId = card.getCardId();
        Long clientId = card.getClientId();

        /**
         * 修改农户卡信息：
         *      挂失时间
         *      最后操作类型-4
         */
        SeClientCard seClientCard = new SeClientCard();
        seClientCard.setId(cardId);
        seClientCard.setUnlockdt(new Date());
        seClientCard.setMoney(po.getMoney());
        seClientCard.setState(CardStateENUM.NORMAL.getCode());
        seClientCard.setLastoper(LastOperateENUM.UNLOCK.getCode());
        Integer rec_updateClientCard = Optional.ofNullable(seClientCardMapper.updateByPrimaryKeySelective(seClientCard)).orElse(0);
        if (rec_updateClientCard == 0) {
            map.put("msg", "解锁失败-农户卡修改异常");
            return map;
        }

        /**
         * 添加解锁记录
         */
        SeCardOperate seCardOperate = new SeCardOperate();
        seCardOperate.setCardId(cardId);
        seCardOperate.setClientId(clientId);
        seCardOperate.setMoney(po.getMoney());
        seCardOperate.setOperateType(OperateTypeENUM.UNLOCK.getCode());
        seCardOperate.setRemarks(po.getRemarks());
        seCardOperate.setOperator(po.getOperator());
        seCardOperate.setOperateDt(new Date());
        seCardOperate.setOperateValid((byte) 2);
        seCardOperateMapper.insert(seCardOperate);
        Long rec = Optional.ofNullable(seCardOperate.getId()).orElse(0L);
        if (rec == 0) {
            map.put("msg", "解锁失败-解锁记录写入异常");
            return map;
        }

        map.put("success", true);
        map.put("msg", "操作成功");
        return map;
    }

    /**
     * 销卡
     * @param po
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public Map cancel(DtoCancel po) {
        Map map = new HashMap<>();
        map.put("success", false);
        map.put("content", null);
        String orderNo = generateOrderNo();

        Map map_canCancel  = canCancel(po);
        if(map_canCancel.get("success").equals(false)) {
            map.put("msg", map_canCancel.get("msg").toString());
            return map;
        }
        CardSimple card = (CardSimple) map_canCancel.get("content");
        Long cardId = card.getCardId();
        Long clientId = card.getClientId();

        SeCardOperate seCardOperate = new SeCardOperate();
        seCardOperate.setCardId(cardId);
        seCardOperate.setClientId(clientId);
        seCardOperate.setTradeAmount(-po.getRefund());
        seCardOperate.setPaymentId(po.getRefundType());
        seCardOperate.setOperateType(OperateTypeENUM.CANCEL.getCode());
        seCardOperate.setRemarks(po.getRemarks());
        seCardOperate.setOperator(po.getOperator());
        seCardOperate.setOperateDt(new Date());
        seCardOperate.setOrderNo(orderNo);
        seCardOperate.setOperateValid((byte) 1);
        seCardOperateMapper.insert(seCardOperate);
        if (seCardOperate.getId() == 0) {
            map.put("msg", "销卡失败-销卡记录写入异常");
            return map;
        }

        VoTermCommon voTermCandel = new VoTermCommon();
        voTermCandel.setProjectNo(projectNo);
        voTermCandel.setCardNum(po.getCardNum());
        voTermCandel.setOrderNo(orderNo);

        map.put("success", true);
        map.put("msg", "操作成功");
        map.put("content", voTermCandel);
        return map;
    }

    /**
     * 操作回调
     * @param po
     * @return
@@ -617,6 +799,46 @@
                turnRechargeHistoryValidByOrderNumber(orderNumber);
                updateCard(cardId, orderNumber+"p");
            }
        } else if (operateType == 2) {
            /**
             * 充值操作执行通知
             * 1. 操作记录改为有效
             * 2. 充值历史记录改为有效
             * 3. 修改水卡表的操作信息
             */
            turnOperateValidByOrderNumber(orderNumber + "p");
            turnRechargeHistoryValidByOrderNumber(orderNumber);
            updateCard(cardId, orderNumber+"p");
        }else if (operateType == 3) {
            /**
             * 销卡操作执行通知
             * 1. 操作记录改为有效
             * 2. 修改水卡表操作信息及余额
             */

            Integer rec_ope = turnOperateValidByOrderNumber(orderNumber);
            Integer rec_card = updateCardInfo(cardId, orderNumber);
            if (rec_ope == 0 || rec_card == 0) {
                map.put("msg", "销卡回调失败");
                return map;
            }

        } else if (operateType == 4) {
            /**
             * 补卡操作执行通知
             * 1. 新水卡记录改为有效
             * 2. 开卡操作记录改为有效
             * 3. 如果存在退还金额
             *     清空原卡余额
             */
            Integer rec_card = turnCardValidByOrderNumber(orderNumber);
            Integer rec_ope = turnOperateValidByOrderNumber(orderNumber);
            emptyCardBalance(orderNumber);
            if (rec_card == 0 || rec_ope == 0) {
                map.put("msg", "补卡回调失败");
                return map;
            }

        }

        map.put("success", true);
@@ -663,4 +885,67 @@
        }
        return true;
    }

    /**
     * 如果补卡时退还了金额，清空挂失卡余额
     * @param orderNumber
     */
    public Integer emptyCardBalance(String orderNumber) {
        Integer rec_empty = 0;
        Float noTradeAmount = seCardOperateMapper.getNoTradeAmount(orderNumber);
        if(noTradeAmount != null && noTradeAmount > 0) {
            rec_empty = seClientCardMapper.emptyCardBalance(orderNumber);
        }
        return rec_empty;
    }

    /**
     * 修改注销水卡表的记录及余额（0）
     * @param orderNumber
     * @return
     */
    public Integer updateCardInfo(Long cardId, String orderNumber) {
        Date operateTime = seCardOperateMapper.getOperateTime(orderNumber);

        SeClientCard clientCard = new SeClientCard();
        clientCard.setId(cardId);
        clientCard.setCanceldt(operateTime);
        clientCard.setMoney(0f);
        clientCard.setState(CardStateENUM.CANCELLED.getCode());
        clientCard.setLastoper(LastOperateENUM.CANCEL.getCode());
        return seClientCardMapper.updateByPrimaryKeySelective(clientCard);
    }

    /**
     * 判断指定水卡是否为挂失状态且无补卡记录
     * @param cardNum
     * @return
     */
    public Boolean isLostAndUnreplaced(Long cardNum) {
        Integer lostCount = seClientCardMapper.getLostCount(cardNum);
        Integer replacedCount = seClientCardMapper.getReplacedCount(cardNum);
        if (lostCount > 0 && replacedCount == 0) {
            return true;
        }
        return false;
    }

    /**
     * 读取水卡信息
     * @param cardAddr
     * @return
     */
    public VoTermCard readCard(String cardAddr) {
        VoTermCard voTermCard = seClientCardMapper.getTermCardInfo(cardAddr);
        if(voTermCard != null) {
            return voTermCard;
        }

        VoTermCard voTermManagerCard = seManagerCardMapper.getTermManagerCardInfo(cardAddr);
        if(voTermManagerCard != null) {
            return voTermManagerCard;
        }

        return null;
    }
}