白单流水报表与费用初始化（差创建折扣使用记录）0821

chengf

2025-08-21 bde271fdbab51e654a293dba02a31eab8ff3ea8b

 service-job/src/main/java/com/java110/job/importData/adapt/ImportRoomFeeQueueDataAdapt.java

@@ -2,35 +2,52 @@

import com.alibaba.fastjson.JSONObject;
import com.java110.core.factory.GenerateCodeFactory;
import com.java110.dto.account.AccountDto;
import com.java110.dto.contract.ContractDto;
import com.java110.dto.contract.ContractPartyaDto;
import com.java110.dto.dict.DictDto;
import com.java110.dto.fee.FeeAttrDto;
import com.java110.dto.fee.FeeConfigDto;
import com.java110.dto.fee.FeeDto;
import com.java110.dto.importData.ImportCustomCreateFeeDto;
import com.java110.dto.importData.ImportFeeDto;
import com.java110.dto.importData.ImportRoomFee;
import com.java110.dto.log.AssetImportLogDetailDto;
import com.java110.dto.menu.MenuDto;
import com.java110.dto.menu.MenuUserDto;
import com.java110.dto.owner.OwnerDto;
import com.java110.dto.payFee.PayFeeBatchDto;
import com.java110.dto.payFee.PayFeeDetailRefreshFeeMonthDto;
import com.java110.dto.room.RoomDto;
import com.java110.dto.user.UserDto;
import com.java110.fee.cmd.fee.SaveRoomCreateFeeCmd;
import com.java110.intf.acct.IAccountInnerServiceSMO;
import com.java110.intf.community.IRoomInnerServiceSMO;
import com.java110.intf.fee.IFeeAttrInnerServiceSMO;
import com.java110.intf.fee.IFeeInnerServiceSMO;
import com.java110.intf.fee.IPayFeeConfigV1InnerServiceSMO;
import com.java110.intf.fee.IPayFeeMonthInnerServiceSMO;
import com.java110.intf.dev.IDictV1InnerServiceSMO;
import com.java110.intf.fee.*;
import com.java110.intf.store.IContractInnerServiceSMO;
import com.java110.intf.store.IContractPartyaInnerServiceSMO;
import com.java110.intf.user.IMenuUserV1InnerServiceSMO;
import com.java110.intf.user.IOwnerCarInnerServiceSMO;
import com.java110.intf.user.IOwnerInnerServiceSMO;
import com.java110.intf.user.IUserInnerServiceSMO;
import com.java110.job.cmd.ImportSaveRoomCreateFeeCmd;
import com.java110.job.importData.DefaultImportData;
import com.java110.job.importData.IImportDataAdapt;
import com.java110.po.fee.FeeAttrPo;
import com.java110.po.fee.PayFeePo;
import com.java110.po.importFee.ImportFeeDetailPo;
import com.java110.utils.util.BeanConvertUtil;
import com.java110.utils.util.DateUtil;
import com.java110.utils.util.StringUtil;
import com.java110.po.importFee.ImportFeePo;
import com.java110.po.payFee.PayFeeBatchPo;
import com.java110.utils.util.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

@Service("importRoomFeeQueueData")
public class ImportRoomFeeQueueDataAdapt extends DefaultImportData implements IImportDataAdapt {
@@ -59,20 +76,34 @@
    @Autowired
    private IPayFeeMonthInnerServiceSMO payFeeMonthInnerServiceSMOImpl;

    @Autowired
    private IImportFeeDetailInnerServiceSMO importFeeDetailInnerServiceSMOImpl;

    @Autowired
    private IImportFeeInnerServiceSMO importFeeInnerServiceSMOImpl;

    @Autowired
    private IDictV1InnerServiceSMO iDictV1InnerServiceSMO;

    @Autowired
    private IAccountInnerServiceSMO accountInnerServiceSMOImpl;

    @Autowired
    private IContractPartyaInnerServiceSMO iContractPartyaInnerServiceSMO;

