Page复杂操作

た入场券 2024-04-19 14:58 54阅读 0赞

## 这些代码，都还是可以优化的… ##

import cn.hutool.core.bean.BeanUtil;
    import cn.hutool.core.date.BetweenFormater;
    import cn.hutool.core.date.DateUtil;
    import cn.hutool.core.util.StrUtil;
    import cn.hutool.json.JSONUtil;
    import com.google.common.collect.Lists;
    import com.querydsl.core.BooleanBuilder;
    import com.wondertek.oes.commons.utils.ResultBean;
    import com.wondertek.oes.workbench.commons.enums.MemberEnum;
    import com.wondertek.oes.workbench.commons.enums.NodeResultEnum;
    import com.wondertek.oes.workbench.commons.enums.YesOrNoEnum;
    import com.wondertek.oes.workbench.commons.model.*;
    import com.wondertek.oes.workbench.manage.dto.dto.*;
    import com.wondertek.oes.workbench.manage.feign.OesSubpApi;
    import com.wondertek.oes.workbench.manage.repository.*;
    import com.wondertek.oes.workbench.manage.repository.customize.EnRepositoryCustom;
    import com.wondertek.oes.workbench.manage.service.BaseQueryService;
    import com.wondertek.oes.workbench.manage.service.ButtonService;
    import com.wondertek.oes.workbench.manage.vo.VideoRecordVo;
    import com.wondertek.oes.workbench.manage.vo.baseQuery.*;
    import com.wondertek.oes.workbench.manage.vo.wait.ProductPackagesVo;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.domain.*;
    import org.springframework.data.jpa.domain.Specification;
    import org.springframework.stereotype.Service;
    
    import javax.annotation.Resource;
    import javax.persistence.criteria.Predicate;
    import javax.transaction.Transactional;
    import java.time.LocalDateTime;
    import java.time.temporal.ChronoUnit;
    import java.util.ArrayList;
    import java.util.List;
    
    @Service
    @Transactional
    @Slf4j
    public class BaseQueryServiceImpl implements BaseQueryService {
    
        @Resource
        private VideoRecordRepository videoRecordRepository;
        @Resource
        private AuditRecordRepository auditRecordRepository;
        @Resource
        private TranscodeRepository transcodeRepository;
        @Resource
        private SyncInfoRepository syncInfoRepository;
        @Resource
        private SubpInfoRepository subpInfoRepository;
        @Resource
        private PublishInfoRepository publishInfoRepository;
        @Resource
        private BrocInfoRepository brocInfoRepository;
        @Resource
        private MoveInfoRepository moveInfoRepository;
        @Resource
        private OesSubpApi oesSubpApi;
        @Resource
        private LocationInfoRepository locationInfoRepository;
        @Resource
        private EnRepositoryCustom repositoryCustom;
        @Autowired
        private ButtonService buttonService;
    
        /**
         * 视屏生产记录
         *
         * @param videoRecordDto 页面传参
         * @param page           页面传参
         * @param rows           页面传参
         * @param sord           页面传参
         * @param sidx           页面传参
         * @return Page<VideoRecordVo>
         */
        @Override
        public Page<VideoRecordVo> findAll(VideoRecordDto videoRecordDto, int page, int rows, String sord, String sidx) {
            if (StrUtil.isBlankIfStr(sidx)) {
                sidx = "produceId";
            }
            PageRequest pageRequest = PageRequest.of(page - 1, rows, Sort.by(Sort.Order.asc(sidx), Sort.Order.desc("collectTime")));
            Page<ColVideo> all = videoRecordRepository.findAll((Specification<ColVideo>) (root, query, cb) -> {
                List<Predicate> predicates = Lists.newArrayList();
                predicates.add(cb.equal(root.get("groupId"), videoRecordDto.getGroupId()));
                if (!StrUtil.isBlankIfStr(videoRecordDto.getVideoName())) {
                    predicates.add(cb.like(root.get("videoName"), "%" + videoRecordDto.getVideoName() + "%"));
                }
                if (!StrUtil.isBlankIfStr(videoRecordDto.getProduceStatus())) {
                    predicates.add(cb.equal(root.get("produceStatus"), videoRecordDto.getProduceStatus()));
                }
                if (!StrUtil.isBlankIfStr(videoRecordDto.getDistributeStatus())) {
                    predicates.add(cb.equal(root.get("distributeStatus"), videoRecordDto.getDistributeStatus()));
                }
                if (!StrUtil.isBlankIfStr(videoRecordDto.getDisPlatform())) {
                    predicates.add(cb.like(root.get("disPlatform"), "%" + videoRecordDto.getDisPlatform() + "%"));
                }
                return cb.and(predicates.toArray(new Predicate[0]));
            }, pageRequest);
    
            Page<VideoRecordVo> vos = all.map(e -> JSONUtil.toBean(JSONUtil.toJsonStr(e), VideoRecordVo.class));
    
            vos.map(e -> {
                        if (NodeResultEnum.DistStatus.FAILED.getKey().equals(e.getDistributeStatus())) {
                            e.setIsOperate(this.buttonService.charge("2", videoRecordDto.getGroupId(), MemberEnum.ButtonType.PRODUCE.getType()));
                        } else {
                            e.setIsOperate(YesOrNoEnum.NO.getCode());
                        }
                        return e;
                    }
            );
            return vos;
        }
    
        /**
         * 转码记录
         *
         * @param transcodeDto 页面传参
         * @param page         页面传参
         * @param rows         页面传参
         * @param sord         页面传参
         * @param sidx         页面传参
         * @return Page<TranscodeRecordVo>
         */
        @Override
        public Page<TranscodeRecordVo> findAll(TranscodeDto transcodeDto, int page, int rows, String sord, String sidx) {
            if (StrUtil.isBlankIfStr(sidx)) {
                sidx = "transcodeId";
            }
            PageRequest pageRequest = PageRequest.of(page - 1, rows, Sort.by(Sort.Order.asc(sidx), Sort.Order.desc("collectTime")));
            Page<Transcode> all = transcodeRepository.findAll((Specification<Transcode>) (root, query, cb) -> {
                List<Predicate> predicates = Lists.newArrayList();
                predicates.add(cb.equal(root.get("groupId"), transcodeDto.getGroupId()));
    
                if (!StrUtil.isBlankIfStr(transcodeDto.getAssetId())) {
                    predicates.add(cb.equal(root.get("assetId"), transcodeDto.getAssetId()));
                }
                if (!StrUtil.isBlankIfStr(transcodeDto.getAssetName())) {
                    predicates.add(cb.like(root.get("assetName"), "%" + transcodeDto.getAssetName() + "%"));
                }
                if (!StrUtil.isBlankIfStr(transcodeDto.getTranscodeStatus())) {
                    predicates.add(cb.equal(root.get("transcodeStatus"), transcodeDto.getTranscodeStatus()));
                }
                if (!StrUtil.isBlankIfStr(transcodeDto.getFromStartTime())) {
                    predicates.add(cb.greaterThanOrEqualTo(root.get("endTime"), transcodeDto.getFromStartTime()));
                }
                if (!StrUtil.isBlankIfStr(transcodeDto.getToEndTime())) {
                    predicates.add(cb.lessThanOrEqualTo(root.get("endTime"), transcodeDto.getToEndTime()));
                }
                return cb.and(predicates.toArray(new Predicate[0]));
            }, pageRequest);
    
            ArrayList<TranscodeRecordVo> list = Lists.newArrayList();
    
            all.getContent().forEach(e -> {
                TranscodeRecordVo vo = new TranscodeRecordVo();
                BeanUtil.copyProperties(e, vo);
                list.add(vo);
            });
    
            list.forEach(e -> {
                if (NodeResultEnum.TranscodeStatus.STARTED.getKey().equals(e.getTranscodeStatus())) {
                    e.setTransTime(DateUtil.formatBetween(ChronoUnit.MILLIS.between(e.getStartTime(), LocalDateTime.now()), BetweenFormater.Level.SECOND));
                } else {
                    e.setTransTime(DateUtil.formatBetween(ChronoUnit.MILLIS.between(e.getStartTime(), e.getEndTime()), BetweenFormater.Level.SECOND));
                }
                if (NodeResultEnum.TranscodeStatus.FAILED.getKey().equals(e.getTranscodeStatus())) {
                    e.setIsOperate(YesOrNoEnum.YES.getCode());
                } else {
                    e.setIsOperate(YesOrNoEnum.NO.getCode());
                }
            });
            return new PageImpl<>(list, all.getPageable(), all.getTotalElements());
        }
    
        /**
         * 审核记录
         *
         * @param auditDto 页面传参
         * @param page     页面传参
         * @param rows     页面传参
         * @param sord     页面传参
         * @param sidx     页面传参
         * @return Page<AuditRecordVo>
         */
        @Override
        public Page<AuditRecordVo> findAll(AuditDto auditDto, int page, int rows, String sord, String sidx) {
            if (StrUtil.isBlankIfStr(sidx)) {
                sidx = "auditInfoId";
            }
            PageRequest pageRequest = PageRequest.of(page - 1, rows, Sort.by(Sort.Order.asc(sidx), Sort.Order.desc("collectTime")));
            Page<AuditInfo> all = auditRecordRepository.findAll((Specification<AuditInfo>) (root, query, cb) -> {
                List<Predicate> predicates = Lists.newArrayList();
                predicates.add(cb.equal(root.get("groupId"), auditDto.getGroupId()));
                if (!StrUtil.isBlankIfStr(auditDto.getAssetId())) {
                    predicates.add(cb.equal(root.get("assetId"), auditDto.getAssetId()));
                }
                if (!StrUtil.isBlankIfStr(auditDto.getAssetName())) {
                    predicates.add(cb.like(root.get("assetName"), "%" + auditDto.getAssetName() + "%"));
                }
                if (!StrUtil.isBlankIfStr(auditDto.getAuditStatus())) {
                    predicates.add(cb.equal(root.get("auditStatus"), auditDto.getAuditStatus()));
                }
                if (!StrUtil.isBlankIfStr(auditDto.getAuditResult())) {
                    predicates.add(cb.equal(root.get("auditResult"), auditDto.getAuditResult()));
                }
                return cb.and(predicates.toArray(new Predicate[0]));
            }, pageRequest);
    
            ArrayList<AuditRecordVo> list = Lists.newArrayList();
    
            all.getContent().forEach(e -> {
                AuditRecordVo vo = new AuditRecordVo();
                BeanUtil.copyProperties(e, vo);
                list.add(vo);
            });
    
            list.forEach(e -> {
                        if (NodeResultEnum.AuditStatus.FAILED.getKey().equals(e.getAuditStatus())) {
                            e.setIsOperate(this.buttonService.charge("2", auditDto.getGroupId(), MemberEnum.ButtonType.SUBMIT.getType()));
                        } else {
                            e.setIsOperate(YesOrNoEnum.NO.getCode());
                        }
                    }
            );
            return new PageImpl<AuditRecordVo>(list, all.getPageable(), all.getTotalElements());
        }
    
        /**
         * 同步记录
         *
         * @param dto  页面传参
         * @param page 页面传参
         * @param rows 页面传参
         * @param sord 页面传参
         * @param sidx 页面传参
         * @return Page<SyncRecordVo>
         */
        @Override
        public Page<SyncRecordVo> findAll(SyncRecordDto dto, int page, int rows, String sord, String sidx) {
            if (StrUtil.isBlankIfStr(sidx)) {
                sidx = "assetId";
            }
            PageRequest pageRequest = PageRequest.of(page - 1, rows, Sort.by(Sort.Order.asc(sidx), Sort.Order.desc("collectTime")));
            Page<SyncInfo> all = syncInfoRepository.findAll((Specification<SyncInfo>) (root, query, cb) -> {
                List<Predicate> predicates = Lists.newArrayList();
                predicates.add(cb.equal(root.get("groupId"), dto.getGroupId()));
    
                if (!StrUtil.isBlankIfStr(dto.getAssetId())) {
                    predicates.add(cb.equal(root.get("assetId"), dto.getAssetId()));
                }
                if (!StrUtil.isBlankIfStr(dto.getAssetName())) {
                    predicates.add(cb.like(root.get("assetName"), "%" + dto.getAssetName() + "%"));
                }
                if (!StrUtil.isBlankIfStr(dto.getSyncStatus())) {
                    predicates.add(cb.equal(root.get("syncStatus"), dto.getSyncStatus()));
                }
                if (!StrUtil.isBlankIfStr(dto.getFromStartTime())) {
                    predicates.add(cb.greaterThanOrEqualTo(root.get("endTime"), dto.getFromStartTime()));
                }
                if (!StrUtil.isBlankIfStr(dto.getToEndTime())) {
                    predicates.add(cb.lessThanOrEqualTo(root.get("endTime"), dto.getToEndTime()));
                }
                return cb.and(predicates.toArray(new Predicate[0]));
            }, pageRequest);
    
            List<SyncRecordVo> list = Lists.newArrayList();
            all.getContent().forEach(s -> {
                SyncRecordVo vo = new SyncRecordVo();
                BeanUtil.copyProperties(s, vo);
                list.add(vo);
            });
    
            // 计算同步时间，根据同步状态
            list.forEach(e -> {
                if (NodeResultEnum.SyncStatus.STARTED.getKey().equals(e.getSyncStatus())) {
                    e.setSyncTime(DateUtil.formatBetween(ChronoUnit.MILLIS.between(e.getStartTime(), LocalDateTime.now()), BetweenFormater.Level.SECOND));
                } else {
                    e.setSyncTime(DateUtil.formatBetween(ChronoUnit.MILLIS.between(e.getStartTime(), e.getEndTime()), BetweenFormater.Level.SECOND));
                }
                if (NodeResultEnum.SyncStatus.FAILED.getKey().equals(e.getSyncStatus())) {
                    e.setIsOperate(YesOrNoEnum.YES.getCode());
                } else {
                    e.setIsOperate(YesOrNoEnum.NO.getCode());
                }
            });
            return new PageImpl<>(list, all.getPageable(), all.getTotalElements());
        }
    
        /**
         * 分包批价记录
         *
         * @param dto  页面传参
         * @param page 页面传参
         * @param rows 页面传参
         * @param sord 页面传参
         * @param sidx 页面传参
         * @return Page<SubpRecordVo>
         */
        @Override
        public Page<SubpRecordVo> findAll(SubpInfo dto, int page, int rows, String sord, String sidx) {
            if (StrUtil.isBlankIfStr(sidx)) {
                sidx = "assetId";
            }
            PageRequest pageRequest = PageRequest.of(page - 1, rows, Sort.by(Sort.Order.asc(sidx), Sort.Order.desc("collectTime")));
            Page<SubpInfo> all = subpInfoRepository.findAll((Specification<SubpInfo>) (root, query, cb) -> {
                List<Predicate> predicates = Lists.newArrayList();
                predicates.add(cb.equal(root.get("groupId"), dto.getGroupId()));
    
                if (!StrUtil.isBlankIfStr(dto.getAssetId())) {
                    predicates.add(cb.equal(root.get("assetId"), dto.getAssetId()));
                }
                if (!StrUtil.isBlankIfStr(dto.getAssetName())) {
                    predicates.add(cb.like(root.get("assetName"), "%" + dto.getAssetName() + "%"));
                }
                if (!StrUtil.isBlankIfStr(dto.getProgramId())) {
                    predicates.add(cb.equal(root.get("programId"), dto.getProgramId()));
                }
                return cb.and(predicates.toArray(new Predicate[0]));
            }, pageRequest);
            return all.map(e -> JSONUtil.toBean(JSONUtil.toJsonStr(e), SubpRecordVo.class));
        }
    
        /**
         * 播控记录
         *
         * @param dto  页面传参
         * @param page 页面传参
         * @param rows 页面传参
         * @param sord 页面传参
         * @param sidx 页面传参
         * @return Page<BrocRecordVo>
         */
        @Override
        public Page<BrocRecordVo> findAll(BrocRecordDto dto, int page, int rows, String sord, String sidx) {
            if (StrUtil.isBlankIfStr(sidx)) {
                sidx = "assetId";
            }
            PageRequest pageRequest = PageRequest.of(page - 1, rows, Sort.by(Sort.Order.asc(sidx), Sort.Order.desc("collectTime")));
            Page<BrocInfo> all = brocInfoRepository.findAll((Specification<BrocInfo>) (root, query, cb) -> {
                List<Predicate> predicates = Lists.newArrayList();
                predicates.add(cb.equal(root.get("groupId"), dto.getGroupId()));
    
                if (!StrUtil.isBlankIfStr(dto.getAssetId())) {
                    predicates.add(cb.equal(root.get("assetId"), dto.getAssetId()));
                }
                if (!StrUtil.isBlankIfStr(dto.getProgramId())) {
                    predicates.add(cb.equal(root.get("programId"), dto.getProgramId()));
                }
                if (!StrUtil.isBlankIfStr(dto.getBrocInfoId())) {
                    predicates.add(cb.equal(root.get("brocInfoId"), dto.getBrocInfoId()));
                }
                if (!StrUtil.isBlankIfStr(dto.getAssetName())) {
                    predicates.add(cb.like(root.get("assetName"), "%" + dto.getAssetName() + "%"));
                }
                if (!StrUtil.isBlankIfStr(dto.getBrocPartyName())) {
                    predicates.add(cb.like(root.get("brocPartyName"), "%" + dto.getBrocPartyName() + "%"));
                }
                if (!StrUtil.isBlankIfStr(dto.getBroadcastStatus())) {
                    predicates.add(cb.equal(root.get("broadcastStatus"), dto.getBroadcastStatus()));
                }
                if (!StrUtil.isBlankIfStr(dto.getContentId())) {
                    predicates.add(cb.equal(root.get("contentId"), dto.getContentId()));
                }
                if (!StrUtil.isBlankIfStr(dto.getOperator())) {
                    predicates.add(cb.equal(root.get("operator"), dto.getOperator()));
                }
                return cb.and(predicates.toArray(new Predicate[0]));
            }, pageRequest);
            return all.map(e -> JSONUtil.toBean(JSONUtil.toJsonStr(e), BrocRecordVo.class));
        }
    
        /**
         * 发布记录
         *
         * @param dto  页面传参
         * @param page 页面传参
         * @param rows 页面传参
         * @param sord 页面传参
         * @param sidx 页面传参
         * @return Page<PublishRecordVo>
         */
        @Override
        public Page<PublishRecordVo> findAll(PublishInfo dto, int page, int rows, String sord, String sidx) {
            if (StrUtil.isBlankIfStr(sidx)) {
                sidx = "publishInfoId";
            }
            PageRequest pageRequest = PageRequest.of(page - 1, rows, Sort.by(Sort.Order.asc(sidx), Sort.Order.desc("collectTime")));
            Page<PublishInfo> all = publishInfoRepository.findAll((Specification<PublishInfo>) (root, query, cb) -> {
                List<Predicate> predicates = Lists.newArrayList();
                predicates.add(cb.equal(root.get("groupId"), dto.getGroupId()));
    
                if (!StrUtil.isBlankIfStr(dto.getAssetId())) {
                    predicates.add(cb.equal(root.get("assetId"), dto.getAssetId()));
                }
                if (!StrUtil.isBlankIfStr(dto.getAssetName())) {
                    predicates.add(cb.like(root.get("assetName"), "%" + dto.getAssetName() + "%"));
                }
                if (!StrUtil.isBlankIfStr(dto.getProgramId())) {
                    predicates.add(cb.equal(root.get("programId"), dto.getProgramId()));
                }
                if (!StrUtil.isBlankIfStr(dto.getPublishStatus())) {
                    predicates.add(cb.equal(root.get("publishStatus"), dto.getPublishStatus()));
                }
                return cb.and(predicates.toArray(new Predicate[0]));
            }, pageRequest);
    
            ArrayList<PublishRecordVo> list = Lists.newArrayList();
            all.getContent().forEach(e -> {
                PublishRecordVo vo = new PublishRecordVo();
                BeanUtil.copyProperties(e, vo);
                list.add(vo);
            });
    
            list.forEach(e -> {
                if (NodeResultEnum.PublishStatus.FAILED.getKey().equals(e.getPublishStatus())) {
                    e.setIsOperate(YesOrNoEnum.YES.getCode());
                } else {
                    e.setIsOperate(YesOrNoEnum.NO.getCode());
                }
            });
            return new PageImpl<>(list, all.getPageable(), all.getTotalElements());
        }
    
        /**
         * 搬迁记录
         *
         * @param dto  页面传参
         * @param page 页面传参
         * @param rows 页面传参
         * @param sord 页面传参
         * @param sidx 页面传参
         * @return Page<moveRecordVo>
         */
        @Override
        public Page<MoveRecordVo> findAll(MoveRecordDto dto, int page, int rows, String sord, String sidx) {
            if (StrUtil.isBlankIfStr(sidx)) {
                sidx = "moveInfoId";
            }
            PageRequest pageRequest = PageRequest.of(page - 1, rows, Sort.by(Sort.Order.asc(sidx), Sort.Order.desc("collectTime")));
            Page<MoveInfo> all = moveInfoRepository.findAll((Specification<MoveInfo>) (root, query, cb) -> {
    
                List<Predicate> predicates = Lists.newArrayList();
                predicates.add(cb.equal(root.get("groupId"), dto.getGroupId()));
    
                if (!StrUtil.isBlankIfStr(dto.getAssetId())) {
                    predicates.add(cb.equal(root.get("assetId"), dto.getAssetId()));
                }
                if (!StrUtil.isBlankIfStr(dto.getAssetName())) {
                    predicates.add(cb.like(root.get("assetName"), "%" + dto.getAssetName() + "%"));
                }
                if (!StrUtil.isBlankIfStr(dto.getMoveStatus())) {
                    predicates.add(cb.equal(root.get("moveStatus"), dto.getMoveStatus()));
                }
                if (!StrUtil.isBlankIfStr(dto.getFromStartTime())) {
                    predicates.add(cb.greaterThanOrEqualTo(root.get("startTime"), dto.getFromStartTime()));
                }
                if (!StrUtil.isBlankIfStr(dto.getToEndTime())) {
                    predicates.add(cb.lessThanOrEqualTo(root.get("startTime"), dto.getToEndTime()));
                }
                return cb.and(predicates.toArray(new Predicate[0]));
            }, pageRequest);
    
            Page<MoveRecordVo> map = all.map(e -> new MoveRecordVo(e));
            // 计算搬迁用时，根据搬迁状态
            map.forEach(e -> {
                if (NodeResultEnum.MoveStatus.STARTED.getKey().equals(e.getMoveStatus())) {
                    e.setMoveTime(DateUtil.formatBetween(ChronoUnit.MILLIS.between(e.getStartTime(), LocalDateTime.now()), BetweenFormater.Level.SECOND));
                } else {
                    e.setMoveTime(DateUtil.formatBetween(ChronoUnit.MILLIS.between(e.getStartTime(), e.getEndTime()), BetweenFormater.Level.SECOND));
                }
                if (NodeResultEnum.MoveStatus.FAILED.getKey().equals(e.getMoveStatus())) {
                    e.setIsOperate(YesOrNoEnum.YES.getCode());
                } else {
                    e.setIsOperate(YesOrNoEnum.NO.getCode());
                }
            });
    
    //        ArrayList<MoveRecordVo> list = Lists.newArrayList();
    //        all.getContent().forEach(e -> {
    //            MoveRecordVo vo = new MoveRecordVo();
    //            BeanUtil.copyProperties(e, vo);
    //            list.add(vo);
    //        });
    //
    //        // 计算搬迁用时，根据搬迁状态
    //        list.forEach(e -> {
    //            if (NodeResultEnum.MoveStatus.STARTED.getKey().equals(e.getMoveStatus())) {
    //                e.setMoveTime(DateUtil.formatBetween(ChronoUnit.MILLIS.between(e.getStartTime(), LocalDateTime.now()), BetweenFormater.Level.SECOND));
    //            }else{
    //                e.setMoveTime(DateUtil.formatBetween(ChronoUnit.MILLIS.between(e.getStartTime(), e.getEndTime()), BetweenFormater.Level.SECOND));
    //            }
    //            if (NodeResultEnum.MoveStatus.FAILED.getKey().equals(e.getMoveStatus())) {
    //                e.setIsOperate(YesOrNoEnum.YES.getCode());
    //            } else {
    //                e.setIsOperate(YesOrNoEnum.NO.getCode());
    //            }
    //        });
    //        return new PageImpl<>(list, pageRequest, list.size());
            return map;
        }
    
        /**
         * 商品包列表查询
         *
         * @param username  用户
         * @param productId 产品ID
         * @return List<ProductPackagesVo>
         */
        @Override
        public List<ProductPackagesVo> findProductPackages(String username, Long productId) {
            ResultBean productPackages = oesSubpApi.getProductPackages(username, productId);
            return (List<ProductPackagesVo>) productPackages.getResult();
        }
    
        /**
         * 展现运营查询
         *
         * @param dto  前端传参
         * @param page 前端传参
         * @param rows 前端传参
         * @param sord 前端传参
         * @param sidx 前端传参
         * @return Page<AssetPageVo>
         */
        @Override
        public Page<AssetPageVo> findAssetPage(AssetRecordDto dto, int page, int rows, String sord, String sidx) {
    
            if (StrUtil.isBlankIfStr(sidx)) {
                sidx = "assetId";
            }
            PageRequest pageRequest = PageRequest.of(page - 1, rows, Sort.by(Sort.Order.asc(sidx), Sort.Order.desc("collectTime")));
            BooleanBuilder booleanBuilder = this.getBooleanBuilder(dto);
    
            return repositoryCustom.AssetPageList(booleanBuilder, pageRequest);
        }
    
        /**
         * 展现运营详情页展示
         *
         * @param groupId   工作组编号
         * @param programId 节目编号
         * @return AssetShowVo
         */
        @Override
        public AssetShowVo findAssetInfo(Long groupId, Long programId) {
            AssetInfoVo assetInfoVo = repositoryCustom.AssetRecordInfo(groupId, programId);
            List<LocationInfo> all = locationInfoRepository.findByPid(programId);
    
            return new AssetShowVo().setAssetInfoVo(assetInfoVo).setLocationInfo(all);
        }
    
        /**
         * mcn 记录列表查询
         *
         * @param dto  前端入参
         * @param page 前端入参
         * @param rows 前端入参
         * @param sord 前端入参
         * @param sidx 前端入参
         * @return Page<McnRecordVo>
         */
        @Override
        public Page<McnRecordVo> findAll(McnRecordDto dto, int page, int rows, String sord, String sidx) {
    
            if (StrUtil.isBlankIfStr(sidx)) {
                sidx = "mcnInfoId";
            }
            PageRequest pageRequest = PageRequest.of(page - 1, rows, Sort.by(Sort.Order.asc(sidx), Sort.Order.desc("collectTime")));
    
            BooleanBuilder booleanBuilder = this.getBooleanBuilder(dto);
    
            return repositoryCustom.McnRecordList(booleanBuilder, pageRequest);
        }
    
        /**
         * mcn运营详情查询
         *
         * @param groupId   工作组编号
         * @param programId 节目编号
         * @return McnRecordVo
         */
        @Override
        public McnRecordVo findMcnInfo(Long groupId, Long programId) {
            List<McnRecordVo> info = repositoryCustom.McnRecordInfo(groupId, programId);
            return info.size() > 0 ? info.get(0) : null;
        }
    
        /**
         * 提取方法，动态条件
         *
         * @param dto
         * @return
         */
        public BooleanBuilder getBooleanBuilder(McnRecordDto dto) {
            QMcnInfo m = QMcnInfo.mcnInfo;
            QSubpInfo s = QSubpInfo.subpInfo;
    
            BooleanBuilder booleanBuilder = new BooleanBuilder();
            booleanBuilder.and(m.groupId.eq(dto.getGroupId()));
            booleanBuilder.and(m.groupId.eq(dto.getGroupId()));
    
            if (!StrUtil.isBlankIfStr(dto.getAssetId())) {
                booleanBuilder.and(m.assetId.eq(dto.getAssetId()));
            }
            if (!StrUtil.isBlankIfStr(dto.getProgramId())) {
                booleanBuilder.and(m.programId.eq(dto.getProgramId()));
            }
            if (!StrUtil.isBlankIfStr(dto.getDisposeChannel())) {
                booleanBuilder.and(m.disposeChannel.eq(dto.getDisposeChannel()));
            }
            if (!StrUtil.isBlankIfStr(dto.getFromStartTime())) {
                booleanBuilder.and(m.startTime.goe(dto.getFromStartTime()));
            }
            if (!StrUtil.isBlankIfStr(dto.getToEndTime())) {
                booleanBuilder.and(m.startTime.loe(dto.getToEndTime()));
            }
            if (!StrUtil.isBlankIfStr(dto.getContentId())) {
                booleanBuilder.and(s.contentId.eq(dto.getContentId()));
            }
            if (!StrUtil.isBlankIfStr(dto.getAssetName())) {
                booleanBuilder.and(s.assetName.like("%" + dto.getAssetName() + "%"));
            }
            return booleanBuilder;
        }
    
        /**
         * 抽取方法
         *
         * @param dto 入参
         * @return BooleanBuilder
         */
        public BooleanBuilder getBooleanBuilder(AssetRecordDto dto) {
            QCatalogInfo ca = QCatalogInfo.catalogInfo;
            QPublishInfo pub = QPublishInfo.publishInfo;
    
            BooleanBuilder booleanBuilder = new BooleanBuilder();
            booleanBuilder.and(ca.groupId.eq(dto.getGroupId()));
            booleanBuilder.and(pub.publishStatus.eq(NodeResultEnum.PublishStatus.FINISHED.getKey()));
    
            if (!StrUtil.isBlankIfStr(dto.getAssetId())) {
                booleanBuilder.and(ca.assetId.eq(dto.getAssetId()));
            }
            if (!StrUtil.isBlankIfStr(dto.getProgramId())) {
                booleanBuilder.and(pub.programId.eq(dto.getProgramId()));
            }
            if (!StrUtil.isBlankIfStr(dto.getAssetName())) {
                booleanBuilder.and(ca.assetName.like("%" + dto.getAssetName() + "%"));
            }
            if (!StrUtil.isBlankIfStr(dto.getProductId())) {
                booleanBuilder.and(pub.productId.eq(dto.getProductId()));
            }
            if (!StrUtil.isBlankIfStr(dto.getProductName())) {
                booleanBuilder.and(pub.productName.like("%" + dto.getProductName() + "%"));
            }
            return booleanBuilder;
        }
    
    }