新需求

src/main/java/com/huiju/estateagents/redpack/controller/TaOrgAccountController.java

      * @param id  实体ID
      */
     @RequestMapping(value="/taOrgAccount/recharge/{id}",method= RequestMethod.PUT)
-    public ResponseBean taOrgAccountDetailedListGet(@PathVariable String id, @RequestBody TaOrgAccount taOrgAccount,
+    public ResponseBean taOrgAccountRecharge(@PathVariable String id, @RequestBody TaOrgAccount taOrgAccount,
                                                     HttpServletRequest request){
         ResponseBean responseBean = new ResponseBean();
         try {
             iTaOrgAccountService.rechargeAccount(id, taOrgAccount, 26, 2149);
         }catch (Exception e){
             e.printStackTrace();
-            logger.error("taOrgAccountDetailedListDelete -=- {}",e.toString());
+            logger.error("taOrgAccountRecharge -=- {}",e.toString());
+            responseBean.addError(e.getMessage());
+        }
+        return responseBean;
+    }
+
+    /**
+     * 系统账户退款
+     * @param id
+     * @param taOrgAccount
+     * @param request
+     * @return
+     */
+    @RequestMapping(value = "/taOrgAccount/refund/{id}")
+    public ResponseBean taOrgAccountRefund(@PathVariable String id, @RequestBody TaOrgAccount taOrgAccount,
+                                           HttpServletRequest request){
+        ResponseBean responseBean = new ResponseBean();
+        try {
+            Integer orgId = getOrgId(request);
+            Integer userId = getUserId(request);
+            responseBean = iTaOrgAccountService.refundAccount(id, taOrgAccount, 26, 2149);
+        }catch (Exception e){
+            e.printStackTrace();
+            logger.error("taOrgAccountRefund -=- {}",e.toString());
             responseBean.addError(e.getMessage());
         }
         return responseBean;

src/main/java/com/huiju/estateagents/redpack/entity/TaOrgAccount.java

      */
     @TableField(exist = false)
     private Integer rechargeAmount;
+
+    /**
+     * 退费金额
+     */
+    @TableField(exist = false)
+    private Integer refundAmount;
 }

src/main/java/com/huiju/estateagents/redpack/service/ITaOrgAccountService.java

      * @return
      */
     ResponseBean rechargeAccount(String accountId, TaOrgAccount taOrgAccount, Integer orgId, Integer userId);
+
+    /**
+     * 账户退费接口
+     * @param accountId
+     * @param taOrgAccount
+     * @param orgId
+     * @param userId
+     * @return
+     */
+    ResponseBean refundAccount(String accountId, TaOrgAccount taOrgAccount, Integer orgId, Integer userId);
 }

src/main/java/com/huiju/estateagents/redpack/service/impl/TaOrgAccountServiceImpl.java

 import java.util.List;
 
 import org.apache.commons.collections.CollectionUtils;
+import org.apache.poi.ss.formula.functions.T;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import com.huiju.estateagents.common.CommConstant;
 import com.huiju.estateagents.common.CommonUtils;
 import com.huiju.estateagents.redpack.entity.TaOrgAccount;
+import com.huiju.estateagents.redpack.entity.TaOrgAccountBlocked;
 import com.huiju.estateagents.redpack.entity.TaOrgAccountCertificate;
 import com.huiju.estateagents.redpack.entity.TaOrgAccountDetailedList;
 import com.huiju.estateagents.redpack.entity.TaOrgOrder;
 import com.huiju.estateagents.redpack.entity.TaOrgOrderDetail;
+import com.huiju.estateagents.redpack.entity.TaOrgRefundApplication;
+import com.huiju.estateagents.redpack.mapper.TaOrgAccountBlockedMapper;
 import com.huiju.estateagents.redpack.mapper.TaOrgAccountCertificateMapper;
 import com.huiju.estateagents.redpack.mapper.TaOrgAccountDetailedListMapper;
 import com.huiju.estateagents.redpack.mapper.TaOrgAccountMapper;
 import com.huiju.estateagents.redpack.mapper.TaOrgOrderDetailMapper;
 import com.huiju.estateagents.redpack.mapper.TaOrgOrderMapper;
