完善

src/main/java/cn/lihongjie/coal/base/dto/CommonQuery.java

@@ -1,13 +1,11 @@
 package cn.lihongjie.coal.base.dto;
 
 import cn.lihongjie.coal.exception.BizException;
+import com.google.common.base.Splitter;
 import io.vavr.Function4;
 import io.vavr.Tuple;
 import io.vavr.Tuple2;
-import jakarta.persistence.criteria.CriteriaBuilder;
+import jakarta.persistence.criteria.*;
-import jakarta.persistence.criteria.CriteriaQuery;
-import jakarta.persistence.criteria.Predicate;
-import jakarta.persistence.criteria.Root;
 import jakarta.persistence.metamodel.Attribute;
 import jakarta.persistence.metamodel.EntityType;
 import lombok.AllArgsConstructor;
@@ -73,341 +71,354 @@ public class CommonQuery {
     }
 
 
+    public static Path parseKey(Root root, String key) {
+        Iterable<String> parts = Splitter.on(".").trimResults().omitEmptyStrings().split(key);
+
+        Path p = null;
+        for (String part : parts) {
+            if (p == null) {
+                p = root.get(part);
+            }else {
+                p = p.get(part);
+            }
+        }
+        return p;
+    }
     public static Map<Tuple2<String, Class>, Function4<Root, CriteriaBuilder, QueryItem, ConversionService, Predicate>> map = new HashMap<>();
 
 
     static {
 
         map.put(Tuple.of("like", String.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.like(root.get(x.key), "%" + c.convert(x.value, String.class) +"%");
+            return criteriaBuilder.like(parseKey(root,x.key), "%" + c.convert(x.value, String.class) +"%");
         });
 
 
         map.put(Tuple.of("nlike", String.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.notLike(root.get(x.key),"%"+c.convert(x.value, String.class) + "%");
+            return criteriaBuilder.notLike(parseKey(root,x.key),"%"+c.convert(x.value, String.class) + "%");
         });
 
 
         map.put(Tuple.of("null", String.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.isNull(root.get(x.key));
+            return criteriaBuilder.isNull(parseKey(root,x.key));
         });
 
         map.put(Tuple.of("null", Integer.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.isNull(root.get(x.key));
+            return criteriaBuilder.isNull(parseKey(root,x.key));
         });
 
         map.put(Tuple.of("null", Long.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.isNull(root.get(x.key));
+            return criteriaBuilder.isNull(parseKey(root,x.key));
         });
 
 
         map.put(Tuple.of("null", Double.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.isNull(root.get(x.key));
+            return criteriaBuilder.isNull(parseKey(root,x.key));
         });
         map.put(Tuple.of("null", BigDecimal.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.isNull(root.get(x.key));
+            return criteriaBuilder.isNull(parseKey(root,x.key));
         });
 
         map.put(Tuple.of("null", LocalDate.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.isNull(root.get(x.key));
+            return criteriaBuilder.isNull(parseKey(root,x.key));
         });
         map.put(Tuple.of("null", LocalDateTime.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.isNull(root.get(x.key));
+            return criteriaBuilder.isNull(parseKey(root,x.key));
         });
 
 
         map.put(Tuple.of("nnull", String.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.isNotNull(root.get(x.key));
+            return criteriaBuilder.isNotNull(parseKey(root,x.key));
         });
 
         map.put(Tuple.of("nnull", Integer.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.isNotNull(root.get(x.key));
+            return criteriaBuilder.isNotNull(parseKey(root,x.key));
         });
 
         map.put(Tuple.of("nnull", Long.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.isNotNull(root.get(x.key));
+            return criteriaBuilder.isNotNull(parseKey(root,x.key));
         });
 
 
         map.put(Tuple.of("nnull", Double.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.isNotNull(root.get(x.key));
+            return criteriaBuilder.isNotNull(parseKey(root,x.key));
         });
         map.put(Tuple.of("nnull", BigDecimal.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.isNotNull(root.get(x.key));
+            return criteriaBuilder.isNotNull(parseKey(root,x.key));
         });
 
         map.put(Tuple.of("nnull", LocalDate.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.isNotNull(root.get(x.key));
+            return criteriaBuilder.isNotNull(parseKey(root,x.key));
         });
         map.put(Tuple.of("nnull", LocalDateTime.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.isNotNull(root.get(x.key));
+            return criteriaBuilder.isNotNull(parseKey(root,x.key));
         });
 
 
         map.put(Tuple.of("eq", String.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.equal(root.get(x.key), c.convert(x.value, String.class));
+            return criteriaBuilder.equal(parseKey(root,x.key), c.convert(x.value, String.class));
         });
 
         map.put(Tuple.of("eq", Integer.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.equal(root.get(x.key), c.convert(x.value, Integer.class));
+            return criteriaBuilder.equal(parseKey(root,x.key), c.convert(x.value, Integer.class));
         });
 
         map.put(Tuple.of("eq", Long.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.equal(root.get(x.key), c.convert(x.value, Long.class));
+            return criteriaBuilder.equal(parseKey(root,x.key), c.convert(x.value, Long.class));
         });
 
 
         map.put(Tuple.of("eq", Double.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.equal(root.get(x.key), c.convert(x.value, Double.class));
+            return criteriaBuilder.equal(parseKey(root,x.key), c.convert(x.value, Double.class));
         });
         map.put(Tuple.of("eq", BigDecimal.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.equal(root.get(x.key), c.convert(x.value, BigDecimal.class));
+            return criteriaBuilder.equal(parseKey(root,x.key), c.convert(x.value, BigDecimal.class));
         });
 
         map.put(Tuple.of("eq", LocalDate.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.equal(root.get(x.key), c.convert(x.value, LocalDate.class));
+            return criteriaBuilder.equal(parseKey(root,x.key), c.convert(x.value, LocalDate.class));
         });
         map.put(Tuple.of("eq", LocalDateTime.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.equal(root.get(x.key), c.convert(x.value, LocalDateTime.class));
+            return criteriaBuilder.equal(parseKey(root,x.key), c.convert(x.value, LocalDateTime.class));
         });
 
 
         map.put(Tuple.of("neq", String.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.notEqual(root.get(x.key), c.convert(x.value, String.class));
+            return criteriaBuilder.notEqual(parseKey(root,x.key), c.convert(x.value, String.class));
         });
 
         map.put(Tuple.of("neq", Integer.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.notEqual(root.get(x.key), c.convert(x.value, Integer.class));
+            return criteriaBuilder.notEqual(parseKey(root,x.key), c.convert(x.value, Integer.class));
         });
 
         map.put(Tuple.of("neq", Long.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.notEqual(root.get(x.key), c.convert(x.value, Long.class));
+            return criteriaBuilder.notEqual(parseKey(root,x.key), c.convert(x.value, Long.class));
         });
 
 
         map.put(Tuple.of("neq", Double.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.notEqual(root.get(x.key), c.convert(x.value, Double.class));
+            return criteriaBuilder.notEqual(parseKey(root,x.key), c.convert(x.value, Double.class));
         });
         map.put(Tuple.of("neq", BigDecimal.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.notEqual(root.get(x.key), c.convert(x.value, BigDecimal.class));
+            return criteriaBuilder.notEqual(parseKey(root,x.key), c.convert(x.value, BigDecimal.class));
         });
 
         map.put(Tuple.of("neq", LocalDate.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.notEqual(root.get(x.key), c.convert(x.value, LocalDate.class));
+            return criteriaBuilder.notEqual(parseKey(root,x.key), c.convert(x.value, LocalDate.class));
         });
         map.put(Tuple.of("neq", LocalDateTime.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.notEqual(root.get(x.key), c.convert(x.value, LocalDateTime.class));
+            return criteriaBuilder.notEqual(parseKey(root,x.key), c.convert(x.value, LocalDateTime.class));
         });
 
 
         map.put(Tuple.of("between", String.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.between(root.get(x.key), c.convert(x.min, String.class), c.convert(x.max, String.class));
+            return criteriaBuilder.between(parseKey(root,x.key), c.convert(x.min, String.class), c.convert(x.max, String.class));
         });
 
         map.put(Tuple.of("between", Integer.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.between(root.get(x.key), c.convert(x.min, Integer.class), c.convert(x.max, Integer.class));
+            return criteriaBuilder.between(parseKey(root,x.key), c.convert(x.min, Integer.class), c.convert(x.max, Integer.class));
         });
 
         map.put(Tuple.of("between", Long.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.between(root.get(x.key), c.convert(x.min, Long.class), c.convert(x.max, Long.class));
+            return criteriaBuilder.between(parseKey(root,x.key), c.convert(x.min, Long.class), c.convert(x.max, Long.class));
         });
 
 
         map.put(Tuple.of("between", Double.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.between(root.get(x.key), c.convert(x.min, Double.class), c.convert(x.max, Double.class));
+            return criteriaBuilder.between(parseKey(root,x.key), c.convert(x.min, Double.class), c.convert(x.max, Double.class));
         });
         map.put(Tuple.of("between", BigDecimal.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.between(root.get(x.key), c.convert(x.min, BigDecimal.class), c.convert(x.max, BigDecimal.class));
+            return criteriaBuilder.between(parseKey(root,x.key), c.convert(x.min, BigDecimal.class), c.convert(x.max, BigDecimal.class));
         });
 
         map.put(Tuple.of("between", LocalDate.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.between(root.get(x.key), c.convert(x.min, LocalDate.class), c.convert(x.max, LocalDate.class));
+            return criteriaBuilder.between(parseKey(root,x.key), c.convert(x.min, LocalDate.class), c.convert(x.max, LocalDate.class));
         });
         map.put(Tuple.of("between", LocalDateTime.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.between(root.get(x.key), c.convert(x.min, LocalDateTime.class), c.convert(x.max, LocalDateTime.class));
+            return criteriaBuilder.between(parseKey(root,x.key), c.convert(x.min, LocalDateTime.class), c.convert(x.max, LocalDateTime.class));
         });
 
 
         map.put(Tuple.of("lt", String.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.lessThan(root.get(x.key), c.convert(x.value, String.class));
+            return criteriaBuilder.lessThan(parseKey(root,x.key), c.convert(x.value, String.class));
         });
 
         map.put(Tuple.of("lt", Integer.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.lessThan(root.get(x.key), c.convert(x.value, Integer.class));
+            return criteriaBuilder.lessThan(parseKey(root,x.key), c.convert(x.value, Integer.class));
         });
 
         map.put(Tuple.of("lt", Long.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.lessThan(root.get(x.key), c.convert(x.value, Long.class));
+            return criteriaBuilder.lessThan(parseKey(root,x.key), c.convert(x.value, Long.class));
         });
 
 
         map.put(Tuple.of("lt", Double.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.lessThan(root.get(x.key), c.convert(x.value, Double.class));
+            return criteriaBuilder.lessThan(parseKey(root,x.key), c.convert(x.value, Double.class));
         });
         map.put(Tuple.of("lt", BigDecimal.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.lessThan(root.get(x.key), c.convert(x.value, BigDecimal.class));
+            return criteriaBuilder.lessThan(parseKey(root,x.key), c.convert(x.value, BigDecimal.class));
         });
 
         map.put(Tuple.of("lt", LocalDate.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.lessThan(root.get(x.key), c.convert(x.value, LocalDate.class));
+            return criteriaBuilder.lessThan(parseKey(root,x.key), c.convert(x.value, LocalDate.class));
         });
         map.put(Tuple.of("lt", LocalDateTime.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.lessThan(root.get(x.key), c.convert(x.value, LocalDateTime.class));
+            return criteriaBuilder.lessThan(parseKey(root,x.key), c.convert(x.value, LocalDateTime.class));
         });
 
 
         map.put(Tuple.of("le", String.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.lessThanOrEqualTo(root.get(x.key), c.convert(x.value, String.class));
+            return criteriaBuilder.lessThanOrEqualTo(parseKey(root,x.key), c.convert(x.value, String.class));
         });
 
         map.put(Tuple.of("le", Integer.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.lessThanOrEqualTo(root.get(x.key), c.convert(x.value, Integer.class));
+            return criteriaBuilder.lessThanOrEqualTo(parseKey(root,x.key), c.convert(x.value, Integer.class));
         });
 
         map.put(Tuple.of("le", Long.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.lessThanOrEqualTo(root.get(x.key), c.convert(x.value, Long.class));
+            return criteriaBuilder.lessThanOrEqualTo(parseKey(root,x.key), c.convert(x.value, Long.class));
         });
 
 
         map.put(Tuple.of("le", Double.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.lessThanOrEqualTo(root.get(x.key), c.convert(x.value, Double.class));
+            return criteriaBuilder.lessThanOrEqualTo(parseKey(root,x.key), c.convert(x.value, Double.class));
         });
         map.put(Tuple.of("le", BigDecimal.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.lessThanOrEqualTo(root.get(x.key), c.convert(x.value, BigDecimal.class));
+            return criteriaBuilder.lessThanOrEqualTo(parseKey(root,x.key), c.convert(x.value, BigDecimal.class));
         });
 
         map.put(Tuple.of("le", LocalDate.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.lessThanOrEqualTo(root.get(x.key), c.convert(x.value, LocalDate.class));
+            return criteriaBuilder.lessThanOrEqualTo(parseKey(root,x.key), c.convert(x.value, LocalDate.class));
         });
         map.put(Tuple.of("le", LocalDateTime.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.lessThanOrEqualTo(root.get(x.key), c.convert(x.value, LocalDateTime.class));
+            return criteriaBuilder.lessThanOrEqualTo(parseKey(root,x.key), c.convert(x.value, LocalDateTime.class));
         });
 
 
         map.put(Tuple.of("gt", String.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.greaterThan(root.get(x.key), c.convert(x.value, String.class));
+            return criteriaBuilder.greaterThan(parseKey(root,x.key), c.convert(x.value, String.class));
         });
 
         map.put(Tuple.of("gt", Integer.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.greaterThan(root.get(x.key), c.convert(x.value, Integer.class));
+            return criteriaBuilder.greaterThan(parseKey(root,x.key), c.convert(x.value, Integer.class));
         });
 
         map.put(Tuple.of("gt", Long.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.greaterThan(root.get(x.key), c.convert(x.value, Long.class));
+            return criteriaBuilder.greaterThan(parseKey(root,x.key), c.convert(x.value, Long.class));
         });
 
 
         map.put(Tuple.of("gt", Double.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.greaterThan(root.get(x.key), c.convert(x.value, Double.class));
+            return criteriaBuilder.greaterThan(parseKey(root,x.key), c.convert(x.value, Double.class));
         });
         map.put(Tuple.of("gt", BigDecimal.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.greaterThan(root.get(x.key), c.convert(x.value, BigDecimal.class));
+            return criteriaBuilder.greaterThan(parseKey(root,x.key), c.convert(x.value, BigDecimal.class));
         });
 
         map.put(Tuple.of("gt", LocalDate.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.greaterThan(root.get(x.key), c.convert(x.value, LocalDate.class));
+            return criteriaBuilder.greaterThan(parseKey(root,x.key), c.convert(x.value, LocalDate.class));
         });
         map.put(Tuple.of("gt", LocalDateTime.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.greaterThan(root.get(x.key), c.convert(x.value, LocalDateTime.class));
+            return criteriaBuilder.greaterThan(parseKey(root,x.key), c.convert(x.value, LocalDateTime.class));
         });
 
 
         map.put(Tuple.of("ge", String.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.greaterThanOrEqualTo(root.get(x.key), c.convert(x.value, String.class));
+            return criteriaBuilder.greaterThanOrEqualTo(parseKey(root,x.key), c.convert(x.value, String.class));
         });
 
         map.put(Tuple.of("ge", Integer.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.greaterThanOrEqualTo(root.get(x.key), c.convert(x.value, Integer.class));
+            return criteriaBuilder.greaterThanOrEqualTo(parseKey(root,x.key), c.convert(x.value, Integer.class));
         });
 
         map.put(Tuple.of("ge", Long.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.greaterThanOrEqualTo(root.get(x.key), c.convert(x.value, Long.class));
+            return criteriaBuilder.greaterThanOrEqualTo(parseKey(root,x.key), c.convert(x.value, Long.class));
         });
 
 
         map.put(Tuple.of("ge", Double.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.greaterThanOrEqualTo(root.get(x.key), c.convert(x.value, Double.class));
+            return criteriaBuilder.greaterThanOrEqualTo(parseKey(root,x.key), c.convert(x.value, Double.class));
         });
         map.put(Tuple.of("ge", BigDecimal.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.greaterThanOrEqualTo(root.get(x.key), c.convert(x.value, BigDecimal.class));
+            return criteriaBuilder.greaterThanOrEqualTo(parseKey(root,x.key), c.convert(x.value, BigDecimal.class));
         });
 
         map.put(Tuple.of("ge", LocalDate.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.greaterThanOrEqualTo(root.get(x.key), c.convert(x.value, LocalDate.class));
+            return criteriaBuilder.greaterThanOrEqualTo(parseKey(root,x.key), c.convert(x.value, LocalDate.class));
         });
         map.put(Tuple.of("ge", LocalDateTime.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
 
-            return criteriaBuilder.greaterThanOrEqualTo(root.get(x.key), c.convert(x.value, LocalDateTime.class));
+            return criteriaBuilder.greaterThanOrEqualTo(parseKey(root,x.key), c.convert(x.value, LocalDateTime.class));
         });
 
 
         map.put(Tuple.of("empty", List.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x,
                                                 ConversionService c) -> {
 
-            return criteriaBuilder.isEmpty(root.get(x.key));
+            return criteriaBuilder.isEmpty(parseKey(root,x.key));
         });
 
 
         map.put(Tuple.of("nempty", List.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x,
                                                  ConversionService c) -> {
 
-            return criteriaBuilder.isNotEmpty(root.get(x.key));
+            return criteriaBuilder.isNotEmpty(parseKey(root,x.key));
         });
 
 
         map.put(Tuple.of("in", String.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, String.class)).toList());