    @Autowired
    private IPayFeeBatchV1InnerServiceSMO payFeeBatchV1InnerServiceSMOImpl;

    @Autowired
    private IContractInnerServiceSMO iContractInnerServiceSMO;
    //    @Autowired
//    private IPayFeeMonth payFeeMonthImpl;
    @Override
    public void importData(List<AssetImportLogDetailDto> assetImportLogDetailDtos) {

        for (AssetImportLogDetailDto assetImportLogDetailDto : assetImportLogDetailDtos) {

            try {
                doImportData(assetImportLogDetailDto);
                updateImportLogDetailState(assetImportLogDetailDto.getDetailId());
            } catch (Exception e) {
                e.printStackTrace();
                updateImportLogDetailState(assetImportLogDetailDto.getDetailId(), e);
            }
        }
    }

@@ -81,11 +112,11 @@
        ImportRoomFee importRoomFee = BeanConvertUtil.covertBean(data, ImportRoomFee.class);

        String communityId = importRoomFee.getCommunityId();
        String batchId = importRoomFee.getCommunityId();
        String batchId = importRoomFee.getBatchId();

        doImportRoomCreateFee(importRoomFee, batchId);
        doImportCarCreateFee(importRoomFee, batchId);

        doImportContractFee(importRoomFee, batchId);

    }

