1

src/main/java/com/xujie/modules/base/controller/BaseDictMaintenanceController.java

@@ -0,0 +1,56 @@
+package com.xujie.modules.base.controller;
+
+import com.xujie.common.utils.R;
+import com.xujie.modules.base.data.BaseDictMaintenanceQuery;
+import com.xujie.modules.base.service.BaseDictMaintenanceService;
+import com.xujie.modules.sys.entity.DictData;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * 字典维护：主记录（字典类型）只读查询，明细（字典数据）增删改查
+ */
+@RestController
+@RequestMapping("/base/dictMaintenance")
+public class BaseDictMaintenanceController {
+
+    @Autowired
+    private BaseDictMaintenanceService dictMaintenanceService;
+
+    @PostMapping("/typeList")
+    public R typeList(@RequestBody BaseDictMaintenanceQuery query) {
+        return R.ok().put("rows", dictMaintenanceService.listType(query));
+    }
+
+    @PostMapping("/dataList")
+    public R dataList(@RequestBody BaseDictMaintenanceQuery query) {
+        return R.ok().put("rows", dictMaintenanceService.listData(query));
+    }
+
+    @PostMapping("/dataSave")
+    public R dataSave(@RequestBody DictData dictData) {
+        dictMaintenanceService.saveData(dictData);
+        return R.ok("保存成功!");
+    }
+
+    @PostMapping("/dataUpdate")
+    public R dataUpdate(@RequestBody DictData dictData) {
+        dictMaintenanceService.updateData(dictData);
+        return R.ok("保存成功!");
+    }
+
+    @PostMapping("/dataDelete")
+    public R dataDelete(@RequestBody DictData dictData) {
+        dictMaintenanceService.deleteData(dictData);
+        return R.ok("删除成功!");
+    }
+
+    @PostMapping("/dataDisable")
+    public R dataDisable(@RequestBody DictData dictData) {
+        dictMaintenanceService.disableData(dictData);
+        return R.ok("操作成功!");
+    }
+}

src/main/java/com/xujie/modules/base/data/BaseDictMaintenanceQuery.java

@@ -0,0 +1,26 @@
+package com.xujie.modules.base.data;
+
+import lombok.Data;
+
+/**
+ * 字典维护（主记录只读 + 明细 CRUD）
+ */
+@Data
+public class BaseDictMaintenanceQuery {
+
+    /** 当前登录工厂 */
+    private String site;
+
+    /** 字典类型编码 */
+    private String dictType;
+
+    private String dictName;
+
+    private String dictLabel;
+
+    private String status;
+
+    private Integer page = 1;
+
+    private Integer limit = 20;
+}

src/main/java/com/xujie/modules/base/service/BaseDictMaintenanceService.java

@@ -0,0 +1,22 @@
+package com.xujie.modules.base.service;
+
+import com.xujie.modules.base.data.BaseDictMaintenanceQuery;
+import com.xujie.modules.sys.entity.DictData;
+import com.xujie.modules.sys.entity.DictType;
+
+import java.util.List;
+
+public interface BaseDictMaintenanceService {
+
+    List<DictType> listType(BaseDictMaintenanceQuery query);
+
+    List<DictData> listData(BaseDictMaintenanceQuery query);
+
+    void saveData(DictData dictData);
+
+    void updateData(DictData dictData);
+
+    void deleteData(DictData dictData);
+
+    void disableData(DictData dictData);
+}

src/main/java/com/xujie/modules/base/service/Impl/BaseDictMaintenanceServiceImpl.java