+            return criteriaBuilder.in(parseKey(root,x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, String.class)).toList());
         });
 
         map.put(Tuple.of("in", Integer.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, Integer.class)).toList());
+            return criteriaBuilder.in(parseKey(root,x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, Integer.class)).toList());
         });
 
         map.put(Tuple.of("in", Long.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, Long.class)).toList());
+            return criteriaBuilder.in(parseKey(root,x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, Long.class)).toList());
         });
 
 
         map.put(Tuple.of("in", Double.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, Double.class)).toList());
+            return criteriaBuilder.in(parseKey(root,x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, Double.class)).toList());
         });
         map.put(Tuple.of("in", BigDecimal.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, BigDecimal.class)).toList());
+            return criteriaBuilder.in(parseKey(root,x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, BigDecimal.class)).toList());
         });
 
         map.put(Tuple.of("in", LocalDate.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, LocalDate.class)).toList());
+            return criteriaBuilder.in(parseKey(root,x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, LocalDate.class)).toList());
         });
         map.put(Tuple.of("in", LocalDateTime.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, LocalDateTime.class)).toList());
+            return criteriaBuilder.in(parseKey(root,x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, LocalDateTime.class)).toList());
         });
 
 
         map.put(Tuple.of("nin", String.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, String.class)).toList()).not();
