szz
/
ShiShiYiBan
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Feat: Code gen V3 ok

This commit is contained in:
Owen 2024-12-16 18:07:59 +08:00
parent 8b5603a1f4
commit 97e3380e3a
11 changed files with 120 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -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")
@Operation(summary = "获得产品身份证限制分页")
@GetMapping("/product-limit-area/list-by-haoka-product-limit-id")
@Operation(summary = "获得产品区域配置列表")
@Parameter(name = "haokaProductLimitId", description = "产品限制ID")
@PreAuthorize("@ss.hasPermission('haoka:product-limit:query')")
public CommonResult<PageResult<ProductLimitCardDO>> getProductLimitCardPage(PageParam pageReqVO,
@RequestParam("haokaProductLimitId") Long haokaProductLimitId) {
return success(productLimitService.getProductLimitCardPage(pageReqVO, haokaProductLimitId));
public CommonResult<List<ProductLimitAreaDO>> getProductLimitAreaListByHaokaProductLimitId(@RequestParam("haokaProductLimitId") Long haokaProductLimitId) {
return success(productLimitService.getProductLimitAreaListByHaokaProductLimitId(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")
@Operation(summary = "更新产品身份证限制")
@PreAuthorize("@ss.hasPermission('haoka:product-limit:update')")
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)
@GetMapping("/product-limit-card/list-by-haoka-product-limit-id")
@Operation(summary = "获得产品身份证限制列表")
@Parameter(name = "haokaProductLimitId", description = "产品限制ID")
@PreAuthorize("@ss.hasPermission('haoka:product-limit:query')")
public CommonResult<ProductLimitCardDO> getProductLimitCard(@RequestParam("id") Long id) {
return success(productLimitService.getProductLimitCard(id));
}
public CommonResult<List<ProductLimitCardDO>> getProductLimitCardListByHaokaProductLimitId(@RequestParam("haokaProductLimitId") Long haokaProductLimitId) {
return success(productLimitService.getProductLimitCardListByHaokaProductLimitId(haokaProductLimitId));
}
}

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

@ -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)

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

@ -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 = "是否使用只发货地址")

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

@ -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 = "最大年龄限制")

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

@ -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;
}

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

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

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

@ -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;
/**

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

@ -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);
}
}

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

@ -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));
}
}

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

@ -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);
/**
* 创建产品身份证限制
*
* @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);
List<ProductLimitCardDO> getProductLimitCardListByHaokaProductLimitId(Long haokaProductLimitId);
}

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

@ -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) {
return productLimitCardMapper.selectPage(pageReqVO, haokaProductLimitId);
public List<ProductLimitCardDO> getProductLimitCardListByHaokaProductLimitId(Long haokaProductLimitId) {
return productLimitCardMapper.selectListByHaokaProductLimitId(haokaProductLimitId);
}
@Override
public Long createProductLimitCard(ProductLimitCardDO productLimitCard) {
productLimitCardMapper.insert(productLimitCard);
return productLimitCard.getId();
private void createProductLimitCardList(Long haokaProductLimitId, List<ProductLimitCardDO> list) {
list.forEach(o -> o.setHaokaProductLimitId(haokaProductLimitId));
productLimitCardMapper.insertBatch(list);
}
@Override
public void updateProductLimitCard(ProductLimitCardDO productLimitCard) {
// 校验存在
validateProductLimitCardExists(productLimitCard.getId());
// 更新
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 updateProductLimitCardList(Long haokaProductLimitId, List<ProductLimitCardDO> list) {
deleteProductLimitCardByHaokaProductLimitId(haokaProductLimitId);
list.forEach(o -> o.setId(null).setUpdater(null).setUpdateTime(null)); // 解决更新情况下：1）id 冲突；2）updateTime 不更新
createProductLimitCardList(haokaProductLimitId, list);
}
private void deleteProductLimitCardByHaokaProductLimitId(Long haokaProductLimitId) {