@@ -0,0 +1,213 @@
+package com.xujie.modules.base.service.Impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.xujie.modules.base.data.BaseDictMaintenanceQuery;
+import com.xujie.modules.base.service.BaseDictMaintenanceService;
+import com.xujie.modules.sys.entity.DictData;
+import com.xujie.modules.sys.entity.DictType;
+import com.xujie.modules.sys.service.DictDataService;
+import com.xujie.modules.sys.service.DictTypeService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+@Service
+public class BaseDictMaintenanceServiceImpl implements BaseDictMaintenanceService {
+
+    private static final String ALL_SITE = "*";
+
+    @Autowired
+    private DictTypeService dictTypeService;
+
+    @Autowired
+    private DictDataService dictDataService;
+
+    @Override
+    public List<DictType> listType(BaseDictMaintenanceQuery query) {
+        String userSite = requireSite(query.getSite());
+        List<DictType> merged = new ArrayList<>();
+        merged.addAll(queryType(userSite, query));
+        merged.addAll(queryType(ALL_SITE, query));
+        Map<String, DictType> map = new LinkedHashMap<>();
+        for (DictType row : merged) {
+            if (row == null || !StringUtils.hasText(row.getDictType())) {
+                continue;
+            }
+            DictType existing = map.get(row.getDictType());
+            if (existing == null || ALL_SITE.equals(row.getSite())) {
+                map.put(row.getDictType(), row);
+            }
+        }
+        return new ArrayList<>(map.values());
+    }
+
+    @Override
+    public List<DictData> listData(BaseDictMaintenanceQuery query) {
+        if (!StringUtils.hasText(query.getDictType())) {
+            throw new RuntimeException("字典类型为空");
+        }
+        String userSite = requireSite(query.getSite());
+        List<DictData> rows = new ArrayList<>();
+        rows.addAll(queryData(ALL_SITE, query));
+        if (!ALL_SITE.equals(userSite)) {
+            rows.addAll(queryData(userSite, query));
+        }
+        rows.sort(Comparator.comparingInt(r -> r.getDictSort() == null ? 0 : r.getDictSort()));
+        return rows;
+    }
+
+    @Override
+    public void saveData(DictData dictData) {
+        assertData(dictData, false);
+        assertDefaultUnique(dictData, null);
+        assertValueUnique(dictData, null);
+        if (!dictDataService.save(dictData)) {
+            throw new RuntimeException("保存失败");
+        }
+    }
+
+    @Override
+    public void updateData(DictData dictData) {
+        assertData(dictData, true);
+        assertDefaultUnique(dictData, dictData.getDictCode());
+        assertValueUnique(dictData, dictData.getDictCode());
+        if (!dictDataService.updateById(dictData)) {
+            throw new RuntimeException("保存失败");
+        }
+    }
+
+    @Override
+    public void deleteData(DictData dictData) {
+        if (Objects.isNull(dictData) || Objects.isNull(dictData.getDictCode())) {
+            throw new RuntimeException("字典数据为空");
+        }
+        DictData existing = dictDataService.getById(dictData.getDictCode());
+        assertExistingData(existing);
+        if ("Y".equals(existing.getIsSystem())) {
+            throw new RuntimeException("系统字典不可删除");
+        }
+        if (!dictDataService.removeById(dictData.getDictCode())) {
+            throw new RuntimeException("删除失败");
+        }
+    }
+
+    @Override
+    public void disableData(DictData dictData) {
+        if (Objects.isNull(dictData) || Objects.isNull(dictData.getDictCode())) {
+            throw new RuntimeException("字典数据为空");
+        }
+        DictData existing = dictDataService.getById(dictData.getDictCode());
+        assertExistingData(existing);
+        if ("Y".equals(existing.getIsSystem())) {
+            throw new RuntimeException("系统字典不可停用");
+        }
+        if (!dictDataService.lambdaUpdate()
+                .set(DictData::getStatus, "N")
+                .eq(DictData::getDictCode, dictData.getDictCode())
+                .update()) {
+            throw new RuntimeException("操作失败");
+        }
+    }
+
+    private List<DictType> queryType(String site, BaseDictMaintenanceQuery query) {
+        LambdaQueryWrapper<DictType> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(DictType::getSite, site);
+        if (StringUtils.hasText(query.getDictType())) {
+            wrapper.like(DictType::getDictType, query.getDictType());
+        }
+        if (StringUtils.hasText(query.getDictName())) {
+            wrapper.like(DictType::getDictName, query.getDictName());
+        }
+        if (StringUtils.hasText(query.getStatus())) {
+            wrapper.eq(DictType::getStatus, query.getStatus());
+        }
+        wrapper.orderByAsc(DictType::getDictType);
+        return dictTypeService.list(wrapper);
+    }
+
+    private List<DictData> queryData(String site, BaseDictMaintenanceQuery query) {
+        LambdaQueryWrapper<DictData> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(DictData::getSite, site);
+        wrapper.eq(DictData::getDictType, query.getDictType());
+        if (StringUtils.hasText(query.getDictLabel())) {
+            wrapper.like(DictData::getDictLabel, query.getDictLabel());
+        }
+        if (StringUtils.hasText(query.getStatus())) {
+            wrapper.eq(DictData::getStatus, query.getStatus());
+        }
+        wrapper.orderByAsc(DictData::getDictSort);
+        return dictDataService.list(wrapper);
+    }
+
+    private String requireSite(String site) {
+        if (!StringUtils.hasText(site)) {
+            throw new RuntimeException("工厂编码为空");
+        }
+        return site.trim();
+    }
+
+    private void assertData(DictData dictData, boolean update) {
+        if (Objects.isNull(dictData)) {
+            throw new RuntimeException("字典数据为空");
+        }
+        if (update && Objects.isNull(dictData.getDictCode())) {
+            throw new RuntimeException("字典编码为空");
+        }
+        if (!StringUtils.hasText(dictData.getDictType())) {
+            throw new RuntimeException("字典类型为空");
+        }
+        if (!StringUtils.hasText(dictData.getDictValue())) {
+            throw new RuntimeException("字典键值为空");
+        }
+        if (!StringUtils.hasText(dictData.getSite())) {
+            throw new RuntimeException("工厂编码为空");
+        }
+    }
+
+    private void assertExistingData(DictData existing) {
+        if (existing == null) {
+            throw new RuntimeException("字典数据不存在");
+        }
+    }
+
+    private void assertDefaultUnique(DictData dictData, Long excludeCode) {
+        if (!"Y".equals(dictData.getIsDefault())) {
+            return;
+        }
+        LambdaQueryWrapper<DictData> wrapper = new LambdaQueryWrapper<DictData>()
+                .eq(DictData::getDictType, dictData.getDictType())
+                .eq(DictData::getSite, dictData.getSite())
+                .eq(DictData::getIsDefault, "Y");
+        List<DictData> list = dictDataService.list(wrapper);
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        if (excludeCode == null || list.stream().anyMatch(item -> !excludeCode.equals(item.getDictCode()))) {
+            throw new RuntimeException("当前字典已存在默认值");
+        }
+    }
+
+    private void assertValueUnique(DictData dictData, Long excludeCode) {
+        LambdaQueryWrapper<DictData> wrapper = new LambdaQueryWrapper<DictData>()
+                .eq(DictData::getDictType, dictData.getDictType())
+                .eq(DictData::getSite, dictData.getSite())
+                .eq(DictData::getDictValue, dictData.getDictValue());
+        List<DictData> list = dictDataService.list(wrapper);
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        if (excludeCode == null) {
+            throw new RuntimeException("字典键值重复");
+        }
+        if (list.size() > 1 || !excludeCode.equals(list.get(0).getDictCode())) {
+            throw new RuntimeException("字典键值重复");
+        }
+    }
+}

