cif/cif-service/src/main/java/com/txz/cif/service/impl/FlowServiceImpl.java

package com.txz.cif.service.impl;

import cn.hutool.core.date.DateUtil;
import com.txz.cif.constants.MyConstants;
import com.txz.cif.dao.FlowMapper;
import com.txz.cif.dto.Result;
import com.txz.cif.model.Account;
import com.txz.cif.model.AccountFlow;
import com.txz.cif.model.AccountFreezd;
import com.txz.cif.model.Flow;
import com.txz.cif.param.*;
import com.txz.cif.service.AccountFlowService;
import com.txz.cif.service.AccountFreezdService;
import com.txz.cif.service.AccountService;
import com.txz.cif.service.FlowService;
import com.txz.cif.core.AbstractService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.Date;

/**
 * Created by CodeGenerator on 2022/11/02.
 */
@Slf4j
@Service
@Transactional
public class FlowServiceImpl extends AbstractService<Flow> implements FlowService {
    @Resource
    private FlowMapper cFlowMapper;

    @Resource
    private AccountService accountService;

    @Resource
    private AccountFlowService accountFlowService;

    @Resource
    private AccountFreezdService accountFreezdService;

    @Override
    public Result freeze(FreezdParam param) {
        try{
            Account account = accountService.getAccount(param.getUserId(),param.getAccountType());
            if (account == null){
                return Result.genFailResult("账号未找到");
            }
            if (account.getEffectiveBalance().subtract(param.getAmount()).compareTo(BigDecimal.ZERO) < 0){
                return Result.genFailResult("冻结金额不足");
            }
            Date today = DateUtil.date();

            Flow flow = Flow.builder().amount(param.getAmount()).bizType(param.getBizType())
                    .bizNo(param.getBizNo()).createTime(today).updateTime(today).transTime(param.getTransTime())
                    .debitAccount(account.getId()).creditAccount(account.getId())
                    .bizId(param.getBizId()).type(4)
                    .build();
            saveUseGeneratedKeys(flow);
            accountService.deal(AccountFlow.builder().accountId(account.getId()).amount(flow.getAmount())
                    .bizId(flow.getBizId()).aliases(account.getAliases()).transTime(param.getTransTime())
                    .bizNo(flow.getBizNo()).balance(account.getBalance()).freezeAmount(account.getFreezeAmount().add(param.getAmount()))
                    .flowType(4).type(1).bizType(param.getBizType()).flowId(flow.getId()).build());
            AccountFreezd freezd = AccountFreezd.builder().accountId(account.getId()).bizId(flow.getId())
                    .amount(param.getAmount()).createTime(today).unfreezeAmount(BigDecimal.ZERO)
                    .updateTime(today).status(1).build();
            accountFreezdService.saveUseGeneratedKeys(freezd);
            return Result.genSuccessResult(freezd.getId());
        }catch (Exception e){
            log.error("冻结异常",e);
            return Result.genFailResult("冻结异常",e);
        }

    }

