Feat: Code gen V3 ok

yudao-module-haoka/yudao-module-haoka-biz/src/main/java/cn/iocoder/yudao/module/haoka/controller/admin/product/ProductLimitController.java

@@ -27,6 +27,7 @@ import static cn.iocoder.yudao.framework.apilog.core.enums.OperateTypeEnum.*;
 
 import cn.iocoder.yudao.module.haoka.controller.admin.product.vo.*;
 import cn.iocoder.yudao.module.haoka.dal.dataobject.product.ProductLimitDO;
+import cn.iocoder.yudao.module.haoka.dal.dataobject.product.ProductLimitAreaDO;
 import cn.iocoder.yudao.module.haoka.dal.dataobject.product.ProductLimitCardDO;
 import cn.iocoder.yudao.module.haoka.service.product.ProductLimitService;
 
@@ -93,47 +94,24 @@ public class ProductLimitController {
                         BeanUtils.toBean(list, ProductLimitRespVO.class));
     }
 
-    // ==================== 子表（产品身份证限制） ====================
+    // ==================== 子表（产品区域配置） ====================
 
-    @GetMapping("/product-limit-card/page")
+    @GetMapping("/product-limit-area/list-by-haoka-product-limit-id")
-    @Operation(summary = "获得产品身份证限制分页")
+    @Operation(summary = "获得产品区域配置列表")
     @Parameter(name = "haokaProductLimitId", description = "产品限制ID")
     @PreAuthorize("@ss.hasPermission('haoka:product-limit:query')")
-    public CommonResult<PageResult<ProductLimitCardDO>> getProductLimitCardPage(PageParam pageReqVO,
+    public CommonResult<List<ProductLimitAreaDO>> getProductLimitAreaListByHaokaProductLimitId(@RequestParam("haokaProductLimitId") Long haokaProductLimitId) {
-                                                                                        @RequestParam("haokaProductLimitId") Long haokaProductLimitId) {
+        return success(productLimitService.getProductLimitAreaListByHaokaProductLimitId(haokaProductLimitId));
-        return success(productLimitService.getProductLimitCardPage(pageReqVO, haokaProductLimitId));
     }
 
-    @PostMapping("/product-limit-card/create")
+    // ==================== 子表（产品身份证限制） ====================
-    @Operation(summary = "创建产品身份证限制")
-    @PreAuthorize("@ss.hasPermission('haoka:product-limit:create')")
-    public CommonResult<Long> createProductLimitCard(@Valid @RequestBody ProductLimitCardDO productLimitCard) {
-        return success(productLimitService.createProductLimitCard(productLimitCard));
-    }
 
-    @PutMapping("/product-limit-card/update")
+    @GetMapping("/product-limit-card/list-by-haoka-product-limit-id")
-    @Operation(summary = "更新产品身份证限制")
+    @Operation(summary = "获得产品身份证限制列表")
-    @PreAuthorize("@ss.hasPermission('haoka:product-limit:update')")
+    @Parameter(name = "haokaProductLimitId", description = "产品限制ID")
-    public CommonResult<Boolean> updateProductLimitCard(@Valid @RequestBody ProductLimitCardDO productLimitCard) {
-        productLimitService.updateProductLimitCard(productLimitCard);
-        return success(true);
-    }
-
-    @DeleteMapping("/product-limit-card/delete")
-    @Parameter(name = "id", description = "编号", required = true)
-    @Operation(summary = "删除产品身份证限制")
-    @PreAuthorize("@ss.hasPermission('haoka:product-limit:delete')")
-    public CommonResult<Boolean> deleteProductLimitCard(@RequestParam("id") Long id) {
-        productLimitService.deleteProductLimitCard(id);
-        return success(true);
-    }
-
-	@GetMapping("/product-limit-card/get")
-	@Operation(summary = "获得产品身份证限制")
-	@Parameter(name = "id", description = "编号", required = true)
     @PreAuthorize("@ss.hasPermission('haoka:product-limit:query')")
-	public CommonResult<ProductLimitCardDO> getProductLimitCard(@RequestParam("id") Long id) {
+    public CommonResult<List<ProductLimitCardDO>> getProductLimitCardListByHaokaProductLimitId(@RequestParam("haokaProductLimitId") Long haokaProductLimitId) {
-	    return success(productLimitService.getProductLimitCard(id));
+        return success(productLimitService.getProductLimitCardListByHaokaProductLimitId(haokaProductLimitId));
-	}
+    }
 
 }

