package org.jeecg.modules.system.service.impl;
|
|
import cn.hutool.core.collection.CollectionUtil;
|
import cn.hutool.core.util.StrUtil;
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import org.apache.commons.lang3.StringUtils;
|
import org.jeecg.common.constant.CommonConstant;
|
import org.jeecg.common.constant.FillRuleConstant;
|
import org.jeecg.common.exception.JeecgBootException;
|
import org.jeecg.common.util.FillRuleUtil;
|
import org.jeecg.common.util.OrgCodeSplitUtil;
|
import org.jeecg.common.util.oConvertUtils;
|
import org.jeecg.modules.system.entity.BaseFactory;
|
import org.jeecg.modules.system.entity.BaseFactoryUser;
|
import org.jeecg.modules.system.mapper.BaseFactoryMapper;
|
import org.jeecg.modules.system.mapper.BaseFactoryUserMapper;
|
import org.jeecg.modules.system.model.EamBaseFactoryIdModel;
|
import org.jeecg.modules.system.model.EamBaseFactoryTreeModel;
|
import org.jeecg.modules.system.service.IBaseFactoryService;
|
import org.jeecg.modules.system.entity.SysUser;
|
import org.jeecg.modules.system.mapper.SysUserMapper;
|
import org.jeecg.modules.system.util.FindsBaseFactorysChildrenUtil;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* @Description: 设备车间管理
|
* @Author: jeecg-boot
|
* @Date: 2025-06-30
|
* @Version: V1.0
|
*/
|
@Service("BaseFactoryServiceImpl")
|
public class BaseFactoryServiceImpl extends ServiceImpl<BaseFactoryMapper, BaseFactory> implements IBaseFactoryService {
|
|
@Autowired
|
private SysUserMapper sysUserMapper;
|
|
@Autowired
|
private BaseFactoryUserMapper BaseFactoryUserMapper;
|
|
/**
|
* queryTreeList 对应 queryTreeList 查询所有的设备车间管理数据,以树结构形式响应给前端
|
*/
|
@Override
|
public List<EamBaseFactoryTreeModel> queryTreeList() {
|
LambdaQueryWrapper<BaseFactory> query = new LambdaQueryWrapper<BaseFactory>();
|
query.eq(BaseFactory::getDelFlag, CommonConstant.DEL_FLAG_0.toString());
|
query.orderByAsc(BaseFactory::getSorter);
|
List<BaseFactory> list = this.list(query);
|
//设置用户id，让前台显示
|
this.setUserIdsByProList(list);
|
//调用wrapTreeDataToTreeList方法生成树状数据
|
return FindsBaseFactorysChildrenUtil.wrapTreeDataToTreeList(list);
|
}
|
|
/**
|
* queryTreeList 根据设备车间管理id查询,前端回显调用
|
*/
|
@Override
|
public List<EamBaseFactoryTreeModel> queryTreeList(String ids) {
|
List<EamBaseFactoryTreeModel> listResult = new ArrayList<>();
|
LambdaQueryWrapper<BaseFactory> query = new LambdaQueryWrapper<BaseFactory>();
|
query.eq(BaseFactory::getDelFlag, CommonConstant.DEL_FLAG_0.toString());
|
if (oConvertUtils.isNotEmpty(ids)) {
|
query.in(true, BaseFactory::getId, ids.split(","));
|
}
|
query.orderByAsc(BaseFactory::getSorter);
|
List<BaseFactory> list = this.list(query);
|
for (BaseFactory production : list) {
|
if (production.getRemark().isEmpty()){
|
production.setRemark("");
|
}
|
listResult.add(new EamBaseFactoryTreeModel(production));
|
}
|
return listResult;
|
}
|
|
/**
|
* 根据关键字搜索相关的部门数据
|
*/
|
@Override
|
public List<EamBaseFactoryTreeModel> searchByKeyWord(String keyWord) {
|
LambdaQueryWrapper<BaseFactory> query = new LambdaQueryWrapper<>();
|
List<EamBaseFactoryTreeModel> newList = new ArrayList<>();
|
query.like(BaseFactory::getFactoryName, keyWord);
|
EamBaseFactoryTreeModel model = new EamBaseFactoryTreeModel();
|
List<BaseFactory> productionList = this.list(query);
|
if (!productionList.isEmpty()) {
|
for (BaseFactory BaseFactory : productionList) {
|
model = new EamBaseFactoryTreeModel(BaseFactory);
|
model.setChildren(null);
|
newList.add(model);
|
}
|
return newList;
|
}
|
return Collections.emptyList();
|
}
|
|
public BaseFactory searchCenterByKeyWord(String keyWord) {
|
if (StringUtils.isBlank(keyWord)) {
|
return null;
|
}
|
|
if (keyWord.contains("/")) {
|
return searchByHierarchy(keyWord);
|
} else {
|
return searchByCodeOrName(keyWord);
|
}
|
}
|
|
private BaseFactory searchByHierarchy(String path) {
|
String[] levels = path.split("/");
|
int depth = levels.length;
|
|
// 支持格式：中心/工区、中心/工段、中心/工区/工段
|
if (depth < 2 || depth > 3) {
|
return null;
|
}
|
|
// 从顶层开始查询 - 第1级：中心节点
|
BaseFactory center = findFactory(levels[0], 1, null);
|
if (center == null) return null;
|
|
// 第2级查询：工区或工段
|
BaseFactory secondLevel;
|
if (depth == 2) {
|
// 兼容方案：优先查工段再查工区
|
secondLevel = findFactory(levels[1], 3, center.getId());
|
if (secondLevel == null) {
|
secondLevel = findFactory(levels[1], 2, center.getId());
|
}
|
return secondLevel; // 可能为null
|
} else {
|
// 第2级必须是工区
|
BaseFactory workArea = findFactory(levels[1], 2, center.getId());
|
if (workArea == null) return null;
|
|
// 第3级：工段
|
return findFactory(levels[2], 3, workArea.getId());
|
}
|
}
|
|
// 保持不变
|
private BaseFactory searchByCodeOrName(String keyword) {
|
LambdaQueryWrapper<BaseFactory> query = new LambdaQueryWrapper<>();
|
query.and(q -> q.eq(BaseFactory::getFactoryName, keyword)
|
.or()
|
.like(BaseFactory::getFactoryCode, keyword));
|
|
Page<BaseFactory> page = new Page<>(1, 1);
|
Page<BaseFactory> resultPage = baseMapper.selectPage(page, query);
|
return resultPage.getRecords().isEmpty() ? null : resultPage.getRecords().get(0);
|
}
|
|
// 保持不变
|
private BaseFactory findFactory(String name, Integer category, String parentId) {
|
LambdaQueryWrapper<BaseFactory> query = new LambdaQueryWrapper<>();
|
query.eq(BaseFactory::getFactoryName, name);
|
|
if (category != null) query.eq(BaseFactory::getFactoryCategory, category);
|
if (parentId != null) query.eq(BaseFactory::getParentId, parentId);
|
|
Page<BaseFactory> page = new Page<>(1, 1);
|
Page<BaseFactory> resultPage = baseMapper.selectPage(page, query);
|
return resultPage.getRecords().isEmpty() ? null : resultPage.getRecords().get(0);
|
}
|
|
|
/**
|
* saveProductionData 对应 add 保存用户在页面添加的新的设备车间管理对象数据
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void saveBaseFactoryData(BaseFactory baseFactory) {
|
if (baseFactory != null) {
|
if (baseFactory.getParentId() == null|| StrUtil.isEmpty(baseFactory.getParentId())) {
|
baseFactory.setParentId("");
|
baseFactory.setFactoryCategory("0");
|
}
|
if (baseFactory.getFactoryCategory() == null|| StrUtil.isEmpty(baseFactory.getFactoryCategory())) {
|
baseFactory.setFactoryCategory("1");
|
}
|
baseFactory.setId(IdWorker.getIdStr(baseFactory));
|
// 先判断该对象有无父级ID,有则意味着不是最高级,否则意味着是最高级
|
// 获取父级ID
|
String parentId = baseFactory.getParentId();
|
JSONObject formData = new JSONObject();
|
formData.put("parentId",parentId);
|
String[] codeArray = (String[]) FillRuleUtil.executeRule(FillRuleConstant.WORKSHOP,formData);
|
baseFactory.setOrgCode(codeArray[0]);
|
String orgType = codeArray[1];
|
baseFactory.setOrgType(String.valueOf(orgType));
|
baseFactory.setDelFlag(CommonConstant.DEL_FLAG_0.toString());
|
this.save(baseFactory);
|
}
|
}
|
|
@Override
|
public List<EamBaseFactoryIdModel> queryProductionIdTreeList() {
|
LambdaQueryWrapper<BaseFactory> query = new LambdaQueryWrapper<>();
|
query.eq(BaseFactory::getDelFlag, CommonConstant.DEL_FLAG_0.toString());
|
query.orderByAsc(BaseFactory::getSorter);
|
List<BaseFactory> list = this.list(query);
|
//调用wrapTreeDataToTreeList方法生成树状数据
|
return FindsBaseFactorysChildrenUtil.wrapTreeDataToProductionIdTreeList(list);
|
}
|
|
|
/**
|
* updateProductionDataById 对应 edit 根据设备车间管理主键来更新对应的设备车间管理数据
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public boolean updateBaseFactoryDataById(BaseFactory baseFactory) {
|
QueryWrapper<BaseFactory> baseFactoryQueryWrapper = new QueryWrapper<>();
|
baseFactoryQueryWrapper.eq(StrUtil.isNotEmpty(baseFactory.getFactoryCode()), "factory_code", baseFactory.getFactoryCode());
|
baseFactoryQueryWrapper.eq("del_flag", CommonConstant.DEL_FLAG_0.toString());
|
if (this.getOne(baseFactoryQueryWrapper) != null) {
|
throw new JeecgBootException("机构编码已存在");
|
}
|
if (baseFactory != null) {
|
this.updateById(baseFactory);
|
return true;
|
}
|
return false;
|
}
|
|
/**
|
* 根据设备车间管理id删除并删除其可能存在的子级设备车间管理
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public boolean delete(String id) {
|
List<String> idList = new ArrayList<>();
|
idList.add(id);
|
this.checkChildrenExists(id, idList);
|
boolean result = this.removeByIds(idList);
|
//根据设备车间管理id删除用户与设备车间管理关系
|
BaseFactoryUserMapper.delete(new LambdaQueryWrapper<BaseFactoryUser>().in(BaseFactoryUser::getFactoryId, idList));
|
return result;
|
}
|
|
/**
|
* 根据设备车间管理id批量删除并删除其可能存在的子级设备车间管理
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void deleteBatchWithChildren(List<String> ids) {
|
List<String> idList = new ArrayList<>();
|
for (String id : ids) {
|
idList.add(id);
|
this.checkChildrenExists(id, idList);
|
}
|
this.removeByIds(idList);
|
//根据设备车间管理id删除用户与设备车间管理关系
|
BaseFactoryUserMapper.delete(new LambdaQueryWrapper<BaseFactoryUser>().in(BaseFactoryUser::getFactoryId, idList));
|
}
|
|
/**
|
* 通过设备车间管理集合为设备车间管理设置用户id，用于前台展示
|
*/
|
private void setUserIdsByProList(List<BaseFactory> productionList) {
|
//查询负责部门不为空的情况
|
LambdaQueryWrapper<SysUser> query = new LambdaQueryWrapper<>();
|
query.isNotNull(SysUser::getDepartIds);
|
List<SysUser> users = sysUserMapper.selectList(query);
|
Map<String, Object> map = new HashMap(5);
|
//先循环一遍找到不同的负责设备车间管理id
|
for (SysUser user : users) {
|
String productionIds = user.getProductionIds();
|
if (StringUtils.isNotBlank(productionIds)) {
|
String[] productionIdArray = productionIds.split(",");
|
for (String productionId : productionIdArray) {
|
if (map.containsKey(productionId)) {
|
String userIds = map.get(productionId) + "," + user.getId();
|
map.put(productionId, userIds);
|
} else {
|
map.put(productionId, user.getId());
|
}
|
}
|
}
|
}
|
}
|
|
/**
|
* delete 方法调用 递归查找子集id
|
*/
|
private void checkChildrenExists(String id, List<String> idList) {
|
LambdaQueryWrapper<BaseFactory> query = new LambdaQueryWrapper<>();
|
query.eq(BaseFactory::getParentId, id);
|
List<BaseFactory> BaseFactoryList = this.list(query);
|
if (BaseFactoryList != null && !BaseFactoryList.isEmpty()) {
|
for (BaseFactory BaseFactory : BaseFactoryList) {
|
idList.add(BaseFactory.getId());
|
this.checkChildrenExists(BaseFactory.getId(), idList);
|
}
|
}
|
}
|
|
/**
|
* 通过orgCode置换中心名称
|
* @param orgCode
|
*/
|
@Override
|
public String factoryDataNameByOrgCode(String orgCode){
|
BaseFactory baseFactory = baseMapper.selectOne(new LambdaQueryWrapper<BaseFactory>().eq(BaseFactory::getOrgCode, orgCode));
|
if (baseFactory != null) {
|
return baseFactory.getFactoryName();
|
}
|
return null;
|
}
|
|
@Override
|
public List<String> queryFactoryIdsByOrgCode(String orgCode) {
|
//分割 orgCode
|
List<String> orgCodeArr = OrgCodeSplitUtil.splitOrgCode(orgCode);
|
if(CollectionUtil.isEmpty(orgCodeArr)){
|
return Collections.emptyList();
|
}
|
LambdaQueryWrapper<BaseFactory> query = new LambdaQueryWrapper<>();
|
query.in(BaseFactory::getOrgCode, orgCodeArr);
|
query.eq(BaseFactory::getDelFlag, CommonConstant.DEL_FLAG_0);
|
List<BaseFactory> list = this.getBaseMapper().selectList(query);
|
Set<String> collect = list.stream().map(BaseFactory::getId).collect(Collectors.toSet());
|
if(CollectionUtil.isEmpty(collect)){
|
return Collections.emptyList();
|
}
|
return new ArrayList<>(collect);
|
}
|
}
|