    @Override
    public Result unFreeze(Long freezdId) {
        AccountFreezd freezd = accountFreezdService.findById(freezdId);
        if (freezd == null){
            return Result.genFailResult("冻结记录未找到");
        }
        Flow oldFlow = findById(freezd.getBizId());
        if (oldFlow == null){
            return Result.genFailResult("冻结记录未找到");
        }

        Account account = accountService.findById(freezd.getAccountId());
        if (account == null){
            return Result.genFailResult("冻结账号未找到");
        }
        Date today = DateUtil.date();
        Flow flow = Flow.builder().amount(freezd.getAmount()).bizType(5001)
                .bizNo(oldFlow.getBizNo()).createTime(today).updateTime(today).transTime(today)
                .debitAccount(oldFlow.getDebitAccount()).creditAccount(oldFlow.getCreditAccount())
                .bizId(oldFlow.getBizId()).type(5)
                .build();
        saveUseGeneratedKeys(flow);
        accountService.deal(AccountFlow.builder().accountId(oldFlow.getDebitAccount()).amount(flow.getAmount())
                .bizId(flow.getBizId()).aliases(account.getAliases()).transTime(today)
                .bizNo(flow.getBizNo()).balance(account.getBalance()).freezeAmount(account.getFreezeAmount().subtract(oldFlow.getAmount()))
                .flowType(5).type(2).bizType(flow.getBizType()).flowId(flow.getId()).build());
        accountFreezdService.update(AccountFreezd.builder().id(freezdId).status(3).unfreezeAmount(oldFlow.getAmount()).build());
        return Result.genSuccessResult();
    }

//    @Override
//    public Result trans(TransParam param) {
//        switch (param.getBizType()){
//            case 1001:
//                RechargeParam p1 = BeanUtil.toBean(param,RechargeParam.class);
//                p1.setAccountId(param.getCreditAccount());
//                return recharge(p1);
//            case 2001:
//                FeeParam p2 = BeanUtil.toBean(param,FeeParam.class);
//                p2.setAccountId(param.getDebitAccount());
//                return fee(p2);
//            case 2002:
//                CommissionParam p3 = BeanUtil.toBean(param,CommissionParam.class);
//                p3.setAccountId(param.getCreditAccount());
//                return commission(p3);
//        }
//        return null;
//    }

//    @Override
//    public Result unFreezeAndTrans(UnFreezdAndTransParam param) {
//        unFreeze(param.getFreezdId());
//        if (CollUtil.isNotEmpty(param.getTrans())){
//            for (TransParam p: param.getTrans()) {
//                Result r = trans(p);
//                if (r == null || !StrUtil.equals(r.getCode() , "200")){
//                    throw new ServiceException(ResultCode.INTERNAL_SERVER_ERROR);
//                }
//            }
//        }
//        return Result.genSuccessResult();
//    }


    @Override
    public Result recharge(RechargeParam param) {
        Account account = accountService.getAccount(param.getUserId(),1);
        if (account == null){
            return Result.genFailResult("账号未找到");
        }
        Account innerCapitalAccount = accountService.findById(MyConstants.INNER_CAPITAL);
        if (innerCapitalAccount == null){
            return Result.genFailResult("账号未找到");
        }
        Date today = DateUtil.date();
        Flow flow = Flow.builder().amount(param.getAmount()).bizType(param.getBizType())
                .bizNo(param.getBizNo()).createTime(today).updateTime(today).transTime(param.getTransTime())
                .debitAccount(MyConstants.INNER_CAPITAL).creditAccount(account.getId())
                .bizId(param.getBizId()).type(1)
                .build();
        saveUseGeneratedKeys(flow);
        //借 ：平台资金银行xx元  内部户1（资产类：借方账户）+钱
        accountService.deal(AccountFlow.builder().accountId(MyConstants.INNER_CAPITAL).amount(flow.getAmount())
                .bizId(flow.getBizId()).aliases(innerCapitalAccount.getAliases()).transTime(param.getTransTime())
                .bizNo(flow.getBizNo()).balance(innerCapitalAccount.getBalance().add(flow.getAmount()))
                .freezeAmount(innerCapitalAccount.getFreezeAmount())
                .flowType(1).type(2).bizType(param.getBizType()).flowId(flow.getId()).build());
        //贷 ：客户资金账户xx元 客户账号(负债类：贷方账户)+钱
        accountService.deal(AccountFlow.builder().accountId(account.getId()).amount(flow.getAmount())
                .bizId(flow.getBizId()).aliases(account.getAliases()).transTime(param.getTransTime())
                .bizNo(flow.getBizNo()).balance(account.getBalance().add(flow.getAmount()))
                .freezeAmount(account.getFreezeAmount())
                .flowType(1).type(2).bizType(param.getBizType()).flowId(flow.getId()).build());

        //充值返点
        Account innerRebateAccount = accountService.findById(MyConstants.INNER_REBATE);
        if (innerCapitalAccount == null){
            return Result.genFailResult("账号未找到");
        }
        flow = Flow.builder().amount(param.getDiscount()).bizType(10)
                .userId(param.getUserId())
                .bizNo(param.getBizNo()).createTime(today).updateTime(today).transTime(param.getTransTime())
                .debitAccount(MyConstants.INNER_REBATE).creditAccount(account.getId())
                .bizId(param.getBizId()).type(10)
                .build();
        saveUseGeneratedKeys(flow);
        //借 ：平台资金银行xx元  内部户1（资产类：借方账户）+钱
        accountService.deal(AccountFlow.builder().accountId(MyConstants.INNER_REBATE).amount(flow.getAmount())
                .bizId(flow.getBizId()).aliases(innerRebateAccount.getAliases()).transTime(param.getTransTime())
                .bizNo(flow.getBizNo()).balance(innerRebateAccount.getBalance().add(flow.getAmount()))
                .freezeAmount(innerRebateAccount.getFreezeAmount())
                .flowType(1).type(2).bizType(param.getBizType()).flowId(flow.getId()).build());
        //贷 ：客户资金账户xx元 客户账号(负债类：贷方账户)+钱
        accountService.deal(AccountFlow.builder().accountId(account.getId()).amount(flow.getAmount())
                .bizId(flow.getBizId()).aliases(account.getAliases()).transTime(param.getTransTime())
                .bizNo(flow.getBizNo()).balance(account.getBalance().add(flow.getAmount()))
                .freezeAmount(account.getFreezeAmount())
                .flowType(1).type(2).bizType(10).flowId(flow.getId()).build());


        return Result.genSuccessResult();
    }