@@ -96,10 +127,19 @@
     * @param batchId
     */
    private void doImportRoomCreateFee(ImportRoomFee importRoomFee, String batchId) {
        if (!ImportCustomCreateFeeDto.TYPE_ROOM.equals(importRoomFee.getObjType())) {
        if (!FeeDto.PAYER_OBJ_TYPE_ROOM.equals(importRoomFee.getObjType())) {
            return;
        }
        List<ImportRoomFee> rooms = new ArrayList<>();

        DictDto dictDto = new DictDto();
        dictDto.setName(importRoomFee.getFeeTypeCd());
        List<DictDto> dictDtos = iDictV1InnerServiceSMO.queryDicts(dictDto);
        try {
            importRoomFee.setFeeTypeCd(dictDtos.get(0).getStatusCd());
        }catch (Exception e){
            throw new IllegalArgumentException("查询费用类型异常");
        }

        String[] objNames;
        objNames = importRoomFee.getPayerObjName().split("-", 3);
@@ -145,7 +185,7 @@
     * @param batchId
     */
    private void doImportCarCreateFee(ImportRoomFee importRoomFee, String batchId) {
        if (!ImportCustomCreateFeeDto.TYPE_CAR.equals(importRoomFee.getObjType())) {
        if (!FeeDto.PAYER_OBJ_TYPE_CONTRACT.equals(importRoomFee.getObjType())) {
            return;
        }
        List<ImportRoomFee> cars = new ArrayList<>();
@@ -155,7 +195,30 @@

        List<ImportRoomFee> importRoomFees = ownerCarInnerServiceSMOImpl.freshCarIds(cars);
        for (ImportRoomFee tmpImportRoomFee : importRoomFees) {
            if (StringUtil.isEmpty(tmpImportRoomFee.getRoomId())) {
            if (StringUtil.isEmpty(tmpImportRoomFee.getPayerObjName())) {
                throw new IllegalArgumentException(tmpImportRoomFee.getCarNum() + "不存在");
            }
        }
        doCreateFeeAndAttrs(importRoomFees.get(0), batchId);
    }
    /**
     * 创建车辆费用
     *
     * @param importRoomFee
     * @param batchId
     */
    private void doImportContractFee(ImportRoomFee importRoomFee, String batchId) {
        if (!FeeDto.PAYER_OBJ_TYPE_CAR.equals(importRoomFee.getObjType())) {
            return;
        }
        List<ImportRoomFee> cars = new ArrayList<>();
        importRoomFee.setCarNum(importRoomFee.getPayerObjName());
        cars.add(importRoomFee);


        List<ImportRoomFee> importRoomFees = ownerCarInnerServiceSMOImpl.freshCarIds(cars);
        for (ImportRoomFee tmpImportRoomFee : importRoomFees) {
            if (StringUtil.isEmpty(tmpImportRoomFee.getCarId())) {
                throw new IllegalArgumentException(tmpImportRoomFee.getCarNum() + "不存在");
            }
        }
@@ -169,9 +232,9 @@
        PayFeePo payFeePo = null;
        ImportFeeDetailPo importFeeDetailPo = null;

        if (StringUtil.isEmpty(importRoomFee.getRoomId())) {
            throw new IllegalArgumentException("收费对象不存在");
        }
//        if (StringUtil.isEmpty(importRoomFee.getRoomId())) {
//            throw new IllegalArgumentException("收费对象不存在");
//        }
        FeeConfigDto feeConfigDto = new FeeConfigDto();
        feeConfigDto.setCommunityId(importRoomFee.getCommunityId());
        if (!StringUtil.isEmpty(importRoomFee.getConfigId())) {
@@ -180,9 +243,11 @@
            feeConfigDto.setFeeNameEq(importRoomFee.getFeeName());
        }
        feeConfigDto.setComputingFormula(FeeConfigDto.COMPUTING_FORMULA_DYNAMIC);
        feeConfigDto.setComputingFormula(null);
        List<FeeConfigDto> feeConfigDtos = payFeeConfigV1InnerServiceSMOImpl.queryPayFeeConfigs(feeConfigDto);
        if (feeConfigDtos == null || feeConfigDtos.size() < 1) {
            throw new IllegalArgumentException("费用项不存在");
        if (ListUtil.isNull(feeConfigDtos)) {

            throw new IllegalArgumentException("费用项不存在,或者费用项公式不是动态费用");
        }
        payFeePo = new PayFeePo();
        payFeePo.setFeeId(GenerateCodeFactory.getGeneratorId(GenerateCodeFactory.CODE_PREFIX_feeId, true));
@@ -191,8 +256,35 @@
        payFeePo.setCommunityId(importRoomFee.getCommunityId());
        payFeePo.setConfigId(feeConfigDtos.get(0).getConfigId());
        if (FeeDto.PAYER_OBJ_TYPE_CONTRACT.equals(importRoomFee.getObjType())) {
            payFeePo.setPayerObjId(importRoomFee.getContractId());
            ContractDto contractDto = new ContractDto();
            contractDto.setContractCode(importRoomFee.getContractId());
            List<ContractDto> contractDtos = iContractInnerServiceSMO.queryContracts(contractDto);
            if(contractDtos.size() == 0){
                throw new IllegalArgumentException("不存在合同编号为"+importRoomFee.getContractId()+"的合同");
            }
            importRoomFee.setFeeTypeCd(feeConfigDtos.get(0).getFeeTypeCd());
            payFeePo.setFeeTypeCd(feeConfigDtos.get(0).getFeeTypeCd());
            payFeePo.setContractFee(contractDtos.get(0).getContractId());
//            payFeePo.setCreateTime(importFeeDetailPo.getC);
            ContractPartyaDto contractPartyaDto = new ContractPartyaDto();
            if(importRoomFee.getPayerObjName() == null || Objects.equals(importRoomFee.getPayerObjName(), "")){//当没写入主体时
                contractPartyaDto.setPartyaId(contractDtos.get(0).getbPartyaId());
            }
            else{//写入了
                contractPartyaDto.setPartyA(importRoomFee.getPayerObjName());
            }
            List<ContractPartyaDto> contractPartyaDtos = iContractPartyaInnerServiceSMO.queryContractPartyas(contractPartyaDto);
            if (ListUtil.isNull(contractPartyaDtos)) {
                throw new IllegalArgumentException("不存在合同主体："+importRoomFee.getPayerObjName());
            }else if (contractPartyaDtos.size() > 1){
                throw new IllegalArgumentException("合同主体"+importRoomFee.getPayerObjName()+"存在重名");
            }
            importRoomFee.setOwnerName(contractPartyaDtos.get(0).getPartyA());
            payFeePo.setPayerObjId(contractPartyaDtos.get(0).getPartyaId());
            payFeePo.setPayerObjType(FeeDto.PAYER_OBJ_TYPE_CONTRACT);
            payFeePo.setIsContractFee("O");
            payFeePo.setEndTime(importRoomFee.getEndTime());

        } else if (FeeDto.PAYER_OBJ_TYPE_CAR.equals(importRoomFee.getObjType())) {
            payFeePo.setPayerObjId(importRoomFee.getCarId());
            payFeePo.setPayerObjType(FeeDto.PAYER_OBJ_TYPE_CAR);
@@ -200,15 +292,58 @@
            payFeePo.setPayerObjId(importRoomFee.getRoomId());
            payFeePo.setPayerObjType(FeeDto.PAYER_OBJ_TYPE_ROOM);
        }

        payFeePo.setCreateTime(importRoomFee.getCreateTime());
        FeeDto feeDto = new FeeDto();
        feeDto.setFeeTypeCd(importRoomFee.getFeeTypeCd());
        feeDto.setCommunityId(importRoomFee.getCommunityId());
        String dateStr = importRoomFee.getStartTime();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        try {
            feeDto.setStartTime(sdf.parse(importRoomFee.getStartTime()));
            feeDto.setEndTime(sdf.parse(importRoomFee.getEndTime()));
        } catch (ParseException e) {
            throw new RuntimeException("导入起始时间异常");
        }
        feeDto.setPayerObjId(payFeePo.getPayerObjId());
        int feeDtos = feeInnerServiceSMOImpl.getFeeInfoBus(feeDto);
        if(feeDtos > 0){
            throw new IllegalArgumentException("重复的费用");
        }



        payFeePo.setUserId(importRoomFee.getUserId());
        payFeePo.setIncomeObjId(importRoomFee.getStoreId());
        payFeePo.setFeeTypeCd(feeConfigDtos.get(0).getFeeTypeCd());
        FeeConfigDto payFeePo1 = new FeeConfigDto();
        payFeePo1.setFeeTypeCd(importRoomFee.getFeeTypeCd());
        List<FeeConfigDto> feeConfigDtos1 = payFeeConfigV1InnerServiceSMOImpl.queryPayFeeConfigs(payFeePo1);
        payFeePo.setFeeTypeCd(importRoomFee.getFeeTypeCd());
        payFeePo.setFeeFlag(feeConfigDtos.get(0).getFeeFlag());
        payFeePo.setAmount("-1");
        payFeePo.setAmount(importRoomFee.getAmount());
        payFeePo.setBatchId(batchId);
        payFeePo.setEndTime(importRoomFee.getStartTime());
        payFeePo.setStartTime(DateUtil.getNow(DateUtil.DATE_FORMATE_STRING_A));
        payFeePo.setStartTime(importRoomFee.getStartTime());
        if (FeeDto.PAYER_OBJ_TYPE_CONTRACT.equals(importRoomFee.getObjType())){
//            payFeePo.setEndTime(importRoomFee.getEndTime());
        }
        if(payFeePo.getAmount() == null && importRoomFee.getFeeName() == null){
            throw new IllegalArgumentException("收费内容和收费金额不能同时为空");
        }
        if(payFeePo.getAmount() == null){
            if(importRoomFee.getFeeName() == null){
                throw new IllegalArgumentException("收费内容为空");
            }
            else if (importRoomFee.getStartTime() == null){
                throw new IllegalArgumentException("收费起始时间为空");
            }
            else if (importRoomFee.getEndTime() == null){
                throw new IllegalArgumentException("收费结束时间为空");
            }
            else{

            }
        }
        payFeePos.add(payFeePo);

        FeeAttrPo feeAttrPo = new FeeAttrPo();
@@ -223,8 +358,17 @@
        feeAttrPo.setCommunityId(importRoomFee.getCommunityId());
        feeAttrPo.setAttrId(GenerateCodeFactory.getGeneratorId(GenerateCodeFactory.CODE_PREFIX_attrId, true));
        feeAttrPo.setSpecCd(FeeAttrDto.SPEC_CD_PAY_OBJECT_NAME);
        feeAttrPo.setValue(importRoomFee.getRoomName());
        if (FeeDto.PAYER_OBJ_TYPE_CONTRACT.equals(importRoomFee.getObjType())) {
            feeAttrPo.setValue(importRoomFee.getContractId());
        } else if (FeeDto.PAYER_OBJ_TYPE_CAR.equals(importRoomFee.getObjType())) {
            feeAttrPo.setValue(importRoomFee.getCarNum());
        } else {
            feeAttrPo.setValue(importRoomFee.getRoomName());
        }
        feeAttrPo.setFeeId(payFeePo.getFeeId());
        if(feeAttrPo.getValue() == null){
            feeAttrPo.setValue(importRoomFee.getPayerObjName());
        }
        feeAttrPos.add(feeAttrPo);

        //todo 不是周期性费用的场景需要写入结束时间
@@ -245,7 +389,9 @@
            feeAttrPo.setSpecCd(FeeAttrDto.SPEC_CD_OWNER_ID);
            feeAttrPo.setValue(importRoomFee.getOwnerId());
            feeAttrPo.setFeeId(payFeePo.getFeeId());
            feeAttrPos.add(feeAttrPo);
            if(feeAttrPo.getValue() != null){
                feeAttrPos.add(feeAttrPo);
            }

            feeAttrPo = new FeeAttrPo();
            feeAttrPo.setCommunityId(importRoomFee.getCommunityId());
@@ -273,6 +419,9 @@

        feeAttrInnerServiceSMOImpl.saveFeeAttrs(feeAttrPos);

        //todo 保存导入记录日志
        saveImportFee(importRoomFee, payFeePo);

        // todo 这里异步的方式计算 月数据 和欠费数据

        PayFeeDetailRefreshFeeMonthDto payFeeDetailRefreshFeeMonthDto = new PayFeeDetailRefreshFeeMonthDto();
@@ -280,4 +429,87 @@
        payFeeDetailRefreshFeeMonthDto.setFeeId(payFeePos.get(0).getFeeId());
        payFeeMonthInnerServiceSMOImpl.doGeneratorOrRefreshFeeMonth(payFeeDetailRefreshFeeMonthDto);
    }

    private void saveImportFee(ImportRoomFee importRoomFee, PayFeePo payFeePo) {
        ImportFeeDetailPo importFeeDetailPo;
        List<ImportFeeDetailPo> importFeeDetailPos = new ArrayList<>();
        importFeeDetailPo = new ImportFeeDetailPo();
        importFeeDetailPo.setAmount(importRoomFee.getAmount());
        importFeeDetailPo.setCommunityId(payFeePo.getCommunityId());
        importFeeDetailPo.setEndTime(importRoomFee.getEndTime());
        importFeeDetailPo.setFeeId(payFeePo.getFeeId());
        importFeeDetailPo.setFeeName(importRoomFee.getFeeName());

        if (FeeDto.PAYER_OBJ_TYPE_CONTRACT.equals(importRoomFee.getObjType())) {
            importFeeDetailPo.setFloorNum("无");
            importFeeDetailPo.setUnitNum("无");
            importFeeDetailPo.setRoomNum(importRoomFee.getContractId());
            importFeeDetailPo.setRoomId(importRoomFee.getContractId());
            importFeeDetailPo.setObjId(importRoomFee.getContractId());
            importFeeDetailPo.setObjName(importRoomFee.getContractId());
        } else if (FeeDto.PAYER_OBJ_TYPE_CAR.equals(importRoomFee.getObjType())) {
            importFeeDetailPo.setFloorNum("无");
            importFeeDetailPo.setUnitNum("无");
            importFeeDetailPo.setRoomNum(importRoomFee.getCarNum());
            importFeeDetailPo.setRoomId(importRoomFee.getCarId());
            importFeeDetailPo.setObjId(importRoomFee.getCarId());
            importFeeDetailPo.setObjName(importRoomFee.getCarNum());
        } else {
            importFeeDetailPo.setFloorNum(importRoomFee.getFloorNum());
            importFeeDetailPo.setUnitNum(importRoomFee.getUnitNum());
            importFeeDetailPo.setRoomNum(importRoomFee.getRoomNum());
            importFeeDetailPo.setRoomId(importRoomFee.getRoomId());
            importFeeDetailPo.setObjId(importRoomFee.getRoomId());
            importFeeDetailPo.setObjName(!"0".equals(importRoomFee.getUnitNum())
                    ? importRoomFee.getFloorNum() + "栋" + importRoomFee.getUnitNum() + "单元" + importRoomFee.getRoomNum() + "室" :
                    importRoomFee.getFloorNum() + "栋" + importRoomFee.getRoomNum() + "室"
            );
        }

        importFeeDetailPo.setObjType(importRoomFee.getObjType());
        importFeeDetailPo.setExpenseSubject(importRoomFee.getExpenseSubject());
        importFeeDetailPo.setStartTime(importRoomFee.getStartTime());
        importFeeDetailPo.setIfdId(GenerateCodeFactory.getGeneratorId(GenerateCodeFactory.CODE_PREFIX_IfdId, true));
        importFeeDetailPo.setState("1000");
        importFeeDetailPo.setImportFeeId(importRoomFee.getBatchId());
        importFeeDetailPos.add(importFeeDetailPo);
        ImportFeeDto importFeeDto = new ImportFeeDto();
        importFeeDto.setCommunityId(payFeePo.getCommunityId());
        importFeeDto.setImportFeeId(importRoomFee.getBatchId());

        List<ImportFeeDto> importRoomFeess = importFeeInnerServiceSMOImpl.queryImportFees(importFeeDto);

        if (ListUtil.isNull(importRoomFeess)) {
            //保存日志
            ImportFeePo importFeePo = new ImportFeePo();
            importFeePo.setCommunityId(importRoomFee.getCommunityId());
            importFeePo.setFeeTypeCd(importRoomFee.getFeeTypeCd());
            importFeePo.setImportFeeId(importRoomFee.getBatchId());
            importFeeInnerServiceSMOImpl.saveImportFee(importFeePo);
        }


        importFeeDetailInnerServiceSMOImpl.saveImportFeeDetails(importFeeDetailPos);
    }
    private void generatorBatch(JSONObject reqJson) {
        PayFeeBatchPo payFeeBatchPo = new PayFeeBatchPo();
        payFeeBatchPo.setBatchId(GenerateCodeFactory.getGeneratorId("12"));
        payFeeBatchPo.setCommunityId(reqJson.getString("communityId"));
        payFeeBatchPo.setCreateUserId(reqJson.getString("userId"));
        UserDto userDto = new UserDto();
        userDto.setUserId(reqJson.getString("userId"));
        List<UserDto> userDtos = userInnerServiceSMOImpl.getUsers(userDto);

        Assert.listOnlyOne(userDtos, "用户不存在");
        payFeeBatchPo.setCreateUserName(userDtos.get(0).getUserName());
        payFeeBatchPo.setState(PayFeeBatchDto.STATE_NORMAL);
        payFeeBatchPo.setMsg("正常");
        int flag = payFeeBatchV1InnerServiceSMOImpl.savePayFeeBatch(payFeeBatchPo);

        if (flag < 1) {
            throw new IllegalArgumentException("生成批次失败");
        }

        reqJson.put("batchId", payFeeBatchPo.getBatchId());
    }
}