Merge remote-tracking branch 'origin/master'

FullCardClient/src/main/java/com/zhongshu/card/client/model/dictionary/AddDictionaryItemParam.java

@@ -31,6 +31,9 @@ public class AddDictionaryItemParam {
     @Schema(name = "name", description = "项名称", example = "15信息1班")
     private String name;
 
+    @Schema(name = "description", description = "描述", example = "班级")
+    private String description;
+
     @Schema(name = "sort", description = "排序", example = "1")
     private Integer sort = 1;
 

FullCardClient/src/main/java/com/zhongshu/card/client/model/dictionary/AddDictionaryParam.java

@@ -13,9 +13,9 @@ import lombok.NoArgsConstructor;
 @NoArgsConstructor
 public class AddDictionaryParam {
 
-    @Schema(name = "oid", description = "项目oid", example = "665fc0ef9083d203896d3549")
-    @NotNull(message = "项目oid不能为null")
-    @NotEmpty(message = "项目oid不能为空")
+    @Schema(name = "projectId", description = "项目oid", example = "665fc0ef9083d203896d3549")
+    @NotNull(message = "projectId不能为null")
+    @NotEmpty(message = "projectId不能为空")
     private String projectId;
 
     @Schema(name = "key", description = "常量", example = "class")
@@ -34,6 +34,6 @@ public class AddDictionaryParam {
 //    @Schema(name = "type", description = "类型", example = "Customize")
 //    private DictionaryType type;
 
-    @Schema(name = "是否禁用", description = "状态", example = "false")
+    @Schema(name = "disabled", description = "状态", example = "false")
     private boolean disabled;
 }

FullCardClient/src/main/java/com/zhongshu/card/client/model/dictionary/DeepQueryParam.java

@@ -0,0 +1,26 @@
+package com.zhongshu.card.client.model.dictionary;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class DeepQueryParam {
+
+    private boolean deep;
+
+    private String projectId;
+
+    private List<KeyFilter> keyFilters;
+
+    @Data
+    public static class KeyFilter{
+
+        @Schema(description = "字典编码")
+        private String dictionaryKey;
+
+        @Schema(description = "字典编码/项编码")
+        private List<String> keys;
+    }
+}

FullCardClient/src/main/java/com/zhongshu/card/client/model/dictionary/DeepTreeItemQueryParam.java

@@ -0,0 +1,13 @@
+package com.zhongshu.card.client.model.dictionary;
+
+import lombok.Data;
+
+@Data
+public class DeepTreeItemQueryParam {
+
+    private String projectId;
+
+    private String dictionaryKey;
+
+    private String dictionaryId;
+}

FullCardClient/src/main/java/com/zhongshu/card/client/model/dictionary/DictionaryItemDeepParam.java

@@ -0,0 +1,16 @@
+package com.zhongshu.card.client.model.dictionary;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class DictionaryItemDeepParam {
+
+    @Schema(description = "字典编码")
+    private List<String> keys;
+
+    @Schema(description = "是否递归")
+    private boolean recursion;
+}

FullCardClient/src/main/java/com/zhongshu/card/client/model/dictionary/DictionaryItemModel.java

@@ -5,7 +5,9 @@ import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;
 import org.springframework.stereotype.Indexed;
 
+import java.util.ArrayList;
 import java.util.Dictionary;
+import java.util.List;
 
 @Data
 public class DictionaryItemModel {
@@ -32,6 +34,9 @@ public class DictionaryItemModel {
     @Schema(description = "项名称")
     private String name;
 
+    @Schema(name = "description", description = "描述", example = "班级")
+    private String description;
+
     //类型
     @Schema(description = "项类型")
     private DictionaryType type;
@@ -43,4 +48,11 @@ public class DictionaryItemModel {
     //禁用状态
     @Schema(description = "状态")
     private boolean disable;
+
+    private List<DictionaryItemModel> children = new ArrayList<>();
+
+
+    public void addChild(DictionaryItemModel child) {
+        this.children.add(child);
+    }
 }

FullCardClient/src/main/java/com/zhongshu/card/client/model/dictionary/DictionaryItemQueryParam.java

@@ -11,4 +11,7 @@ public class DictionaryItemQueryParam {
 
     @Schema(name = "dictionaryId", description = "字典id")
     private String dictionaryId;
+
+    @Schema(name = "parentId", description = "父级id")
+    private String parentId;
 }

FullCardClient/src/main/java/com/zhongshu/card/client/model/dictionary/ListDictionaryParam.java

@@ -0,0 +1,20 @@
+package com.zhongshu.card.client.model.dictionary;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class ListDictionaryParam {
+
+    @Schema(description = "项目id")
+    private String projectId;
+
+    @Schema(description = "字典编码")
+    private String dictionaryKey;
+
+    @Schema(description = "字典编码/项编码")
+    private List<String> keys;
+
+}

FullCardClient/src/main/java/com/zhongshu/card/client/model/pay/TotalStatisticsModel.java

@@ -0,0 +1,11 @@
+package com.zhongshu.card.client.model.pay;
+
+import lombok.Data;
+
+@Data
+public class TotalStatisticsModel {
+
+    private String id;
+
+    private Integer totalAmount;
+}

FullCardServer/pom.xml

@@ -43,12 +43,12 @@
             <version>${project.version}</version>
         </dependency>
 
-        <!--   支付中心     -->
-        <dependency>
-            <groupId>com.github.microservice.payment</groupId>
-            <artifactId>PaymentClient</artifactId>
-            <version>${project.version}</version>
-        </dependency>
+<!--        &lt;!&ndash;   支付中心     &ndash;&gt;-->
+<!--        <dependency>-->
+<!--            <groupId>com.github.microservice.payment</groupId>-->
+<!--            <artifactId>PaymentClient</artifactId>-->
+<!--            <version>${project.version}</version>-->
+<!--        </dependency>-->
 
 <!--         支付中心客户端-->
         <dependency>

FullCardServer/src/main/java/com/zhongshu/card/server/core/config/PaymentServerConfig.java

@@ -1,11 +1,11 @@
-package com.zhongshu.card.server.core.config;
-
-import com.github.microservice.auth.config.AuthClientConfiguration;
-import com.zhongshu.payment.client.config.PaymentClientConfiguration;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Import;
-
-@Configuration
-@Import(PaymentClientConfiguration.class)
-public class PaymentServerConfig {
-}
+//package com.zhongshu.card.server.core.config;
+//
+//import com.github.microservice.auth.config.AuthClientConfiguration;
+//import com.zhongshu.payment.client.config.PaymentClientConfiguration;
+//import org.springframework.context.annotation.Configuration;
+//import org.springframework.context.annotation.Import;
+//
+//@Configuration
+//@Import(PaymentClientConfiguration.class)
+//public class PaymentServerConfig {
+//}

FullCardServer/src/main/java/com/zhongshu/card/server/core/controller/dictionary/DictionaryController.java

@@ -60,7 +60,7 @@ public class DictionaryController {
         return dictionaryService.updateItem(param);
     }
 
-    @Operation(summary = "删除字典", description = "修改字典")
+    @Operation(summary = "删除项", description = "删除项")
     @RequestMapping(value = "deleteItem", method = RequestMethod.GET)
     public ResultContent deleteItem(@RequestParam("id") String id){
         return dictionaryService.deleteItem(id);
@@ -72,4 +72,22 @@ public class DictionaryController {
                            @Parameter(required = true) DictionaryItemQueryParam param){
         return dictionaryService.pageItem(pageable, param);
     }
+
+    @Operation(summary = "根据编码获取字典", description = "根据编码获取字典")
+    @RequestMapping(value = "listDictionary", method = RequestMethod.POST)
+    public ResultContent listDictionary(@RequestBody ListDictionaryParam param){
+        return dictionaryService.listDictionary(param);
+    }
+
+    @Operation(summary = "根据编码获取项", description = "根据编码获取字典")
+    @RequestMapping(value = "listItem", method = RequestMethod.POST)
+    public ResultContent listItem(@RequestBody ListDictionaryParam param){
+        return dictionaryService.listItem(param);
+    }
+
+    @Operation(summary = "查询字典所有项（树形）", description = "查询字典所有项（树形）")
+    @RequestMapping(value = "deepTreeItem", method = RequestMethod.POST)
+    public Object deepTreeItem(@RequestBody DeepTreeItemQueryParam param){
+        return dictionaryService.deepTreeItem(param.getProjectId(), param.getDictionaryKey(), param.getDictionaryId());
+    }
 }

FullCardServer/src/main/java/com/zhongshu/card/server/core/dao/dictionary/DictionaryDao.java

@@ -4,10 +4,13 @@ import com.github.microservice.components.data.mongo.mongo.dao.MongoDao;
 import com.zhongshu.card.server.core.dao.dictionary.extend.DictionaryDaoExtend;
 import com.zhongshu.card.server.core.domain.dictionary.Dictionary;
 
+import java.util.List;
+
 public interface DictionaryDao extends MongoDao<Dictionary>, DictionaryDaoExtend {
 
     Dictionary findTopById(String id);
 
     Dictionary findTopByProjectIdAndKey(String projectId, String key);
 
+    List<Dictionary> findTopByProjectIdAndKeyIn(String projectId, List<String> keys);
 }

FullCardServer/src/main/java/com/zhongshu/card/server/core/dao/dictionary/DictionaryItemDao.java

@@ -5,9 +5,19 @@ import com.zhongshu.card.server.core.dao.dictionary.extend.DictionaryDaoExtend;
 import com.zhongshu.card.server.core.dao.dictionary.extend.DictionaryItemDaoExtend;
 import com.zhongshu.card.server.core.domain.dictionary.DictionaryItem;
 
+import java.util.List;
+
 public interface DictionaryItemDao extends MongoDao<DictionaryItem>, DictionaryItemDaoExtend {
 
     DictionaryItem findTopById(String id);
 
     DictionaryItem findTopByDictionary_IdAndKey(String dictionaryId, String key);
+
+    List<DictionaryItem> findTopByDictionary_IdAndKeyIn(String dictionaryId, List<String> keys);
+
+    List<DictionaryItem> findByDictionary_Id(String dictionaryId);
+
+    List<DictionaryItem> findByDictionary_IdAndId(String dictionaryId, String id);
+
+    List<DictionaryItem> findByParentId(String parentId);
 }

FullCardServer/src/main/java/com/zhongshu/card/server/core/dao/dictionary/extend/DictionaryItemDaoExtend.java

@@ -2,10 +2,15 @@ package com.zhongshu.card.server.core.dao.dictionary.extend;
 
 import com.zhongshu.card.client.model.dictionary.DictionaryItemModel;
 import com.zhongshu.card.server.core.domain.dictionary.DictionaryItem;
+import com.zhongshu.card.server.core.model.dictionary.DItemChildrenResult;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 
+import java.util.List;
+
 public interface DictionaryItemDaoExtend {
 
-    Page<DictionaryItem> page(Pageable pageable, String dictionaryId, String name);
+    Page<DictionaryItem> page(Pageable pageable, String dictionaryId, String name, String parentId);
+
+    List<DictionaryItemModel> deepAggregate(String dictionaryId, List<String> keys);
 }

FullCardServer/src/main/java/com/zhongshu/card/server/core/dao/dictionary/impl/DictionaryItemDaoImpl.java

@@ -1,17 +1,28 @@
 package com.zhongshu.card.server.core.dao.dictionary.impl;
 
 import com.github.microservice.components.data.mongo.mongo.helper.DBHelper;
+import com.mongodb.client.MongoCollection;
+import com.zhongshu.card.client.model.dictionary.DictionaryItemModel;
 import com.zhongshu.card.server.core.dao.dictionary.extend.DictionaryItemDaoExtend;
 import com.zhongshu.card.server.core.domain.dictionary.DictionaryItem;
+import com.zhongshu.card.server.core.model.dictionary.DItemChildrenResult;
 import org.apache.commons.lang3.StringUtils;
+import org.bson.Document;
+import org.bson.conversions.Bson;
+import org.bson.types.ObjectId;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.MongoTemplate;
 import org.springframework.data.mongodb.core.query.Criteria;
 import org.springframework.data.mongodb.core.query.Query;
 
 import javax.imageio.metadata.IIOMetadataFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
 import java.util.regex.Pattern;
 
 public class DictionaryItemDaoImpl implements DictionaryItemDaoExtend {
@@ -19,22 +30,67 @@ public class DictionaryItemDaoImpl implements DictionaryItemDaoExtend {
     @Autowired
     DBHelper dbHelper;
 
+    @Autowired
+    MongoTemplate mongoTemplate;
+
     @Override
-    public Page<DictionaryItem> page(Pageable pageable, String dictionaryId, String name) {
+    public Page<DictionaryItem> page(Pageable pageable, String dictionaryId, String name, String parentId) {
         Criteria criteria = new Criteria();
 
-        if (StringUtils.isNotBlank(dictionaryId)) {
-            criteria.and("dictionary._id").is(dictionaryId);
-        }
-
         if (StringUtils.isNotBlank(name)) {
             Pattern pattern = Pattern.compile("^.*" + name + ".*$");
             criteria.orOperator(Criteria.where("name").regex(pattern), Criteria.where("key").regex(pattern));
         }
 
+        if (StringUtils.isNotBlank(parentId)) {
+            criteria.and("parentId").is(parentId);
+        }else {
+            criteria.and("parentId").isNull();
+        }
+
+        criteria.and("dictionary._id").is(dictionaryId);
         Query query = Query.query(criteria);
         query.with(Sort.by(Sort.Order.asc("sort"), Sort.Order.desc("createTime")));
 
         return dbHelper.pages(query, pageable, DictionaryItem.class);
     }
+
+    @Override
+    public List<DictionaryItemModel> deepAggregate(String dictionaryId, List<String> keys) {
+
+        List<Document> pipeline =  new ArrayList<>() {{
+                add(new Document()
+                        .append("$match", new Document()
+                                .append("key", new Document()
+                                        .append("$in", keys
+                                        )
+                                )
+                                .append("dictionary", new Document()
+                                        .append("$ref", "dictionary")
+                                        .append("$id", new ObjectId(dictionaryId))
+                                )
+                        ));
+        }};
+
+        pipeline.add( new Document()
+                .append("$graphLookup", new Document()
+                        .append("from", "dictionaryItem")
+                        .append("startWith", "$idString")
+                        .append("connectFromField", "idString")
+                        .append("connectToField", "parentId")
+                        .append("as", "children")
+                        .append("depthField", "level")
+                ));
+        final MongoCollection<Document> collection = this.mongoTemplate.getCollection(this.mongoTemplate.getCollectionName(DictionaryItem.class));
+
+        List<DictionaryItemModel> ret = new ArrayList<>();
+
+
+        collection.aggregate(pipeline).allowDiskUse(false).forEach((document)->{
+            Optional.ofNullable(document).ifPresent((it) -> {
+                ret.add(this.mongoTemplate.getConverter().read(DictionaryItemModel.class, it));
+            });
+        });
+        return ret;
+    }
 }

FullCardServer/src/main/java/com/zhongshu/card/server/core/dao/pay/extend/BalanceRechargeOrderDaoExtend.java

@@ -1,15 +1,8 @@
 package com.zhongshu.card.server.core.dao.pay.extend;
 
-import ch.qos.logback.core.util.StringUtil;
-import com.github.microservice.types.OrderState;
-import com.zhongshu.card.client.model.pay.QueryRechargeParam;
+
 import com.zhongshu.card.client.type.payAccount.RechargeOrderStatus;
 import com.zhongshu.card.server.core.domain.pay.BalanceRechargeOrder;
-import com.zhongshu.payment.client.model.TotalStatisticsModel;
-import com.zhongshu.payment.client.types.TradeType;
-import org.springframework.data.mongodb.core.aggregation.Aggregation;
-import org.springframework.data.mongodb.core.aggregation.AggregationResults;
-import org.springframework.data.mongodb.core.query.Criteria;
 
 import java.util.ArrayList;
 import java.util.List;

FullCardServer/src/main/java/com/zhongshu/card/server/core/dao/pay/impl/BalanceRechargeOrderDaoImpl.java

@@ -3,14 +3,12 @@ package com.zhongshu.card.server.core.dao.pay.impl;
 import ch.qos.logback.core.util.StringUtil;
 import com.github.microservice.types.OrderState;
 import com.zhongshu.card.client.model.pay.QueryRechargeParam;
+import com.zhongshu.card.client.model.pay.TotalStatisticsModel;
 import com.zhongshu.card.client.type.payAccount.RechargeOrderStatus;
 import com.zhongshu.card.client.utils.DateUtils;
 import com.zhongshu.card.server.core.dao.pay.extend.BalanceRechargeOrderDaoExtend;
 import com.zhongshu.card.server.core.domain.pay.BalanceRechargeOrder;
 import com.zhongshu.card.server.core.util.CommonUtil;
-import com.zhongshu.payment.client.model.TotalStatisticsModel;
-import com.zhongshu.payment.client.types.TradeType;
-import org.apache.commons.lang3.ObjectUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.domain.Sort;

FullCardServer/src/main/java/com/zhongshu/card/server/core/domain/dictionary/DictionaryItem.java

@@ -38,6 +38,8 @@ public class DictionaryItem extends SuperEntity {
     //字典项
     private String name;
 
+    private String description;
+
     //类型
     private DictionaryType type;
 

FullCardServer/src/main/java/com/zhongshu/card/server/core/domain/wallet/Wallet.java

@@ -3,7 +3,6 @@ package com.zhongshu.card.server.core.domain.wallet;
 import com.zhongshu.card.client.type.DataState;
 import com.zhongshu.card.server.core.domain.base.SuperMain;
 import com.zhongshu.card.server.core.domain.org.UserAccount;
-import com.zhongshu.payment.client.types.WalletType;
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
@@ -34,8 +33,8 @@ public class Wallet extends SuperMain {
     @DBRef(lazy = true)
     private UserAccount userAccount;
 
-    @Schema(description = "类型")
-    private WalletType walletType;
+//    @Schema(description = "类型")
+//    private WalletType walletType;
 
     @Schema(description = "支付账户-对应支付中心")
     private String payAccount;

FullCardServer/src/main/java/com/zhongshu/card/server/core/model/dictionary/DItemChildrenResult.java

@@ -18,11 +18,9 @@ public class DItemChildrenResult {
     private Dictionary dictionary;
 
     //父级id
-    @Indexed
     private String parentId;
 
     //唯一值
-    @Indexed
     private String key;
 
     //字典项
@@ -32,14 +30,13 @@ public class DItemChildrenResult {
     private DictionaryType type;
 
     //排序
-    @Indexed
     private Integer sort;
 
     //禁用状态
-    @Indexed
     private boolean disable;
 
     private Long level;
 
     private List<DItemChildrenResult> children;
+
 }

FullCardServer/src/main/java/com/zhongshu/card/server/core/service/dictionary/DictionaryService.java

@@ -2,6 +2,7 @@ package com.zhongshu.card.server.core.service.dictionary;
 
 import com.github.microservice.auth.security.helper.AuthHelper;
 import com.github.microservice.components.data.base.util.PageEntityUtil;
+import com.github.microservice.components.data.mongo.mongo.domain.SuperEntity;
 import com.github.microservice.net.ResultContent;
 import com.zhongshu.card.client.model.dictionary.*;
 import com.zhongshu.card.client.type.DictionaryType;
@@ -9,6 +10,7 @@ import com.zhongshu.card.server.core.dao.dictionary.DictionaryDao;
 import com.zhongshu.card.server.core.dao.dictionary.DictionaryItemDao;
 import com.zhongshu.card.server.core.domain.dictionary.Dictionary;
 import com.zhongshu.card.server.core.domain.dictionary.DictionaryItem;
+import com.zhongshu.card.server.core.model.dictionary.DItemChildrenResult;
 import com.zhongshu.card.server.core.service.base.SuperService;
 import org.apache.commons.lang3.StringUtils;
 import org.bson.types.ObjectId;
@@ -18,6 +20,12 @@ import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
 @Service
 public class DictionaryService extends SuperService {
 
@@ -106,7 +114,7 @@ public class DictionaryService extends SuperService {
         };
 
         Page<Dictionary> page = dictionaryDao.page(pageable, param.getProjectId(), param.getName(), param.getType());
-        return PageEntityUtil.concurrent2PageModel(page, this::toModel);
+        return ResultContent.buildContent(PageEntityUtil.concurrent2PageModel(page, this::toModel));
     }
 
     private DictionaryModel toModel(Dictionary dictionary){
@@ -182,8 +190,51 @@ public class DictionaryService extends SuperService {
     }
 
     public Object pageItem(Pageable pageable, DictionaryItemQueryParam param){
-        Page<DictionaryItem> page = dictionaryItemDao.page(pageable, param.getDictionaryId(), param.getName());
-        return PageEntityUtil.concurrent2PageModel(page, this::toItemModel);
+        Page<DictionaryItem> page = dictionaryItemDao.page(pageable, param.getDictionaryId(), param.getName(), param.getParentId());
+        Page<DictionaryItemModel> pageModel = PageEntityUtil.concurrent2PageModel(page, it -> {
+            return toItemModel(it);
+        });
+
+        List<DictionaryItemModel> dItemChildrenResults = dictionaryItemDao.deepAggregate(param.getDictionaryId(), pageModel.getContent().stream().map(DictionaryItemModel::getKey).toList());
+        List<DictionaryItemModel> ret = new ArrayList<>();
+        dItemChildrenResults.forEach(it->{
+            if (it.getChildren()!=null && it.getChildren().size() > 0){
+                ret.addAll(it.getChildren());
+            }
+            it.setChildren(new ArrayList<>());
+            ret.add(it);
+        });
+
+        List<DictionaryItemModel> modelList = buildTree(ret, null);
+        return ResultContent.buildContent(PageEntityUtil.buildPage(modelList, pageable, page.getTotalElements()));
+    }
+
+    public static DictionaryItemModel buildChildren(List<DictionaryItemModel> allItems, String rootId) {
+        // 使用一个Map来根据idString查找节点
+        Map<String, DictionaryItemModel> itemMap = new HashMap<>();
+        for (DictionaryItemModel item : allItems) {
+            itemMap.put(item.getId(), item);
+        }
+
+        // 获取根节点
+        DictionaryItemModel root = itemMap.get(rootId);
+        if (root != null) {
+            // 从根节点开始构建树
+            buildSubTree(itemMap, root);
+        }
+        return root;
+    }
+    // 递归构建子树
+    private static void buildSubTree(Map<String, DictionaryItemModel> itemMap, DictionaryItemModel parent) {
+        // 遍历所有节点，查找当前parent的子节点
+        for (DictionaryItemModel item : itemMap.values()) {
+            if (item.getParentId() != null && item.getParentId().equals(parent.getId())) {
+                // 找到子节点，添加到父节点的children列表中
+                parent.addChild(item);
+                // 递归处理子节点
+                buildSubTree(itemMap, item);
+            }
+        }
     }
 
     private DictionaryItemModel toItemModel(DictionaryItem dictionaryItem){
@@ -195,4 +246,155 @@ public class DictionaryService extends SuperService {
         return dictionaryItemModel;
     }
 
+    /**
+     * 根据字典编码获取字典
+     * @param param
+     * @return
+     */
+    public ResultContent listDictionary(ListDictionaryParam param){
+
+        String projectId = param.getProjectId();
+        if (StringUtils.isBlank(projectId)){
+            projectId = getCurrentProjectOid();
+        }
+        if (StringUtils.isBlank(projectId)){
+            return ResultContent.buildFail("项目id不能为空");
+        };
+
+        if (param.getKeys()==null || param.getKeys().isEmpty()){
+            return ResultContent.buildFail("字典编码不能为null或空");
+        }
+
+        List<Dictionary> dictionaryList = dictionaryDao.findTopByProjectIdAndKeyIn(projectId, param.getKeys());
+        return ResultContent.buildContent(dictionaryList.stream().map(this::toModel).toList());
+    }
+
+//    public ResultContent listItem(String projectId,String dictionary, String key){
+//        dictionaryItemDao.findTopByDictionary_IdAndKeyIn()
+//    }
+
+    /**
+     * 根据项编码获取项
+     * @param param
+     * @return
+     */
+    public ResultContent listItem(ListDictionaryParam param){
+
+        if (StringUtils.isBlank(param.getDictionaryKey())){
+            return ResultContent.buildFail("字典编码不能为空");
+        }
+
+
+        Dictionary dictionary = dictionaryDao.findTopByProjectIdAndKey(param.getProjectId(), param.getDictionaryKey());
+        if (dictionary == null){
+            return ResultContent.buildFail("字典不存在");
+        }
+
+        List<DictionaryItem> dictionaryItemList = new ArrayList<>();
+
+        if (param.getKeys()==null || param.getKeys().isEmpty()){
+            dictionaryItemList = dictionaryItemDao.findByDictionary_Id(dictionary.getId());
+        }else {
+            dictionaryItemList = dictionaryItemDao.findTopByDictionary_IdAndKeyIn(dictionary.getId(), param.getKeys());
+        }
+        return ResultContent.buildContent(dictionaryItemList.stream().map(this::toItemModel).toList());
+    }
+
+    public Object deepTreeItem(String projectId, String dictionaryKey, String dictionaryId){
+        if (StringUtils.isBlank(dictionaryKey) && StringUtils.isBlank(dictionaryId)){
+            return ResultContent.buildFail("字典编码和字典id不能为空");
+        }
+
+        Dictionary dictionary = null;
+
+        if (StringUtils.isNotBlank(dictionaryId)){
+            dictionary = dictionaryDao.findTopById(dictionaryId);
+        }else if (StringUtils.isNotBlank(dictionaryKey)){
+            dictionary = dictionaryDao.findTopByProjectIdAndKey(projectId, dictionaryKey);
+        }
+
+        if (dictionary == null){
+            return ResultContent.buildFail("字典不存在");
+        }
+        if (dictionary.isDisabled()){
+            return ResultContent.buildFail("字典已被禁用");
+        }
+
+        List<DictionaryItem> list = dictionaryItemDao.findByDictionary_Id(dictionary.getId());
+        List<DictionaryItemModel> modelList = list.stream().map(this::toItemModel).toList();
+
+        return ResultContent.buildContent(buildTree(modelList, null));
+    }
+
+    private List<DictionaryItemModel> buildTree(List<DictionaryItemModel> list, String parentId){
+        Map<String, DictionaryItemModel> itemMap = new HashMap<>();
+        itemMap = list.stream().collect(Collectors.toMap(DictionaryItemModel::getId, it->it));
+
+        List<DictionaryItemModel> rootItems = new ArrayList<>();
+
+//        for (DictionaryItemModel item : list) {
+//            if (item.getParentId() == null || item.getParentId().isEmpty()) {
+//                // 没有父节点的项是根节点
+//                rootItems.add(item);
+//            } else {
+//                // 将子节点添加到父节点的 children 中
+//                DictionaryItemModel parentItem = itemMap.get(item.getParentId());
+//                if (parentItem != null) {
+//                    parentItem.addChild(item);
+//                }
+//            }
+//        }
+
+        if (StringUtils.isNotBlank(parentId)){
+            for (DictionaryItemModel item : list) {
+                if (item.getId().equals(parentId)) {
+                    // 没有父节点的项是根节点
+                    rootItems.add(item);
+                } else {
+                    // 将子节点添加到父节点的 children 中
+                    DictionaryItemModel parentItem = itemMap.get(item.getParentId());
+                    if (parentItem != null) {
+                        parentItem.addChild(item);
+                    }
+                }
+            }
+        }else {
+            for (DictionaryItemModel item : list) {
+                if (item.getParentId() == null || item.getParentId().isEmpty()) {
+                    // 没有父节点的项是根节点
+                    rootItems.add(item);
+                } else {
+                    // 将子节点添加到父节点的 children 中
+                    DictionaryItemModel parentItem = itemMap.get(item.getParentId());
+                    if (parentItem != null) {
+                        parentItem.addChild(item);
+                    }
+                }
+            }
+        }
+        return rootItems;
+    }
+
+//    /**
+//     * 字典项向下查询
+//     */
+//    public Object deepListItem(DeepQueryParam queryParam){
+//
+//        List<DeepQueryParam.KeyFilter> keyFilters = queryParam.getKeyFilters();
+//
+//        keyFilters.stream().map(keyFilter -> {
+//           Dictionary dictionary = dictionaryDao.findTopByProjectIdAndKey(queryParam.getProjectId(), keyFilter.getDictionaryKey());
+//
+//           if (queryParam.isDeep() && !keyFilter.getKeys().isEmpty()){
+//               List<DItemChildrenResult> itemList = dictionaryItemDao.deepAggregate(dictionary.getId(), keyFilter.getKeys());
+//           }
+//
+//       }).toList();
+//
+//        Dictionary dictionary = dictionaryDao.findTopByProjectIdAndKey(projectId, dictionaryKey);
+//
+//        dictionaryItemDao.f
+//    }
+
+
 }