PAS/src/main/java/cn/cslg/pas/service/business/ProofGroupService.java

package cn.cslg.pas.service.business;

import cn.cslg.pas.common.dto.DomainFieldDTO;
import cn.cslg.pas.common.dto.invalidDTO.AddProofGroupDTO;
import cn.cslg.pas.common.dto.invalidDTO.GetProofGroupDTO;
import cn.cslg.pas.common.dto.invalidDTO.UpdateMessageDTO;
import cn.cslg.pas.common.utils.GenerateObjectUtil;
import cn.cslg.pas.common.vo.invalidVO.ProofGroupVO;
import cn.cslg.pas.domain.business.AssoGroupFeature;
import cn.cslg.pas.domain.business.InvalidStatutes;
import cn.cslg.pas.domain.business.ProofGroup;
import cn.cslg.pas.exception.XiaoShiException;
import cn.cslg.pas.mapper.ProofGroupMapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.RequestBody;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 无效证据Service
 *
 * @Author xiexiang
 * @Date 2023/12/25
 */
@Service
@Slf4j
public class ProofGroupService extends ServiceImpl<ProofGroupMapper, ProofGroup> {
    @Autowired
    private InvalidStatutesService invalidStatutesService;

    /**
     * 添加or修改证据组合
     *
     * @param addProofGroupDTO
     * @return
     */
    public List<Integer> addProofGroup(AddProofGroupDTO addProofGroupDTO) {
        List<Integer> proofGroupIds = new ArrayList<>();
        if (addProofGroupDTO != null) {
            Integer id = addProofGroupDTO.getId();
            List<String> descriptions = addProofGroupDTO.getDescriptions();
            Integer projectId = addProofGroupDTO.getProjectId();
            Integer claimId = addProofGroupDTO.getClaimId();
            Integer statutesId = addProofGroupDTO.getStatutesId();
            if (projectId == null) {
                throw new XiaoShiException("projectId不能为空");
            }
            if (claimId == null) {
                throw new XiaoShiException("claimId不能为空");
            }
            if (statutesId == null) {
                throw new XiaoShiException("invalidStatutesId不能为空");
            }
            LambdaQueryWrapper<InvalidStatutes> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(InvalidStatutes::getStatutesId, statutesId)
                    .eq(InvalidStatutes::getClaimId, claimId)
                    .eq(InvalidStatutes::getProjectId, projectId);
            InvalidStatutes invalidStatutes = invalidStatutesService.getOne(queryWrapper, false);
            if (invalidStatutes == null) {
                throw new XiaoShiException("查询无效法条错误");
            }
            Integer invalidStatutesId = invalidStatutes.getId();
            List<ProofGroup> proofGroups = new ArrayList<>();

            if (id != null) {
                //单个更新
                ProofGroup proofGroup = this.getById(id);
                proofGroup.setInvalidStatutesId(invalidStatutesId);
                if (!descriptions.isEmpty() && descriptions.size() == 1) {
                    proofGroup.setDescription(descriptions.get(0));
                } else {
                    proofGroup.setDescription(null);
                }
                proofGroup.updateById();
                proofGroupIds.add(proofGroup.getId());
            } else {
                //批量新增

                //如果证据组合说明不为空
                if (!descriptions.isEmpty()) {
                    descriptions.forEach(item -> {
                        ProofGroup proofGroup = new ProofGroup();
                        proofGroup.setInvalidStatutesId(invalidStatutesId);
                        proofGroup.setDescription(item);
                        proofGroups.add(proofGroup);
                    });
                } else {
                    ProofGroup proofGroup = new ProofGroup();
                    proofGroup.setInvalidStatutesId(invalidStatutesId);
                    proofGroups.add(proofGroup);
                }
                this.saveBatch(proofGroups);
            }
            proofGroupIds = proofGroups.stream().map(ProofGroup::getId).collect(Collectors.toList());
        } else {
            throw new XiaoShiException("参数不能为空");
        }
        return proofGroupIds;
    }

    /**
     * 查询证据组合
     *
     * @param invalidStatutesId
     * @return
     */
    public List<ProofGroupVO> queryProofGroup(Integer invalidStatutesId) {
        List<ProofGroupVO> proofGroupVOS = new ArrayList<>();
        if (invalidStatutesId == null) {
            throw new XiaoShiException("invalidStatutesId不能为空");
        }
        InvalidStatutes invalidStatutes = invalidStatutesService.getById(invalidStatutesId);
        if (invalidStatutes == null) {
            throw new XiaoShiException("查询invalidStatutes错误");
        }
        LambdaQueryWrapper<ProofGroup> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ProofGroup::getInvalidStatutesId, invalidStatutesId);
        List<ProofGroup> proofGroups = this.list(queryWrapper);
        if (!proofGroups.isEmpty()) {
            proofGroups.forEach(item -> {
                ProofGroupVO proofGroupVO = new ProofGroupVO();
                proofGroupVO.setId(item.getId());
                proofGroupVO.setInvalidStatutesId(invalidStatutesId);
                proofGroupVO.setStatutesId(invalidStatutes.getStatutesId());
                proofGroupVO.setClaimId(invalidStatutes.getClaimId());
                proofGroupVO.setProjectId(invalidStatutes.getProjectId());
                proofGroupVO.setDescription(item.getDescription());
                proofGroupVOS.add(proofGroupVO);
            });
        }
        return proofGroupVOS;
    }

    /**
     * 更新信息
     *
     * @param updateMessageDTO
     * @return
     */
    public Boolean updateMessage(@RequestBody UpdateMessageDTO updateMessageDTO) {
        List<Integer> ids = updateMessageDTO.getIds();
        List<DomainFieldDTO> domainFieldDTOS = updateMessageDTO.getFieldList();
        for(Integer id:ids) {
            ProofGroup proofGroup = this.getById(id);
            if (proofGroup == null) {
                throw new XiaoShiException("证据不存在");

            }
            if (domainFieldDTOS == null || domainFieldDTOS.size() == 0) {
                throw new XiaoShiException("请输入值");
            }
            domainFieldDTOS.forEach(item -> {
                try {
                    if (item.getValue() != null) {
                        GenerateObjectUtil.setObjectProperty(proofGroup, item.getField(), item.getValue());
                    }
                } catch (Exception e) {
                    throw new XiaoShiException("装载失败");
                }
            });
            proofGroup.updateById();
        }
        return true;
    }


    /**
     * 查询详情
     *
     * @param getProofGroupDTO
     * @return
     */
    public ProofGroupVO queryProofGroupDetail(GetProofGroupDTO getProofGroupDTO) {
        Integer proofId = getProofGroupDTO.getProofGroupId();
        if (proofId == null) {
            throw new XiaoShiException("请输入id");
        }
        ProofGroup proofGroup = this.getById(proofId);
        if (proofGroup == null) {
            throw new XiaoShiException("证据组合不存在");
        }
        ProofGroupVO proofGroupVO = new ProofGroupVO();
        BeanUtils.copyProperties(proofGroup, proofGroupVO);

        return proofGroupVO;

    }


    /**
     * 查询详情
     *
     * @param ids
     * @return
     */
    public Boolean removeProofGroup(List<Integer> ids) {
        if(ids==null||ids.size()==0){
            throw new XiaoShiException("请至少选择一个组合");
        }
        this.removeBatchByIds(ids);
        return true;


    }
}