新需求

src/main/java/com/huiju/estateagents/common/CommConstant.java

      */
     public static final String ITEM_TYPE_REFUND = "refund";
 
+    /**
+     * 明细类型--退费
+     */
+    public static final String ITEM_TYPE_REJECT = "reject";
+
+
     /**
      * 明细类型--红包
      */

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

 import com.huiju.estateagents.base.ResponseBean;
 import com.huiju.estateagents.common.StringUtils;
 import com.huiju.estateagents.redpack.entity.TaOrgAccount;
+import com.huiju.estateagents.redpack.entity.TaOrgOrder;
+import com.huiju.estateagents.redpack.entity.TaOrgRefundApplication;
 import com.huiju.estateagents.redpack.service.ITaOrgAccountService;
+import com.huiju.estateagents.redpack.service.ITaOrgOrderService;
 
 /**
  * <p>
     @Autowired
     public ITaOrgAccountService iTaOrgAccountService;
 
+    @Autowired
+    public ITaOrgOrderService iTaOrgOrderService;
 
     /**
      * 分页查询列表
         }
         return responseBean;
     }
+
+    /**
+     * 订单退款
+     * @param id
+     * @param refundApplication
+     * @param request
+     * @return
+     */
+    @RequestMapping(value = "/taOrgOrder/refund/{id}")
+    public ResponseBean taOrgOrderRefund(@PathVariable String id, @RequestBody TaOrgRefundApplication refundApplication,
+                                           HttpServletRequest request){
+        ResponseBean responseBean = new ResponseBean();
+        try {
+            Integer userId = getUserId(request);
+            responseBean = iTaOrgOrderService.refundOrder(id, refundApplication,  2149);
+        }catch (Exception e){
+            e.printStackTrace();
+            logger.error("taOrgAccountRefund -=- {}",e.toString());
+            responseBean.addError(e.getMessage());
+        }
+        return responseBean;
+    }
+
+    /**
+     * 订单驳回
+     * @param id
+     * @param refundApplication
+     * @param request
+     * @return
+     */
+    @RequestMapping(value = "/taOrgOrder/reject/{id}")
+    public ResponseBean taOrgOrderReject(@PathVariable String id, @RequestBody TaOrgRefundApplication refundApplication,
+                                         HttpServletRequest request){
+        ResponseBean responseBean = new ResponseBean();
+        try {
+            Integer userId = getUserId(request);
+            responseBean = iTaOrgOrderService.rejectOrder(id, refundApplication,  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/TaOrgRefundApplication.java

 
 import java.time.LocalDateTime;
 import java.io.Serializable;
+import java.util.List;
 
 import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableId;
 
 import lombok.Data;
      */
     private Integer status;
 
-
+    @TableField(exist = false)
+    private List<String> certificateList;
 }

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

 package com.huiju.estateagents.redpack.service;
 
 import com.baomidou.mybatisplus.extension.service.IService;
+import com.huiju.estateagents.base.ResponseBean;
 import com.huiju.estateagents.redpack.entity.TaOrgOrder;
+import com.huiju.estateagents.redpack.entity.TaOrgRefundApplication;
 
 /**
  * <p>
  * @since 2020-06-03
  */
 public interface ITaOrgOrderService extends IService<TaOrgOrder> {
+    /**
+     * 订单退款
+     * @param id
+     * @param refundApplication
+     * @param userId
+     * @return
+     */
+    ResponseBean refundOrder(String id, TaOrgRefundApplication refundApplication, Integer userId);
 
+
+    /**
+     * 订单驳回
+     * @param id
+     * @param refundApplication
+     * @param userId
+     * @return
+     */
+    ResponseBean rejectOrder(String id, TaOrgRefundApplication refundApplication, Integer userId);
 }

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

 
         //更新系统账户充值金额
         TaOrgAccount rechargeAccount = assembleRechargeAccount(accountId, taOrgAccount);
-        int rechargeAccountInsertResult = taOrgAccountMapper.updateById(rechargeAccount);
+        synchronized (this){
+            taOrgAccountMapper.updateById(rechargeAccount);
+        }
 
         //新增订单记录
         TaOrgOrder taOrgOrder = assembleTaOrgOrder(orgId, taOrgAccount.getRechargeAmount(), userId, CommConstant.ITEM_TYPE_RECHARGE);
             });
         }
 
-        if (rechargeAccountInsertResult < 1 ||
-                taOrgOrderInsertResult < 1 ||
+        if (    taOrgOrderInsertResult < 1 ||
                 taOrgOrderDetailInsertResult < 1 ||
                 taOrgAccountDetailedListInsertResult < 1){
             responseBean.addError("充值失败");
             });
         }
 