src/main/java/com/xujie/modules/supplierPerformance/service/impl/PerEvaluateRequestServiceImpl.java

@@ -121,8 +121,10 @@ public class PerEvaluateRequestServiceImpl extends ServiceImpl<PerEvaluateReques
     public ResponseData getSupplierList(PerEvaluateRequestEntity data) {
         SrmSupplierData srmSupplierData = new SrmSupplierData();
         srmSupplierData.setSite(data.getSite());
+        srmSupplierData.setSupplierNo(data.getSupplierNo());
+        srmSupplierData.setSupplierName(data.getSupplierName());
         srmSupplierData.setPage(1);
-        srmSupplierData.setLimit(-1);
+        srmSupplierData.setLimit(1000);
         List<?> list = srmSupplierService.searchSrmSupplierList(srmSupplierData).getList();
         ResponseData rd = new ResponseData();
         rd.setCode("0");

src/main/java/com/xujie/modules/sys/service/impl/DictTypeServiceImpl.java

@@ -91,7 +91,7 @@ public class DictTypeServiceImpl extends ServiceImpl<DictTypeDao, DictType> impl
         if (Objects.isNull(entity)||Objects.isNull(entity.getDictId())){
             throw new RuntimeException("字典编码为空");
         }
-        removeById(entity.getDictId());
+        super.removeById(entity.getDictId());
         dictGroupService.lambdaUpdate().eq(DictGroup::getSite,entity.getSite()).eq(DictGroup::getDictType,entity.getDictType()).remove();
         dictDataService.lambdaUpdate().eq(DictData::getSite,entity.getSite()).eq(DictData::getDictType,entity.getDictType()).remove();
         return true;