package cn.huge.module.knowledge.service;
|
|
import cn.huge.base.common.exception.ServiceException;
|
import cn.huge.base.common.utils.DateUtils;
|
import cn.huge.base.common.utils.IdUtils;
|
import cn.huge.module.client.api.impl.UtilsClientImpl;
|
import cn.huge.module.knowledge.dao.mapper.LawInfoMapper;
|
import cn.huge.module.knowledge.dao.mapper.LawProvisionMapper;
|
import cn.huge.module.knowledge.domain.dto.DictionaryDTO;
|
import cn.huge.module.knowledge.domain.dto.LawInfoPageDTO;
|
import cn.huge.module.knowledge.domain.dto.LawProvisionKeyDTO;
|
import cn.huge.module.knowledge.domain.po.Dictionary;
|
import cn.huge.module.knowledge.domain.po.LawInfo;
|
// import com.baomidou.dynamic.datasource.annotation.DS;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.google.common.collect.Maps;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.data.domain.Page;
|
import org.springframework.data.domain.PageImpl;
|
import org.springframework.data.domain.PageRequest;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.util.*;
|
|
/**
|
* @title: 法律表业务逻辑处理
|
* @Description 法律表业务逻辑处理
|
* @company hugeinfo
|
* @author huangh
|
* @Time 2024-12-05 16:15:00
|
* @version 1.0
|
*/
|
@Slf4j
|
@Service
|
@Transactional(rollbackFor = Exception.class)
|
public class LawInfoService extends ServiceImpl<LawInfoMapper, LawInfo> {
|
|
@Autowired
|
private LawInfoMapper mapper;
|
|
@Autowired
|
private LawProvisionMapper lawProvisionMapper;
|
|
@Autowired
|
private DictionaryService dictionaryService;
|
|
@Autowired
|
private UtilsClientImpl utilsClient;
|
|
/**
|
* 更新对象
|
* @param entity 对象
|
*/
|
public void updateLawInfo(LawInfo entity) {
|
try {
|
mapper.updateLawInfo(entity);
|
} catch (Exception e) {
|
log.error("[LawInfoService.updateLawInfo]调用失败，异常信息：" + e, e);
|
throw new ServiceException("LawInfoService.updateLawInfo", e);
|
}
|
}
|
|
/**
|
* 条件更新对象
|
* @param entity 对象
|
* @param terms 条件
|
*/
|
public void updateLawInfoTerms(LawInfo entity, Map<String, Object> terms) {
|
try {
|
mapper.updateLawInfoTerms(entity, terms);
|
} catch (Exception e) {
|
log.error("[LawInfoService.updateLawInfoTerms]调用失败，异常信息：" + e, e);
|
throw new ServiceException("LawInfoService.updateLawInfoTerms", e);
|
}
|
}
|
|
/**
|
* 根据编号物理删除
|
* @param id 查询条件集合
|
*/
|
public void deleteLawInfo(String id) {
|
try {
|
mapper.deleteLawInfo(id);
|
} catch (Exception e) {
|
log.error("[LawInfoService.deleteLawInfo]调用失败，异常信息：" + e, e);
|
throw new ServiceException("LawInfoService.deleteLawInfo", e);
|
}
|
}
|
|
/**
|
* 按条件查询
|
* @param terms 条件
|
* @return List
|
*/
|
public List<LawInfo> listTerms(Map<String, Object> terms) {
|
return mapper.listTerms(terms);
|
}
|
|
/**
|
* 按条件统计
|
* @param terms 条件
|
* @return long
|
*/
|
public long countTerms(Map<String, Object> terms) {
|
return mapper.countTerms(terms);
|
}
|
|
/**
|
* 按条件分页查询
|
* @param page 分页对象
|
* @param terms 条件
|
* @return Page
|
*/
|
public Page<LawInfoPageDTO> pageQuery(PageRequest page, Map<String, Object> terms) {
|
long total;
|
List<LawInfoPageDTO> content;
|
// 检查 terms 是否有 keyword 字段
|
if (terms.get("keyword") == null) {
|
// 如果没有 keyword，使用 法律信息 进行总数计算和分页查询
|
total = mapper.countTerms(terms);
|
content = mapper.pageTerms(page, terms);
|
}else {
|
// 如果有 keyword，使用 包含法条的sql 进行总数计算和分页查询
|
total = mapper.countTermsKeyLaw(terms);
|
content = mapper.pageTermsKeyLaw(page, terms);
|
// 对查询结果进行遍历，为每个法律信息添加关键字相关的条款
|
for (LawInfoPageDTO lawInfoPageDTO : content) {
|
// 创建一个新的条件对象，用于查询关键字相关的条款
|
Map<String, Object> termsProvision = Maps.newHashMap();
|
termsProvision.put("lawInfoId", lawInfoPageDTO.getLawInfoId());
|
termsProvision.put("keyword", terms.get("keyword"));
|
// 查询关键字相关的条款，并将其设置到法律信息对象中
|
List<LawProvisionKeyDTO> lawProvisionList = lawProvisionMapper.listTermsKey(termsProvision);
|
lawInfoPageDTO.setKeywordProvisionList(lawProvisionList);
|
}
|
// 如果查询结果为空，则使用 法律信息 重新进行总数计算和分页查询
|
if (content.isEmpty()){
|
total = mapper.countTerms(terms);
|
content = mapper.pageTerms(page, terms);
|
}
|
}
|
// 创建并返回一个新的分页对象
|
return new PageImpl<>(content, page, total);
|
}
|
|
/**
|
* 统计各类别法律数量
|
*
|
*/
|
public List<DictionaryDTO> categoryCount(Map<String, Object> terms) {
|
QueryWrapper<Dictionary> queryWrapper = new QueryWrapper<>();
|
queryWrapper.eq("parent_code", "1");
|
List<Dictionary> dictionaryList = dictionaryService.list(queryWrapper);
|
List<DictionaryDTO> dictionaryDTOList = new ArrayList<>();
|
List<DictionaryDTO> selectList = mapper.categoryCount(terms);
|
|
// 创建一个map来快速查找子节点
|
// Map<String, DictionaryDTO> map = new HashMap<>();
|
|
for (Dictionary dictionary : dictionaryList) {
|
QueryWrapper<Dictionary> queryWrapperSec = new QueryWrapper<>();
|
DictionaryDTO dictionaryDTO = new DictionaryDTO();
|
BeanUtils.copyProperties(dictionary, dictionaryDTO);
|
dictionaryDTO.setChildren(new ArrayList<>());
|
queryWrapperSec.eq("parent_code", dictionary.getCode());
|
List<Dictionary> dictionaryListSec = dictionaryService.list(queryWrapperSec);
|
|
for (Dictionary dictionarySec : dictionaryListSec) {
|
DictionaryDTO dictionarySecDTO = new DictionaryDTO();
|
BeanUtils.copyProperties(dictionarySec, dictionarySecDTO);
|
for (DictionaryDTO selectItem : selectList) {
|
if (dictionaryDTO.getCode().equals(selectItem.getCode()) && dictionarySecDTO.getValue().equals(selectItem.getValue())) {
|
dictionarySecDTO.setCount(selectItem.getCount());
|
}
|
}
|
dictionaryDTO.getChildren().add(dictionarySecDTO);
|
// map.put(dictionarySec.getCode(), dictionarySecDTO);
|
}
|
dictionaryDTOList.add(dictionaryDTO);
|
// map.put(dictionary.getCode(), dictionaryDTO);
|
}
|
|
|
log.debug("各类别: " + dictionaryDTOList);
|
log.debug("统计各类别法律数量: " + selectList);
|
|
// // 合并selectList中的count值到dictionaryDTOList中
|
// for (DictionaryDTO selectItem : selectList) {
|
// DictionaryDTO targetItem = map.get(selectItem.getCode());
|
// if (targetItem != null) {
|
// targetItem.setCount(selectItem.getCount());
|
// }
|
// }
|
|
return dictionaryDTOList;
|
}
|
|
/**
|
* 新增或更新对象
|
* @param lawInfo 实体对象
|
*/
|
public void saveLawInfo(LawInfo lawInfo) {
|
try {
|
Date nowDate = DateUtils.getNowDate();
|
// 判断是否新增
|
if (IdUtils.checkNewId(lawInfo.getLawInfoId())) {
|
lawInfo.setLawInfoId(utilsClient.getNewTimeId());
|
lawInfo.setCreateTime(nowDate);
|
}
|
lawInfo.setUpdateTime(nowDate);
|
this.saveOrUpdate(lawInfo);
|
} catch (Exception e) {
|
log.error("[LawInfoService.saveLawInfo]调用失败，异常信息：" + e, e);
|
throw new ServiceException("LawInfoService.saveLawInfo", e);
|
}
|
}
|
|
}
|
