package com.dy.pipIrrTerminal.card;
|
|
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.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.VoTermCommon;
|
import com.dy.pipIrrTerminal.card.dto.*;
|
import com.dy.pipIrrTerminal.card.enums.CardStateENUM;
|
import com.dy.pipIrrTerminal.card.enums.LastOperateENUM;
|
import com.dy.pipIrrTerminal.card.enums.OperateTypeENUM;
|
import com.dy.pipIrrTerminal.card.enums.RechargeTypeENUM;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.time.LocalDateTime;
|
import java.time.format.DateTimeFormatter;
|
import java.util.*;
|
|
/**
|
* @author ZhuBaoMin
|
* @date 2025-05-08 10:15
|
* @LastEditTime 2025-05-08 10:15
|
* @Description
|
*/
|
|
@Slf4j
|
@Service
|
public class CardSv {
|
@Autowired
|
private SeCardOperateMapper seCardOperateMapper;
|
|
@Autowired
|
private SeClientCardMapper seClientCardMapper;
|
|
@Autowired
|
private SeClientMapper seClientMapper;
|
|
@Autowired
|
private PrWaterPriceMapper prWaterPriceMapper;
|
|
@Autowired
|
private SeRechargeHistoryMapper seRechargeHistoryMapper;
|
|
@Value("${project.projectNo}")
|
private Integer projectNo;
|
|
/**
|
* 根据水卡地址判断该卡是否可以开卡
|
* @param cardAddr
|
* @return true:可以开卡
|
*/
|
public Boolean canActiveCard(String cardAddr) {
|
// 指定水卡地址的水卡数量，无效卡片排除在外
|
Long cardCount = Optional.ofNullable(seClientCardMapper.getCountByCardAddr(cardAddr)).orElse(0L);
|
if (cardCount == 0) {
|
return true;
|
}
|
|
// 指定水卡地址且正常状态或挂失状态的水卡数量
|
cardCount = Optional.ofNullable(seClientCardMapper.getCountByCardAddrAndState(cardAddr)).orElse(0L);
|
if (cardCount == 0) {
|
return true;
|
}
|
|
return false;
|
}
|
|
/**
|
* 根据水卡编号判断该卡是否可以充值
|
* @param po
|
* @return true:可以充值
|
*/
|
public Map canRecharge(DtoRecharge po) {
|
Map map = new HashMap<>();
|
map.put("success", false);
|
map.put("content", null);
|
|
String stateName = Optional.ofNullable(seClientCardMapper.getCardStateByCardNum(po.getCardNum())).orElse("");
|
// 单独充值时卡片必须为正常
|
if((po.getRechargeType() == RechargeTypeENUM.RECHARGE.getCode()) && !stateName.equals("正常")) {
|
map.put("msg", stateName + ", " + "水卡状态不支持当前操作");
|
return map;
|
}
|
|
map.put("success", true);
|
return map;
|
}
|
|
/**
|
* 根据水卡编号判断该卡是否可以挂失
|
* @param po
|
* @return true:可以报失
|
*/
|
public Map canReportLoss(DtoLoss 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()));
|
//card.setProtocol(map_card.get("protocol").toString());
|
|
map.put("success", true);
|
map.put("content", card);
|
return map;
|
}
|
|
/**
|
* 根据水卡编号判断该卡是否可以解锁
|
* @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:可以补卡
|
*/
|
public Map canReissue(DtoReissue po) {
|
Map map = new HashMap<>();
|
map.put("success", false);
|
map.put("content", null);
|
|
Long cardNum = po.getCardNum();
|
Integer lostCount = seClientCardMapper.getLostCount(cardNum);
|
Integer replacedCount = seClientCardMapper.getReplacedCount(cardNum);
|
if(lostCount == 0 || replacedCount > 0) {
|
map.put("msg", "水卡未挂失或已补卡，不能补卡");
|
return map;
|
}
|
|
Float reissueAmount = po.getReissueAmount();
|
if (reissueAmount != null && reissueAmount > 0) {
|
Double tradeAmount = seCardOperateMapper.getTradeAmountByCardNo(cardNum);
|
if (tradeAmount != null && tradeAmount > 0) {
|
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()));
|
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);
|
return map;
|
}
|
|
/**
|
* 根据农户编号获取5级行政区划串areaCode，补卡过程中开新卡使用
|
* @param clientId
|
* @return
|
*/
|
public Long getAreaCodeById(Long clientId) {
|
return seClientMapper.getAreaCodeById(clientId);
|
}
|
|
public String getCardNumOfMax(String areaCode) {
|
return seClientCardMapper.getCardNumOfMax(areaCode);
|
}
|
|
public Map generateCardNum(Long clientId) {
|
Map map_cardNum = new HashMap<>();
|
map_cardNum.put("success", false);
|
map_cardNum.put("content", null);
|
|
// 获取5级行政区划串areaCode
|
Long areaCodeL = getAreaCodeById(clientId);
|
if (areaCodeL == null) {
|
map_cardNum.put("msg", "该农户行政区划异常");
|
return map_cardNum;
|
}
|
|
String areaCode = String.valueOf(areaCodeL);
|
String cardNum = Optional.ofNullable(getCardNumOfMax(areaCode)).orElse("");
|
if (cardNum != null && cardNum.trim().length() > 0) {
|
Integer number = Integer.parseInt(cardNum.substring(12));
|
number = number + 1;
|
if (number > 65535) {
|
map_cardNum.put("msg", "水卡编号已满");
|
return map_cardNum;
|
}
|
cardNum = cardNum.substring(0, 12) + String.format("%05d", number);
|
} else {
|
cardNum = areaCode + "00001";
|
}
|
|
map_cardNum.put("success", true);
|
map_cardNum.put("content", cardNum);
|
return map_cardNum;
|
}
|
|
public String generateOrderNo() {
|
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyMMddHHmmss");
|
LocalDateTime dateTime = LocalDateTime.now();
|
Random random = new Random();
|
String CHARACTERS = "0123456789";
|
StringBuilder sb = new StringBuilder(4);
|
for (int i = 0; i < 4; i++) {
|
int index = random.nextInt(CHARACTERS.length());
|
sb.append(CHARACTERS.charAt(index));
|
}
|
return dtf.format(dateTime) + sb.toString();
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
public Map addCardAndOperate(ActiveCard po, Long cardNum, String orderNo) {
|
Map map = new HashMap<>();
|
map.put("success", false);
|
map.put("content", null);
|
|
// amount：充值接口为输入参数，补卡接口为原卡退还金额
|
SeClientCard seClientCard = new SeClientCard();
|
seClientCard.setProtocol(po.getProtocol());
|
seClientCard.setCardaddr(po.getCardAddr());
|
seClientCard.setCardnum(String.valueOf(cardNum));
|
seClientCard.setClientid(po.getClientId());
|
seClientCard.setMoney(po.getAmount());
|
seClientCard.setState(CardStateENUM.INVALID.getCode());
|
seClientCard.setOrderNo(orderNo);
|
if (po.getOriginalCardId() != null) {
|
// 补卡
|
seClientCard.setOriginalCardId(po.getOriginalCardId());
|
seClientCard.setLastoper(LastOperateENUM.REPLACE.getCode());
|
seClientCard.setReplacedt(new Date());
|
} else {
|
// 开新卡
|
seClientCard.setLastoper(LastOperateENUM.ACTIVE.getCode());
|
seClientCard.setCreatedt(new Date());
|
}
|
|
seClientCardMapper.insert(seClientCard);
|
Long cardId = Optional.ofNullable(seClientCard.getId()).orElse(0L);
|
if (cardId == 0) {
|
map.put("msg", "开卡失败-农户卡写入异常");
|
return map;
|
}
|
|
SeCardOperate seCardOperate = new SeCardOperate();
|
seCardOperate.setCardId(cardId);
|
seCardOperate.setClientId(po.getClientId());
|
seCardOperate.setMoney(0f);
|
seCardOperate.setCardCost(po.getCardCost());
|
seCardOperate.setPaymentId(po.getPaymentId());
|
if (po.getOriginalCardId() != null) {
|
// 补卡
|
seCardOperate.setOperateType(OperateTypeENUM.REISSUE.getCode());
|
seCardOperate.setNoTradeAmount(po.getAmount());
|
} else {
|
// 开新卡
|
seCardOperate.setOperateType(OperateTypeENUM.ACTIVE.getCode());
|
}
|
seCardOperate.setRemarks(po.getRemarks());
|
seCardOperate.setOperator(po.getOperator());
|
seCardOperate.setOperateDt(new Date());
|
seCardOperate.setOrderNo(orderNo);
|
seCardOperate.setOperateValid((byte) 1);
|
|
seCardOperateMapper.insert(seCardOperate);
|
Long rec = Optional.ofNullable(seCardOperate.getId()).orElse(0L);
|
if (rec == 0) {
|
map.put("msg", "开卡失败-开卡记录写入异常");
|
return map;
|
}
|
|
map.put("success", true);
|
return map;
|
}
|
|
/**
|
* 开卡附加充值
|
* @param po
|
* @param cardNum
|
* @return
|
*/
|
@Transactional(rollbackFor = Exception.class)
|
public Map plusRecharge(ActiveCard po, Long cardNum, String orderNo) {
|
Map map = new HashMap<>();
|
map.put("success", false);
|
map.put("content", null);
|
|
/**
|
* 添加水卡操作记录
|
*/
|
DtoRecharge dtoRecharge = new DtoRecharge();
|
dtoRecharge.setCardNum(cardNum);
|
dtoRecharge.setAmount(po.getAmount());
|
dtoRecharge.setPaymentId(po.getPaymentId());
|
dtoRecharge.setRemarks(po.getRemarks());
|
dtoRecharge.setOperator(po.getOperator());
|
dtoRecharge.setMoney(0f);
|
dtoRecharge.setGift(0f);
|
dtoRecharge.setPrice(0f);
|
Map map_plusRecharge = addRecharge(dtoRecharge, orderNo);
|
if (!map_plusRecharge.get("success").equals(true)) {
|
map.put("msg", "开卡失败-充值异常");
|
return map;
|
}
|
map.put("success", true);
|
return map;
|
}
|
|
/**
|
* 激活或补卡
|
* @param po
|
* @return
|
*/
|
@Transactional(rollbackFor = Exception.class)
|
public Map activeOrReissueTermCard(ActiveCard po) {
|
Map map = new HashMap<>();
|
map.put("success", false);
|
map.put("content", null);
|
Float amount = po.getAmount();
|
Long originalCardId = po.getOriginalCardId();
|
|
if (!canActiveCard(po.getCardAddr())) {
|
map.put("msg", "开卡失败-此卡已存在");
|
return map;
|
}
|
|
Map map_cardNum = generateCardNum(po.getClientId());
|
if(map_cardNum.get("success").equals(false)) {
|
map.put("msg", map_cardNum.get("msg").toString());
|
return map;
|
}
|
Long cardNum = Long.parseLong(map_cardNum.get("content").toString());
|
|
String orderNo = generateOrderNo();
|
Map map_addCardAndOperate = addCardAndOperate(po, cardNum, orderNo);
|
if(map_addCardAndOperate.get("success").equals(false)) {
|
map.put("msg", map_addCardAndOperate.get("msg").toString());
|
return map;
|
}
|
|
if (amount != null && amount > 0 && originalCardId == null) {
|
Map map_plusRecharge = plusRecharge(po, cardNum, orderNo);
|
if(map_plusRecharge.get("success").equals(false)) {
|
map.put("msg", map_plusRecharge.get("msg").toString());
|
return map;
|
}
|
}
|
|
Float balance = Optional.ofNullable(seClientCardMapper.getMoneyByCardNum(cardNum)).orElse(0f);
|
Double waterPrice = prWaterPriceMapper.getPrice();
|
|
VoTermActiveCard voTermActiveCard = new VoTermActiveCard();
|
voTermActiveCard.setProjectNo(projectNo);
|
voTermActiveCard.setCardNum(cardNum);
|
voTermActiveCard.setBalance(balance);
|
voTermActiveCard.setWaterPrice(waterPrice);
|
voTermActiveCard.setTime(new Date());
|
voTermActiveCard.setOrderNo(orderNo);
|
|
map.put("success", true);
|
map.put("msg", "操作成功");
|
map.put("content", voTermActiveCard);
|
return map;
|
}
|
|
/**
|
* 充值
|
* @param po
|
* @return
|
*/
|
@Transactional(rollbackFor = Exception.class)
|
public Map addRecharge(DtoRecharge po, String orderNo) {
|
Map map = new HashMap<>();
|
map.put("success", false);
|
map.put("content", null);
|
|
Map map_canRecharge = canRecharge(po);
|
if(map_canRecharge.get("success").equals(false)) {
|
map.put("msg", map_canRecharge.get("msg").toString());
|
return map;
|
}
|
|
/**
|
* 依据水卡编号获取水卡表主键及农户编号
|
*/
|
Map map_cardAndClient = seClientCardMapper.getCardIdAndClientNum(po.getCardNum());
|
if (map_cardAndClient == null || map_cardAndClient.size() <= 0) {
|
map.put("msg", "卡号错误，该卡不存在");
|
return map;
|
}
|
Long cardId = Long.parseLong(map_cardAndClient.get("cardId").toString());
|
Long clientId = Long.parseLong(map_cardAndClient.get("clientId").toString());
|
if(orderNo == null || orderNo.length() <= 0) {
|
orderNo = generateOrderNo();
|
}
|
|
/**
|
* 添加水卡充值操作记录
|
*/
|
SeCardOperate seCardOperate = new SeCardOperate();
|
seCardOperate.setCardId(cardId);
|
seCardOperate.setClientId(clientId);
|
seCardOperate.setMoney(po.getMoney());
|
seCardOperate.setTradeAmount(po.getAmount());
|
seCardOperate.setGift(po.getGift());
|
seCardOperate.setOperateType(OperateTypeENUM.RECHARGE.getCode());
|
seCardOperate.setPaymentId(po.getPaymentId());
|
seCardOperate.setPrice(po.getPrice());
|
seCardOperate.setRemarks(po.getRemarks());
|
seCardOperate.setOperator(po.getOperator());
|
seCardOperate.setOperateDt(new Date());
|
seCardOperate.setOrderNo(orderNo + "p");
|
seCardOperate.setOperateValid((byte) 1);
|
seCardOperateMapper.insert(seCardOperate);
|
Long rec = Optional.ofNullable(seCardOperate.getId()).orElse(0L);
|
if (rec == 0) {
|
map.put("msg", "充值失败-充值记录写入异常");
|
return map;
|
}
|
|
/**
|
* 添加充值历史记录
|
*/
|
SeRechargeHistory seRechargeHistory = new SeRechargeHistory();
|
seRechargeHistory.setCardid(cardId);
|
seRechargeHistory.setClientid(clientId);
|
seRechargeHistory.setMoney(po.getMoney());
|
seRechargeHistory.setAmount(po.getAmount());
|
seRechargeHistory.setGift(po.getGift());
|
Float afterRecharge = po.getMoney() + po.getAmount() + po.getGift();
|
seRechargeHistory.setAfterrecharge(afterRecharge);
|
seRechargeHistory.setPaymentid(po.getPaymentId());
|
seRechargeHistory.setPrice(po.getPrice());
|
seRechargeHistory.setRemarks(po.getRemarks());
|
seRechargeHistory.setOperator(po.getOperator());
|
seRechargeHistory.setOperatedt(new Date());
|
seRechargeHistory.setOperateValid((byte) 1);
|
seRechargeHistory.setOrderNo(orderNo);
|
seRechargeHistoryMapper.insert(seRechargeHistory);
|
Long rec_seRechargeHistory = Optional.ofNullable(seRechargeHistory.getId()).orElse(0L);
|
if (rec_seRechargeHistory == 0) {
|
map.put("msg", "充值失败-充值历史记录写入异常");
|
return map;
|
}
|
|
VoTermCommon voTermRecharge = new VoTermCommon();
|
voTermRecharge.setProjectNo(projectNo);
|
voTermRecharge.setCardNum(po.getCardNum());
|
voTermRecharge.setOrderNo(orderNo);
|
|
map.put("success", true);
|
map.put("msg", "操作成功");
|
map.put("content", voTermRecharge);
|
return map;
|
}
|
|
/**
|
* 补卡
|
* @param po
|
* @return
|
*/
|
@Transactional(rollbackFor = Exception.class)
|
public Map reissue(DtoReissue po) {
|
Map map = new HashMap<>();
|
map.put("success", false);
|
map.put("content", null);
|
|
Map map_canReissue = canReissue(po);
|
if(map_canReissue.get("success").equals(false)) {
|
map.put("msg", map_canReissue.get("msg").toString());
|
return map;
|
}
|
CardSimple card = (CardSimple) map_canReissue.get("content");
|
Long cardId = card.getCardId();
|
Long clientId = card.getClientId();
|
String protocol = card.getProtocol();
|
|
/**
|
* 添加开卡记录，退还金额冲到新卡中
|
*/
|
ActiveCard activeCard = new ActiveCard();
|
activeCard.setProtocol(protocol);
|
activeCard.setCardAddr(po.getCardAddr());
|
activeCard.setClientId(clientId);
|
activeCard.setOriginalCardId(cardId);
|
activeCard.setCardCost(po.getCardCost());
|
activeCard.setAmount(po.getReissueAmount());
|
activeCard.setPaymentId(po.getPaymentId());
|
activeCard.setRemarks(po.getRemarks());
|
activeCard.setOperator(po.getOperator());
|
|
Map map_newCard = activeOrReissueTermCard(activeCard);
|
VoTermActiveCard voTermActiveCard = (VoTermActiveCard) map_newCard.get("content");
|
|
map.put("success", true);
|
map.put("msg", "操作成功");
|
map.put("content", voTermActiveCard);
|
return map;
|
}
|
|
/**
|
* 挂失
|
* @param po
|
* @return
|
*/
|
@Transactional(rollbackFor = Exception.class)
|
public Map reportLoss(DtoLoss po) {
|
Map map = new HashMap<>();
|
map.put("success", false);
|
map.put("content", null);
|
|
Map map_canReportLoss = canReportLoss(po);
|
if(map_canReportLoss.get("success").equals(false)) {
|
map.put("msg", map_canReportLoss.get("msg").toString());
|
return map;
|
}
|
CardSimple card = (CardSimple) map_canReportLoss.get("content");
|
Long cardId = card.getCardId();
|
Long clientId = card.getClientId();
|
|
Float money = Optional.ofNullable(po.getMoney()).orElse(0f);
|
Float refund = Optional.ofNullable(po.getRefund()).orElse(0f);
|
|
SeClientCard seClientCard = new SeClientCard();
|
seClientCard.setId(cardId);
|
seClientCard.setMoney(money);
|
seClientCard.setLossdtdt(new Date());
|
seClientCard.setState(CardStateENUM.LOSS.getCode());
|
seClientCard.setLastoper(LastOperateENUM.LOSS.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(money);
|
seCardOperate.setTradeAmount(-refund);
|
seCardOperate.setPaymentId(1L);
|
seCardOperate.setOperateType(OperateTypeENUM.LOSS.getCode());
|
seCardOperate.setRemarks(po.getRemarks());
|
seCardOperate.setOperator(po.getOperator());
|
seCardOperate.setOperateDt(new Date());
|
seCardOperate.setOperateValid((byte) 2);
|
seCardOperateMapper.insert(seCardOperate);
|
if (seCardOperate.getId() == 0) {
|
map.put("msg", "挂失失败-挂失记录写入异常");
|
return map;
|
}
|
|
map.put("success", true);
|
map.put("msg", "操作成功");
|
return map;
|
}
|
|
/**
|
* 解锁
|
* @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
|
*/
|
@Transactional(rollbackFor = Exception.class)
|
public Map callBack(DtoCallBack po) {
|
Map map = new HashMap<>();
|
map.put("success", false);
|
map.put("content", null);
|
|
String cardAddr = po.getCardAddr();
|
Integer operateType = po.getOperateType();
|
String orderNumber = po.getOrderNumber();
|
|
Long cardId = seClientCardMapper.getCardIdByAddr(cardAddr);
|
if (cardId == null || cardId.equals(0)) {
|
map.put("msg", "您指定的水卡不存在");
|
return map;
|
}
|
|
if(operateType == 1) {
|
/**
|
* 开卡操作执行通知
|
* 1.依据订单号将无效状态的操作记录改为有效
|
* 2.依据水卡ID将无效状态的水卡记录改为有效
|
* 3.如果开卡同步充值
|
* 修改充值操作记录为有效
|
* 修改充值历史记录为有效
|
* 修改水卡表的操作信息
|
*/
|
Integer rec_ope = turnOperateValidByOrderNumber(orderNumber);
|
Integer rec_card = turnCardValidByOrderNumber(orderNumber);
|
if (rec_ope == 0 || rec_card == 0) {
|
map.put("msg", "不存在未生效的水卡");
|
return map;
|
}
|
|
if(isMergeRecharge(cardId)) {
|
turnOperateValidByOrderNumber(orderNumber + "p");
|
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);
|
map.put("msg", "操作成功");
|
return map;
|
}
|
|
// 根据订单号将操作记录改为有效
|
public Integer turnOperateValidByOrderNumber(String orderNumber) {
|
return seCardOperateMapper.turnOperateValidByOrderNumber(orderNumber);
|
}
|
|
// 根据订单号将水卡改为有效
|
public Integer turnCardValidByOrderNumber(String orderNumber) {
|
return seClientCardMapper.turnCardValidByOrderNumber(orderNumber);
|
}
|
|
// 根据订单号将充值历史改为有效
|
public Integer turnRechargeHistoryValidByOrderNumber(String orderNumber) {
|
return seRechargeHistoryMapper.turnRechargeHistoryValidByOrderNumber(orderNumber);
|
}
|
|
// 根据cardId判断是否是合并充值
|
public Boolean isMergeRecharge(Long cardId) {
|
Integer plusRechargeCount = seCardOperateMapper.getPlusRechargeCount(cardId);
|
if (plusRechargeCount == 0) {
|
return false;
|
}
|
return true;
|
}
|
|
// 修改水卡信息
|
public Boolean updateCard(Long cardId, String orderNumber) {
|
VoAfterRecharge voAfterRecharge = seCardOperateMapper.getBalanceAfterRecharge(orderNumber);
|
|
SeClientCard clientCard = new SeClientCard();
|
clientCard.setId(cardId);
|
clientCard.setMoney(voAfterRecharge.getBalanceAfterRecharge());
|
clientCard.setRechargedt(voAfterRecharge.getOperateTime());
|
clientCard.setLastoper(LastOperateENUM.RECHARGE.getCode());
|
Integer rec_updateClientCard = seClientCardMapper.updateByPrimaryKeySelective(clientCard);
|
if (rec_updateClientCard == null || rec_updateClientCard == 0) {
|
return false;
|
}
|
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;
|
}
|
}
|
