Merge remote-tracking branch 'origin/sit-plantform' into sit-plantform

alien-entity/src/main/java/shop/alien/entity/store/StoreInfo.java

@@ -266,6 +266,19 @@ public class StoreInfo {
     @TableField("update_entertainment_licence_time")
     private Date updateEntertainmentLicenceTime;
 
+    @ApiModelProperty(value = "人工复核状态(1:通过,2:拒绝)")
+    @TableField("manual_review_status")
+    private Integer manualReviewStatus;
+
+    @ApiModelProperty(value = "人工复核时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    @TableField("manual_review_time")
+    private Date manualReviewTime;
+
+    @ApiModelProperty(value = "人工复核原因")
+    @TableField("manual_review_reason")
+    private String manualReviewReason;
+
     @ApiModelProperty(value = "审核时间")
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
     @TableField("review_date")

alien-entity/src/main/java/shop/alien/entity/store/dto/StoreInfoDto.java

@@ -213,6 +213,17 @@ public class StoreInfoDto {
     @DateTimeFormat(pattern = "yyyy-MM-dd")
     private Date entertainmentLicenceExpirationTime;
 
+    @ApiModelProperty(value = "人工复核状态(1:通过,2:拒绝)")
+    private Integer manualReviewStatus;
+
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @ApiModelProperty(value = "人工复核时间")
+    private Date manualReviewTime;
+
+    @ApiModelProperty(value = "人工复核原因")
+    private String manualReviewReason;
+
     @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
     @DateTimeFormat(pattern = "yyyy-MM-dd")
     @ApiModelProperty(value = "审核时间")

alien-entity/src/main/java/shop/alien/entity/store/vo/StoreInfoVo.java

@@ -249,6 +249,16 @@ public class StoreInfoVo extends StoreInfo {
     @ApiModelProperty(value = "娱乐经营许可证")
     private JSONObject entertainmentLicence;
 
+    @ApiModelProperty(value = "人工复核状态(1:通过,2:拒绝)")
+    private Integer manualReviewStatus;
+
+    @ApiModelProperty(value = "人工复核时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date manualReviewTime;
+
+    @ApiModelProperty(value = "人工复核原因")
+    private String manualReviewReason;
+
     @ApiModelProperty(value = "审核时间")
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
     private Date reviewDate;

alien-entity/src/main/java/shop/alien/entity/store/vo/StoreLicenseInfoVo.java

@@ -79,3 +79,5 @@ public class StoreLicenseInfoVo {
 
 
 
+
+

alien-entity/src/main/java/shop/alien/mapper/StoreInfoMapper.java

@@ -191,7 +191,9 @@ public interface StoreInfoMapper extends BaseMapper<StoreInfo> {
      *
      * @param page            分页对象
      * @param storeName       门店名称（模糊）
+     * @param storeContact    门店联系人（模糊）
      * @param storeTel        门店电话（模糊）
+     * @param businessSection 经营板块
      * @param imgType         证照图片类型（14：营业执照；24/25：食品经营许可证；31/32：娱乐经营许可证）
      * @param states          证照状态
      * @param startSubmitDate 提交开始时间（yyyy-MM-dd HH:mm:ss）
@@ -200,7 +202,9 @@ public interface StoreInfoMapper extends BaseMapper<StoreInfo> {
      */
     IPage<StoreLicenseInfoVo> getStoreLicensePage(IPage<StoreLicenseInfoVo> page,
                                                   @Param("storeName") String storeName,
+                                                  @Param("storeContact") String storeContact,
                                                   @Param("storeTel") String storeTel,
+                                                  @Param("businessSection") String businessSection,
                                                   @Param("imgType") Integer imgType,
                                                   @Param("states") String states,
                                                   @Param("startSubmitDate") String startSubmitDate,

alien-entity/src/main/resources/mapper/StoreInfoMapper.xml

@@ -69,9 +69,15 @@
         <if test="storeName != null and storeName != ''">
             AND s.store_name LIKE CONCAT('%', #{storeName}, '%')
         </if>
+        <if test="storeContact != null and storeContact != ''">
+            AND su.name LIKE CONCAT('%', #{storeContact}, '%')
+        </if>
         <if test="storeTel != null and storeTel != ''">
             AND s.store_tel LIKE CONCAT('%', #{storeTel}, '%')
         </if>
+        <if test="businessSection != null and businessSection != ''">
+            AND s.business_section = #{businessSection}
+        </if>
         <if test="imgType != null">
             AND si.img_type = #{imgType}
         </if>

alien-store/src/main/java/shop/alien/store/controller/DictOpinionFeedbackController.java

@@ -41,12 +41,12 @@ public class DictOpinionFeedbackController {
 
     private final DictOpinionFeedbackService dictOpinionFeedbackService;
 
-    @ApiOperation("查询意见反馈字典（三级树形结构）")
+    @ApiOperation("查询意见反馈字典（三级树形结构），支持根据dictDetail过滤")
     @ApiOperationSupport(order = 1)
     @GetMapping("/queryDictOpinionFeedbackTree")
-    public R<List<StoreDictionary>> queryDictOpinionFeedbackTree() {
-        log.info("dictOpinionFeedback.queryDictOpinionFeedbackTree");
-        List<StoreDictionary> result = dictOpinionFeedbackService.queryDictOpinionFeedbackTree();
+    public R<List<StoreDictionary>> queryDictOpinionFeedbackTree(@RequestParam(required = false) String dictDetail) {
+        log.info("dictOpinionFeedback.queryDictOpinionFeedbackTree dictDetail={}", dictDetail);
+        List<StoreDictionary> result = dictOpinionFeedbackService.queryDictOpinionFeedbackTree(dictDetail);
         return R.data(result);
     }
 

alien-store/src/main/java/shop/alien/store/controller/DictStoreTagController.java

@@ -41,12 +41,12 @@ public class DictStoreTagController {
 
     private final DictStoreTagService dictStoreTagService;
 
-    @ApiOperation("查询店铺标签字典（三级树形结构）")
+    @ApiOperation("查询店铺标签字典（三级树形结构），支持根据dictDetail过滤")
     @ApiOperationSupport(order = 1)
     @GetMapping("/queryDictStoreTagTree")
-    public R<List<StoreDictionary>> queryDictStoreTagTree() {
-        log.info("dictStoreTag.queryDictStoreTagTree");
-        List<StoreDictionary> result = dictStoreTagService.queryDictStoreTagTree();
+    public R<List<StoreDictionary>> queryDictStoreTagTree(@RequestParam(required = false) String dictDetail) {
+        log.info("dictStoreTag.queryDictStoreTagTree dictDetail={}", dictDetail);
+        List<StoreDictionary> result = dictStoreTagService.queryDictStoreTagTree(dictDetail);
         return R.data(result);
     }
 

alien-store/src/main/java/shop/alien/store/controller/DictionaryLibraryController.java

@@ -32,12 +32,12 @@ public class DictionaryLibraryController {
 
     private final DictionaryLibraryService dictionaryLibraryService;
 
-    @ApiOperation("查询字典库（三级树形结构）")
+    @ApiOperation("查询字典库（三级树形结构），支持根据dictDetail过滤")
     @ApiOperationSupport(order = 1)
     @GetMapping("/queryDictionaryLibraryTree")
-    public R<List<StoreDictionary>> queryDictionaryLibraryTree() {
-        log.info("dictionaryLibrary.queryDictionaryLibraryTree");
-        List<StoreDictionary> result = dictionaryLibraryService.queryDictionaryLibraryTree();
+    public R<List<StoreDictionary>> queryDictionaryLibraryTree(@RequestParam(required = false) String dictDetail) {
+        log.info("dictionaryLibrary.queryDictionaryLibraryTree dictDetail={}", dictDetail);
+        List<StoreDictionary> result = dictionaryLibraryService.queryDictionaryLibraryTree(dictDetail);
         return R.data(result);
     }
 
@@ -154,4 +154,62 @@ public class DictionaryLibraryController {
         }
     }
 
+
+    @ApiOperation("删除字典库（支持一级、二级、三级）")
+    @ApiOperationSupport(order = 6)
+    @DeleteMapping("/deleteDictionaryLibrary/{id}")
+    public R<Boolean> deleteDictionaryLibrary(@PathVariable Long id) {
+        log.info("dictionaryLibrary.deleteDictionaryLibrary id={}", id);
+        try {
+            int result = dictionaryLibraryService.deleteDictionaryLibrary(id);
+            if (result > 0) {
+                return R.success("删除成功");
+            } else {
+                return R.fail("删除失败");
+            }
+        } catch (IllegalArgumentException e) {
+            log.error("dictionaryLibrary.deleteDictionaryLibrary error: {}", e.getMessage());
+            return R.fail(e.getMessage());
+        } catch (Exception e) {
+            log.error("dictionaryLibrary.deleteDictionaryLibrary error", e);
+            return R.fail("删除失败：" + e.getMessage());
+        }
+    }
+
+    @ApiOperation("修改字典库状态（通过id修改hidden为1）")
+    @ApiOperationSupport(order = 7)
+    @PutMapping("/updateHiddenStatus/{id}")
+    public R<Boolean> updateHiddenStatus(@PathVariable Long id) {
+        log.info("dictionaryLibrary.updateHiddenStatus id={}", id);
+        try {
+            int result = dictionaryLibraryService.updateHiddenStatus(id);
+            if (result > 0) {
+                return R.success("删除成功");
+            } else {
+                return R.fail("删除失败");
+            }
+        } catch (IllegalArgumentException e) {
+            log.error("dictionaryLibrary.updateHiddenStatus error: {}", e.getMessage());
+            return R.fail(e.getMessage());
+        } catch (Exception e) {
+            log.error("dictionaryLibrary.updateHiddenStatus error", e);
+            return R.fail("修改失败：" + e.getMessage());
+        }
+    }
+
+    @ApiOperation("根据dictDetail查询字典库（包含父级或子级树形结构）")
+    @ApiOperationSupport(order = 8)
+    @GetMapping("/selectDictBydictDetail")
+    public R<List<StoreDictionary>> selectDictBydictDetail(@RequestParam String dictDetail) {
+        log.info("dictionaryLibrary.selectDictBydictDetail dictDetail={}", dictDetail);
+        try {
+            // 内部调用queryDictionaryLibraryTree方法
+            List<StoreDictionary> result = dictionaryLibraryService.queryDictionaryLibraryTree(dictDetail);
+            return R.data(result);
+        } catch (Exception e) {
+            log.error("dictionaryLibrary.selectDictBydictDetail error", e);
+            return R.fail("查询失败：" + e.getMessage());
+        }
+    }
+
 }

alien-store/src/main/java/shop/alien/store/controller/FilterConditionController.java

@@ -32,12 +32,12 @@ public class FilterConditionController {
 
     private final FilterConditionService filterConditionService;
 
-    @ApiOperation("查询筛选条件（三级树形结构）")
+    @ApiOperation("查询筛选条件（四级树形结构），支持根据dictDetail过滤")
     @ApiOperationSupport(order = 1)
     @GetMapping("/queryFilterConditionTree")
-    public R<List<StoreDictionary>> queryFilterConditionTree() {
-        log.info("filterCondition.queryFilterConditionTree");
-        List<StoreDictionary> result = filterConditionService.queryFilterConditionTree();
+    public R<List<StoreDictionary>> queryFilterConditionTree(@RequestParam(required = false) String dictDetail) {
+        log.info("filterCondition.queryFilterConditionTree dictDetail={}", dictDetail);
+        List<StoreDictionary> result = filterConditionService.queryFilterConditionTree(dictDetail);
         return R.data(result);
     }
 

alien-store/src/main/java/shop/alien/store/controller/PlatformBusinessSectionController.java

@@ -26,12 +26,12 @@ public class PlatformBusinessSectionController {
 
     private final PlatformBusinessSectionService platformBusinessSectionService;
 
-    @ApiOperation("查询经营种类（三级树形结构）")
+    @ApiOperation("查询经营种类（三级树形结构），支持根据dictDetail过滤")
     @ApiOperationSupport(order = 1)
     @GetMapping("/queryBusinessSectionTree")
-    public R<List<StoreDictionary>> queryBusinessSectionTree() {
-        log.info("platformBusinessSection.queryBusinessSectionTree");
-        List<StoreDictionary> result = platformBusinessSectionService.queryBusinessSectionTree();
+    public R<List<StoreDictionary>> queryBusinessSectionTree(@RequestParam(required = false) String dictDetail) {
+        log.info("platformBusinessSection.queryBusinessSectionTree dictDetail={}", dictDetail);
+        List<StoreDictionary> result = platformBusinessSectionService.queryBusinessSectionTree(dictDetail);
         return R.data(result);
     }
 

alien-store/src/main/java/shop/alien/store/controller/StoreInfoController.java

@@ -252,7 +252,9 @@ public class StoreInfoController {
             @ApiImplicitParam(name = "weidu", value = "weidu", dataType = "String", paramType = "query"),
             @ApiImplicitParam(name = "renewContractStatus", value = "门店续签合同状态", dataType = "String", paramType = "query"),
             @ApiImplicitParam(name = "foodLicenceStatus", value = "门店经营许可证状态", dataType = "String", paramType = "query"),
-            @ApiImplicitParam(name = "foodLicenceWhetherExpiredStatus", value = "门店经营许可证是否过期状态", dataType = "String", paramType = "query")
+            @ApiImplicitParam(name = "foodLicenceWhetherExpiredStatus", value = "门店经营许可证是否过期状态", dataType = "String", paramType = "query"),
+            @ApiImplicitParam(name = "startApplyTime", value = "开始时间", dataType = "String", paramType = "query"),
+            @ApiImplicitParam(name = "endApplyTime", value = "结束时间", dataType = "String", paramType = "query")
     })
     @GetMapping("/getNewStorePage")
     public R<IPage<StoreInfoVo>> getNewStorePage(
@@ -271,7 +273,9 @@ public class StoreInfoController {
             @RequestParam(required = false) String weidu,
             @RequestParam(required = false) String renewContractStatus,
             @RequestParam(required = false) String foodLicenceStatus,
-            @RequestParam(required = false) String foodLicenceWhetherExpiredStatus)
+            @RequestParam(required = false) String foodLicenceWhetherExpiredStatus,
+            @RequestParam(required = false) String startApplyTime,
+            @RequestParam(required = false) String endApplyTime)
     {
         log.info("StoreInfoController.getStoresPage?pageNum={}," +
                         "pageSize={},storeName={},storeContact={}," +
@@ -279,12 +283,12 @@ public class StoreInfoController {
                         "storeApplicationStatus={},storeStatus={}," +
                         "businessSection={},jingdu={},weidu={}," +
                         "renewContractStatus={},foodLicenceStatus={}" +
-                        ",foodLicenceWhetherExpiredStatus={}",
+                        ",foodLicenceWhetherExpiredStatus={},startApplyTime={},endApplyTime={}",
                 pageNum, pageSize, storeName, storeContact,
                 id, storePhone, storeType, expiredState, storeApplicationStatus,
                 storeStatus, businessSection, jingdu, weidu, renewContractStatus,
-                foodLicenceStatus, foodLicenceWhetherExpiredStatus);
-        return R.data(storeInfoService.getNewStorePage(pageNum, pageSize, storeName, storeContact, id, storePhone, storeType, expiredState, storeApplicationStatus, storeStatus, businessSection, jingdu, weidu, renewContractStatus, foodLicenceStatus, foodLicenceWhetherExpiredStatus));
+                foodLicenceStatus, foodLicenceWhetherExpiredStatus, startApplyTime, endApplyTime);
+        return R.data(storeInfoService.getNewStorePage(pageNum, pageSize, storeName, storeContact, id, storePhone, storeType, expiredState, storeApplicationStatus, storeStatus, businessSection, jingdu, weidu, renewContractStatus, foodLicenceStatus, foodLicenceWhetherExpiredStatus, startApplyTime, endApplyTime));
     }
 
     /**
@@ -421,6 +425,25 @@ public class StoreInfoController {
         return R.success("审批完成");
     }
 
+    @ApiOperation(value = "web端人工复核店铺")
+    @ApiOperationSupport(order = 24)
+    @PostMapping("/manualReview")
+    public R<Boolean> manualReview(@RequestBody StoreInfoDto storeInfoDto) {
+        log.info("StoreInfoController.manualReview?storeInfoDto={}", storeInfoDto);
+        try {
+            boolean success = storeInfoService.manualReview(storeInfoDto);
+            if (success) {
+                return R.success("人工复核保存成功");
+            }
+            return R.fail("人工复核保存失败");
+        } catch (IllegalArgumentException e) {
+            return R.fail(e.getMessage());
+        } catch (Exception e) {
+            log.error("StoreInfoController.manualReview ERROR", e);
+            return R.fail("人工复核失败");
+        }
+    }
+
     @ApiOperation(value = "中台web端获取店铺明细详情")
     @ApiOperationSupport(order = 21)
     @GetMapping("/getNewStoreDetail")
@@ -1110,7 +1133,9 @@ public class StoreInfoController {
             @ApiImplicitParam(name = "pageNum", value = "页码", dataType = "int", paramType = "query", required = true),
             @ApiImplicitParam(name = "pageSize", value = "页容", dataType = "int", paramType = "query", required = true),
             @ApiImplicitParam(name = "storeName", value = "门店名称", dataType = "String", paramType = "query"),
+            @ApiImplicitParam(name = "storeContact", value = "联系人", dataType = "String", paramType = "query"),
             @ApiImplicitParam(name = "storeTel", value = "门店电话", dataType = "String", paramType = "query"),
+            @ApiImplicitParam(name = "businessSection", value = "经营板块", dataType = "String", paramType = "query"),
             @ApiImplicitParam(name = "imgType", value = "证照图片类型（14：营业执照；24/25：食品经营许可证；31/32：娱乐经营许可证）", dataType = "int", paramType = "query"),
             @ApiImplicitParam(name = "states", value = "证照状态", dataType = "String", paramType = "query"),
             @ApiImplicitParam(name = "startSubmitDate", value = "提交开始时间（yyyy-MM-dd HH:mm:ss）", dataType = "String", paramType = "query"),
@@ -1120,14 +1145,16 @@ public class StoreInfoController {
             @RequestParam(value = "pageNum", defaultValue = "1") int pageNum,
             @RequestParam(value = "pageSize", defaultValue = "10") int pageSize,
             @RequestParam(value = "storeName", required = false) String storeName,
+            @RequestParam(value = "storeContact", required = false) String storeContact,
             @RequestParam(value = "storeTel", required = false) String storeTel,
+            @RequestParam(value = "businessSection", required = false) String businessSection,
             @RequestParam(value = "imgType", required = false) Integer imgType,
             @RequestParam(value = "states", required = false) String states,
             @RequestParam(value = "startSubmitDate", required = false) String startSubmitDate,
             @RequestParam(value = "endSubmitDate", required = false) String endSubmitDate) {
-        log.info("StoreInfoController.getStoreLicenseList?pageNum={},pageSize={},storeName={},storeTel={},imgType={},states={},startSubmitDate={},endSubmitDate={}",
-                pageNum, pageSize, storeName, storeTel, imgType, states, startSubmitDate, endSubmitDate);
-        IPage<StoreLicenseInfoVo> page = storeInfoService.getStoreLicenseList(pageNum, pageSize, storeName, storeTel, imgType, states, startSubmitDate, endSubmitDate);
+        log.info("StoreInfoController.getStoreLicenseList?pageNum={},pageSize={},storeName={},storeContact={},storeTel={},businessSection={},imgType={},states={},startSubmitDate={},endSubmitDate={}",
+                pageNum, pageSize, storeName, storeContact, storeTel, businessSection, imgType, states, startSubmitDate, endSubmitDate);
+        IPage<StoreLicenseInfoVo> page = storeInfoService.getStoreLicenseList(pageNum, pageSize, storeName, storeContact, storeTel, businessSection, imgType, states, startSubmitDate, endSubmitDate);
         return R.data(page);
     }
 

alien-store/src/main/java/shop/alien/store/controller/UserViolationController.java

@@ -100,11 +100,12 @@ public class UserViolationController {
             @RequestParam(value = "nickname", required = false) String nickname,
             @RequestParam(value = "phone", required = false) String phone,
             @RequestParam(value = "processingStatus", required = false) String processingStatus,
+            @RequestParam(value = "reportContextType", required = false) String reportContextType,
             @RequestParam(value = "startTime", required = false) String startTime,
             @RequestParam(value = "endTime", required = false) String endTime ) {
         log.info("UserViolationController.getAllViolationPage?pageNum={},pageSize={},nickName={},phone={},processingStatus={},startTime={},endTime={}", 
                 pageNum, pageSize, nickname, phone, processingStatus, startTime, endTime);
-        return R.data(lifeUserViolationService.getAllViolationPage(pageNum, pageSize, nickname, phone, processingStatus, startTime, endTime));
+        return R.data(lifeUserViolationService.getAllViolationPage(pageNum, pageSize, nickname, phone, processingStatus, startTime, endTime, reportContextType));
     }
 
     @ApiOperation(value = "举报审核")

alien-store/src/main/java/shop/alien/store/service/DictOpinionFeedbackService.java

@@ -14,10 +14,13 @@ public interface DictOpinionFeedbackService {
 
     /**
      * 查询意见反馈字典（三级树形结构）
+     * 如果传入dictDetail，则查询匹配的记录及其父级和子级树形结构
+     * 如果不传dictDetail，则返回完整的字典库树形结构
      *
+     * @param dictDetail 字典描述（可选），如果传入则根据此参数过滤
      * @return 字典树形结构列表
      */
-    List<StoreDictionary> queryDictOpinionFeedbackTree();
+    List<StoreDictionary> queryDictOpinionFeedbackTree(String dictDetail);
 
     /**
      * 新增意见反馈字典（支持一级、二级、三级）

alien-store/src/main/java/shop/alien/store/service/DictStoreTagService.java

@@ -14,10 +14,13 @@ public interface DictStoreTagService {
 
     /**
      * 查询店铺字典标签（三级树形结构）
+     * 如果传入dictDetail，则查询匹配的记录及其父级和子级树形结构
+     * 如果不传dictDetail，则返回完整的字典库树形结构
      *
+     * @param dictDetail 字典描述（可选），如果传入则根据此参数过滤
      * @return 标签树形结构列表
      */
-    List<StoreDictionary> queryDictStoreTagTree();
+    List<StoreDictionary> queryDictStoreTagTree(String dictDetail);
 
     /**
      * 新增店铺字典标签（支持一级、二级、三级）

alien-store/src/main/java/shop/alien/store/service/DictionaryLibraryService.java

@@ -18,10 +18,13 @@ public interface DictionaryLibraryService {
 
     /**
      * 查询字典库（三级树形结构）
+     * 如果传入dictDetail，则查询匹配的记录及其父级和子级树形结构
+     * 如果不传dictDetail，则返回完整的字典库树形结构
      *
+     * @param dictDetail 字典描述（可选），如果传入则根据此参数过滤
      * @return 字典库树形结构列表
      */
-    List<StoreDictionary> queryDictionaryLibraryTree();
+    List<StoreDictionary> queryDictionaryLibraryTree(String dictDetail);
 
     /**
      * 新增字典库（支持一级、二级、三级）
@@ -54,4 +57,22 @@ public interface DictionaryLibraryService {
      * @throws IOException IO异常
      */
     void downloadTemplate(HttpServletResponse response) throws IOException;
+
+    int deleteDictionaryLibrary(Long id);
+
+    /**
+     * 修改字典库状态（通过id修改hidden为1）
+     *
+     * @param id 字典库ID
+     * @return 修改结果
+     */
+    int updateHiddenStatus(Long id);
+
+    /**
+     * 根据dictDetail查询字典库（包含父级或子级树形结构）
+     *
+     * @param dictDetail 字典描述
+     * @return 字典库树形结构列表
+     */
+    List<StoreDictionary> selectDictBydictDetail(String dictDetail);
 }

alien-store/src/main/java/shop/alien/store/service/FilterConditionService.java

@@ -17,11 +17,14 @@ import java.util.List;
 public interface FilterConditionService {
 
     /**
-     * 查询筛选条件（三级树形结构）
+     * 查询筛选条件（四级树形结构）
+     * 如果传入dictDetail，则查询匹配的记录及其父级和子级树形结构
+     * 如果不传dictDetail，则返回完整的字典库树形结构
      *
+     * @param dictDetail 字典描述（可选），如果传入则根据此参数过滤
      * @return 筛选条件树形结构列表
      */
-    List<StoreDictionary> queryFilterConditionTree();
+    List<StoreDictionary> queryFilterConditionTree(String dictDetail);
 
     /**
      * 新增筛选条件（支持一级、二级、三级）

alien-store/src/main/java/shop/alien/store/service/LifeUserViolationService.java

@@ -28,7 +28,7 @@ public interface LifeUserViolationService extends IService<LifeUserViolation> {
 
     IPage<LifeUserViolationDto> getViolationPage(int page, int size, String nickName, String phone, String processingStatus);
 
-    IPage<LifeUserViolationDto> getAllViolationPage(int page, int size, String nickName, String phone, String processingStatus, String startTime, String endTime);
+    IPage<LifeUserViolationDto> getAllViolationPage(int page, int size, String nickName, String phone, String processingStatus, String startTime, String endTime, String reportContextType);
 
     void approve(int id, String processingStatus, String reportResult);
 

alien-store/src/main/java/shop/alien/store/service/PlatformBusinessSectionService.java

@@ -18,10 +18,13 @@ public interface PlatformBusinessSectionService {
 
     /**
      * 查询经营种类（三级树形结构）
+     * 如果传入dictDetail，则查询匹配的记录及其父级和子级树形结构
+     * 如果不传dictDetail，则返回完整的字典库树形结构
      *
+     * @param dictDetail 字典描述（可选），如果传入则根据此参数过滤
      * @return 经营种类树形结构列表
      */
-    List<StoreDictionary> queryBusinessSectionTree();
+    List<StoreDictionary> queryBusinessSectionTree(String dictDetail);
 
     /**
      * 新增经营种类（支持一级、二级、三级）

alien-store/src/main/java/shop/alien/store/service/StoreInfoService.java

@@ -72,7 +72,7 @@ public interface StoreInfoService extends IService<StoreInfo> {
      * @param storeType    门店类型
      * @return IPage<StoreInfoVo>
      */
-    IPage<StoreInfoVo> getNewStorePage(int page, int size, String storeName, String storeContact, String id, String storePhone, String storeType, String expiredState, String storeApplicationStatus, String storeStatus, String businessSection, String jingdu, String weidu, String renewContractStatus, String foodLicenceStatus, String foodLicenceWhetherExpiredStatus);
+    IPage<StoreInfoVo> getNewStorePage(int page, int size, String storeName, String storeContact, String id, String storePhone, String storeType, String expiredState, String storeApplicationStatus, String storeStatus, String businessSection, String jingdu, String weidu, String renewContractStatus, String foodLicenceStatus, String foodLicenceWhetherExpiredStatus, String startApplyTime, String endApplyTime);
 
     /**
      * web-重置门店密码
@@ -194,6 +194,14 @@ public interface StoreInfoService extends IService<StoreInfo> {
     void approveStoreInfo(String storeId, Integer approvalStatus, String reason);
 
     /**
+     * web端人工复核店铺
+     *
+     * @param storeInfoDto 复核信息（包含门店ID、复核状态、时间、原因）
+     * @return true 表示保存成功
+     */
+    boolean manualReview(StoreInfoDto storeInfoDto);
+
+    /**
      * web端导出商铺信息结果
      */
     String exportExcel(String id, String storePhone, String businessSection, String storeApplicationStatus) throws IOException;
@@ -453,7 +461,9 @@ public interface StoreInfoService extends IService<StoreInfo> {
      * @param pageNum         页码
      * @param pageSize        页容
      * @param storeName       门店名称（模糊）
+     * @param storeContact    联系人姓名（模糊）
      * @param storeTel        门店电话（模糊）
+     * @param businessSection 经营板块
      * @param imgType         证照图片类型（14：营业执照；24/25：食品经营许可证；31/32：娱乐经营许可证）
      * @param states          证照状态
      * @param startSubmitDate 提交开始时间（yyyy-MM-dd HH:mm:ss）
@@ -463,7 +473,9 @@ public interface StoreInfoService extends IService<StoreInfo> {
     IPage<StoreLicenseInfoVo> getStoreLicenseList(int pageNum,
                                                   int pageSize,
                                                   String storeName,
+                                                  String storeContact,
                                                   String storeTel,
+                                                  String businessSection,
                                                   Integer imgType,
                                                   String states,
                                                   String startSubmitDate,

alien-store/src/main/java/shop/alien/store/service/impl/DictOpinionFeedbackServiceImpl.java

@@ -38,8 +38,10 @@ import java.net.URLEncoder;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * 意见反馈字典管理ServiceImpl
@@ -55,9 +57,20 @@ public class DictOpinionFeedbackServiceImpl extends ServiceImpl<StoreDictionaryM
 
     /**
      * 查询意见反馈字典（三级树形结构）
+     * 如果传入dictDetail，则查询匹配的记录及其父级和子级树形结构
+     * 如果不传dictDetail，则返回完整的字典库树形结构
+     *
+     * @param dictDetail 字典描述（可选），如果传入则根据此参数过滤
+     * @return 字典树形结构列表
      */
     @Override
-    public List<StoreDictionary> queryDictOpinionFeedbackTree() {
+    public List<StoreDictionary> queryDictOpinionFeedbackTree(String dictDetail) {
+        // 如果传入了dictDetail，使用过滤逻辑
+        if (StringUtils.isNotBlank(dictDetail)) {
+            return selectDictBydictDetail(dictDetail);
+        }
+        
+        // 否则使用原有逻辑：查询所有意见反馈字典数据
         LambdaQueryWrapper<StoreDictionary> queryWrapper = new LambdaQueryWrapper<>();
         queryWrapper.in(StoreDictionary::getTypeName, "opinion_feedback", "opinion_feedback_type", "opinion_feedback_classify");
         queryWrapper.eq(StoreDictionary::getDeleteFlag, 0);
@@ -66,6 +79,254 @@ public class DictOpinionFeedbackServiceImpl extends ServiceImpl<StoreDictionaryM
 
         return buildTreeOptimized(dictList);
     }
+    
+    /**
+     * 根据dictDetail查询意见反馈字典（包含父级或子级树形结构）
+     * 支持查询多个同名数据及其父级和子级
+     *
+     * @param dictDetail 字典描述
+     * @return 意见反馈字典树形结构列表
+     */
+    private List<StoreDictionary> selectDictBydictDetail(String dictDetail) {
+        if (StringUtils.isBlank(dictDetail)) {
+            throw new IllegalArgumentException("dictDetail不能为空");
+        }
+
+        // 通过dictDetail模糊查询所有匹配的记录（可能有多个同名数据）
+        LambdaQueryWrapper<StoreDictionary> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.in(StoreDictionary::getTypeName, "opinion_feedback", "opinion_feedback_type", "opinion_feedback_classify");
+        queryWrapper.eq(StoreDictionary::getDeleteFlag, 0);
+        queryWrapper.like(StoreDictionary::getDictDetail, dictDetail);
+        
+        List<StoreDictionary> matchedDicts = storeDictionaryMapper.selectList(queryWrapper);
+        
+        if (matchedDicts == null || matchedDicts.isEmpty()) {
+            log.warn("未找到dictDetail为[{}]的记录", dictDetail);
+            return new ArrayList<>();
+        }
+
+        log.info("找到{}条dictDetail为[{}]的记录", matchedDicts.size(), dictDetail);
+
+        // 用于存储每个根节点对应的所有节点（按根节点分组）
+        Map<Integer, Set<Integer>> rootToNodeIdsMap = new HashMap<>();
+        
+        // 遍历所有匹配的记录，收集相关节点ID
+        for (StoreDictionary currentDict : matchedDicts) {
+            Integer parentId = currentDict.getParentId();
+            Integer rootId;
+            
+            if (parentId != null && parentId != 0) {
+                // 如果有父级，查找根节点
+                rootId = findRootId(currentDict.getId());
+                log.info("记录ID[{}]有父级[{}], 根节点ID[{}]", currentDict.getId(), parentId, rootId);
+                
+                // 收集从根节点到当前节点的路径上的所有节点ID
+                List<Integer> pathNodeIds = new ArrayList<>();
+                collectPathNodes(currentDict.getId(), pathNodeIds);
+                log.info("路径节点IDs: {}", pathNodeIds);
+                
+                // 收集该根节点下的所有相关节点ID（包括路径节点及其所有子节点）
+                Set<Integer> nodeIds = rootToNodeIdsMap.computeIfAbsent(rootId, k -> new HashSet<>());
+                for (Integer nodeId : pathNodeIds) {
+                    nodeIds.add(nodeId);
+                    collectChildrenIds(nodeId, nodeIds);
+                }
+            } else {
+                // 如果没有父级，以当前节点为根
+                rootId = currentDict.getId();
+                log.info("记录ID[{}]没有父级, 作为根节点", currentDict.getId());
+                
+                // 收集该根节点下的所有相关节点ID
+                Set<Integer> nodeIds = rootToNodeIdsMap.computeIfAbsent(rootId, k -> new HashSet<>());
+                nodeIds.add(currentDict.getId());
+                collectChildrenIds(currentDict.getId(), nodeIds);
+            }
+        }
+        
+        // 收集所有需要返回的节点数据
+        Map<Integer, StoreDictionary> allNodeMap = new HashMap<>();
+        for (Set<Integer> nodeIds : rootToNodeIdsMap.values()) {
+            for (Integer nodeId : nodeIds) {
+                if (!allNodeMap.containsKey(nodeId)) {
+                    StoreDictionary node = storeDictionaryMapper.selectById(nodeId);
+                    if (node != null && node.getDeleteFlag() == 0) {
+                        allNodeMap.put(nodeId, node);
+                    }
+                }
+            }
+        }
+        
+        log.info("总共收集到{}个节点", allNodeMap.size());
+        
+        // 构建树形结构，为每个唯一的根节点构建一棵树
+        List<StoreDictionary> resultList = new ArrayList<>();
+        
+        for (Map.Entry<Integer, Set<Integer>> entry : rootToNodeIdsMap.entrySet()) {
+            Integer rootId = entry.getKey();
+            Set<Integer> nodeIds = entry.getValue();
+            
+            log.info("处理根节点[{}], 包含{}个节点", rootId, nodeIds.size());
+            
+            // 从所有节点中筛选出该根节点下的相关节点
+            List<StoreDictionary> relatedNodes = new ArrayList<>();
+            for (Integer nodeId : nodeIds) {
+                StoreDictionary node = allNodeMap.get(nodeId);
+                if (node != null) {
+                    relatedNodes.add(node);
+                }
+            }
+            
+            log.info("根节点[{}]筛选出{}个相关节点", rootId, relatedNodes.size());
+            
+            // 如果找到相关节点，构建树形结构
+            if (!relatedNodes.isEmpty()) {
+                StoreDictionary root = buildTreeFromNodeList(relatedNodes, rootId);
+                if (root != null) {
+                    resultList.add(root);
+                    log.info("成功构建根节点[{}]的树形结构", rootId);
+                } else {
+                    log.warn("构建根节点[{}]的树形结构失败", rootId);
+                }
+            } else {
+                log.warn("根节点[{}]没有相关节点", rootId);
+            }
+        }
+        
+        log.info("最终返回{}棵树", resultList.size());
+        return resultList;
+    }
+    
+    /**
+     * 收集节点的所有子节点ID（递归）
+     *
+     * @param nodeId 节点ID
+     * @param childrenIds 子节点ID集合
+     */
+    private void collectChildrenIds(Integer nodeId, Set<Integer> childrenIds) {
+        LambdaQueryWrapper<StoreDictionary> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.in(StoreDictionary::getTypeName, "opinion_feedback", "opinion_feedback_type", "opinion_feedback_classify");
+        queryWrapper.eq(StoreDictionary::getDeleteFlag, 0);
+        queryWrapper.eq(StoreDictionary::getParentId, nodeId);
+        
+        List<StoreDictionary> children = storeDictionaryMapper.selectList(queryWrapper);
+        
+        if (children != null && !children.isEmpty()) {
+            for (StoreDictionary child : children) {
+                if (!childrenIds.contains(child.getId())) {
+                    childrenIds.add(child.getId());
+                    collectChildrenIds(child.getId(), childrenIds);
+                }
+            }
+        }
+    }
+
+    /**
+     * 递归查找根节点ID
+     *
+     * @param id 当前节点ID
+     * @return 根节点ID
+     */
+    private Integer findRootId(Integer id) {
+        StoreDictionary dict = storeDictionaryMapper.selectById(id);
+        if (dict == null || dict.getDeleteFlag() == 1) {
+            // 如果节点不存在或已删除，返回当前ID作为根节点
+            return id;
+        }
+        
+        Integer parentId = dict.getParentId();
+        if (parentId == null || parentId == 0) {
+            return id;
+        }
+        
+        return findRootId(parentId);
+    }
+
+    /**
+     * 收集从当前节点到根节点的路径上的所有节点ID
+     *
+     * @param nodeId 当前节点ID
+     * @param pathNodeIds 路径节点ID列表
+     */
+    private void collectPathNodes(Integer nodeId, List<Integer> pathNodeIds) {
+        StoreDictionary dict = storeDictionaryMapper.selectById(nodeId);
+        if (dict == null || dict.getDeleteFlag() == 1) {
+            return;
+        }
+        
+        // 避免重复添加
+        if (!pathNodeIds.contains(nodeId)) {
+            pathNodeIds.add(nodeId);
+        }
+        
+        Integer parentId = dict.getParentId();
+        if (parentId != null && parentId != 0) {
+            collectPathNodes(parentId, pathNodeIds);
+        }
+    }
+
+    /**
+     * 从节点列表构建树形结构
+     *
+     * @param nodeList 节点列表
+     * @param rootId 根节点ID
+     * @return 根节点
+     */
+    private StoreDictionary buildTreeFromNodeList(List<StoreDictionary> nodeList, Integer rootId) {
+        // 创建ID到节点的映射
+        Map<Integer, StoreDictionary> nodeMap = new HashMap<>();
+        for (StoreDictionary node : nodeList) {
+            nodeMap.put(node.getId(), node);
+            node.setStoreDictionaryList(new ArrayList<>());
+        }
+        
+        // 找到根节点
+        StoreDictionary root = nodeMap.get(rootId);
+        if (root == null) {
+            return null;
+        }
+        
+        // 建立父子关系
+        for (StoreDictionary node : nodeList) {
+            if (node.getId().equals(rootId)) {
+                continue; // 跳过根节点
+            }
+            
+            Integer parentId = node.getParentId();
+            if (parentId != null && parentId != 0) {
+                StoreDictionary parent = nodeMap.get(parentId);
+                if (parent != null) {
+                    parent.getStoreDictionaryList().add(node);
+                }
+            }
+        }
+        
+        // 对子节点列表按sortId排序
+        sortChildren(root);
+        
+        return root;
+    }
+
+    /**
+     * 递归排序子节点
+     *
+     * @param node 节点
+     */
+    private void sortChildren(StoreDictionary node) {
+        if (node == null || node.getStoreDictionaryList() == null) {
+            return;
+        }
+        
+        node.getStoreDictionaryList().sort((a, b) -> {
+            Integer sortIdA = a.getSortId() != null ? a.getSortId() : 0;
+            Integer sortIdB = b.getSortId() != null ? b.getSortId() : 0;
+            return sortIdA.compareTo(sortIdB);
+        });
+        
+        // 递归排序所有子节点
+        for (StoreDictionary child : node.getStoreDictionaryList()) {
+            sortChildren(child);
+        }
+    }
 
     /**
      * 构建树形结构（优化版）

alien-store/src/main/java/shop/alien/store/service/impl/DictStoreTagServiceImpl.java

@@ -38,8 +38,10 @@ import java.net.URLEncoder;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * 店铺字典标签管理ServiceImpl
@@ -55,11 +57,20 @@ public class DictStoreTagServiceImpl extends ServiceImpl<StoreDictionaryMapper,
 
     /**
      * 查询店铺字典标签（三级树形结构）
+     * 如果传入dictDetail，则查询匹配的记录及其父级和子级树形结构
+     * 如果不传dictDetail，则返回完整的字典库树形结构
      *
+     * @param dictDetail 字典描述（可选），如果传入则根据此参数过滤
      * @return 标签树形结构列表
      */
     @Override
-    public List<StoreDictionary> queryDictStoreTagTree() {
+    public List<StoreDictionary> queryDictStoreTagTree(String dictDetail) {
+        // 如果传入了dictDetail，使用过滤逻辑
+        if (StringUtils.isNotBlank(dictDetail)) {
+            return selectDictBydictDetail(dictDetail);
+        }
+        
+        // 否则使用原有逻辑：查询所有店铺标签字典数据
         LambdaQueryWrapper<StoreDictionary> queryWrapper = new LambdaQueryWrapper<>();
         queryWrapper.in(StoreDictionary::getTypeName, "store_tag", "store_tag_type", "store_tag_classify");
         queryWrapper.eq(StoreDictionary::getDeleteFlag, 0);
@@ -68,6 +79,254 @@ public class DictStoreTagServiceImpl extends ServiceImpl<StoreDictionaryMapper,
 
         return buildTreeOptimized(dictStoreTags);
     }
+    
+    /**
+     * 根据dictDetail查询店铺标签字典（包含父级或子级树形结构）
+     * 支持查询多个同名数据及其父级和子级
+     *
+     * @param dictDetail 字典描述
+     * @return 店铺标签字典树形结构列表
+     */
+    private List<StoreDictionary> selectDictBydictDetail(String dictDetail) {
+        if (StringUtils.isBlank(dictDetail)) {
+            throw new IllegalArgumentException("dictDetail不能为空");
+        }
+
+        // 通过dictDetail模糊查询所有匹配的记录（可能有多个同名数据）
+        LambdaQueryWrapper<StoreDictionary> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.in(StoreDictionary::getTypeName, "store_tag", "store_tag_type", "store_tag_classify");
+        queryWrapper.eq(StoreDictionary::getDeleteFlag, 0);
+        queryWrapper.like(StoreDictionary::getDictDetail, dictDetail);
+        
+        List<StoreDictionary> matchedDicts = storeDictionaryMapper.selectList(queryWrapper);
+        
+        if (matchedDicts == null || matchedDicts.isEmpty()) {
+            log.warn("未找到dictDetail为[{}]的记录", dictDetail);
+            return new ArrayList<>();
+        }
+
+        log.info("找到{}条dictDetail为[{}]的记录", matchedDicts.size(), dictDetail);
+
+        // 用于存储每个根节点对应的所有节点（按根节点分组）
+        Map<Integer, Set<Integer>> rootToNodeIdsMap = new HashMap<>();
+        
+        // 遍历所有匹配的记录，收集相关节点ID
+        for (StoreDictionary currentDict : matchedDicts) {
+            Integer parentId = currentDict.getParentId();
+            Integer rootId;
+            
+            if (parentId != null && parentId != 0) {
+                // 如果有父级，查找根节点
+                rootId = findRootId(currentDict.getId());
+                log.info("记录ID[{}]有父级[{}], 根节点ID[{}]", currentDict.getId(), parentId, rootId);
+                
+                // 收集从根节点到当前节点的路径上的所有节点ID
+                List<Integer> pathNodeIds = new ArrayList<>();
+                collectPathNodes(currentDict.getId(), pathNodeIds);
+                log.info("路径节点IDs: {}", pathNodeIds);
+                
+                // 收集该根节点下的所有相关节点ID（包括路径节点及其所有子节点）
+                Set<Integer> nodeIds = rootToNodeIdsMap.computeIfAbsent(rootId, k -> new HashSet<>());
+                for (Integer nodeId : pathNodeIds) {
+                    nodeIds.add(nodeId);
+                    collectChildrenIds(nodeId, nodeIds);
+                }
+            } else {
+                // 如果没有父级，以当前节点为根
+                rootId = currentDict.getId();
+                log.info("记录ID[{}]没有父级, 作为根节点", currentDict.getId());
+                
+                // 收集该根节点下的所有相关节点ID
+                Set<Integer> nodeIds = rootToNodeIdsMap.computeIfAbsent(rootId, k -> new HashSet<>());
+                nodeIds.add(currentDict.getId());
+                collectChildrenIds(currentDict.getId(), nodeIds);
+            }
+        }
+        
+        // 收集所有需要返回的节点数据
+        Map<Integer, StoreDictionary> allNodeMap = new HashMap<>();
+        for (Set<Integer> nodeIds : rootToNodeIdsMap.values()) {
+            for (Integer nodeId : nodeIds) {
+                if (!allNodeMap.containsKey(nodeId)) {
+                    StoreDictionary node = storeDictionaryMapper.selectById(nodeId);
+                    if (node != null && node.getDeleteFlag() == 0) {
+                        allNodeMap.put(nodeId, node);
+                    }
+                }
+            }
+        }
+        
+        log.info("总共收集到{}个节点", allNodeMap.size());
+        
+        // 构建树形结构，为每个唯一的根节点构建一棵树
+        List<StoreDictionary> resultList = new ArrayList<>();
+        
+        for (Map.Entry<Integer, Set<Integer>> entry : rootToNodeIdsMap.entrySet()) {
+            Integer rootId = entry.getKey();
+            Set<Integer> nodeIds = entry.getValue();
+            
+            log.info("处理根节点[{}], 包含{}个节点", rootId, nodeIds.size());
+            
+            // 从所有节点中筛选出该根节点下的相关节点
+            List<StoreDictionary> relatedNodes = new ArrayList<>();
+            for (Integer nodeId : nodeIds) {
+                StoreDictionary node = allNodeMap.get(nodeId);
+                if (node != null) {
+                    relatedNodes.add(node);
+                }
+            }
+            
+            log.info("根节点[{}]筛选出{}个相关节点", rootId, relatedNodes.size());
+            
+            // 如果找到相关节点，构建树形结构
+            if (!relatedNodes.isEmpty()) {
+                StoreDictionary root = buildTreeFromNodeList(relatedNodes, rootId);
+                if (root != null) {
+                    resultList.add(root);
+                    log.info("成功构建根节点[{}]的树形结构", rootId);
+                } else {
+                    log.warn("构建根节点[{}]的树形结构失败", rootId);
+                }
+            } else {
+                log.warn("根节点[{}]没有相关节点", rootId);
+            }
+        }
+        
+        log.info("最终返回{}棵树", resultList.size());
+        return resultList;
+    }
+    
+    /**
+     * 收集节点的所有子节点ID（递归）
+     *
+     * @param nodeId 节点ID
+     * @param childrenIds 子节点ID集合
+     */
+    private void collectChildrenIds(Integer nodeId, Set<Integer> childrenIds) {
+        LambdaQueryWrapper<StoreDictionary> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.in(StoreDictionary::getTypeName, "store_tag", "store_tag_type", "store_tag_classify");
+        queryWrapper.eq(StoreDictionary::getDeleteFlag, 0);
+        queryWrapper.eq(StoreDictionary::getParentId, nodeId);
+        
+        List<StoreDictionary> children = storeDictionaryMapper.selectList(queryWrapper);
+        
+        if (children != null && !children.isEmpty()) {
+            for (StoreDictionary child : children) {
+                if (!childrenIds.contains(child.getId())) {
+                    childrenIds.add(child.getId());
+                    collectChildrenIds(child.getId(), childrenIds);
+                }
+            }
+        }
+    }
+
+    /**
+     * 递归查找根节点ID
+     *
+     * @param id 当前节点ID
+     * @return 根节点ID
+     */
+    private Integer findRootId(Integer id) {
+        StoreDictionary dict = storeDictionaryMapper.selectById(id);
+        if (dict == null || dict.getDeleteFlag() == 1) {
+            // 如果节点不存在或已删除，返回当前ID作为根节点
+            return id;
+        }
+        
+        Integer parentId = dict.getParentId();
+        if (parentId == null || parentId == 0) {
+            return id;
+        }
+        
+        return findRootId(parentId);
+    }
+
+    /**
+     * 收集从当前节点到根节点的路径上的所有节点ID
+     *
+     * @param nodeId 当前节点ID
+     * @param pathNodeIds 路径节点ID列表
+     */
+    private void collectPathNodes(Integer nodeId, List<Integer> pathNodeIds) {
+        StoreDictionary dict = storeDictionaryMapper.selectById(nodeId);
+        if (dict == null || dict.getDeleteFlag() == 1) {
+            return;
+        }
+        
+        // 避免重复添加
+        if (!pathNodeIds.contains(nodeId)) {
+            pathNodeIds.add(nodeId);
+        }
+        
+        Integer parentId = dict.getParentId();
+        if (parentId != null && parentId != 0) {
+            collectPathNodes(parentId, pathNodeIds);
+        }
+    }
+
+    /**
+     * 从节点列表构建树形结构
+     *
+     * @param nodeList 节点列表
+     * @param rootId 根节点ID
+     * @return 根节点
+     */
+    private StoreDictionary buildTreeFromNodeList(List<StoreDictionary> nodeList, Integer rootId) {
+        // 创建ID到节点的映射
+        Map<Integer, StoreDictionary> nodeMap = new HashMap<>();
+        for (StoreDictionary node : nodeList) {
+            nodeMap.put(node.getId(), node);
+            node.setStoreDictionaryList(new ArrayList<>());
+        }
+        
+        // 找到根节点
+        StoreDictionary root = nodeMap.get(rootId);
+        if (root == null) {
+            return null;
+        }
+        
+        // 建立父子关系
+        for (StoreDictionary node : nodeList) {
+            if (node.getId().equals(rootId)) {
+                continue; // 跳过根节点
+            }
+            
+            Integer parentId = node.getParentId();
+            if (parentId != null && parentId != 0) {
+                StoreDictionary parent = nodeMap.get(parentId);
+                if (parent != null) {
+                    parent.getStoreDictionaryList().add(node);
+                }
+            }
+        }
+        
+        // 对子节点列表按sortId排序
+        sortChildren(root);
+        
+        return root;
+    }
+
+    /**
+     * 递归排序子节点
+     *
+     * @param node 节点
+     */
+    private void sortChildren(StoreDictionary node) {
+        if (node == null || node.getStoreDictionaryList() == null) {
+            return;
+        }
+        
+        node.getStoreDictionaryList().sort((a, b) -> {
+            Integer sortIdA = a.getSortId() != null ? a.getSortId() : 0;
+            Integer sortIdB = b.getSortId() != null ? b.getSortId() : 0;
+            return sortIdA.compareTo(sortIdB);
+        });
+        
+        // 递归排序所有子节点
+        for (StoreDictionary child : node.getStoreDictionaryList()) {
+            sortChildren(child);
+        }
+    }
 
     /**
      * 构建树形结构

alien-store/src/main/java/shop/alien/store/service/impl/DictionaryLibraryServiceImpl.java

@@ -26,8 +26,10 @@ import java.net.URLEncoder;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * 平台字典库管理ServiceImpl
@@ -45,12 +47,20 @@ public class DictionaryLibraryServiceImpl extends ServiceImpl<StoreDictionaryMap
 
     /**
      * 查询字典库（三级树形结构）
+     * 如果传入dictDetail，则查询匹配的记录及其父级和子级树形结构
+     * 如果不传dictDetail，则返回完整的字典库树形结构
      *
+     * @param dictDetail 字典描述（可选），如果传入则根据此参数过滤
      * @return 字典库树形结构列表
      */
     @Override
-    public List<StoreDictionary> queryDictionaryLibraryTree() {
-        // 查询所有字典库数据
+    public List<StoreDictionary> queryDictionaryLibraryTree(String dictDetail) {
+        // 如果传入了dictDetail，使用过滤逻辑
+        if (StringUtils.isNotBlank(dictDetail)) {
+            return selectDictBydictDetail(dictDetail);
+        }
+        
+        // 否则使用原有逻辑：查询所有字典库数据
         LambdaQueryWrapper<StoreDictionary> queryWrapper = new LambdaQueryWrapper<>();
         queryWrapper.in(StoreDictionary::getTypeName, "report", "report_type", "report_classify");
         queryWrapper.eq(StoreDictionary::getDeleteFlag, 0);
@@ -951,5 +961,456 @@ public class DictionaryLibraryServiceImpl extends ServiceImpl<StoreDictionaryMap
             }
         }
     }
+
+    @Override
+    public int deleteDictionaryLibrary(Long id) {
+        return storeDictionaryMapper.deleteById(id);
+    }
+
+    /**
+     * 修改字典库状态（通过id修改hidden为1）
+     *
+     * @param id 字典库ID
+     * @return 修改结果
+     */
+    @Override
+    public int updateHiddenStatus(Long id) {
+        if (id == null) {
+            throw new IllegalArgumentException("ID不能为空");
+        }
+
+        // 查询原记录
+        StoreDictionary existing = storeDictionaryMapper.selectById(id);
+        if (existing == null) {
+            throw new IllegalArgumentException("记录不存在");
+        }
+        if (existing.getDeleteFlag() == 1) {
+            throw new IllegalArgumentException("该记录已删除");
+        }
+
+        // 设置hidden为1
+        existing.setHidden(1);
+        existing.setUpdatedTime(new Date());
+
+        // 更新记录
+        return storeDictionaryMapper.updateById(existing);
+    }
+
+    /**
+     * 根据dictDetail查询字典库（包含父级或子级树形结构）
+     * 支持查询多个同名数据及其父级和子级
+     *
+     * @param dictDetail 字典描述
+     * @return 字典库树形结构列表
+     */
+    @Override
+    public List<StoreDictionary> selectDictBydictDetail(String dictDetail) {
+        if (StringUtils.isBlank(dictDetail)) {
+            throw new IllegalArgumentException("dictDetail不能为空");
+        }
+
+        // 通过dictDetail模糊查询所有匹配的记录（可能有多个同名数据）
+        LambdaQueryWrapper<StoreDictionary> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.in(StoreDictionary::getTypeName, "report", "report_type", "report_classify");
+        queryWrapper.eq(StoreDictionary::getDeleteFlag, 0);
+        queryWrapper.like(StoreDictionary::getDictDetail, dictDetail);
+        
+        List<StoreDictionary> matchedDicts = storeDictionaryMapper.selectList(queryWrapper);
+        
+        if (matchedDicts == null || matchedDicts.isEmpty()) {
+            log.warn("未找到dictDetail为[{}]的记录", dictDetail);
+            return new ArrayList<>();
+        }
+
+        log.info("找到{}条dictDetail为[{}]的记录", matchedDicts.size(), dictDetail);
+
+        // 用于存储每个根节点对应的所有节点（按根节点分组）
+        Map<Integer, Set<Integer>> rootToNodeIdsMap = new HashMap<>();
+        
+        // 遍历所有匹配的记录，收集相关节点ID
+        for (StoreDictionary currentDict : matchedDicts) {
+            Integer parentId = currentDict.getParentId();
+            Integer rootId;
+            
+            if (parentId != null && parentId != 0) {
+                // 如果有父级，查找根节点
+                rootId = findRootId(currentDict.getId());
+                log.info("记录ID[{}]有父级[{}], 根节点ID[{}]", currentDict.getId(), parentId, rootId);
+                
+                // 收集从根节点到当前节点的路径上的所有节点ID
+                List<Integer> pathNodeIds = new ArrayList<>();
+                collectPathNodes(currentDict.getId(), pathNodeIds);
+                log.info("路径节点IDs: {}", pathNodeIds);
+                
+                // 收集该根节点下的所有相关节点ID（包括路径节点及其所有子节点）
+                Set<Integer> nodeIds = rootToNodeIdsMap.computeIfAbsent(rootId, k -> new HashSet<>());
+                for (Integer nodeId : pathNodeIds) {
+                    nodeIds.add(nodeId);
+                    collectChildrenIds(nodeId, nodeIds);
+                }
+            } else {
+                // 如果没有父级，以当前节点为根
+                rootId = currentDict.getId();
+                log.info("记录ID[{}]没有父级, 作为根节点", currentDict.getId());
+                
+                // 收集该根节点下的所有相关节点ID
+                Set<Integer> nodeIds = rootToNodeIdsMap.computeIfAbsent(rootId, k -> new HashSet<>());
+                nodeIds.add(currentDict.getId());
+                collectChildrenIds(currentDict.getId(), nodeIds);
+            }
+        }
+        
+        // 收集所有需要返回的节点数据
+        Map<Integer, StoreDictionary> allNodeMap = new HashMap<>();
+        for (Set<Integer> nodeIds : rootToNodeIdsMap.values()) {
+            for (Integer nodeId : nodeIds) {
+                if (!allNodeMap.containsKey(nodeId)) {
+                    StoreDictionary node = storeDictionaryMapper.selectById(nodeId);
+                    if (node != null && node.getDeleteFlag() == 0) {
+                        allNodeMap.put(nodeId, node);
+                    }
+                }
+            }
+        }
+        
+        log.info("总共收集到{}个节点", allNodeMap.size());
+        
+        // 构建树形结构，为每个唯一的根节点构建一棵树
+        List<StoreDictionary> resultList = new ArrayList<>();
+        
+        for (Map.Entry<Integer, Set<Integer>> entry : rootToNodeIdsMap.entrySet()) {
+            Integer rootId = entry.getKey();
+            Set<Integer> nodeIds = entry.getValue();
+            
+            log.info("处理根节点[{}], 包含{}个节点", rootId, nodeIds.size());
+            
+            // 从所有节点中筛选出该根节点下的相关节点
+            List<StoreDictionary> relatedNodes = new ArrayList<>();
+            for (Integer nodeId : nodeIds) {
+                StoreDictionary node = allNodeMap.get(nodeId);
+                if (node != null) {
+                    relatedNodes.add(node);
+                }
+            }
+            
+            log.info("根节点[{}]筛选出{}个相关节点", rootId, relatedNodes.size());
+            
+            // 如果找到相关节点，构建树形结构
+            if (!relatedNodes.isEmpty()) {
+                StoreDictionary root = buildTreeFromNodeList(relatedNodes, rootId);
+                if (root != null) {
+                    resultList.add(root);
+                    log.info("成功构建根节点[{}]的树形结构", rootId);
+                } else {
+                    log.warn("构建根节点[{}]的树形结构失败", rootId);
+                }
+            } else {
+                log.warn("根节点[{}]没有相关节点", rootId);
+            }
+        }
+        
+        log.info("最终返回{}棵树", resultList.size());
+        return resultList;
+    }
+    
+    /**
+     * 收集节点的所有子节点ID（递归）
+     *
+     * @param nodeId 节点ID
+     * @param childrenIds 子节点ID集合
+     */
+    private void collectChildrenIds(Integer nodeId, Set<Integer> childrenIds) {
+        LambdaQueryWrapper<StoreDictionary> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.in(StoreDictionary::getTypeName, "report", "report_type", "report_classify");
+        queryWrapper.eq(StoreDictionary::getDeleteFlag, 0);
+        queryWrapper.eq(StoreDictionary::getParentId, nodeId);
+        
+        List<StoreDictionary> children = storeDictionaryMapper.selectList(queryWrapper);
+        
+        if (children != null && !children.isEmpty()) {
+            for (StoreDictionary child : children) {
+                if (!childrenIds.contains(child.getId())) {
+                    childrenIds.add(child.getId());
+                    collectChildrenIds(child.getId(), childrenIds);
+                }
+            }
+        }
+    }
+
+    /**
+     * 递归查找根节点ID
+     *
+     * @param id 当前节点ID
+     * @return 根节点ID
+     */
+    private Integer findRootId(Integer id) {
+        StoreDictionary dict = storeDictionaryMapper.selectById(id);
+        if (dict == null || dict.getDeleteFlag() == 1) {
+            // 如果节点不存在或已删除，返回当前ID作为根节点
+            return id;
+        }
+        
+        Integer parentId = dict.getParentId();
+        if (parentId == null || parentId == 0) {
+            return id;
+        }
+        
+        return findRootId(parentId);
+    }
+
+    /**
+     * 收集从当前节点到根节点的路径上的所有节点ID
+     *
+     * @param nodeId 当前节点ID
+     * @param pathNodeIds 路径节点ID列表
+     */
+    private void collectPathNodes(Integer nodeId, List<Integer> pathNodeIds) {
+        StoreDictionary dict = storeDictionaryMapper.selectById(nodeId);
+        if (dict == null || dict.getDeleteFlag() == 1) {
+            return;
+        }
+        
+        // 避免重复添加
+        if (!pathNodeIds.contains(nodeId)) {
+            pathNodeIds.add(nodeId);
+        }
+        
+        Integer parentId = dict.getParentId();
+        if (parentId != null && parentId != 0) {
+            collectPathNodes(parentId, pathNodeIds);
+        }
+    }
+
+    /**
+     * 从树形结构中过滤出包含指定dictDetail的树
+     *
+     * @param treeList 树形结构列表
+     * @param dictDetail 字典描述
+     * @return 过滤后的树形结构列表
+     */
+    private List<StoreDictionary> filterTreeByDictDetail(List<StoreDictionary> treeList, String dictDetail) {
+        List<StoreDictionary> result = new ArrayList<>();
+        
+        for (StoreDictionary node : treeList) {
+            // 检查当前节点是否包含目标dictDetail
+            if (containsDictDetail(node, dictDetail)) {
+                // 如果包含，复制节点并保留树形结构
+                StoreDictionary filteredNode = filterNodeByDictDetail(node, dictDetail);
+                if (filteredNode != null) {
+                    result.add(filteredNode);
+                }
+            }
+        }
+        
+        return result;
+    }
+
+    /**
+     * 检查节点及其子树是否包含指定dictDetail
+     *
+     * @param node 节点
+     * @param dictDetail 字典描述
+     * @return 是否包含
+     */
+    private boolean containsDictDetail(StoreDictionary node, String dictDetail) {
+        if (node == null) {
+            return false;
+        }
+        
+        if (dictDetail.equals(node.getDictDetail())) {
+            return true;
+        }
+        
+        List<StoreDictionary> children = node.getStoreDictionaryList();
+        if (children != null && !children.isEmpty()) {
+            for (StoreDictionary child : children) {
+                if (containsDictDetail(child, dictDetail)) {
+                    return true;
+                }
+            }
+        }
+        
+        return false;
+    }
+
+    /**
+     * 过滤节点，只保留包含目标dictDetail的路径
+     *
+     * @param node 节点
+     * @param dictDetail 字典描述
+     * @return 过滤后的节点
+     */
+    private StoreDictionary filterNodeByDictDetail(StoreDictionary node, String dictDetail) {
+        if (node == null) {
+            return null;
+        }
+        
+        StoreDictionary result = new StoreDictionary();
+        result.setId(node.getId());
+        result.setTypeName(node.getTypeName());
+        result.setTypeDetail(node.getTypeDetail());
+        result.setParentId(node.getParentId());
+        result.setDictId(node.getDictId());
+        result.setDictDetail(node.getDictDetail());
+        result.setDeleteFlag(node.getDeleteFlag());
+        result.setCreatedTime(node.getCreatedTime());
+        result.setCreatedUserId(node.getCreatedUserId());
+        result.setUpdatedTime(node.getUpdatedTime());
+        result.setUpdatedUserId(node.getUpdatedUserId());
+        result.setHidden(node.getHidden());
+        result.setSortId(node.getSortId());
+        
+        List<StoreDictionary> filteredChildren = new ArrayList<>();
+        List<StoreDictionary> children = node.getStoreDictionaryList();
+        
+        if (children != null && !children.isEmpty()) {
+            for (StoreDictionary child : children) {
+                if (containsDictDetail(child, dictDetail)) {
+                    StoreDictionary filteredChild = filterNodeByDictDetail(child, dictDetail);
+                    if (filteredChild != null) {
+                        filteredChildren.add(filteredChild);
+                    }
+                }
+            }
+        }
+        
+        result.setStoreDictionaryList(filteredChildren);
+        
+        // 如果当前节点匹配，或者有子节点，则返回
+        if (dictDetail.equals(node.getDictDetail()) || !filteredChildren.isEmpty()) {
+            return result;
+        }
+        
+        return null;
+    }
+
+    /**
+     * 收集节点及其所有子节点
+     *
+     * @param nodeId 节点ID
+     * @param nodeList 节点列表
+     */
+    private void collectNodeAndChildren(Integer nodeId, List<StoreDictionary> nodeList) {
+        StoreDictionary node = storeDictionaryMapper.selectById(nodeId);
+        if (node == null || node.getDeleteFlag() == 1) {
+            return;
+        }
+        
+        // 检查是否已经添加过（避免重复）
+        boolean alreadyAdded = nodeList.stream().anyMatch(n -> n.getId().equals(nodeId));
+        if (!alreadyAdded) {
+            nodeList.add(node);
+        }
+        
+        // 查询所有子节点
+        LambdaQueryWrapper<StoreDictionary> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.in(StoreDictionary::getTypeName, "report", "report_type", "report_classify");
+        queryWrapper.eq(StoreDictionary::getDeleteFlag, 0);
+        queryWrapper.eq(StoreDictionary::getParentId, nodeId);
+        queryWrapper.orderByAsc(StoreDictionary::getSortId);
+        
+        List<StoreDictionary> children = storeDictionaryMapper.selectList(queryWrapper);
+        
+        if (children != null && !children.isEmpty()) {
+            for (StoreDictionary child : children) {
+                collectNodeAndChildren(child.getId(), nodeList);
+            }
+        }
+    }
+
+    /**
+     * 收集节点及其所有子节点（使用Map去重）
+     *
+     * @param nodeId 节点ID
+     * @param nodeMap 节点Map（用于去重）
+     */
+    private void collectNodeAndChildren(Integer nodeId, Map<Integer, StoreDictionary> nodeMap) {
+        StoreDictionary node = storeDictionaryMapper.selectById(nodeId);
+        if (node == null || node.getDeleteFlag() == 1) {
+            return;
+        }
+        
+        // 添加到Map（自动去重）
+        nodeMap.put(nodeId, node);
+        
+        // 查询所有子节点
+        LambdaQueryWrapper<StoreDictionary> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.in(StoreDictionary::getTypeName, "report", "report_type", "report_classify");
+        queryWrapper.eq(StoreDictionary::getDeleteFlag, 0);
+        queryWrapper.eq(StoreDictionary::getParentId, nodeId);
+        queryWrapper.orderByAsc(StoreDictionary::getSortId);
+        
+        List<StoreDictionary> children = storeDictionaryMapper.selectList(queryWrapper);
+        
+        if (children != null && !children.isEmpty()) {
+            for (StoreDictionary child : children) {
+                collectNodeAndChildren(child.getId(), nodeMap);
+            }
+        }
+    }
+
+    /**
+     * 从节点列表构建树形结构
+     *
+     * @param nodeList 节点列表
+     * @param rootId 根节点ID
+     * @return 根节点
+     */
+    private StoreDictionary buildTreeFromNodeList(List<StoreDictionary> nodeList, Integer rootId) {
+        // 创建ID到节点的映射
+        Map<Integer, StoreDictionary> nodeMap = new HashMap<>();
+        for (StoreDictionary node : nodeList) {
+            nodeMap.put(node.getId(), node);
+            node.setStoreDictionaryList(new ArrayList<>());
+        }
+        
+        // 找到根节点
+        StoreDictionary root = nodeMap.get(rootId);
+        if (root == null) {
+            return null;
+        }
+        
+        // 建立父子关系
+        for (StoreDictionary node : nodeList) {
+            if (node.getId().equals(rootId)) {
+                continue; // 跳过根节点
+            }
+            
+            Integer parentId = node.getParentId();
+            if (parentId != null && parentId != 0) {
+                StoreDictionary parent = nodeMap.get(parentId);
+                if (parent != null) {
+                    parent.getStoreDictionaryList().add(node);
+                }
+            }
+        }
+        
+        // 对子节点列表按sortId排序
+        sortChildren(root);
+        
+        return root;
+    }
+
+    /**
+     * 递归排序子节点
+     *
+     * @param node 节点
+     */
+    private void sortChildren(StoreDictionary node) {
+        if (node == null || node.getStoreDictionaryList() == null) {
+            return;
+        }
+        
+        node.getStoreDictionaryList().sort((a, b) -> {
+            Integer sortIdA = a.getSortId() != null ? a.getSortId() : 0;
+            Integer sortIdB = b.getSortId() != null ? b.getSortId() : 0;
+            return sortIdA.compareTo(sortIdB);
+        });
+        
+        // 递归排序所有子节点
+        for (StoreDictionary child : node.getStoreDictionaryList()) {
+            sortChildren(child);
+        }
+    }
 }
 

alien-store/src/main/java/shop/alien/store/service/impl/FilterConditionServiceImpl.java

@@ -27,8 +27,10 @@ import java.net.URLEncoder;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * 平台筛选条件管理ServiceImpl
@@ -46,12 +48,20 @@ public class FilterConditionServiceImpl extends ServiceImpl<StoreDictionaryMappe
 
     /**
      * 查询筛选条件（四级树形结构）
+     * 如果传入dictDetail，则查询匹配的记录及其父级和子级树形结构
+     * 如果不传dictDetail，则返回完整的字典库树形结构
      *
+     * @param dictDetail 字典描述（可选），如果传入则根据此参数过滤
      * @return 筛选条件树形结构列表
      */
     @Override
-    public List<StoreDictionary> queryFilterConditionTree() {
-        // 查询所有筛选条件数据
+    public List<StoreDictionary> queryFilterConditionTree(String dictDetail) {
+        // 如果传入了dictDetail，使用过滤逻辑
+        if (StringUtils.isNotBlank(dictDetail)) {
+            return selectDictBydictDetail(dictDetail);
+        }
+        
+        // 否则使用原有逻辑：查询所有筛选条件数据
         LambdaQueryWrapper<StoreDictionary> queryWrapper = new LambdaQueryWrapper<>();
         queryWrapper.in(StoreDictionary::getTypeName, "filter_condition","filter_condition_type","filter_condition_classify", "filter_condition_timeRange");
         queryWrapper.eq(StoreDictionary::getDeleteFlag, 0);
@@ -61,6 +71,254 @@ public class FilterConditionServiceImpl extends ServiceImpl<StoreDictionaryMappe
         // 构建四级树形结构
         return buildTreeOptimized(filterConditionList);
     }
+    
+    /**
+     * 根据dictDetail查询筛选条件（包含父级或子级树形结构）
+     * 支持查询多个同名数据及其父级和子级
+     *
+     * @param dictDetail 字典描述
+     * @return 筛选条件树形结构列表
+     */
+    private List<StoreDictionary> selectDictBydictDetail(String dictDetail) {
+        if (StringUtils.isBlank(dictDetail)) {
+            throw new IllegalArgumentException("dictDetail不能为空");
+        }
+
+        // 通过dictDetail模糊查询所有匹配的记录（可能有多个同名数据）
+        LambdaQueryWrapper<StoreDictionary> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.in(StoreDictionary::getTypeName, "filter_condition","filter_condition_type","filter_condition_classify", "filter_condition_timeRange");
+        queryWrapper.eq(StoreDictionary::getDeleteFlag, 0);
+        queryWrapper.like(StoreDictionary::getDictDetail, dictDetail);
+        
+        List<StoreDictionary> matchedDicts = storeDictionaryMapper.selectList(queryWrapper);
+        
+        if (matchedDicts == null || matchedDicts.isEmpty()) {
+            log.warn("未找到dictDetail为[{}]的记录", dictDetail);
+            return new ArrayList<>();
+        }
+
+        log.info("找到{}条dictDetail为[{}]的记录", matchedDicts.size(), dictDetail);
+
+        // 用于存储每个根节点对应的所有节点（按根节点分组）
+        Map<Integer, Set<Integer>> rootToNodeIdsMap = new HashMap<>();
+        
+        // 遍历所有匹配的记录，收集相关节点ID
+        for (StoreDictionary currentDict : matchedDicts) {
+            Integer parentId = currentDict.getParentId();
+            Integer rootId;
+            
+            if (parentId != null && parentId != 0) {
+                // 如果有父级，查找根节点
+                rootId = findRootId(currentDict.getId());
+                log.info("记录ID[{}]有父级[{}], 根节点ID[{}]", currentDict.getId(), parentId, rootId);
+                
+                // 收集从根节点到当前节点的路径上的所有节点ID
+                List<Integer> pathNodeIds = new ArrayList<>();
+                collectPathNodes(currentDict.getId(), pathNodeIds);
+                log.info("路径节点IDs: {}", pathNodeIds);
+                
+                // 收集该根节点下的所有相关节点ID（包括路径节点及其所有子节点）
+                Set<Integer> nodeIds = rootToNodeIdsMap.computeIfAbsent(rootId, k -> new HashSet<>());
+                for (Integer nodeId : pathNodeIds) {
+                    nodeIds.add(nodeId);
+                    collectChildrenIds(nodeId, nodeIds);
+                }
+            } else {
+                // 如果没有父级，以当前节点为根
+                rootId = currentDict.getId();
+                log.info("记录ID[{}]没有父级, 作为根节点", currentDict.getId());
+                
+                // 收集该根节点下的所有相关节点ID
+                Set<Integer> nodeIds = rootToNodeIdsMap.computeIfAbsent(rootId, k -> new HashSet<>());
+                nodeIds.add(currentDict.getId());
+                collectChildrenIds(currentDict.getId(), nodeIds);
+            }
+        }
+        
+        // 收集所有需要返回的节点数据
+        Map<Integer, StoreDictionary> allNodeMap = new HashMap<>();
+        for (Set<Integer> nodeIds : rootToNodeIdsMap.values()) {
+            for (Integer nodeId : nodeIds) {
+                if (!allNodeMap.containsKey(nodeId)) {
+                    StoreDictionary node = storeDictionaryMapper.selectById(nodeId);
+                    if (node != null && node.getDeleteFlag() == 0) {
+                        allNodeMap.put(nodeId, node);
+                    }
+                }
+            }
+        }
+        
+        log.info("总共收集到{}个节点", allNodeMap.size());
+        
+        // 构建树形结构，为每个唯一的根节点构建一棵树
+        List<StoreDictionary> resultList = new ArrayList<>();
+        
+        for (Map.Entry<Integer, Set<Integer>> entry : rootToNodeIdsMap.entrySet()) {
+            Integer rootId = entry.getKey();
+            Set<Integer> nodeIds = entry.getValue();
+            
+            log.info("处理根节点[{}], 包含{}个节点", rootId, nodeIds.size());
+            
+            // 从所有节点中筛选出该根节点下的相关节点
+            List<StoreDictionary> relatedNodes = new ArrayList<>();
+            for (Integer nodeId : nodeIds) {
+                StoreDictionary node = allNodeMap.get(nodeId);
+                if (node != null) {
+                    relatedNodes.add(node);
+                }
+            }
+            
+            log.info("根节点[{}]筛选出{}个相关节点", rootId, relatedNodes.size());
+            
+            // 如果找到相关节点，构建树形结构
+            if (!relatedNodes.isEmpty()) {
+                StoreDictionary root = buildTreeFromNodeList(relatedNodes, rootId);
+                if (root != null) {
+                    resultList.add(root);
+                    log.info("成功构建根节点[{}]的树形结构", rootId);
+                } else {
+                    log.warn("构建根节点[{}]的树形结构失败", rootId);
+                }
+            } else {
+                log.warn("根节点[{}]没有相关节点", rootId);
+            }
+        }
+        
+        log.info("最终返回{}棵树", resultList.size());
+        return resultList;
+    }
+    
+    /**
+     * 收集节点的所有子节点ID（递归）
+     *
+     * @param nodeId 节点ID
+     * @param childrenIds 子节点ID集合
+     */
+    private void collectChildrenIds(Integer nodeId, Set<Integer> childrenIds) {
+        LambdaQueryWrapper<StoreDictionary> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.in(StoreDictionary::getTypeName, "filter_condition","filter_condition_type","filter_condition_classify", "filter_condition_timeRange");
+        queryWrapper.eq(StoreDictionary::getDeleteFlag, 0);
+        queryWrapper.eq(StoreDictionary::getParentId, nodeId);
+        
+        List<StoreDictionary> children = storeDictionaryMapper.selectList(queryWrapper);
+        
+        if (children != null && !children.isEmpty()) {
+            for (StoreDictionary child : children) {
+                if (!childrenIds.contains(child.getId())) {
+                    childrenIds.add(child.getId());
+                    collectChildrenIds(child.getId(), childrenIds);
+                }
+            }
+        }
+    }
+
+    /**
+     * 递归查找根节点ID
+     *
+     * @param id 当前节点ID
+     * @return 根节点ID
+     */
+    private Integer findRootId(Integer id) {
+        StoreDictionary dict = storeDictionaryMapper.selectById(id);
+        if (dict == null || dict.getDeleteFlag() == 1) {
+            // 如果节点不存在或已删除，返回当前ID作为根节点
+            return id;
+        }
+        
+        Integer parentId = dict.getParentId();
+        if (parentId == null || parentId == 0) {
+            return id;
+        }
+        
+        return findRootId(parentId);
+    }
+
+    /**
+     * 收集从当前节点到根节点的路径上的所有节点ID
+     *
+     * @param nodeId 当前节点ID
+     * @param pathNodeIds 路径节点ID列表
+     */
+    private void collectPathNodes(Integer nodeId, List<Integer> pathNodeIds) {
+        StoreDictionary dict = storeDictionaryMapper.selectById(nodeId);
+        if (dict == null || dict.getDeleteFlag() == 1) {
+            return;
+        }
+        
+        // 避免重复添加
+        if (!pathNodeIds.contains(nodeId)) {
+            pathNodeIds.add(nodeId);
+        }
+        
+        Integer parentId = dict.getParentId();
+        if (parentId != null && parentId != 0) {
+            collectPathNodes(parentId, pathNodeIds);
+        }
+    }
+
+    /**
+     * 从节点列表构建树形结构
+     *
+     * @param nodeList 节点列表
+     * @param rootId 根节点ID
+     * @return 根节点
+     */
+    private StoreDictionary buildTreeFromNodeList(List<StoreDictionary> nodeList, Integer rootId) {
+        // 创建ID到节点的映射
+        Map<Integer, StoreDictionary> nodeMap = new HashMap<>();
+        for (StoreDictionary node : nodeList) {
+            nodeMap.put(node.getId(), node);
+            node.setStoreDictionaryList(new ArrayList<>());
+        }
+        
+        // 找到根节点
+        StoreDictionary root = nodeMap.get(rootId);
+        if (root == null) {
+            return null;
+        }
+        
+        // 建立父子关系
+        for (StoreDictionary node : nodeList) {
+            if (node.getId().equals(rootId)) {
+                continue; // 跳过根节点
+            }
+            
+            Integer parentId = node.getParentId();
+            if (parentId != null && parentId != 0) {
+                StoreDictionary parent = nodeMap.get(parentId);
+                if (parent != null) {
+                    parent.getStoreDictionaryList().add(node);
+                }
+            }
+        }
+        
+        // 对子节点列表按sortId排序
+        sortChildren(root);
+        
+        return root;
+    }
+
+    /**
+     * 递归排序子节点
+     *
+     * @param node 节点
+     */
+    private void sortChildren(StoreDictionary node) {
+        if (node == null || node.getStoreDictionaryList() == null) {
+            return;
+        }
+        
+        node.getStoreDictionaryList().sort((a, b) -> {
+            Integer sortIdA = a.getSortId() != null ? a.getSortId() : 0;
+            Integer sortIdB = b.getSortId() != null ? b.getSortId() : 0;
+            return sortIdA.compareTo(sortIdB);
+        });
+        
+        // 递归排序所有子节点
+        for (StoreDictionary child : node.getStoreDictionaryList()) {
+            sortChildren(child);
+        }
+    }
 
     /**
      * 构建树形结构（优化版）

alien-store/src/main/java/shop/alien/store/service/impl/LifeUserViolationServiceImpl.java

@@ -730,7 +730,7 @@ public class LifeUserViolationServiceImpl extends ServiceImpl<LifeUserViolationM
     }
 
     @Override
-    public IPage<LifeUserViolationDto> getAllViolationPage(int page, int size, String nickName, String phone, String processingStatus, String startTime, String endTime) {
+    public IPage<LifeUserViolationDto> getAllViolationPage(int page, int size, String nickName, String phone, String processingStatus, String startTime, String endTime, String reportContextType) {
         IPage<LifeUserViolationVo> pageRequest = new Page<>(page, size);
         QueryWrapper<LifeUserViolationVo> queryWrapper = new QueryWrapper<>();
 
@@ -741,6 +741,10 @@ public class LifeUserViolationServiceImpl extends ServiceImpl<LifeUserViolationM
         if (StringUtils.isNotEmpty(processingStatus)) {
             queryWrapper.eq("processing_status", processingStatus);
         }
+
+        if (StringUtils.isNotEmpty(reportContextType)) {
+            queryWrapper.eq("report_context_type", reportContextType);
+        }
         // 根据开始时间和结束时间过滤
         if (StringUtils.isNotEmpty(startTime)) {
             queryWrapper.ge("created_time", startTime);

alien-store/src/main/java/shop/alien/store/service/impl/PlatformBusinessSectionServiceImpl.java

@@ -26,8 +26,10 @@ import java.net.URLEncoder;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * 平台经营版块管理ServiceImpl
@@ -45,12 +47,20 @@ public class PlatformBusinessSectionServiceImpl extends ServiceImpl<StoreDiction
 
     /**
      * 查询经营种类（三级树形结构）
+     * 如果传入dictDetail，则查询匹配的记录及其父级和子级树形结构
+     * 如果不传dictDetail，则返回完整的字典库树形结构
      *
+     * @param dictDetail 字典描述（可选），如果传入则根据此参数过滤
      * @return 经营种类树形结构列表
      */
     @Override
-    public List<StoreDictionary> queryBusinessSectionTree() {
-        // 查询所有经营种类数据
+    public List<StoreDictionary> queryBusinessSectionTree(String dictDetail) {
+        // 如果传入了dictDetail，使用过滤逻辑
+        if (StringUtils.isNotBlank(dictDetail)) {
+            return selectDictBydictDetail(dictDetail);
+        }
+        
+        // 否则使用原有逻辑：查询所有经营种类数据
         LambdaQueryWrapper<StoreDictionary> queryWrapper = new LambdaQueryWrapper<>();
         queryWrapper.in(StoreDictionary::getTypeName, "business_section","business_type","business_classify");
         queryWrapper.eq(StoreDictionary::getDeleteFlag, 0);
@@ -60,6 +70,254 @@ public class PlatformBusinessSectionServiceImpl extends ServiceImpl<StoreDiction
         // 构建三级树形结构
         return buildTreeOptimized(storeDictionaryList);
     }
+    
+    /**
+     * 根据dictDetail查询经营种类（包含父级或子级树形结构）
+     * 支持查询多个同名数据及其父级和子级
+     *
+     * @param dictDetail 字典描述
+     * @return 经营种类树形结构列表
+     */
+    private List<StoreDictionary> selectDictBydictDetail(String dictDetail) {
+        if (StringUtils.isBlank(dictDetail)) {
+            throw new IllegalArgumentException("dictDetail不能为空");
+        }
+
+        // 通过dictDetail模糊查询所有匹配的记录（可能有多个同名数据）
+        LambdaQueryWrapper<StoreDictionary> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.in(StoreDictionary::getTypeName, "business_section","business_type","business_classify");
+        queryWrapper.eq(StoreDictionary::getDeleteFlag, 0);
+        queryWrapper.like(StoreDictionary::getDictDetail, dictDetail);
+        
+        List<StoreDictionary> matchedDicts = storeDictionaryMapper.selectList(queryWrapper);
+        
+        if (matchedDicts == null || matchedDicts.isEmpty()) {
+            log.warn("未找到dictDetail为[{}]的记录", dictDetail);
+            return new ArrayList<>();
+        }
+
+        log.info("找到{}条dictDetail为[{}]的记录", matchedDicts.size(), dictDetail);
+
+        // 用于存储每个根节点对应的所有节点（按根节点分组）
+        Map<Integer, Set<Integer>> rootToNodeIdsMap = new HashMap<>();
+        
+        // 遍历所有匹配的记录，收集相关节点ID
+        for (StoreDictionary currentDict : matchedDicts) {
+            Integer parentId = currentDict.getParentId();
+            Integer rootId;
+            
+            if (parentId != null && parentId != 0) {
+                // 如果有父级，查找根节点
+                rootId = findRootId(currentDict.getId());
+                log.info("记录ID[{}]有父级[{}], 根节点ID[{}]", currentDict.getId(), parentId, rootId);
+                
+                // 收集从根节点到当前节点的路径上的所有节点ID
+                List<Integer> pathNodeIds = new ArrayList<>();
+                collectPathNodes(currentDict.getId(), pathNodeIds);
+                log.info("路径节点IDs: {}", pathNodeIds);
+                
+                // 收集该根节点下的所有相关节点ID（包括路径节点及其所有子节点）
+                Set<Integer> nodeIds = rootToNodeIdsMap.computeIfAbsent(rootId, k -> new HashSet<>());
+                for (Integer nodeId : pathNodeIds) {
+                    nodeIds.add(nodeId);
+                    collectChildrenIds(nodeId, nodeIds);
+                }
+            } else {
+                // 如果没有父级，以当前节点为根
+                rootId = currentDict.getId();
+                log.info("记录ID[{}]没有父级, 作为根节点", currentDict.getId());
+                
+                // 收集该根节点下的所有相关节点ID
+                Set<Integer> nodeIds = rootToNodeIdsMap.computeIfAbsent(rootId, k -> new HashSet<>());
+                nodeIds.add(currentDict.getId());
+                collectChildrenIds(currentDict.getId(), nodeIds);
+            }
+        }
+        
+        // 收集所有需要返回的节点数据
+        Map<Integer, StoreDictionary> allNodeMap = new HashMap<>();
+        for (Set<Integer> nodeIds : rootToNodeIdsMap.values()) {
+            for (Integer nodeId : nodeIds) {
+                if (!allNodeMap.containsKey(nodeId)) {
+                    StoreDictionary node = storeDictionaryMapper.selectById(nodeId);
+                    if (node != null && node.getDeleteFlag() == 0) {
+                        allNodeMap.put(nodeId, node);
+                    }
+                }
+            }
+        }
+        
+        log.info("总共收集到{}个节点", allNodeMap.size());
+        
+        // 构建树形结构，为每个唯一的根节点构建一棵树
+        List<StoreDictionary> resultList = new ArrayList<>();
+        
+        for (Map.Entry<Integer, Set<Integer>> entry : rootToNodeIdsMap.entrySet()) {
+            Integer rootId = entry.getKey();
+            Set<Integer> nodeIds = entry.getValue();
+            
+            log.info("处理根节点[{}], 包含{}个节点", rootId, nodeIds.size());
+            
+            // 从所有节点中筛选出该根节点下的相关节点
+            List<StoreDictionary> relatedNodes = new ArrayList<>();
+            for (Integer nodeId : nodeIds) {
+                StoreDictionary node = allNodeMap.get(nodeId);
+                if (node != null) {
+                    relatedNodes.add(node);
+                }
+            }
+            
+            log.info("根节点[{}]筛选出{}个相关节点", rootId, relatedNodes.size());
+            
+            // 如果找到相关节点，构建树形结构
+            if (!relatedNodes.isEmpty()) {
+                StoreDictionary root = buildTreeFromNodeList(relatedNodes, rootId);
+                if (root != null) {
+                    resultList.add(root);
+                    log.info("成功构建根节点[{}]的树形结构", rootId);
+                } else {
+                    log.warn("构建根节点[{}]的树形结构失败", rootId);
+                }
+            } else {
+                log.warn("根节点[{}]没有相关节点", rootId);
+            }
+        }
+        
+        log.info("最终返回{}棵树", resultList.size());
+        return resultList;
+    }
+    
+    /**
+     * 收集节点的所有子节点ID（递归）
+     *
+     * @param nodeId 节点ID
+     * @param childrenIds 子节点ID集合
+     */
+    private void collectChildrenIds(Integer nodeId, Set<Integer> childrenIds) {
+        LambdaQueryWrapper<StoreDictionary> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.in(StoreDictionary::getTypeName, "business_section","business_type","business_classify");
+        queryWrapper.eq(StoreDictionary::getDeleteFlag, 0);
+        queryWrapper.eq(StoreDictionary::getParentId, nodeId);
+        
+        List<StoreDictionary> children = storeDictionaryMapper.selectList(queryWrapper);
+        
+        if (children != null && !children.isEmpty()) {
+            for (StoreDictionary child : children) {
+                if (!childrenIds.contains(child.getId())) {
+                    childrenIds.add(child.getId());
+                    collectChildrenIds(child.getId(), childrenIds);
+                }
+            }
+        }
+    }
+
+    /**
+     * 递归查找根节点ID
+     *
+     * @param id 当前节点ID
+     * @return 根节点ID
+     */
+    private Integer findRootId(Integer id) {
+        StoreDictionary dict = storeDictionaryMapper.selectById(id);
+        if (dict == null || dict.getDeleteFlag() == 1) {
+            // 如果节点不存在或已删除，返回当前ID作为根节点
+            return id;
+        }
+        
+        Integer parentId = dict.getParentId();
+        if (parentId == null || parentId == 0) {
+            return id;
+        }
+        
+        return findRootId(parentId);
+    }
+
+    /**
+     * 收集从当前节点到根节点的路径上的所有节点ID
+     *
+     * @param nodeId 当前节点ID
+     * @param pathNodeIds 路径节点ID列表
+     */
+    private void collectPathNodes(Integer nodeId, List<Integer> pathNodeIds) {
+        StoreDictionary dict = storeDictionaryMapper.selectById(nodeId);
+        if (dict == null || dict.getDeleteFlag() == 1) {
+            return;
+        }
+        
+        // 避免重复添加
+        if (!pathNodeIds.contains(nodeId)) {
+            pathNodeIds.add(nodeId);
+        }
+        
+        Integer parentId = dict.getParentId();
+        if (parentId != null && parentId != 0) {
+            collectPathNodes(parentId, pathNodeIds);
+        }
+    }
+
+    /**
+     * 从节点列表构建树形结构
+     *
+     * @param nodeList 节点列表
+     * @param rootId 根节点ID
+     * @return 根节点
+     */
+    private StoreDictionary buildTreeFromNodeList(List<StoreDictionary> nodeList, Integer rootId) {
+        // 创建ID到节点的映射
+        Map<Integer, StoreDictionary> nodeMap = new HashMap<>();
+        for (StoreDictionary node : nodeList) {
+            nodeMap.put(node.getId(), node);
+            node.setStoreDictionaryList(new ArrayList<>());
+        }
+        
+        // 找到根节点
+        StoreDictionary root = nodeMap.get(rootId);
+        if (root == null) {
+            return null;
+        }
+        
+        // 建立父子关系
+        for (StoreDictionary node : nodeList) {
+            if (node.getId().equals(rootId)) {
+                continue; // 跳过根节点
+            }
+            
+            Integer parentId = node.getParentId();
+            if (parentId != null && parentId != 0) {
+                StoreDictionary parent = nodeMap.get(parentId);
+                if (parent != null) {
+                    parent.getStoreDictionaryList().add(node);
+                }
+            }
+        }
+        
+        // 对子节点列表按sortId排序
+        sortChildren(root);
+        
+        return root;
+    }
+
+    /**
+     * 递归排序子节点
+     *
+     * @param node 节点
+     */
+    private void sortChildren(StoreDictionary node) {
+        if (node == null || node.getStoreDictionaryList() == null) {
+            return;
+        }
+        
+        node.getStoreDictionaryList().sort((a, b) -> {
+            Integer sortIdA = a.getSortId() != null ? a.getSortId() : 0;
+            Integer sortIdB = b.getSortId() != null ? b.getSortId() : 0;
+            return sortIdA.compareTo(sortIdB);
+        });
+        
+        // 递归排序所有子节点
+        for (StoreDictionary child : node.getStoreDictionaryList()) {
+            sortChildren(child);
+        }
+    }
 
     /**
      * 构建树形结构（优化版）

alien-store/src/main/java/shop/alien/store/service/impl/StoreInfoServiceImpl.java

@@ -520,11 +520,14 @@ public class StoreInfoServiceImpl extends ServiceImpl<StoreInfoMapper, StoreInfo
     }
 
     @Override
-    public IPage<StoreInfoVo> getNewStorePage(int page, int size, String storeName, String storeContact, String id, String storePhone, String storeType, String expiredState, String storeApplicationStatus, String storeStatus, String businessSection, String jingdu, String weidu, String renewContractStatus, String foodLicenceStatus, String foodLicenceWhetherExpiredStatus) {
+    public IPage<StoreInfoVo> getNewStorePage(int page, int size, String storeName, String storeContact, String id, String storePhone, String storeType, String expiredState, String storeApplicationStatus, String storeStatus, String businessSection, String jingdu, String weidu, String renewContractStatus, String foodLicenceStatus, String foodLicenceWhetherExpiredStatus, String startApplyTime, String endApplyTime) {
         checkAndUpdateExpiredRecords();
         IPage<StoreInfoVo> iPage = new Page<>(page, size);
         QueryWrapper<StoreInfoVo> queryWrapper = new QueryWrapper<>();
         queryWrapper.like(storeName != null && !storeName.isEmpty(), "a.store_name", storeName).like(storeContact != null && !storeContact.isEmpty(), "b.name", storeContact).like(storePhone != null && !storePhone.isEmpty(), "b.phone", storePhone).like(storeType != null && !storeType.isEmpty(), "a.store_type", storeType).eq(StringUtils.isNotEmpty(storeApplicationStatus), "a.store_application_status", storeApplicationStatus).eq(StringUtils.isNotEmpty(businessSection), "a.business_section", businessSection).eq(StringUtils.isNotEmpty(storeStatus), "a.store_status", storeStatus).eq(StringUtils.isNotEmpty(renewContractStatus), "a.renew_contract_status", renewContractStatus).eq(StringUtils.isNotEmpty(foodLicenceStatus), "a.food_licence_status", foodLicenceStatus).like(StringUtils.isNotEmpty(id), "a.id", id).eq("a.delete_flag", 0).eq("b.delete_flag", 0).orderByDesc("a.created_time");
+        if (StringUtils.isNotEmpty(startApplyTime) && StringUtils.isNotEmpty(endApplyTime)) {
+            queryWrapper.between("a.created_time", startApplyTime,endApplyTime);
+        }
         //如果查询未过期
         // 获取当前时刻
         Date currentDate = new Date();
@@ -1865,6 +1868,29 @@ public class StoreInfoServiceImpl extends ServiceImpl<StoreInfoMapper, StoreInfo
     }
 
     @Override
+    public boolean manualReview(StoreInfoDto storeInfoDto) {
+        if (storeInfoDto == null || storeInfoDto.getId() == null) {
+            throw new IllegalArgumentException("门店ID不能为空");
+        }
+
+        LambdaUpdateWrapper<StoreInfo> wrapper = new LambdaUpdateWrapper<>();
+        wrapper.eq(StoreInfo::getId, storeInfoDto.getId());
+
+        if (storeInfoDto.getManualReviewStatus() != null) {
+            wrapper.set(StoreInfo::getManualReviewStatus, storeInfoDto.getManualReviewStatus());
+        }
+
+        Date reviewTime = storeInfoDto.getManualReviewTime() == null ? new Date() : storeInfoDto.getManualReviewTime();
+        wrapper.set(StoreInfo::getManualReviewTime, reviewTime);
+
+        if (StringUtils.isNotEmpty(storeInfoDto.getManualReviewReason())) {
+            wrapper.set(StoreInfo::getManualReviewReason, storeInfoDto.getManualReviewReason());
+        }
+
+        return storeInfoMapper.update(null, wrapper) > 0;
+    }
+
+    @Override
     public String exportExcel(String id, String storePhone, String businessSection, String storeApplicationStatusStr) throws IOException {
         // 定义格式化模式
         DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
@@ -3789,13 +3815,15 @@ public class StoreInfoServiceImpl extends ServiceImpl<StoreInfoMapper, StoreInfo
     public IPage<StoreLicenseInfoVo> getStoreLicenseList(int pageNum,
                                                          int pageSize,
                                                          String storeName,
+                                                         String storeContact,
                                                          String storeTel,
+                                                         String businessSection,
                                                          Integer imgType,
                                                          String states,
                                                          String startSubmitDate,
                                                          String endSubmitDate) {
         IPage<StoreLicenseInfoVo> page = new Page<>(pageNum, pageSize);
-        IPage<StoreLicenseInfoVo> storeLicensePage = storeInfoMapper.getStoreLicensePage(page, storeName, storeTel, imgType, states, startSubmitDate, endSubmitDate);
+        IPage<StoreLicenseInfoVo> storeLicensePage = storeInfoMapper.getStoreLicensePage(page, storeName, storeContact, storeTel, businessSection, imgType, states, startSubmitDate, endSubmitDate);
         for (StoreLicenseInfoVo record : storeLicensePage.getRecords()) {
             if(record.getStates() != null){
                 StoreDictionary storeDictionary = storeDictionaryMapper.selectOne(new LambdaQueryWrapper<StoreDictionary>().eq(StoreDictionary::getDictId, record.getStates())