package com.finance.system.service.impl;
|
|
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
|
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.finance.common.basic.PageDTO;
|
import com.finance.common.enums.ShowStatusEnum;
|
import com.finance.common.exception.ServiceException;
|
import com.finance.common.utils.BeanUtils;
|
import com.finance.common.utils.CollUtils;
|
import com.finance.common.utils.StringUtils;
|
import com.finance.system.domain.TbField;
|
import com.finance.system.domain.TbFieldCategory;
|
import com.finance.system.dto.FieldCategoryDTO;
|
import com.finance.system.dto.ShowHideDTO;
|
import com.finance.system.dto.update.FieldCategoryUpdateDTO;
|
import com.finance.system.mapper.TbFieldCategoryMapper;
|
import com.finance.system.query.FieldCategoryQuery;
|
import com.finance.system.service.TbFieldCategoryService;
|
import com.finance.system.service.TbFieldService;
|
import com.finance.system.vo.FieldCategoryDetailVO;
|
import com.finance.system.vo.FieldCategoryVO;
|
import java.util.List;
|
import java.util.Objects;
|
import java.util.concurrent.CompletableFuture;
|
import java.util.stream.Collectors;
|
import lombok.RequiredArgsConstructor;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
/**
|
* <p>
|
* 字段分类表 服务实现类
|
* </p>
|
*
|
* @author mitao
|
* @since 2024-03-13
|
*/
|
@Slf4j
|
@Service
|
@RequiredArgsConstructor
|
public class TbFieldCategoryServiceImpl extends
|
ServiceImpl<TbFieldCategoryMapper, TbFieldCategory> implements TbFieldCategoryService {
|
|
private final TbFieldService tbFieldService;
|
|
@Override
|
public void add(FieldCategoryDTO dto) {
|
//一级分类
|
TbFieldCategory oneCategory = new TbFieldCategory();
|
oneCategory.setFieldCategoryName(dto.getFieldCategoryName());
|
oneCategory.setSortOrder(dto.getSortOrder());
|
this.save(oneCategory);
|
//二级分类
|
List<FieldCategoryDTO> children = dto.getChildren();
|
if (!CollectionUtils.isEmpty(children)) {
|
children.forEach(item -> {
|
TbFieldCategory twoCategory = new TbFieldCategory();
|
twoCategory.setParentId(oneCategory.getId());
|
twoCategory.setFieldCategoryName(item.getFieldCategoryName());
|
this.save(twoCategory);
|
//三级分类
|
List<FieldCategoryDTO> next = item.getChildren();
|
if (!CollectionUtils.isEmpty(next)) {
|
next.forEach(nextItem -> {
|
TbFieldCategory threeCategory = new TbFieldCategory();
|
threeCategory.setParentId(twoCategory.getId());
|
threeCategory.setFieldCategoryName(nextItem.getFieldCategoryName());
|
this.save(threeCategory);
|
});
|
}
|
});
|
}
|
}
|
|
@Override
|
public PageDTO<FieldCategoryVO> queryPage(FieldCategoryQuery query) {
|
Page<TbFieldCategory> page = this.lambdaQuery()
|
.like(StringUtils.isNotBlank(query.getFieldCategoryName()),
|
TbFieldCategory::getFieldCategoryName, query.getFieldCategoryName())
|
.eq(ObjectUtils.isNotEmpty(query.getStatus()), TbFieldCategory::getStatus,
|
query.getStatus())
|
.eq(TbFieldCategory::getParentId, 0)
|
.orderByDesc(TbFieldCategory::getCreateTime)
|
.page(new Page<>(query.getPageNum(), query.getPageSize()));
|
if (CollUtils.isEmpty(page.getRecords())) {
|
return PageDTO.empty(page);
|
}
|
return PageDTO.of(page, FieldCategoryVO.class);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void showHide(ShowHideDTO dto) {
|
updateCategoryAndChildren(dto.getId(), dto.getStatus());
|
}
|
|
private void updateCategoryAndChildren(Long id, ShowStatusEnum status) {
|
TbFieldCategory category = this.validateParam(id);
|
this.lambdaUpdate()
|
.eq(TbFieldCategory::getId, id)
|
.set(TbFieldCategory::getStatus, status)
|
.update();
|
List<TbFieldCategory> children = this.lambdaQuery()
|
.eq(TbFieldCategory::getParentId, category.getId()).list();
|
if (CollUtils.isNotEmpty(children)) {
|
List<Long> childIds = children.stream().map(TbFieldCategory::getId)
|
.collect(Collectors.toList());
|
childIds.forEach(childId -> updateCategoryAndChildren(childId, status));
|
}
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void deleteChildren(Long id) {
|
//认定为二级分类
|
TbFieldCategory category = this.getById(id);
|
if (Objects.nonNull(category)) {
|
//查询是否有三级分类
|
List<TbFieldCategory> threeCategoryList = this.lambdaQuery()
|
.eq(TbFieldCategory::getParentId, id).list();
|
if (CollectionUtils.isNotEmpty(threeCategoryList)) {
|
List<Long> ids = threeCategoryList.stream().map(TbFieldCategory::getId)
|
.collect(Collectors.toList());
|
//删除该二级分类下面的三级分类
|
this.removeByIds(ids);
|
}
|
//删除二级分类
|
this.removeById(id);
|
}
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void delete(Long id) {
|
//一级分类
|
validateParam(id);
|
//查询是否有二级分类
|
List<TbFieldCategory> threeCategoryList = this.lambdaQuery()
|
.eq(TbFieldCategory::getParentId, id).list();
|
if (CollectionUtils.isNotEmpty(threeCategoryList)) {
|
List<Long> ids = threeCategoryList.stream().map(TbFieldCategory::getId)
|
.collect(Collectors.toList());
|
//查询三级分类
|
List<TbFieldCategory> list = this.lambdaQuery().in(TbFieldCategory::getParentId, ids)
|
.list();
|
if (CollectionUtils.isNotEmpty(list)) {
|
List<Long> ids1 = list.stream().map(TbFieldCategory::getId)
|
.collect(Collectors.toList());
|
//删除三级分类
|
this.removeByIds(ids1);
|
}
|
//删除二级分类
|
this.removeByIds(ids);
|
}
|
//删除一级分类
|
this.removeById(id);
|
}
|
|
private TbFieldCategory validateParam(Long id) {
|
TbFieldCategory category = this.getById(id);
|
if (Objects.isNull(category)) {
|
throw new ServiceException("非法参数");
|
}
|
return category;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void edit(FieldCategoryUpdateDTO dto) {
|
log.info("主线程名{}", Thread.currentThread().getName());
|
validateParam(dto.getId());
|
//更新一级分类
|
TbFieldCategory category1 = updateCategory(dto, null);
|
CompletableFuture.runAsync(() -> handleFieldCategory(category1));
|
List<FieldCategoryUpdateDTO> children = dto.getChildren();
|
//更新二级分类
|
if (CollUtils.isNotEmpty(children)) {
|
children.forEach(item -> {
|
//二级分类
|
TbFieldCategory category2 = updateCategory(item, category1);
|
CompletableFuture.runAsync(() -> handleFieldCategory(category2));
|
//三级分类
|
List<FieldCategoryUpdateDTO> next = item.getChildren();
|
if (!CollectionUtils.isEmpty(next)) {
|
for (FieldCategoryUpdateDTO fieldCategoryUpdateDTO : next) {
|
TbFieldCategory category3 = updateCategory(fieldCategoryUpdateDTO,
|
category2);
|
CompletableFuture.runAsync(() -> handleFieldCategory(category3));
|
}
|
}
|
});
|
}
|
}
|
|
protected void handleFieldCategory(TbFieldCategory category) {
|
log.info("开始处理字段分类名称同步，线程名{}", Thread.currentThread().getName());
|
//查询使用到该分类的字段
|
List<TbField> list1 = tbFieldService.list(Wrappers.<TbField>lambdaQuery()
|
.eq(TbField::getLevelOneCategoryId, category.getId()));
|
if (CollUtils.isNotEmpty(list1)) {
|
List<TbField> fieldList = list1.stream().peek(item -> {
|
item.setLevelOneCategoryId(category.getId());
|
item.setLevelOneCategory(category.getFieldCategoryName());
|
}).collect(Collectors.toList());
|
tbFieldService.updateBatchById(fieldList);
|
}
|
List<TbField> list2 = tbFieldService.list(Wrappers.<TbField>lambdaQuery()
|
.eq(TbField::getLevelTwoCategoryId, category.getId()));
|
if (CollUtils.isNotEmpty(list2)) {
|
List<TbField> fieldList = list2.stream().peek(item -> {
|
item.setLevelTwoCategoryId(category.getId());
|
item.setLevelTwoCategory(category.getFieldCategoryName());
|
}).collect(Collectors.toList());
|
tbFieldService.updateBatchById(fieldList);
|
}
|
List<TbField> list3 = tbFieldService.list(Wrappers.<TbField>lambdaQuery()
|
.eq(TbField::getLevelThreeCategoryId, category.getId()));
|
if (CollUtils.isNotEmpty(list2)) {
|
List<TbField> fieldList = list3.stream().peek(item -> {
|
item.setLevelThreeCategoryId(category.getParentId());
|
item.setLevelThreeCategory(category.getFieldCategoryName());
|
}).collect(Collectors.toList());
|
tbFieldService.updateBatchById(fieldList);
|
}
|
}
|
|
private TbFieldCategory updateCategory(FieldCategoryUpdateDTO dto,
|
TbFieldCategory parent) {
|
TbFieldCategory category = BeanUtils.copyBean(dto, TbFieldCategory.class);
|
if (Objects.isNull(dto.getId()) && Objects.nonNull(parent)) {
|
assert category != null;
|
category.setParentId(parent.getId());
|
this.save(category);
|
} else {
|
this.updateById(category);
|
}
|
return category;
|
}
|
|
@Override
|
public List<FieldCategoryVO> queryFieldCategories(Long id) {
|
List<TbFieldCategory> list = this.lambdaQuery()
|
.select(TbFieldCategory::getId, TbFieldCategory::getFieldCategoryName)
|
.eq(TbFieldCategory::getParentId, id)
|
.eq(TbFieldCategory::getStatus, ShowStatusEnum.SHOW)
|
.list();
|
return BeanUtils.copyList(list, FieldCategoryVO.class);
|
}
|
|
@Override
|
public FieldCategoryDetailVO getDetailsById(Long id) {
|
TbFieldCategory oneCategory = this.getById(id);
|
if (Objects.isNull(oneCategory)) {
|
return new FieldCategoryDetailVO();
|
}
|
FieldCategoryDetailVO vo = BeanUtils.copyBean(oneCategory, FieldCategoryDetailVO.class);
|
//根据一级分类id，查询二级分类
|
List<TbFieldCategory> twoCategoryList = this.lambdaQuery()
|
.eq(TbFieldCategory::getParentId, oneCategory.getId()).list();
|
twoCategoryList.forEach(item -> {
|
FieldCategoryDetailVO twoCategoryVO = BeanUtils.copyBean(item,
|
FieldCategoryDetailVO.class);
|
vo.getChildren().add(twoCategoryVO);
|
//根据二级分类id，查询三级分类
|
List<TbFieldCategory> threeCategoryList = this.lambdaQuery()
|
.eq(TbFieldCategory::getParentId, item.getId()).list();
|
threeCategoryList.forEach(threeCategory -> {
|
FieldCategoryDetailVO threeCategoryVO = BeanUtils.copyBean(threeCategory,
|
FieldCategoryDetailVO.class);
|
twoCategoryVO.getChildren().add(threeCategoryVO);
|
});
|
});
|
return vo;
|
}
|
}
|