+            return criteriaBuilder.in(parseKey(root,x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, String.class)).toList()).not();
         });
 
         map.put(Tuple.of("nin", Integer.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, Integer.class)).toList()).not();
+            return criteriaBuilder.in(parseKey(root,x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, Integer.class)).toList()).not();
         });
 
         map.put(Tuple.of("nin", Long.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, Long.class)).toList()).not();
+            return criteriaBuilder.in(parseKey(root,x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, Long.class)).toList()).not();
         });
 
 
         map.put(Tuple.of("nin", Double.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, Double.class)).toList()).not();
+            return criteriaBuilder.in(parseKey(root,x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, Double.class)).toList()).not();
         });
         map.put(Tuple.of("nin", BigDecimal.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, BigDecimal.class)).toList()).not();
+            return criteriaBuilder.in(parseKey(root,x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, BigDecimal.class)).toList()).not();
         });
 
         map.put(Tuple.of("nin", LocalDate.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, LocalDate.class)).toList()).not();
+            return criteriaBuilder.in(parseKey(root,x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, LocalDate.class)).toList()).not();
         });
         map.put(Tuple.of("nin", LocalDateTime.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
-            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, LocalDateTime.class)).toList()).not();
+            return criteriaBuilder.in(parseKey(root,x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, LocalDateTime.class)).toList()).not();
         });
 
 