+import com.huiju.estateagents.redpack.mapper.TaOrgRefundApplicationMapper;
 import com.huiju.estateagents.redpack.service.ITaOrgAccountService;
 
 import io.swagger.models.auth.In;
     @Autowired
     private TaOrgAccountDetailedListMapper taOrgAccountDetailedListMapper;
 
+    @Autowired
+    private TaOrgRefundApplicationMapper taOrgRefundApplicationMapper;
+
+    @Autowired
+    private TaOrgAccountBlockedMapper taOrgAccountBlockedMapper;
+
     @Autowired
     private TaUserMapper taUserMapper;
 
         int rechargeAccountInsertResult = taOrgAccountMapper.updateById(rechargeAccount);
 
         //新增订单记录
-        TaOrgOrder taOrgOrder = assembleTaOrgOrder(orgId, taOrgAccount.getRechargeAmount(), userId);
+        TaOrgOrder taOrgOrder = assembleTaOrgOrder(orgId, taOrgAccount.getRechargeAmount(), userId, CommConstant.ITEM_TYPE_RECHARGE);
         int taOrgOrderInsertResult = taOrgOrderMapper.insert(taOrgOrder);
 
         //新增关联订单明细
-        TaOrgOrderDetail taOrgOrderDetail = assembleTaOrgOrderDetail(taOrgOrder.getOrderId(), orgId, taOrgAccount.getRechargeAmount());
+        TaOrgOrderDetail taOrgOrderDetail = assembleTaOrgOrderDetail(taOrgOrder.getOrderId(), orgId, taOrgAccount.getRechargeAmount(), CommConstant.ITEM_TYPE_RECHARGE);
         int taOrgOrderDetailInsertResult = taOrgOrderDetailMapper.insert(taOrgOrderDetail);
 
         //新增账户消费流水记录
-        TaOrgAccountDetailedList taOrgAccountDetailedList = assembleAccountDetailList(orgId, taOrgAccount, taOrgOrder.getOrderId(), userId);
+        TaOrgAccountDetailedList taOrgAccountDetailedList = assembleAccountDetailList(orgId, taOrgAccount, taOrgOrder.getOrderId(), userId, CommConstant.ITEM_TYPE_RECHARGE);
         int taOrgAccountDetailedListInsertResult = taOrgAccountDetailedListMapper.insert(taOrgAccountDetailedList);
 
         //插入凭证记录
         if (CollectionUtils.isNotEmpty(taOrgAccount.getCertificateList())){
-            List<TaOrgAccountCertificate> taOrgAccountCertificateList = assembleAccountCertificate(orgId, taOrgAccount, taOrgAccountDetailedList.getSerialNo(), taOrgOrder.getOrderId(), userId);
+            List<TaOrgAccountCertificate> taOrgAccountCertificateList = assembleAccountCertificate(orgId, taOrgAccount, taOrgAccountDetailedList.getSerialNo(), taOrgOrder.getOrderId(), userId, CommConstant.ITEM_TYPE_RECHARGE);
             taOrgAccountCertificateList.forEach(e -> {
                 taOrgAccountCertificateMapper.insert(e);
             });
         return responseBean;
     }
 
