提交新增企业查询

sckw-modules/sckw-system/src/main/java/com/sckw/system/controller/KwsEnterpriseController.java

@@ -390,6 +390,18 @@ public class KwsEnterpriseController {
         return BaseResult.success(kwsEntService.queryEnterpriseByPageType(req));
     }
 
+    /**
+     * 根据企业类型查询企业列表，支持企业名称模糊查询，不按当前登录企业过滤。
+     *
+     * @param req 企业类型查询参数
+     * @return 企业ID和企业名称列表
+     */
+    @PostMapping("/queryEnterpriseByType")
+    @Operation(summary = "根据企业类型查询企业列表")
+    public BaseResult<List<EntInfo>> queryEnterpriseByType(@Valid @RequestBody EnterprisePageQueryReqVo req) {
+        return BaseResult.success(kwsEntService.queryEnterpriseByType(req));
+    }
+
     /**
      * 查询企业信息
      * @param entName

sckw-modules/sckw-system/src/main/java/com/sckw/system/service/KwsEnterpriseService.java

@@ -1772,6 +1772,71 @@ public class KwsEnterpriseService {
         }).collect(Collectors.toList());
     }
 
+    /**
+     * 根据企业类型查询企业列表，支持企业名称模糊查询，不限制当前登录企业ID。
+     *
+     * @param req 企业类型和企业名称查询参数
+     * @return 企业ID和企业名称列表
+     */
+    public List<EntInfo> queryEnterpriseByType(EnterprisePageQueryReqVo req) {
+        log.info("根据企业类型查询全部企业信息请求参数：{}", JSON.toJSONString(req));
+        try {
+            // 参数校验：请求对象和企业类型不能为空
+            if (Objects.isNull(req) || Objects.isNull(req.getEnterpriseType())) {
+                log.warn("根据企业类型查询企业参数校验失败，请求参数或企业类型为空");
+                throw new BusinessException("企业类型不能为空");
+            }
+
+            // 步骤1：根据企业类型查询企业类型关联表，获取该类型下的所有企业类型记录
+            List<KwsEntType> entTypes = kwsEntTypeRepository.queryByType(req.getEnterpriseType());
+            log.debug("根据企业类型[{}]查询到企业类型记录数：{}", req.getEnterpriseType(), 
+                CollectionUtils.isEmpty(entTypes) ? 0 : entTypes.size());
+            if (CollectionUtils.isEmpty(entTypes)) {
+                log.info("根据企业类型[{}]未查询到企业类型记录，返回空列表", req.getEnterpriseType());
+                return Collections.emptyList();
+            }
+
+            // 步骤2：从企业类型记录中提取企业ID集合，过滤掉null值
+            Set<Long> entIds = entTypes.stream()
+                    .map(KwsEntType::getEntId)
+                    .filter(Objects::nonNull)
+                    .collect(Collectors.toSet());
+            log.debug("从企业类型记录中提取到企业ID数量：{}", entIds.size());
+            if (CollectionUtils.isEmpty(entIds)) {
+                log.warn("从企业类型记录中未提取到有效的企业ID，返回空列表");
+                return Collections.emptyList();
+            }
+
+            // 步骤3：根据企业ID集合和企业名称（可选，支持模糊查询）查询企业详细信息
+            List<KwsEnterprise> enterprises = kwsEnterpriseRepository.queryByEntIds(entIds, req.getEntName());
+            log.debug("根据企业ID集合和企业名称[{}]查询到企业数量：{}", 
+                req.getEntName(), CollectionUtils.isEmpty(enterprises) ? 0 : enterprises.size());
+            if (CollectionUtils.isEmpty(enterprises)) {
+                log.info("根据企业ID集合和企业名称[{}]未查询到企业信息，返回空列表", req.getEntName());
+                return Collections.emptyList();
+            }
+
+            // 步骤4：将企业实体转换为EntInfo对象，只返回企业ID和企业名称
+            List<EntInfo> result = enterprises.stream()
+                    .filter(Objects::nonNull)
+                    .map(item -> {
+                        EntInfo info = new EntInfo();
+                        info.setEntId(String.valueOf(item.getId()));
+                        info.setEntName(item.getFirmName());
+                        return info;
+                    })
+                    .collect(Collectors.toList());
+            log.info("根据企业类型查询企业成功，返回企业数量：{}", result.size());
+            return result;
+        } catch (BusinessException e) {
+            log.warn("根据企业类型查询企业参数校验失败",  e);
+            throw e;
+        } catch (Exception e) {
+            log.error("根据企业类型查询企业异常", e);
+            throw new BusinessException("根据企业类型查询企业失败");
+        }
+    }
+
     public EntInfo queryEnt(String entName) {
         return kwsEnterpriseDao.query(entName);
     }

