package com.qianwen.smartman.modules.tool.service.impl;
|
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.stream.Collectors;
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.context.annotation.Lazy;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.qianwen.core.coderule.constant.enums.ElementTypeEnum;
|
import com.qianwen.core.log.exception.ServiceException;
|
import com.qianwen.core.mp.base.BaseServiceImpl;
|
import com.qianwen.core.mp.support.Query;
|
import com.qianwen.core.tool.node.ForestNodeMerger;
|
import com.qianwen.core.tool.utils.Func;
|
import com.qianwen.smartman.common.constant.DncConstant;
|
import com.qianwen.smartman.common.utils.Lambda;
|
import com.qianwen.smartman.common.utils.MessageUtils;
|
import com.qianwen.smartman.modules.system.dto.BasCoderuleDTO;
|
import com.qianwen.smartman.modules.system.entity.BasCodeRule;
|
import com.qianwen.smartman.modules.system.entity.BasCodeRuleEntry;
|
import com.qianwen.smartman.modules.system.entity.Dict;
|
import com.qianwen.smartman.modules.system.entity.MetaObjectType;
|
import com.qianwen.smartman.modules.system.service.IBasCoderuleService;
|
import com.qianwen.smartman.modules.system.service.IDictService;
|
import com.qianwen.smartman.modules.system.service.IMetaObjectTypeService;
|
import com.qianwen.smartman.modules.system.vo.DictVO;
|
import com.qianwen.smartman.modules.tool.constant.ToolConstant;
|
import com.qianwen.smartman.modules.tool.convert.ToolCategoryConvert;
|
import com.qianwen.smartman.modules.tool.entity.Tool;
|
import com.qianwen.smartman.modules.tool.entity.ToolCategory;
|
import com.qianwen.smartman.modules.tool.entity.ToolModel;
|
import com.qianwen.smartman.modules.tool.mapper.ToolCategoryMapper;
|
import com.qianwen.smartman.modules.tool.service.IToolCategoryService;
|
import com.qianwen.smartman.modules.tool.service.IToolManageService;
|
import com.qianwen.smartman.modules.tool.service.IToolModelService;
|
import com.qianwen.smartman.modules.tool.vo.ToolCategoryTreeVO;
|
import com.qianwen.smartman.modules.tool.vo.ToolCategoryVO;
|
|
@Service
|
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/tool/service/impl/ToolCategoryServiceImpl.class */
|
public class ToolCategoryServiceImpl extends BaseServiceImpl<ToolCategoryMapper, ToolCategory> implements IToolCategoryService {
|
@Autowired
|
private IDictService dictService;
|
@Autowired
|
private IMetaObjectTypeService metaObjectTypeService;
|
@Autowired
|
private IBasCoderuleService basCoderuleService;
|
@Autowired
|
@Lazy
|
private IToolManageService toolManageService;
|
@Autowired
|
private IToolModelService toolModelService;
|
private final Integer MIN_SORT = 1;
|
|
|
@Override // org.springblade.modules.tool.service.IToolCategoryService
|
public List<ToolCategoryTreeVO> tree() {
|
List<ToolCategoryTreeVO> toolCategoryList = ((ToolCategoryMapper) this.baseMapper).listCategoryList();
|
List<ToolCategoryTreeVO> tree = ForestNodeMerger.merge(toolCategoryList);
|
calculateModelNum(tree);
|
return tree;
|
}
|
|
private Integer calculateModelNum(List<ToolCategoryTreeVO> toolCategoryList) {
|
Integer allItemNum = 0;
|
for (ToolCategoryTreeVO toolCategoryTreeVO : toolCategoryList) {
|
List<ToolCategoryTreeVO> children = toolCategoryTreeVO.getChildren();
|
Integer childrenItemNum = calculateModelNum(children);
|
toolCategoryTreeVO.setItemNum(Integer.valueOf(childrenItemNum.intValue() + toolCategoryTreeVO.getItemNum().intValue()));
|
allItemNum = Integer.valueOf(allItemNum.intValue() + toolCategoryTreeVO.getItemNum().intValue());
|
}
|
return allItemNum;
|
}
|
|
@Override // org.springblade.modules.tool.service.IToolCategoryService
|
@Transactional(rollbackFor = {Exception.class})
|
public ToolCategoryVO save(ToolCategoryVO toolCategoryVO) {
|
checkName(null, toolCategoryVO.getName());
|
int nextSort = getNextSort(toolCategoryVO.getParentId());
|
toolCategoryVO.setSort(Integer.valueOf(nextSort));
|
ToolCategory toolCategory = ToolCategoryConvert.INSTANCE.convert(toolCategoryVO);
|
save(toolCategory);
|
Dict dict = createDict(toolCategory);
|
createCodeRule(toolCategoryVO, dict);
|
return ToolCategoryConvert.INSTANCE.convert(toolCategory);
|
}
|
|
private Dict createDict(ToolCategory toolCategory) {
|
Long dictParentId;
|
HashMap<String, Object> dictQueryMap = new HashMap<>();
|
dictQueryMap.put("code", ToolConstant.TOOL_CATEGORY_DICT_KEY);
|
Query query = new Query().setSize(15).setCurrent(1);
|
IPage<DictVO> dictVOIPage = this.dictService.parentList(dictQueryMap, query);
|
if (Func.isEmpty(dictVOIPage.getRecords())) {
|
Dict parentDict = new Dict();
|
parentDict.setIsSealed(0);
|
parentDict.setCode(ToolConstant.TOOL_CATEGORY_DICT_KEY);
|
parentDict.setDictKey(DncConstant.DNC_DEFAULT_PARENT_ID);
|
parentDict.setDictValue("刀具类型");
|
parentDict.setSort(1);
|
this.dictService.submit(parentDict);
|
dictParentId = parentDict.getId();
|
} else {
|
dictParentId = ((DictVO) dictVOIPage.getRecords().get(0)).getId();
|
}
|
Dict dict = new Dict();
|
dict.setId(toolCategory.getId());
|
dict.setCode(ToolConstant.TOOL_CATEGORY_DICT_KEY);
|
dict.setDictKey(String.valueOf(toolCategory.getId()));
|
dict.setDictValue(toolCategory.getName());
|
dict.setIsSealed(0);
|
dict.setSort(Integer.valueOf(getNextDictSort(dictParentId)));
|
dict.setParentId(dictParentId);
|
dict.setIsDeleted(0);
|
this.dictService.save(dict);
|
return dict;
|
}
|
|
private void createCodeRule(ToolCategoryVO toolCategoryVO, Dict dict) {
|
if (Func.isEmpty(toolCategoryVO.getCodeLength())) {
|
if (Func.isNotEmpty(toolCategoryVO.getToolPrefixCode())) {
|
throw new ServiceException(MessageUtils.message("tool.code.generate.code.length.can.bot.be.empty", new Object[0]));
|
}
|
if (Func.isEmpty(toolCategoryVO.getToolPrefixCode())) {
|
return;
|
}
|
}
|
MetaObjectType metaObjectType = (MetaObjectType) this.metaObjectTypeService.getOne(Lambda.eq((v0) -> {
|
return v0.getFId();
|
}, ToolConstant.TOOL_MANAGE));
|
if (Func.isEmpty(metaObjectType.getRuleDictCode())) {
|
this.metaObjectTypeService.saveRuleFiled(ToolConstant.TOOL_MANAGE, "tool_category", ToolConstant.TOOL_CATEGORY_DICT_KEY);
|
}
|
BasCoderuleDTO basCoderuleDTO = new BasCoderuleDTO();
|
basCoderuleDTO.setAutoBillno(false);
|
basCoderuleDTO.setBillFormId(ToolConstant.TOOL_MANAGE);
|
basCoderuleDTO.setSystemDefault(true);
|
basCoderuleDTO.setName(toolCategoryVO.getToolPrefixCode() + toolCategoryVO.getCodeLength());
|
basCoderuleDTO.setPreview(toolCategoryVO.getToolPrefixCode() + toolCategoryVO.getCodeLength());
|
basCoderuleDTO.setRemark(toolCategoryVO.getToolPrefixCode() + toolCategoryVO.getCodeLength());
|
basCoderuleDTO.setRepairBillno(false);
|
basCoderuleDTO.setRuleFieldDictKey(dict.getDictKey());
|
List<BasCodeRuleEntry> basCodeRuleEntryList = new ArrayList<>();
|
if (Func.isNotEmpty(toolCategoryVO.getToolPrefixCode())) {
|
BasCodeRuleEntry basCodeRuleEntry = new BasCodeRuleEntry();
|
basCodeRuleEntry.setAddChar("");
|
basCodeRuleEntry.setAddStyle(false);
|
basCodeRuleEntry.setCodeElement(true);
|
basCodeRuleEntry.setCutStyle(true);
|
basCodeRuleEntry.setElementSource("");
|
basCodeRuleEntry.setElementType(ElementTypeEnum.CONSTANT.getType());
|
basCodeRuleEntry.setElementValue(toolCategoryVO.getToolPrefixCode());
|
basCodeRuleEntry.setIncrementStep(1);
|
basCodeRuleEntry.setLength(Integer.valueOf(toolCategoryVO.getToolPrefixCode().length()));
|
basCodeRuleEntry.setReChar("");
|
basCodeRuleEntry.setSeed(0);
|
basCodeRuleEntry.setCodeOnlyBy(false);
|
basCodeRuleEntry.setFormat("");
|
basCodeRuleEntry.setSeparatorChar("");
|
basCodeRuleEntry.setSeq(1);
|
basCodeRuleEntryList.add(basCodeRuleEntry);
|
}
|
BasCodeRuleEntry basCodeRuleEntry1 = new BasCodeRuleEntry();
|
basCodeRuleEntry1.setAddChar("0");
|
basCodeRuleEntry1.setAddStyle(false);
|
basCodeRuleEntry1.setCodeElement(true);
|
basCodeRuleEntry1.setCodeOnlyBy(false);
|
basCodeRuleEntry1.setCutStyle(true);
|
basCodeRuleEntry1.setElementSource("");
|
basCodeRuleEntry1.setElementType(ElementTypeEnum.SEQUENCE.getType());
|
basCodeRuleEntry1.setElementValue("");
|
basCodeRuleEntry1.setIncrementStep(1);
|
basCodeRuleEntry1.setLength(Integer.valueOf(toolCategoryVO.getCodeLength().length()));
|
basCodeRuleEntry1.setReChar("");
|
basCodeRuleEntry1.setSeed(1);
|
basCodeRuleEntry1.setCodeOnlyBy(false);
|
basCodeRuleEntry1.setFormat("");
|
basCodeRuleEntry1.setSeparatorChar("");
|
basCodeRuleEntry1.setSeq(2);
|
basCodeRuleEntryList.add(basCodeRuleEntry1);
|
basCoderuleDTO.setEntryList(basCodeRuleEntryList);
|
this.basCoderuleService.submitCoderule(basCoderuleDTO);
|
}
|
|
@Override // org.springblade.modules.tool.service.IToolCategoryService
|
@Transactional(rollbackFor = {Exception.class})
|
public Boolean updateName(Long id, String newName) {
|
checkName(id, newName);
|
ToolCategory toolCategory = (ToolCategory) getById(id);
|
toolCategory.setName(newName);
|
updateById(toolCategory);
|
Dict dict = (Dict) this.dictService.getById(toolCategory.getId());
|
dict.setDictValue(newName);
|
this.dictService.updateById(dict);
|
return null;
|
}
|
|
@Override // org.springblade.modules.tool.service.IToolCategoryService
|
@Transactional(rollbackFor = {Exception.class})
|
public Boolean remove(List<Long> ids) {
|
List<Long> categoryIds = getChildrenIds(ids, ids);
|
long count = this.toolManageService.count(Wrappers.<Tool>lambdaQuery().in(Tool::getToolCategoryId, categoryIds));
|
/*
|
long count = this.toolManageService.count((Wrapper) Wrappers.lambdaQuery().in((v0) -> {
|
return v0.getToolCategoryId();
|
}, categoryIds));*/
|
if (count > 0) {
|
throw new ServiceException(MessageUtils.message("tool.have.tool.can.not.delete", new Object[0]));
|
}
|
this.toolModelService.remove(Wrappers.<ToolModel>lambdaQuery().in(ToolModel::getToolCategoryId, categoryIds));
|
List<String> idStrList = categoryIds.stream().map((v0) -> {
|
return String.valueOf(v0);
|
}).collect(Collectors.toList());
|
|
this.basCoderuleService.remove(Wrappers.<BasCodeRule>lambdaQuery().in(BasCodeRule::getRuleFieldDictKey, idStrList));
|
/*
|
this.basCoderuleService.remove((Wrapper) Wrappers.lambdaQuery().in((v0) -> {
|
return v0.getRuleFieldDictKey();
|
}, idStrList));*/
|
String idList = categoryIds.stream().map((v0) -> {
|
return String.valueOf(v0);
|
}).reduce((a, b) -> {
|
return a + "," + b;
|
}).get();
|
this.dictService.removeDict(idList);
|
return Boolean.valueOf(removeBatchByIds(categoryIds));
|
}
|
|
private int getNextDictSort(Long parentId) {
|
List<DictVO> dictVOS = this.dictService.childList(new HashMap<>(), parentId);
|
return ((Integer) dictVOS.stream().map((v0) -> {
|
return v0.getSort();
|
}).max((v0, v1) -> {
|
return v0.compareTo(v1);
|
}).orElse(-1)).intValue() + 1;
|
}
|
|
private int getNextSort(Long parentId) {
|
List<ToolCategory> toolCategoryList = list(Wrappers.<ToolCategory>lambdaQuery().eq(ToolCategory::getParentId, parentId).orderByDesc(ToolCategory::getSort));
|
/*
|
List<ToolCategory> toolCategoryList = list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getParentId();
|
}, parentId)).orderByDesc((v0) -> {
|
return v0.getSort();
|
}));*/
|
if (Func.isEmpty(toolCategoryList)) {
|
return this.MIN_SORT.intValue();
|
}
|
return toolCategoryList.get(0).getSort().intValue() + 1;
|
}
|
|
private void checkName(Long id, String name) {
|
long count = count(Wrappers.<ToolCategory>lambdaQuery().ne(Func.isNotEmpty(id), ToolCategory::getId, id).eq(ToolCategory::getName, name));
|
/*
|
long count = count((Wrapper) Wrappers.lambdaQuery().ne(Func.isNotEmpty(id), (v0) -> {
|
return v0.getId();
|
}, id).eq((v0) -> {
|
return v0.getName();
|
}, name));*/
|
if (count > 0) {
|
throw new ServiceException(MessageUtils.message("tool.category.already.exists", new Object[0]));
|
}
|
}
|
|
@Override // org.springblade.modules.tool.service.IToolCategoryService
|
public List<Long> getChildrenIds(List<Long> queryIdList, List<Long> ids) {
|
List<Long> categoryIdList = list(Lambda.in((v0) -> {
|
return v0.getParentId();
|
}, queryIdList)).stream().map((v0) -> {
|
return v0.getId();
|
}).collect(Collectors.toList());
|
if (Func.isEmpty(categoryIdList)) {
|
return ids;
|
}
|
ids.addAll(categoryIdList);
|
return getChildrenIds(categoryIdList, ids);
|
}
|
}
|