+    @Override
+    @Transactional(rollbackFor = {RuntimeException.class})
+    public ResponseBean refundAccount(String accountId, TaOrgAccount taOrgAccount, Integer orgId, Integer userId) {
+        ResponseBean responseBean = new ResponseBean();
+
+        //更新系统账户余额
+        TaOrgAccount selectOneAccount = selectTaOrgAccountById(accountId);
+        if (selectOneAccount.getAvailableBalance() < taOrgAccount.getRefundAmount()){
+            responseBean.addError("退款额不能大于余额");
+            return responseBean;
+        }
+        TaOrgAccount refundAccount = assembleRefundAccount(accountId, taOrgAccount);
+        taOrgAccountMapper.updateById(refundAccount);
+
+        //新增订单记录
+        TaOrgOrder taOrgOrder = assembleTaOrgOrder(orgId, taOrgAccount.getRefundAmount(), userId, CommConstant.ITEM_TYPE_REFUND);
+        int taOrgOrderInsertResult = taOrgOrderMapper.insert(taOrgOrder);
+
+        //新增关联订单明细
+        TaOrgOrderDetail taOrgOrderDetail = assembleTaOrgOrderDetail(taOrgOrder.getOrderId(), orgId, taOrgAccount.getRefundAmount(), CommConstant.ITEM_TYPE_REFUND);
+        int taOrgOrderDetailInsertResult = taOrgOrderDetailMapper.insert(taOrgOrderDetail);
+
+        //新增账户消费流水
+        TaOrgAccountDetailedList taOrgAccountDetailedList = assembleAccountDetailList(orgId, taOrgAccount, taOrgOrder.getOrderId(), userId, CommConstant.ITEM_TYPE_REFUND);
+        int taOrgAccountDetailedListInsertResult = taOrgAccountDetailedListMapper.insert(taOrgAccountDetailedList);
+
+        //插入凭证记录
+        if (CollectionUtils.isNotEmpty(taOrgAccount.getCertificateList())){
+            List<TaOrgAccountCertificate> taOrgAccountCertificateList = assembleAccountCertificate(orgId, taOrgAccount, taOrgAccountDetailedList.getSerialNo(), taOrgOrder.getOrderId(), userId, CommConstant.ITEM_TYPE_REFUND);
+            taOrgAccountCertificateList.forEach(e -> {
+                taOrgAccountCertificateMapper.insert(e);
+            });
+        }
+
+        //更新退款申请状态
+        TaOrgRefundApplication taOrgRefundApplication = assembleAcctApplication(userId);
+        QueryWrapper<TaOrgRefundApplication> taOrgRefundApplicationQueryWrapper = new QueryWrapper<>();
+        taOrgRefundApplicationQueryWrapper.eq("org_id", taOrgAccount.getOrgId());
+        int taOrgRefundApplicationUpdateResult = taOrgRefundApplicationMapper.update(taOrgRefundApplication, taOrgRefundApplicationQueryWrapper);
+
+        //更新账户冻结记录
+        TaOrgAccountBlocked taOrgAccountBlocked = new TaOrgAccountBlocked();
+        taOrgAccountBlocked.setStatus(CommConstant.STATUS_UNACCALIMED);
+        QueryWrapper<TaOrgAccountBlocked> taOrgAccountBlockedQueryWrapper = new QueryWrapper<>();
+        taOrgAccountBlockedQueryWrapper.eq("account_id", taOrgAccount.getAccountId());
+        taOrgAccountBlockedQueryWrapper.eq("org_id", taOrgAccount.getOrgId());
+        int taOrgAccountBlockedUpdateResult = taOrgAccountBlockedMapper.update(taOrgAccountBlocked, taOrgAccountBlockedQueryWrapper);
+
+        if (taOrgOrderInsertResult < 1 ||
+                taOrgOrderInsertResult < 1 ||
+                taOrgOrderDetailInsertResult < 1 ||
+                taOrgAccountDetailedListInsertResult < 1 ||
+                taOrgRefundApplicationUpdateResult < 1 ||
+                taOrgAccountBlockedUpdateResult < 1){
+            responseBean.addError("退费失败");
+            return responseBean;
+        }
+
+        return responseBean;
+    }
+
     /**
      * 构造充值账户
      * @param accountId
      * @return
      */
     private TaOrgAccount assembleRechargeAccount(String accountId, TaOrgAccount taOrgAccount){
-        QueryWrapper<TaOrgAccount> selectOneQuery = new QueryWrapper<>();
-        selectOneQuery.eq("account_id", accountId);
-        TaOrgAccount selectOneAccount = taOrgAccountMapper.selectOne(selectOneQuery);
+        TaOrgAccount selectOneAccount = selectTaOrgAccountById(accountId);
 
         TaOrgAccount rechargeAccount = new TaOrgAccount();
         rechargeAccount.setAccountId(accountId);
-        if (selectOneAccount.getAvailableBalance() == 0){
-            rechargeAccount.setAvailableBalance(taOrgAccount.getRechargeAmount());
-        }else{
-            rechargeAccount.setAvailableBalance(selectOneAccount.getAvailableBalance() + taOrgAccount.getRechargeAmount());
-        }
-
-        if (selectOneAccount.getRealBalance() == 0){
-            rechargeAccount.setRealBalance(taOrgAccount.getRechargeAmount());
-        }else{
-            rechargeAccount.setRealBalance(selectOneAccount.getRealBalance() + taOrgAccount.getRechargeAmount());
-        }
+        rechargeAccount.setAvailableBalance(selectOneAccount.getAvailableBalance() + taOrgAccount.getRechargeAmount());
+        rechargeAccount.setRealBalance(selectOneAccount.getRealBalance() + taOrgAccount.getRechargeAmount());
         rechargeAccount.setModifyDate(LocalDateTime.now());
 
         return rechargeAccount;
     }
 