    @Override
    public Result pay(PayParam param) {

        Account account = accountService.getAccount(param.getUserId(),1);
        if (account == null){
            return Result.genFailResult("账号未找到");
        }
        Account innerIncomeAccount = accountService.findById(MyConstants.INNER_INCOME);
        if (innerIncomeAccount == null){
            return Result.genFailResult("账号未找到");
        }

        //借：个人账户钱包（贷）     -500元
        //贷：平台主营收入（贷）   +500元
        Date today = DateUtil.date();
        Flow flow = Flow.builder().amount(param.getAmount()).bizType(param.getBizType())
                .userId(param.getUserId())
                .bizNo(param.getBizNo()).createTime(today).updateTime(today).transTime(param.getTransTime())
                .debitAccount(account.getId()).creditAccount(MyConstants.INNER_INCOME).createUser(param.getUserId()+"")
                .bizId(param.getBizId()).type(6)
                .build();
        saveUseGeneratedKeys(flow);
        //借：个人账户钱包（贷）     -500元
        accountService.deal(AccountFlow.builder().accountId(account.getId()).amount(flow.getAmount())
                .bizId(flow.getBizId()).aliases(account.getAliases()).transTime(param.getTransTime())
                .bizNo(flow.getBizNo()).balance(account.getBalance().subtract(flow.getAmount()))
                .freezeAmount(account.getFreezeAmount())
                .flowType(6).type(1).bizType(param.getBizType()).flowId(flow.getId()).build());
        //贷：平台主营收入（贷）   +500元
        accountService.deal(AccountFlow.builder().accountId(MyConstants.INNER_INCOME).amount(flow.getAmount())
                .bizId(flow.getBizId()).aliases(innerIncomeAccount.getAliases()).transTime(param.getTransTime())
                .bizNo(flow.getBizNo()).balance(innerIncomeAccount.getBalance().add(flow.getAmount()))
                .freezeAmount(innerIncomeAccount.getFreezeAmount())
                .flowType(6).type(2).bizType(param.getBizType()).flowId(flow.getId()).build());
        return Result.genSuccessResult();
    }