sckw-modules/sckw-system/src/test/java/com/sckw/system/service/KwsEnterpriseServiceTest.java

@@ -0,0 +1,113 @@
+package com.sckw.system.service;
+
+import com.sckw.core.exception.BusinessException;
+import com.sckw.system.model.KwsEntType;
+import com.sckw.system.model.KwsEnterprise;
+import com.sckw.system.model.vo.req.EnterprisePageQueryReqVo;
+import com.sckw.system.model.vo.res.EntInfo;
+import com.sckw.system.repository.KwsEntTypeRepository;
+import com.sckw.system.repository.KwsEnterpriseRepository;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * 企业信息查询服务测试。
+ */
+public class KwsEnterpriseServiceTest {
+
+    /**
+     * 验证按企业类型查询时不依赖当前登录企业ID，并支持企业名称模糊查询参数透传。
+     */
+    @Test
+    public void queryEnterpriseByTypeShouldReturnIdAndNameWithoutLoginEntFilter() {
+        FakeKwsEntTypeRepository entTypeRepository = new FakeKwsEntTypeRepository(List.of(
+                buildEntType(1001L, 1),
+                buildEntType(1002L, 1),
+                buildEntType(null, 1)
+        ));
+        FakeKwsEnterpriseRepository enterpriseRepository = new FakeKwsEnterpriseRepository(List.of(
+                buildEnterprise(1001L, "山西供应商"),
+                buildEnterprise(1002L, "陕西供应商")
+        ));
+        KwsEnterpriseService service = new KwsEnterpriseService(entTypeRepository, enterpriseRepository);
+
+        EnterprisePageQueryReqVo req = new EnterprisePageQueryReqVo();
+        req.setEnterpriseType(1);
+        req.setEntName("供应商");
+
+        List<EntInfo> result = service.queryEnterpriseByType(req);
+
+        assertEquals(1, entTypeRepository.lastEnterpriseType.intValue());
+        assertEquals("供应商", enterpriseRepository.lastEntName);
+        assertEquals(Set.of(1001L, 1002L), enterpriseRepository.lastEntIds);
+        assertEquals(2, result.size());
+        assertEquals("1001", result.get(0).getEntId());
+        assertEquals("山西供应商", result.get(0).getEntName());
+        assertEquals("1002", result.get(1).getEntId());
+        assertEquals("陕西供应商", result.get(1).getEntName());
+    }
+
+    /**
+     * 验证企业类型为空时抛出业务异常，避免无条件全量查询。
+     */
+    @Test(expected = BusinessException.class)
+    public void queryEnterpriseByTypeShouldRejectEmptyEnterpriseType() {
+        KwsEnterpriseService service = new KwsEnterpriseService(
+                new FakeKwsEntTypeRepository(List.of()),
+                new FakeKwsEnterpriseRepository(List.of())
+        );
+
+        service.queryEnterpriseByType(new EnterprisePageQueryReqVo());
+    }
+
+    private static KwsEntType buildEntType(Long entId, Integer type) {
+        KwsEntType entType = new KwsEntType();
+        entType.setEntId(entId);
+        entType.setType(type);
+        return entType;
+    }
+
+    private static KwsEnterprise buildEnterprise(Long id, String firmName) {
+        KwsEnterprise enterprise = new KwsEnterprise();
+        enterprise.setId(id);
+        enterprise.setFirmName(firmName);
+        return enterprise;
+    }
+
+    private static class FakeKwsEntTypeRepository extends KwsEntTypeRepository {
+        private final List<KwsEntType> entTypes;
+        private Integer lastEnterpriseType;
+
+        private FakeKwsEntTypeRepository(List<KwsEntType> entTypes) {
+            this.entTypes = new ArrayList<>(entTypes);
+        }
+
+        @Override
+        public List<KwsEntType> queryByType(Integer entType) {
+            lastEnterpriseType = entType;
+            return entTypes;
+        }
+    }
+
+    private static class FakeKwsEnterpriseRepository extends KwsEnterpriseRepository {
+        private final List<KwsEnterprise> enterprises;
+        private Set<Long> lastEntIds;
+        private String lastEntName;
+
+        private FakeKwsEnterpriseRepository(List<KwsEnterprise> enterprises) {
+            this.enterprises = new ArrayList<>(enterprises);
+        }
+
+        @Override
+        public List<KwsEnterprise> queryByEntIds(Set<Long> entIds, String entName) {
+            lastEntIds = entIds;
+            lastEntName = entName;
+            return enterprises;
+        }
+    }
+}