-    public List<TaOrgAccountCertificate> assembleAccountCertificate(Integer orgId, TaOrgAccount taOrgAccount, Integer accountSerialNo, String orderId, Integer userId){
+    /**
+     * 构造交易凭证信息
+     * @param orgId
+     * @param taOrgAccount
+     * @param accountSerialNo
+     * @param orderId
+     * @param userId
+     * @return
+     */
+    public List<TaOrgAccountCertificate> assembleAccountCertificate(Integer orgId, TaOrgAccount taOrgAccount, Integer accountSerialNo, String orderId, Integer userId, String consumeType){
         TaUser taUser = selectUserById(userId);
         List<TaOrgAccountCertificate> taOrgAccountCertificateList = new ArrayList<>();
 
             taOrgAccountCertificate.setAccountId(taOrgAccount.getAccountId());
             taOrgAccountCertificate.setAccountSerialNo(accountSerialNo);
             taOrgAccountCertificate.setOrderId(orderId);
-            taOrgAccountCertificate.setConsumptionType(CommConstant.ITEM_TYPE_RECHARGE);
-            taOrgAccountCertificate.setRemark("线下充值缴费");
+            taOrgAccountCertificate.setConsumptionType(CommConstant.ITEM_TYPE_RECHARGE.equals(consumeType) ? CommConstant.ITEM_TYPE_RECHARGE : CommConstant.ITEM_TYPE_REFUND);
+            taOrgAccountCertificate.setRemark(CommConstant.ITEM_TYPE_RECHARGE.equals(consumeType) ? "线下缴费" : "线下退费");
             taOrgAccountCertificate.setUrl(e);
             taOrgAccountCertificate.setCreateDate(LocalDateTime.now());
             taOrgAccountCertificate.setUserId(userId);
      * @param userId
      * @return
      */
-    private TaOrgOrder assembleTaOrgOrder(Integer orgId, Integer amount, Integer userId){
+    private TaOrgOrder assembleTaOrgOrder(Integer orgId, Integer amount, Integer userId, String consumeType){
 
         TaUser taUser = selectUserById(userId);
         TaOrgOrder taOrgOrder = new TaOrgOrder();
         taOrgOrder.setOrgId(orgId);
-        taOrgOrder.setTradeNo(CommonUtils.generateTradeNo(CommConstant.RECHARGE));
+        taOrgOrder.setTradeNo(CommonUtils.generateTradeNo(CommConstant.ITEM_TYPE_RECHARGE.equals(consumeType) ? CommConstant.RECHARGE : CommConstant.REFUND));
         taOrgOrder.setAmount(amount);
         taOrgOrder.setCreateDate(LocalDateTime.now());
         taOrgOrder.setExpiryDate(LocalDateTime.now());
-        taOrgOrder.setRemark("线下充值缴费");
+        taOrgOrder.setRemark(CommConstant.ITEM_TYPE_RECHARGE.equals(consumeType) ? "线下账户缴费" : "线下账户退费");
         taOrgOrder.setTradingStatus(String.valueOf(CommConstant.STATUS_NORMAL));
         taOrgOrder.setIsOffline(true);
         taOrgOrder.setUserId(userId);
         return taOrgOrder;
     }
 
-    private TaOrgOrderDetail assembleTaOrgOrderDetail(String orderId, Integer orgId, Integer amount){
+    /**
+     * 构造交订单详情信息
+     * @param orderId
+     * @param orgId
+     * @param amount
+     * @return
+     */
+    private TaOrgOrderDetail assembleTaOrgOrderDetail(String orderId, Integer orgId, Integer amount, String consumeType){
         TaOrgOrderDetail taOrgOrderDetail = new TaOrgOrderDetail();
 
         taOrgOrderDetail.setOrderId(orderId);
         taOrgOrderDetail.setOrgId(orgId);
-        taOrgOrderDetail.setItemType(CommConstant.ITEM_TYPE_RECHARGE);
+        taOrgOrderDetail.setItemType(CommConstant.ITEM_TYPE_RECHARGE.equals(consumeType) ? CommConstant.ITEM_TYPE_RECHARGE : CommConstant.ITEM_TYPE_REFUND);
         taOrgOrderDetail.setAmount(amount);
 
         return taOrgOrderDetail;
      * @param userId
      * @return
      */
-    private TaOrgAccountDetailedList assembleAccountDetailList(Integer orgId, TaOrgAccount taOrgAccount, String orderId, Integer userId){
+    private TaOrgAccountDetailedList assembleAccountDetailList(Integer orgId, TaOrgAccount taOrgAccount, String orderId, Integer userId, String consumeType){
 
         TaUser taUser = selectUserById(userId);
         TaOrgAccountDetailedList taOrgAccountDetailed = new TaOrgAccountDetailedList();
         taOrgAccountDetailed.setAccountId(taOrgAccount.getAccountId());
         taOrgAccountDetailed.setOrgId(orgId);
-        taOrgAccountDetailed.setAmount(taOrgAccount.getRechargeAmount());
+        taOrgAccountDetailed.setAmount(CommConstant.ITEM_TYPE_RECHARGE.equals(consumeType) ? taOrgAccount.getRechargeAmount() : taOrgAccount.getRefundAmount());
         //1收入,-1支出
-        taOrgAccountDetailed.setSignType(CommConstant.STATUS_NORMAL);
-        taOrgAccountDetailed.setRemark("线下充值缴费");
+        taOrgAccountDetailed.setSignType(CommConstant.ITEM_TYPE_RECHARGE.equals(consumeType) ? CommConstant.STATUS_NORMAL : CommConstant.STATUS_DELETE);
+        taOrgAccountDetailed.setRemark(CommConstant.ITEM_TYPE_RECHARGE.equals(consumeType) ? "线下账户缴费" : "线下账户退费");
         taOrgAccountDetailed.setOrderId(orderId);
         taOrgAccountDetailed.setUserId(userId);
         taOrgAccountDetailed.setUserName(taUser.getUserName());
         return taOrgAccountDetailed;
     }
 
+    /**
+     * 构造退费账户
+     * @param accountId
+     * @param taOrgAccount
+     * @return
+     */
+    private TaOrgAccount assembleRefundAccount(String accountId, TaOrgAccount taOrgAccount){
+        TaOrgAccount selectOneAccount = selectTaOrgAccountById(accountId);
+
+        TaOrgAccount refundAccount = new TaOrgAccount();
+        refundAccount.setAccountId(accountId);
+        refundAccount.setAvailableBalance(selectOneAccount.getAvailableBalance() - taOrgAccount.getRefundAmount());
+        refundAccount.setRealBalance(selectOneAccount.getRealBalance() - taOrgAccount.getRefundAmount());
+        refundAccount.setTotalRefund(taOrgAccount.getRefundAmount() + selectOneAccount.getTotalRefund());
+        refundAccount.setModifyDate(LocalDateTime.now());
+
+        return refundAccount;
+    }
+
+    /**
+     * 退费审核通过
+     * @param userId
+     * @return
+     */
+    private TaOrgRefundApplication assembleAcctApplication(Integer userId){
+        TaUser taUser = selectUserById(userId);
+
+        TaOrgRefundApplication taOrgRefundApplication = new TaOrgRefundApplication();
+        taOrgRefundApplication.setAuditStatus("同意");
+        taOrgRefundApplication.setAuditorId(userId);
+        taOrgRefundApplication.setAuditorName(taUser.getUserName());
+
+        return taOrgRefundApplication;
+    }
+
+    public TaOrgAccount selectTaOrgAccountById(String accountId){
+        QueryWrapper<TaOrgAccount> selectOneQuery = new QueryWrapper<>();
+        selectOneQuery.eq("account_id", accountId);
+        TaOrgAccount selectOneAccount = taOrgAccountMapper.selectOne(selectOneQuery);
+        return selectOneAccount;
+    }
+
     public TaUser selectUserById(Integer userId){
         //获取操作人
         QueryWrapper<TaUser> taUserQueryWrapper = new QueryWrapper<>();