    @Override
    public Result refund(RefundParam param) {

        //借：主营支出-退款（借）     +100元
        //贷：个人账户    （贷）     +100元

        Account account = accountService.getAccount(param.getUserId(),1);
        if (account == null){
            return Result.genFailResult("账号未找到");
        }
        Account innerRefundAccount = accountService.findById(MyConstants.INNER_REFUND);
        if (innerRefundAccount == null){
            return Result.genFailResult("账号未找到");
        }
        Date today = DateUtil.date();
        Flow flow = Flow.builder().amount(param.getAmount()).bizType(param.getBizType())
                .userId(param.getUserId())
                .bizNo(param.getBizNo()).createTime(today).updateTime(today).transTime(param.getTransTime())
                .debitAccount(MyConstants.INNER_REFUND).creditAccount(account.getId())
                .bizId(param.getBizId()).type(9)
                .build();
        saveUseGeneratedKeys(flow);
        //借：主营支出-退款（借）     +100元
        accountService.deal(AccountFlow.builder().accountId(MyConstants.INNER_REFUND).amount(flow.getAmount())
                .bizId(flow.getBizId()).aliases(innerRefundAccount.getAliases()).transTime(param.getTransTime())
                .bizNo(flow.getBizNo()).balance(innerRefundAccount.getBalance().add(flow.getAmount()))
                .freezeAmount(innerRefundAccount.getFreezeAmount())
                .flowType(7).type(2).bizType(param.getBizType()).flowId(flow.getId()).build());
        //贷：个人账户（贷）  +100元
        accountService.deal(AccountFlow.builder().accountId(account.getId()).amount(flow.getAmount())
                .bizId(flow.getBizId()).aliases(account.getAliases()).transTime(param.getTransTime())
                .bizNo(flow.getBizNo()).balance(account.getBalance().add(flow.getAmount()))
                .freezeAmount(account.getFreezeAmount())
                .flowType(7).type(2).bizType(param.getBizType()).flowId(flow.getId()).build());
        return Result.genSuccessResult();
    }

    @Override
    public Result withdraw(WithdrawParam param) {

        Account account = accountService.getAccount(param.getUserId(),param.getAccountType());
        if (account == null){
            return Result.genFailResult("账号未找到");
        }
        Account innerCapitalAccount = accountService.findById(MyConstants.INNER_CAPITAL);
        if (innerCapitalAccount == null){
            return Result.genFailResult("账号未找到");
        }

        Date today = DateUtil.date();
        Flow flow = Flow.builder().amount(param.getAmount()).bizType(param.getBizType())
                .userId(param.getUserId())
                .bizNo(param.getBizNo()).createTime(today).updateTime(today).transTime(param.getTransTime())
                .creditAccount(MyConstants.INNER_CAPITAL).debitAccount(account.getId())
                .bizId(param.getBizId()).type(3)
                .build();
        saveUseGeneratedKeys(flow);

        //借 ：客户资金账户xx元 客户账号(负债类：贷方账户)-钱
        accountService.deal(AccountFlow.builder().accountId(account.getId()).amount(flow.getAmount())
                .bizId(flow.getBizId()).aliases(account.getAliases()).transTime(param.getTransTime())
                .bizNo(flow.getBizNo()).balance(account.getBalance().subtract(flow.getAmount()))
                .freezeAmount(account.getFreezeAmount())
                .flowType(3).type(1).bizType(param.getBizType()).flowId(flow.getId()).build());
        //贷 ：资金应收-渠道款-银行xx元  内部户1（资产类：借方账户）-钱
        accountService.deal(AccountFlow.builder().accountId(MyConstants.INNER_CAPITAL).amount(flow.getAmount())
                .bizId(flow.getBizId()).aliases(innerCapitalAccount.getAliases()).transTime(param.getTransTime())
                .bizNo(flow.getBizNo()).balance(innerCapitalAccount.getBalance().subtract(flow.getAmount()))
                .freezeAmount(innerCapitalAccount.getFreezeAmount())
                .flowType(3).type(1).bizType(param.getBizType()).flowId(flow.getId()).build());
        return Result.genSuccessResult();
    }


}