package org.jeecg.modules.system.service.impl;
|
|
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 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.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.*;
|
|
/**
|
* @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 searchByCode(keyWord);
|
}
|
}
|
|
private BaseFactory searchByHierarchy(String path) {
|
String[] levels = path.split("/");
|
int depth = levels.length;
|
|
// 检查层级深度
|
if (depth < 2 || depth > 3) {
|
return null; // 无效的层级深度
|
}
|
|
// 查询第一级中心
|
BaseFactory center = findFactory(levels[0], 1, null);
|
if (center == null) return null;
|
|
// 查询第二级工区
|
BaseFactory workArea = findFactory(levels[1], null, center.getId());
|
if (workArea == null || depth == 2) return workArea;
|
|
// 查询第三级工段
|
return findFactory(levels[2], null, workArea.getId());
|
}
|
|
private BaseFactory searchByCode(String code) {
|
LambdaQueryWrapper<BaseFactory> query = new LambdaQueryWrapper<>();
|
query.like(BaseFactory::getFactoryCode, code);
|
return this.baseMapper.selectOne(query); // 使用selectOne避免多个结果
|
}
|
|
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);
|
|
return this.baseMapper.selectOne(query);
|
}
|
|
/**
|
* 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);
|
}
|
}
|
}
|
}
|