-        //更新退款申请状态
-        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){
+                taOrgAccountDetailedListInsertResult < 1){
             responseBean.addError("退费失败");
             return responseBean;
         }
 
         return taOrgAccountCertificateList;
     }
+
     /**
      * 构造订单
      * @param orgId
         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);

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

 package com.huiju.estateagents.redpack.service.impl;
 
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.commons.collections.CollectionUtils;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.huiju.estateagents.base.ResponseBean;
+import com.huiju.estateagents.center.taUser.entity.TaUser;
+import com.huiju.estateagents.center.taUser.mapper.TaUserMapper;
+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.ITaOrgOrderService;
 
 /**
 @Service
 public class TaOrgOrderServiceImpl extends ServiceImpl<TaOrgOrderMapper, TaOrgOrder> implements ITaOrgOrderService {
 
+    @Autowired
+    private TaOrgAccountMapper taOrgAccountMapper;
+
+    @Autowired
+    private TaOrgOrderMapper taOrgOrderMapper;
+
+    @Autowired
+    private TaOrgOrderDetailMapper taOrgOrderDetailMapper;
+
+    @Autowired
+    private TaOrgAccountDetailedListMapper taOrgAccountDetailedListMapper;
+
+    @Autowired
+    private TaOrgRefundApplicationMapper taOrgRefundApplicationMapper;
+
+    @Autowired
+    private TaOrgAccountBlockedMapper taOrgAccountBlockedMapper;
+
+    @Autowired
+    private TaOrgAccountCertificateMapper taOrgAccountCertificateMapper;
+
+    @Autowired
+    private TaUserMapper taUserMapper;
+
+
+    @Override
+    @Transactional(rollbackFor = {RuntimeException.class})
+    public ResponseBean refundOrder(String id, TaOrgRefundApplication refundApplication, Integer userId) {
+        ResponseBean responseBean = new ResponseBean();
+
+        //订单退款申请，更新账户的实际余额
+        TaOrgAccount taOrgAccount = assembleRefundAccount(refundApplication.getOrgId(), refundApplication, CommConstant.ITEM_TYPE_REFUND);
+        taOrgAccountMapper.updateById(taOrgAccount);
+
+        //新增订单记录
+        TaOrgOrder taOrgOrder = assembleTaOrgOrder(refundApplication.getOrgId(), taOrgAccount.getRechargeAmount(), userId);
+        int taOrgOrderInsertResult = taOrgOrderMapper.insert(taOrgOrder);
+
+        //新增关联订单明细
+        TaOrgOrderDetail taOrgOrderDetail = assembleTaOrgOrderDetail(taOrgOrder.getOrderId(), refundApplication.getOrgId(), taOrgAccount.getRechargeAmount());
+        int taOrgOrderDetailInsertResult = taOrgOrderDetailMapper.insert(taOrgOrderDetail);
+
+        //新建账户消费流水
+        TaOrgAccountDetailedList taOrgAccountDetailedList = assembleAccountDetailList(refundApplication, userId);
+        int taOrgAccountDetailedListInsertResult = taOrgAccountDetailedListMapper.insert(taOrgAccountDetailedList);
+
+        //更新账户退款申请
+        TaOrgRefundApplication updateRefundApplication = assembleRefundApplication(userId, CommConstant.ITEM_TYPE_REJECT, refundApplication);
+        QueryWrapper<TaOrgRefundApplication> taOrgRefundApplicationQueryWrapper = new QueryWrapper<>();
+        taOrgRefundApplicationQueryWrapper.eq("org_id", refundApplication.getOrgId());
+        int taOrgRefundApplicationUpdateResult = taOrgRefundApplicationMapper.update(updateRefundApplication, taOrgRefundApplicationQueryWrapper);
+
+        //更新账户冻结记录
+        int taOrgAccountBlockedUpdateResult = updateOrgAccountBlock(refundApplication);
+
+        //插入凭证记录
+        if (CollectionUtils.isNotEmpty(refundApplication.getCertificateList())){
+            List<TaOrgAccountCertificate> taOrgAccountCertificateList = assembleAccountCertificate(refundApplication.getOrgId(), taOrgAccount, taOrgAccountDetailedList.getSerialNo(), taOrgOrder.getOrderId(), userId, CommConstant.ITEM_TYPE_REFUND);
+            taOrgAccountCertificateList.forEach(e -> {
+                taOrgAccountCertificateMapper.insert(e);
+            });
+        }
+
+        if (taOrgOrderInsertResult < 1 ||
+                taOrgOrderDetailInsertResult < 1 ||
+                taOrgAccountDetailedListInsertResult < 1 ||
+                taOrgRefundApplicationUpdateResult < 1 ||
+                taOrgAccountBlockedUpdateResult < 1){
+            responseBean.addError("订单退款失败");
+            return responseBean;
+        }
+
+        return responseBean;
+    }
+
+    @Override
+    @Transactional(rollbackFor = {RuntimeException.class})
+    public ResponseBean rejectOrder(String id, TaOrgRefundApplication refundApplication, Integer userId) {
+        ResponseBean responseBean = new ResponseBean();
+
+        //退款订单驳回，更新账户的可用余额
+        TaOrgAccount taOrgAccount = assembleRefundAccount(refundApplication.getOrgId(), refundApplication, CommConstant.ITEM_TYPE_REJECT);
+        taOrgAccountMapper.updateById(taOrgAccount);
+
+        //更新账户冻结记录
+        int taOrgAccountBlockedUpdateResult = updateOrgAccountBlock(refundApplication);
+
+        //更新退款申请记录
+        TaOrgRefundApplication updateRefundApplication = assembleRefundApplication(userId, CommConstant.ITEM_TYPE_REJECT, refundApplication);
+        QueryWrapper<TaOrgRefundApplication> taOrgRefundApplicationQueryWrapper = new QueryWrapper<>();
+        taOrgRefundApplicationQueryWrapper.eq("org_id", refundApplication.getOrgId());
+        int taOrgRefundApplicationUpdateResult = taOrgRefundApplicationMapper.update(updateRefundApplication, taOrgRefundApplicationQueryWrapper);
+
+        if (taOrgAccountBlockedUpdateResult < 1 ||
+                taOrgRefundApplicationUpdateResult < 1){
+            responseBean.addError("驳回失败");
+            return responseBean;
+        }
+
+        return responseBean;
+
+    }
+
+    /**
+     * 构造充值账户
+     * @param orgId
+     * @param refundApplication
+     * @return
+     */
+    private TaOrgAccount assembleRefundAccount(Integer orgId, TaOrgRefundApplication refundApplication, String operateType){
+        TaOrgAccount selectOneAccount = selectTaOrgAccountById(orgId);
+
+        TaOrgAccount rechargeAccount = new TaOrgAccount();
+        rechargeAccount.setAccountId(selectOneAccount.getAccountId());
+
+        if (CommConstant.ITEM_TYPE_REFUND.equals(operateType)){
+            rechargeAccount.setRealBalance(selectOneAccount.getRealBalance() - refundApplication.getAmount());
+            rechargeAccount.setTotalRefund(selectOneAccount.getTotalRefund() + refundApplication.getAmount());
+        }
+
+        if (CommConstant.ITEM_TYPE_REJECT.equals(operateType)){
+            rechargeAccount.setAvailableBalance(refundApplication.getAmount());
+        }
+
+        rechargeAccount.setModifyDate(LocalDateTime.now());
+
+        return rechargeAccount;
+    }
+
+    /**
+     * 构造订单
+     * @param orgId
+     * @param amount
+     * @param userId
+     * @return
+     */
+    private TaOrgOrder assembleTaOrgOrder(Integer orgId, Integer amount, Integer userId){
+
+        TaUser taUser = selectUserById(userId);
+        TaOrgOrder taOrgOrder = new TaOrgOrder();
+        taOrgOrder.setOrgId(orgId);
+        taOrgOrder.setTradeNo(CommonUtils.generateTradeNo(CommConstant.RECHARGE));
+        taOrgOrder.setAmount(amount);
+        taOrgOrder.setCreateDate(LocalDateTime.now());
+        taOrgOrder.setExpiryDate(LocalDateTime.now());
+        taOrgOrder.setRemark("线下订单退费");
+        taOrgOrder.setTradingStatus(String.valueOf(CommConstant.STATUS_NORMAL));
+        taOrgOrder.setIsOffline(true);
+        taOrgOrder.setUserId(userId);
+        taOrgOrder.setUserName(taUser.getUserName());
+
+        return taOrgOrder;
+    }
+
+    /**
+     * 构造交订单详情信息
+     * @param orderId
+     * @param orgId
+     * @param amount
+     * @return
+     */
+    private TaOrgOrderDetail assembleTaOrgOrderDetail(String orderId, Integer orgId, Integer amount){
+        TaOrgOrderDetail taOrgOrderDetail = new TaOrgOrderDetail();
+
+        taOrgOrderDetail.setOrderId(orderId);
+        taOrgOrderDetail.setOrgId(orgId);
+        taOrgOrderDetail.setItemType(CommConstant.ITEM_TYPE_REFUND);
+        taOrgOrderDetail.setAmount(amount);
+
+        return taOrgOrderDetail;
+    }
+
+    /**
+     * 构造消费流水记录
+     * @param refundApplication
+     * @param userId
+     * @return
+     */
+    private TaOrgAccountDetailedList assembleAccountDetailList(TaOrgRefundApplication refundApplication, Integer userId){
+
+        TaUser taUser = selectUserById(userId);
+        TaOrgAccount taOrgAccount = selectTaOrgAccountById(refundApplication.getOrgId());
+
+        TaOrgAccountDetailedList taOrgAccountDetailed = new TaOrgAccountDetailedList();
+        taOrgAccountDetailed.setAccountId(taOrgAccount.getAccountId());
+        taOrgAccountDetailed.setOrgId(refundApplication.getOrgId());
+        taOrgAccountDetailed.setAmount(refundApplication.getAmount());
+        //1收入,-1支出
+        taOrgAccountDetailed.setSignType(CommConstant.STATUS_DELETE);
+        taOrgAccountDetailed.setRemark("线下订单退费");
+        taOrgAccountDetailed.setOrderId(refundApplication.getOrderId());
+        taOrgAccountDetailed.setUserId(userId);
+        taOrgAccountDetailed.setUserName(taUser.getUserName());
+
+        return taOrgAccountDetailed;
+    }
+
+    /**
+     * 构造交易凭证信息
+     * @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<>();
+
+        taOrgAccount.getCertificateList().forEach(e -> {
+            TaOrgAccountCertificate taOrgAccountCertificate = new TaOrgAccountCertificate();
+            taOrgAccountCertificate.setOrgId(orgId);
+            taOrgAccountCertificate.setAccountId(taOrgAccount.getAccountId());
+            taOrgAccountCertificate.setAccountSerialNo(accountSerialNo);
+            taOrgAccountCertificate.setOrderId(orderId);
+            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);
+            taOrgAccountCertificate.setUserName(taUser.getUserName());
+            taOrgAccountCertificateList.add(taOrgAccountCertificate);
+        });
+
+        return taOrgAccountCertificateList;
+    }
+
+    /**
+     * 构造订单退款申请
+     * @param userId
+     * @return
+     */
+    private TaOrgRefundApplication assembleRefundApplication(Integer userId, String operateType, TaOrgRefundApplication refundApplication) {
+        TaUser taUser = selectUserById(userId);
+        TaOrgRefundApplication taOrgRefundApplication = new TaOrgRefundApplication();
+        taOrgRefundApplication.setAuditorId(userId);
+        taOrgRefundApplication.setAuditorName(taUser.getUserName());
+        taOrgRefundApplication.setAuditResult(CommConstant.ITEM_TYPE_REFUND.equals(operateType) ? "退款成功" : refundApplication.getAuditResult());
+        taOrgRefundApplication.setAuditStatus(CommConstant.ITEM_TYPE_REFUND.equals(operateType) ? "同意" : "不同意");
+
+        return taOrgRefundApplication;
+    }
+
+    private Integer updateOrgAccountBlock(TaOrgRefundApplication refundApplication){
+        //更新账户冻结记录
+        TaOrgAccountBlocked taOrgAccountBlocked = new TaOrgAccountBlocked();
+        taOrgAccountBlocked.setStatus(CommConstant.STATUS_UNACCALIMED);
+        QueryWrapper<TaOrgAccountBlocked> taOrgAccountBlockedQueryWrapper = new QueryWrapper<>();
+        taOrgAccountBlockedQueryWrapper.eq("org_id", refundApplication.getOrgId());
+        return taOrgAccountBlockedMapper.update(taOrgAccountBlocked, taOrgAccountBlockedQueryWrapper);
+    }
+
+    public TaOrgAccount selectTaOrgAccountById(Integer orgId){
+        QueryWrapper<TaOrgAccount> selectOneQuery = new QueryWrapper<>();
+        selectOneQuery.eq("org_id", orgId);
+        TaOrgAccount selectOneAccount = taOrgAccountMapper.selectOne(selectOneQuery);
+        return selectOneAccount;
+    }
+
+    /**
+     * 获取操作人
+     * @param userId
+     * @return
+     */
+    public TaUser selectUserById(Integer userId){
+        //获取操作人
+        QueryWrapper<TaUser> taUserQueryWrapper = new QueryWrapper<>();
+        taUserQueryWrapper.eq("user_id", userId);
+        TaUser taUser = taUserMapper.selectOne(taUserQueryWrapper);
+        return taUser;
+    }
+
 }