@@ -478,7 +489,7 @@ public class CommonQuery {
             case ONE_TO_ONE -> {
 
 
-                Function4<Root, CriteriaBuilder, QueryItem, ConversionService, Predicate> function4 = map.get(Tuple.of(x.opt, attribute.getJavaType()));
+                Function4<Root, CriteriaBuilder, QueryItem, ConversionService, Predicate> function4 = map.get(Tuple.of(x.opt, String.class));
 
                 if (function4 == null) {
                     throw new RuntimeException("无法识别的查询 " + x);
@@ -491,7 +502,7 @@ public class CommonQuery {
             case MANY_TO_ONE -> {
 
 
-                Function4<Root, CriteriaBuilder, QueryItem, ConversionService, Predicate> function4 = map.get(Tuple.of(x.opt, attribute.getJavaType()));
+                Function4<Root, CriteriaBuilder, QueryItem, ConversionService, Predicate> function4 = map.get(Tuple.of(x.opt, String.class));
 
                 if (function4 == null) {
                     throw new RuntimeException("无法识别的查询 " + x);

src/main/java/cn/lihongjie/coal/coalInfo/dto/CoalInfoDto.java

@@ -1,7 +1,6 @@
 package cn.lihongjie.coal.coalInfo.dto;
 
 import cn.lihongjie.coal.base.dto.OrgCommonDto;
-import cn.lihongjie.coal.supplier.entity.SupplierEntity;
 import lombok.Data;
 import org.hibernate.annotations.Comment;
 
@@ -9,9 +8,9 @@ import org.hibernate.annotations.Comment;
 public class CoalInfoDto extends OrgCommonDto {
 
     @Comment("供应商")
-    private SupplierEntity supplier;
+    private String supplier;
-
 
+    private String supplierName;
 
     @Comment("初始报价")
     private Double initPrice;

src/main/java/cn/lihongjie/coal/coalInfo/entity/CoalInfoEntity.java

@@ -17,8 +17,20 @@ public class CoalInfoEntity extends OrgCommonEntity {
 
 
 
+
     @Comment("初始报价")
     private Double initPrice;
 
 
+    public String getSupplierName() {
+
+        if (supplier != null) {
+
+        return supplier.getName();
+        }else {
+            return "";
+        }
+    }
+
+
 }

src/main/java/cn/lihongjie/coal/coalInfo/mapper/CoalInfoMapper.java

@@ -7,12 +7,16 @@ import cn.lihongjie.coal.coalInfo.dto.CreateCoalInfoDto;
 import cn.lihongjie.coal.coalInfo.dto.UpdateCoalInfoDto;
 import cn.lihongjie.coal.coalInfo.entity.CoalInfoEntity;
 import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+import org.mapstruct.Mappings;
 import org.mapstruct.control.DeepClone;
 
 @Mapper(
-    componentModel = org.mapstruct.MappingConstants.ComponentModel.SPRING,
+        componentModel = org.mapstruct.MappingConstants.ComponentModel.SPRING,
-    uses = {CommonMapper.class},
+        uses = {CommonMapper.class},
-    mappingControl = DeepClone.class
+        mappingControl = DeepClone.class
 )
 public interface CoalInfoMapper extends BaseMapper<CoalInfoEntity, CoalInfoDto, CreateCoalInfoDto, UpdateCoalInfoDto> {
+    @Override
+    CoalInfoDto toDto(CoalInfoEntity user);
 }

src/main/java/cn/lihongjie/coal/coalInfo/service/CoalInfoService.java

@@ -19,30 +19,33 @@ import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Sort;
 import org.springframework.stereotype.Service;
 
+import java.util.Objects;
+
 @Service
 @Slf4j
 public class CoalInfoService extends BaseService<CoalInfoEntity, CoalInfoRepository> {
-  @Autowired
+    @Autowired
-  private CoalInfoRepository repository;
+    private CoalInfoRepository repository;
 
-  @Autowired
+    @Autowired
-  private CoalInfoMapper mapper;
+    private CoalInfoMapper mapper;
 
-  @Autowired
+    @Autowired
-  private ConversionService conversionService;
+    private ConversionService conversionService;
 
-  @Autowired
+    @Autowired
-  CoalPriceService coalPriceService;
+    CoalPriceService coalPriceService;
-  public CoalInfoDto create(CreateCoalInfoDto request) {
+
-    CoalInfoEntity entity = mapper.toEntity(request);
+    public CoalInfoDto create(CreateCoalInfoDto request) {
+        CoalInfoEntity entity = mapper.toEntity(request);
 
 
-      this.repository.save(entity);
+        this.repository.save(entity);
 
-      updatePrice(entity);
+        updatePrice(entity);
-      return getById(entity.getId())
+        return getById(entity.getId())
-        ;
+                ;
-  }
+    }
 
     private void updatePrice(CoalInfoEntity entity) {
         CoalPriceEntity coalPrice = new CoalPriceEntity();
@@ -53,33 +56,37 @@ public class CoalInfoService extends BaseService<CoalInfoEntity, CoalInfoReposit
     }
 
     public CoalInfoDto update(UpdateCoalInfoDto request) {
-    CoalInfoEntity entity = this.repository.get(request.getId());
+        CoalInfoEntity entity = this.repository.get(request.getId());
+        Double old = request.getInitPrice();
         this.mapper.updateEntity(entity, request);
 
         this.repository.save(entity);
-        updatePrice(entity);
+        if (!Objects.equals(old, request.getInitPrice())) {
+
+            updatePrice(entity);
+        }
         return getById(entity.getId())
-        ;
+                ;
-  }
+    }
 
-  public void delete(IdRequest request) {
+    public void delete(IdRequest request) {
-    this.repository.deleteAllById(request.getIds())
+        this.repository.deleteAllById(request.getIds())
         ;
-  }
+    }
 
-  public CoalInfoDto getById(String id) {
+    public CoalInfoDto getById(String id) {
-    CoalInfoEntity entity = repository.get(id);
+        CoalInfoEntity entity = repository.get(id);
 
 
         return mapper.toDto(entity)
-        ;
+                ;
-  }
+    }
 
-  public Page<CoalInfoDto> list(CommonQuery query) {
+    public Page<CoalInfoDto> list(CommonQuery query) {
-     Page<CoalInfoEntity> page = repository.findAll(query.specification(conversionService), PageRequest.of(query.getPageNo(), query.getPageSize(), Sort.by(query.getOrders())));
+        Page<CoalInfoEntity> page = repository.findAll(query.specification(conversionService), PageRequest.of(query.getPageNo(), query.getPageSize(), Sort.by(query.getOrders())));
 
 
         return page.map(this.mapper::toDto)
-        ;
+                ;
-  }
+    }
 }