yudao-module-haoka/yudao-module-haoka-biz/src/main/java/cn/iocoder/yudao/module/haoka/controller/admin/product/vo/ProductLimitAreaRespVO.java

@@ -6,6 +6,8 @@ import java.util.*;
 import org.springframework.format.annotation.DateTimeFormat;
 import java.time.LocalDateTime;
 import com.alibaba.excel.annotation.*;
+import cn.iocoder.yudao.framework.excel.core.annotations.DictFormat;
+import cn.iocoder.yudao.framework.excel.core.convert.DictConvert;
 
 @Schema(description = "管理后台 - 产品区域配置 Response VO")
 @Data
@@ -29,7 +31,8 @@ public class ProductLimitAreaRespVO {
     private String addressName;
 
     @Schema(description = "是否允许")
-    @ExcelProperty("是否允许")
+    @ExcelProperty(value = "是否允许", converter = DictConvert.class)
+    @DictFormat("infra_boolean_string") // TODO 代码优化：建议设置到对应的 DictTypeConstants 枚举类中
     private Boolean allowed;
 
     @Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)

yudao-module-haoka/yudao-module-haoka-biz/src/main/java/cn/iocoder/yudao/module/haoka/controller/admin/product/vo/ProductLimitPageReqVO.java

@@ -15,7 +15,7 @@ import static cn.iocoder.yudao.framework.common.util.date.DateUtils.FORMAT_YEAR_
 @ToString(callSuper = true)
 public class ProductLimitPageReqVO extends PageParam {
 
-    @Schema(description = "产品类型名称", example = "王五")
+    @Schema(description = "产品类型名称")
     private String name;
 
     @Schema(description = "是否使用只发货地址")

yudao-module-haoka/yudao-module-haoka-biz/src/main/java/cn/iocoder/yudao/module/haoka/controller/admin/product/vo/ProductLimitRespVO.java

@@ -6,6 +6,8 @@ import java.util.*;
 import org.springframework.format.annotation.DateTimeFormat;
 import java.time.LocalDateTime;
 import com.alibaba.excel.annotation.*;
+import cn.iocoder.yudao.framework.excel.core.annotations.DictFormat;
+import cn.iocoder.yudao.framework.excel.core.convert.DictConvert;
 
 @Schema(description = "管理后台 - 产品限制条件 Response VO")
 @Data
@@ -16,20 +18,23 @@ public class ProductLimitRespVO {
     @ExcelProperty("产品类型ID")
     private Long id;
 
-    @Schema(description = "产品类型名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "王五")
+    @Schema(description = "产品类型名称", requiredMode = Schema.RequiredMode.REQUIRED)
     @ExcelProperty("产品类型名称")
     private String name;
 
     @Schema(description = "是否使用只发货地址", requiredMode = Schema.RequiredMode.REQUIRED)
-    @ExcelProperty("是否使用只发货地址")
+    @ExcelProperty(value = "是否使用只发货地址", converter = DictConvert.class)
+    @DictFormat("infra_boolean_string") // TODO 代码优化：建议设置到对应的 DictTypeConstants 枚举类中
     private Boolean useOnlySendArea;
 
     @Schema(description = "是否使用不发货地址", requiredMode = Schema.RequiredMode.REQUIRED)
-    @ExcelProperty("是否使用不发货地址")
+    @ExcelProperty(value = "是否使用不发货地址", converter = DictConvert.class)
+    @DictFormat("infra_boolean_string") // TODO 代码优化：建议设置到对应的 DictTypeConstants 枚举类中
     private Boolean useNotSendArea;
 
     @Schema(description = "是否使用身份证限制", requiredMode = Schema.RequiredMode.REQUIRED)
-    @ExcelProperty("是否使用身份证限制")
+    @ExcelProperty(value = "是否使用身份证限制", converter = DictConvert.class)
+    @DictFormat("infra_boolean_string") // TODO 代码优化：建议设置到对应的 DictTypeConstants 枚举类中
     private Boolean useCardLimit;
 
     @Schema(description = "最大年龄限制")

yudao-module-haoka/yudao-module-haoka-biz/src/main/java/cn/iocoder/yudao/module/haoka/controller/admin/product/vo/ProductLimitSaveReqVO.java

@@ -4,6 +4,7 @@ import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.*;
 import java.util.*;
 import jakarta.validation.constraints.*;
+import cn.iocoder.yudao.module.haoka.dal.dataobject.product.ProductLimitAreaDO;
 import cn.iocoder.yudao.module.haoka.dal.dataobject.product.ProductLimitCardDO;
 
 @Schema(description = "管理后台 - 产品限制条件新增/修改 Request VO")
@@ -13,7 +14,7 @@ public class ProductLimitSaveReqVO {
     @Schema(description = "产品类型ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "24464")
     private Long id;
 
-    @Schema(description = "产品类型名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "王五")
+    @Schema(description = "产品类型名称", requiredMode = Schema.RequiredMode.REQUIRED)
     @NotEmpty(message = "产品类型名称不能为空")
     private String name;
 
@@ -41,4 +42,10 @@ public class ProductLimitSaveReqVO {
     @Schema(description = "检测周期(月)")
     private Integer detectionCycle;
 
+    @Schema(description = "产品区域配置列表")
+    private List<ProductLimitAreaDO> productLimitAreas;
+
+    @Schema(description = "产品身份证限制列表")
+    private List<ProductLimitCardDO> productLimitCards;
+
 }

yudao-module-haoka/yudao-module-haoka-biz/src/main/java/cn/iocoder/yudao/module/haoka/dal/dataobject/product/ProductLimitAreaDO.java

@@ -41,6 +41,8 @@ public class ProductLimitAreaDO extends BaseDO {
     private String addressName;
     /**
      * 是否允许
+     *
+     * 枚举 {@link TODO infra_boolean_string 对应的类}
      */
     private Boolean allowed;
     /**

yudao-module-haoka/yudao-module-haoka-biz/src/main/java/cn/iocoder/yudao/module/haoka/dal/dataobject/product/ProductLimitDO.java

@@ -33,14 +33,20 @@ public class ProductLimitDO extends BaseDO {
     private String name;
     /**
      * 是否使用只发货地址
+     *
+     * 枚举 {@link TODO infra_boolean_string 对应的类}
      */
     private Boolean useOnlySendArea;
     /**
      * 是否使用不发货地址
+     *
+     * 枚举 {@link TODO infra_boolean_string 对应的类}
      */
     private Boolean useNotSendArea;
     /**
      * 是否使用身份证限制
+     *
+     * 枚举 {@link TODO infra_boolean_string 对应的类}
      */
     private Boolean useCardLimit;
     /**

yudao-module-haoka/yudao-module-haoka-biz/src/main/java/cn/iocoder/yudao/module/haoka/dal/mysql/product/ProductLimitAreaMapper.java

@@ -27,4 +27,12 @@ public interface ProductLimitAreaMapper extends BaseMapperX<ProductLimitAreaDO>
                 .orderByDesc(ProductLimitAreaDO::getId));
     }
 
-}
+    default List<ProductLimitAreaDO> selectListByHaokaProductLimitId(Long haokaProductLimitId) {
+        return selectList(new LambdaQueryWrapperX<ProductLimitAreaDO>()
+                .eqIfPresent(ProductLimitAreaDO::getHaokaProductLimitId, haokaProductLimitId));
+    }
+
+    default void deleteByHaokaProductLimitId(Long haokaProductLimitId) {
+        delete(ProductLimitAreaDO::getHaokaProductLimitId, haokaProductLimitId);
+    }
+}

yudao-module-haoka/yudao-module-haoka-biz/src/main/java/cn/iocoder/yudao/module/haoka/dal/mysql/product/ProductLimitCardMapper.java

@@ -1,12 +1,14 @@
 package cn.iocoder.yudao.module.haoka.dal.mysql.product;
 
+import java.util.*;
+
 import cn.iocoder.yudao.framework.common.pojo.PageParam;
 import cn.iocoder.yudao.framework.common.pojo.PageResult;
-import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
 import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
-import cn.iocoder.yudao.module.haoka.controller.admin.product.vo.ProductLimitCardPageReqVO;
+import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
 import cn.iocoder.yudao.module.haoka.dal.dataobject.product.ProductLimitCardDO;
 import org.apache.ibatis.annotations.Mapper;
+import cn.iocoder.yudao.module.haoka.controller.admin.product.vo.*;
 
 /**
  * 产品身份证限制 Mapper
@@ -34,5 +36,8 @@ public interface ProductLimitCardMapper extends BaseMapperX<ProductLimitCardDO>
         delete(ProductLimitCardDO::getHaokaProductLimitId, haokaProductLimitId);
     }
 
-
+    default List<ProductLimitCardDO> selectListByHaokaProductLimitId(Long haokaProductLimitId) {
+        return selectList(new LambdaQueryWrapperX<ProductLimitCardDO>()
+                .eqIfPresent(ProductLimitCardDO::getHaokaProductLimitId, haokaProductLimitId));
+    }
 }

yudao-module-haoka/yudao-module-haoka-biz/src/main/java/cn/iocoder/yudao/module/haoka/service/product/ProductLimitService.java

@@ -4,6 +4,7 @@ import java.util.*;
 import jakarta.validation.*;
 import cn.iocoder.yudao.module.haoka.controller.admin.product.vo.*;
 import cn.iocoder.yudao.module.haoka.dal.dataobject.product.ProductLimitDO;
+import cn.iocoder.yudao.module.haoka.dal.dataobject.product.ProductLimitAreaDO;
 import cn.iocoder.yudao.module.haoka.dal.dataobject.product.ProductLimitCardDO;
 import cn.iocoder.yudao.framework.common.pojo.PageResult;
 import cn.iocoder.yudao.framework.common.pojo.PageParam;
@@ -53,45 +54,24 @@ public interface ProductLimitService {
      */
     PageResult<ProductLimitDO> getProductLimitPage(ProductLimitPageReqVO pageReqVO);
 
+    // ==================== 子表（产品区域配置） ====================
+
+    /**
+     * 获得产品区域配置列表
+     *
+     * @param haokaProductLimitId 产品限制ID
+     * @return 产品区域配置列表
+     */
+    List<ProductLimitAreaDO> getProductLimitAreaListByHaokaProductLimitId(Long haokaProductLimitId);
+
     // ==================== 子表（产品身份证限制） ====================
 
     /**
-     * 获得产品身份证限制分页
+     * 获得产品身份证限制列表
      *
-     * @param pageReqVO 分页查询
      * @param haokaProductLimitId 产品限制ID
-     * @return 产品身份证限制分页
+     * @return 产品身份证限制列表
      */
-    PageResult<ProductLimitCardDO> getProductLimitCardPage(PageParam pageReqVO, Long haokaProductLimitId);
+    List<ProductLimitCardDO> getProductLimitCardListByHaokaProductLimitId(Long haokaProductLimitId);
-
-    /**
-     * 创建产品身份证限制
-     *
-     * @param productLimitCard 创建信息
-     * @return 编号
-     */
-    Long createProductLimitCard(@Valid ProductLimitCardDO productLimitCard);
-
-    /**
-     * 更新产品身份证限制
-     *
-     * @param productLimitCard 更新信息
-     */
-    void updateProductLimitCard(@Valid ProductLimitCardDO productLimitCard);
-
-    /**
-     * 删除产品身份证限制
-     *
-     * @param id 编号
-     */
-    void deleteProductLimitCard(Long id);
-
-	/**
-	 * 获得产品身份证限制
-	 *
-	 * @param id 编号
-     * @return 产品身份证限制
-	 */
-    ProductLimitCardDO getProductLimitCard(Long id);
 
 }

yudao-module-haoka/yudao-module-haoka-biz/src/main/java/cn/iocoder/yudao/module/haoka/service/product/ProductLimitServiceImpl.java

@@ -8,12 +8,14 @@ import org.springframework.transaction.annotation.Transactional;
 import java.util.*;
 import cn.iocoder.yudao.module.haoka.controller.admin.product.vo.*;
 import cn.iocoder.yudao.module.haoka.dal.dataobject.product.ProductLimitDO;
+import cn.iocoder.yudao.module.haoka.dal.dataobject.product.ProductLimitAreaDO;
 import cn.iocoder.yudao.module.haoka.dal.dataobject.product.ProductLimitCardDO;
 import cn.iocoder.yudao.framework.common.pojo.PageResult;
 import cn.iocoder.yudao.framework.common.pojo.PageParam;
 import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
 
 import cn.iocoder.yudao.module.haoka.dal.mysql.product.ProductLimitMapper;
+import cn.iocoder.yudao.module.haoka.dal.mysql.product.ProductLimitAreaMapper;
 import cn.iocoder.yudao.module.haoka.dal.mysql.product.ProductLimitCardMapper;
 
 import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
@@ -31,24 +33,36 @@ public class ProductLimitServiceImpl implements ProductLimitService {
     @Resource
     private ProductLimitMapper productLimitMapper;
     @Resource
+    private ProductLimitAreaMapper productLimitAreaMapper;
+    @Resource
     private ProductLimitCardMapper productLimitCardMapper;
 
     @Override
+    @Transactional(rollbackFor = Exception.class)
     public Long createProductLimit(ProductLimitSaveReqVO createReqVO) {
         // 插入
         ProductLimitDO productLimit = BeanUtils.toBean(createReqVO, ProductLimitDO.class);
         productLimitMapper.insert(productLimit);
+
+        // 插入子表
+        createProductLimitAreaList(productLimit.getId(), createReqVO.getProductLimitAreas());
+        createProductLimitCardList(productLimit.getId(), createReqVO.getProductLimitCards());
         // 返回
         return productLimit.getId();
     }
 
     @Override
+    @Transactional(rollbackFor = Exception.class)
     public void updateProductLimit(ProductLimitSaveReqVO updateReqVO) {
         // 校验存在
         validateProductLimitExists(updateReqVO.getId());
         // 更新
         ProductLimitDO updateObj = BeanUtils.toBean(updateReqVO, ProductLimitDO.class);
         productLimitMapper.updateById(updateObj);
+
+        // 更新子表
+        updateProductLimitAreaList(updateReqVO.getId(), updateReqVO.getProductLimitAreas());
+        updateProductLimitCardList(updateReqVO.getId(), updateReqVO.getProductLimitCards());
     }
 
     @Override
@@ -60,6 +74,7 @@ public class ProductLimitServiceImpl implements ProductLimitService {
         productLimitMapper.deleteById(id);
 
         // 删除子表
+        deleteProductLimitAreaByHaokaProductLimitId(id);
         deleteProductLimitCardByHaokaProductLimitId(id);
     }
 
@@ -79,45 +94,44 @@ public class ProductLimitServiceImpl implements ProductLimitService {
         return productLimitMapper.selectPage(pageReqVO);
     }
 
+    // ==================== 子表（产品区域配置） ====================
+
+    @Override
+    public List<ProductLimitAreaDO> getProductLimitAreaListByHaokaProductLimitId(Long haokaProductLimitId) {
+        return productLimitAreaMapper.selectListByHaokaProductLimitId(haokaProductLimitId);
+    }
+
+    private void createProductLimitAreaList(Long haokaProductLimitId, List<ProductLimitAreaDO> list) {
+        list.forEach(o -> o.setHaokaProductLimitId(haokaProductLimitId));
+        productLimitAreaMapper.insertBatch(list);
+    }
+
+    private void updateProductLimitAreaList(Long haokaProductLimitId, List<ProductLimitAreaDO> list) {
+        deleteProductLimitAreaByHaokaProductLimitId(haokaProductLimitId);
+		list.forEach(o -> o.setId(null).setUpdater(null).setUpdateTime(null)); // 解决更新情况下：1）id 冲突；2）updateTime 不更新
+        createProductLimitAreaList(haokaProductLimitId, list);
+    }
+
+    private void deleteProductLimitAreaByHaokaProductLimitId(Long haokaProductLimitId) {
+        productLimitAreaMapper.deleteByHaokaProductLimitId(haokaProductLimitId);
+    }
+
     // ==================== 子表（产品身份证限制） ====================
 
     @Override
-    public PageResult<ProductLimitCardDO> getProductLimitCardPage(PageParam pageReqVO, Long haokaProductLimitId) {
+    public List<ProductLimitCardDO> getProductLimitCardListByHaokaProductLimitId(Long haokaProductLimitId) {
-        return productLimitCardMapper.selectPage(pageReqVO, haokaProductLimitId);
+        return productLimitCardMapper.selectListByHaokaProductLimitId(haokaProductLimitId);
     }
 
-    @Override
+    private void createProductLimitCardList(Long haokaProductLimitId, List<ProductLimitCardDO> list) {
-    public Long createProductLimitCard(ProductLimitCardDO productLimitCard) {
+        list.forEach(o -> o.setHaokaProductLimitId(haokaProductLimitId));
-        productLimitCardMapper.insert(productLimitCard);
+        productLimitCardMapper.insertBatch(list);
-        return productLimitCard.getId();
     }
 
-    @Override
+    private void updateProductLimitCardList(Long haokaProductLimitId, List<ProductLimitCardDO> list) {
-    public void updateProductLimitCard(ProductLimitCardDO productLimitCard) {
+        deleteProductLimitCardByHaokaProductLimitId(haokaProductLimitId);
-        // 校验存在
+		list.forEach(o -> o.setId(null).setUpdater(null).setUpdateTime(null)); // 解决更新情况下：1）id 冲突；2）updateTime 不更新
-        validateProductLimitCardExists(productLimitCard.getId());
+        createProductLimitCardList(haokaProductLimitId, list);
-        // 更新
-        productLimitCard.setUpdater(null).setUpdateTime(null); // 解决更新情况下：updateTime 不更新
-        productLimitCardMapper.updateById(productLimitCard);
-    }
-
-    @Override
-    public void deleteProductLimitCard(Long id) {
-        // 校验存在
-        validateProductLimitCardExists(id);
-        // 删除
-        productLimitCardMapper.deleteById(id);
-    }
-
-    @Override
-    public ProductLimitCardDO getProductLimitCard(Long id) {
-        return productLimitCardMapper.selectById(id);
-    }
-
-    private void validateProductLimitCardExists(Long id) {
-        if (productLimitCardMapper.selectById(id) == null) {
-            throw exception(PRODUCT_LIMIT_CARD_NOT_EXISTS);
-        }
     }
 
     private void deleteProductLimitCardByHaokaProductLimitId(Long haokaProductLimitId) {