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

Feat: Api 联通 + 地区整理

This commit is contained in:
Owen 2024-12-26 18:22:06 +08:00
parent 4df3bfb6b5
commit 598d68cab3
25 changed files with 1296 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
yudao-module-haoka/yudao-module-haoka-biz/src/main/java/cn/iocoder/yudao/module/haoka/controller/admin/address/AddressAreaController.java Normal file
View File

@ -0,0 +1,46 @@
package cn.iocoder.yudao.module.haoka.controller.admin.address;
import cn.iocoder.yudao.framework.common.pojo.CommonResult;
import cn.iocoder.yudao.module.haoka.controller.admin.address.vo.AddressVo;
import cn.iocoder.yudao.module.haoka.service.address.HaoKaAddressService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
@Tag(name = "管理后台 - 地址")
@RestController
@RequestMapping("/haoka/address")
@Validated
public class AddressAreaController {
@Resource
private HaoKaAddressService haoKaAddressService;
@GetMapping("/get")
@Operation(summary = "获得区县")
@Parameter(name = "code", description = "编号", required = true, example = "1024")
@Parameter(name = "level", description = "编号", required = true, example = "1024")
public CommonResult<List<AddressVo>> getSubAddressList(@RequestParam("code") String code, @RequestParam AddressVo.Level level) {
return success(haoKaAddressService.getSubAddressList(code, level));
}
@GetMapping("/getAllAddress")
@Operation(summary = "获得省市县")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
public CommonResult<List<AddressVo>> getAllAddress() {
return success(haoKaAddressService.getAllAddress());
}
}

12
yudao-module-haoka/yudao-module-haoka-biz/src/main/java/cn/iocoder/yudao/module/haoka/controller/admin/address/vo/AddressVo.java
View File

@ -1,5 +1,7 @@
package cn.iocoder.yudao.module.haoka.controller.admin.address.vo;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.Data;
@ -33,6 +35,14 @@ public class AddressVo {
@Schema(description = "级别:省，市，县区，镇街道乡，乡村")
private Level level;
@Schema(description = "名字")
@Schema(description = "子地区")
private List<AddressVo> addressList;
private String streetCode;
private String provinceCode;
private String cityCode;
private String areaCode;
}

41
yudao-module-haoka/yudao-module-haoka-biz/src/main/java/cn/iocoder/yudao/module/haoka/dal/dataobject/address/AddressAreaDO.java Normal file
View File

@ -0,0 +1,41 @@
package cn.iocoder.yudao.module.haoka.dal.dataobject.address;
import lombok.*;
import java.util.*;
import com.baomidou.mybatisplus.annotation.*;
import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
/**
* 区县 DO
*
* @author 芋道源码
*/
@TableName("haoka_area")
@KeySequence("haoka_area_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库，可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class AddressAreaDO extends BaseDO {
/**
* 区县编码
*/
@TableId(type = IdType.INPUT)
private String code;
/**
* 区县名字
*/
private String name;
/**
* 市编码
*/
private String cityCode;
/**
* 省编码
*/
private String provinceCode;
}

37
yudao-module-haoka/yudao-module-haoka-biz/src/main/java/cn/iocoder/yudao/module/haoka/dal/dataobject/address/AddressCityDO.java Normal file
View File

@ -0,0 +1,37 @@
package cn.iocoder.yudao.module.haoka.dal.dataobject.address;
import lombok.*;
import java.util.*;
import com.baomidou.mybatisplus.annotation.*;
import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
/**
* 市 DO
*
* @author 芋道源码
*/
@TableName("haoka_city")
@KeySequence("haoka_city_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库，可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class AddressCityDO extends BaseDO {
/**
* 市编码
*/
@TableId(type = IdType.INPUT)
private String code;
/**
* 市名字
*/
private String name;
/**
* 省编码
*/
private String provinceCode;
}

33
yudao-module-haoka/yudao-module-haoka-biz/src/main/java/cn/iocoder/yudao/module/haoka/dal/dataobject/address/AddressProvinceDO.java Normal file
View File

@ -0,0 +1,33 @@
package cn.iocoder.yudao.module.haoka.dal.dataobject.address;
import lombok.*;
import java.util.*;
import com.baomidou.mybatisplus.annotation.*;
import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
/**
* 省 DO
*
* @author 芋道源码
*/
@TableName("haoka_province")
@KeySequence("haoka_province_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库，可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class AddressProvinceDO extends BaseDO {
/**
* 省编码
*/
@TableId(type = IdType.INPUT)
private String code;
/**
* 省名字
*/
private String name;
}

45
yudao-module-haoka/yudao-module-haoka-biz/src/main/java/cn/iocoder/yudao/module/haoka/dal/dataobject/address/AddressStreetDO.java Normal file
View File

@ -0,0 +1,45 @@
package cn.iocoder.yudao.module.haoka.dal.dataobject.address;
import lombok.*;
import java.util.*;
import com.baomidou.mybatisplus.annotation.*;
import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
/**
* 街道/镇 DO
*
* @author 芋道源码
*/
@TableName("haoka_street")
@KeySequence("haoka_street_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库，可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class AddressStreetDO extends BaseDO {
/**
* 街道编码
*/
@TableId(type = IdType.INPUT)
private String code;
/**
* 街道名字
*/
private String name;
/**
* 区县编码
*/
private String areaCode;
/**
* 省编码
*/
private String provinceCode;
/**
* 市编码
*/
private String cityCode;
}

49
yudao-module-haoka/yudao-module-haoka-biz/src/main/java/cn/iocoder/yudao/module/haoka/dal/dataobject/address/AddressVillageDO.java Normal file
View File

@ -0,0 +1,49 @@
package cn.iocoder.yudao.module.haoka.dal.dataobject.address;
import lombok.*;
import java.util.*;
import com.baomidou.mybatisplus.annotation.*;
import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
/**
* 乡村 DO
*
* @author 芋道源码
*/
@TableName("haoka_village")
@KeySequence("haoka_village_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库，可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class AddressVillageDO extends BaseDO {
/**
* 乡村编码
*/
@TableId(type = IdType.INPUT)
private String code;
/**
* 乡村名字
*/
private String name;
/**
* 街道编码
*/
private String streetCode;
/**
* 省编码
*/
private String provinceCode;
/**
* 市区编码
*/
private String cityCode;
/**
* 区县编码
*/
private String areaCode;
}

16
yudao-module-haoka/yudao-module-haoka-biz/src/main/java/cn/iocoder/yudao/module/haoka/dal/mysql/address/AddressAreaMapper.java Normal file
View File

@ -0,0 +1,16 @@
package cn.iocoder.yudao.module.haoka.dal.mysql.address;
import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.module.haoka.dal.dataobject.address.AddressAreaDO;
import org.apache.ibatis.annotations.Mapper;
/**
* 区县 Mapper
*
* @author 芋道源码
*/
@Mapper
public interface AddressAreaMapper extends BaseMapperX<AddressAreaDO> {
}

15
yudao-module-haoka/yudao-module-haoka-biz/src/main/java/cn/iocoder/yudao/module/haoka/dal/mysql/address/AddressCityMapper.java Normal file
View File

@ -0,0 +1,15 @@
package cn.iocoder.yudao.module.haoka.dal.mysql.address;
import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.module.haoka.dal.dataobject.address.AddressCityDO;
import org.apache.ibatis.annotations.Mapper;
/**
* 市 Mapper
*
* @author 芋道源码
*/
@Mapper
public interface AddressCityMapper extends BaseMapperX<AddressCityDO> {
}

16
yudao-module-haoka/yudao-module-haoka-biz/src/main/java/cn/iocoder/yudao/module/haoka/dal/mysql/address/AddressProvinceMapper.java Normal file
View File

@ -0,0 +1,16 @@
package cn.iocoder.yudao.module.haoka.dal.mysql.address;
import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.module.haoka.dal.dataobject.address.AddressProvinceDO;
import org.apache.ibatis.annotations.Mapper;
/**
* 省 Mapper
*
* @author 芋道源码
*/
@Mapper
public interface AddressProvinceMapper extends BaseMapperX<AddressProvinceDO> {
}

15
yudao-module-haoka/yudao-module-haoka-biz/src/main/java/cn/iocoder/yudao/module/haoka/dal/mysql/address/AddressStreetMapper.java Normal file
View File

@ -0,0 +1,15 @@
package cn.iocoder.yudao.module.haoka.dal.mysql.address;
import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.module.haoka.dal.dataobject.address.AddressStreetDO;
import org.apache.ibatis.annotations.Mapper;
/**
* 街道/镇 Mapper
*
* @author 芋道源码
*/
@Mapper
public interface AddressStreetMapper extends BaseMapperX<AddressStreetDO> {
}

20
yudao-module-haoka/yudao-module-haoka-biz/src/main/java/cn/iocoder/yudao/module/haoka/dal/mysql/address/AddressVillageMapper.java Normal file
View File

@ -0,0 +1,20 @@
package cn.iocoder.yudao.module.haoka.dal.mysql.address;
import java.util.*;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.module.haoka.dal.dataobject.address.AddressVillageDO;
import org.apache.ibatis.annotations.Mapper;
import cn.iocoder.yudao.module.haoka.controller.admin.address.vo.*;
/**
* 乡村 Mapper
*
* @author 芋道源码
*/
@Mapper
public interface AddressVillageMapper extends BaseMapperX<AddressVillageDO> {
}

22
yudao-module-haoka/yudao-module-haoka-biz/src/main/java/cn/iocoder/yudao/module/haoka/service/address/HaoKaAddressService.java Normal file
View File

@ -0,0 +1,22 @@
package cn.iocoder.yudao.module.haoka.service.address;
import java.util.*;
import jakarta.validation.*;
import cn.iocoder.yudao.module.haoka.controller.admin.address.vo.*;
import cn.iocoder.yudao.module.haoka.dal.dataobject.address.AddressAreaDO;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
/**
* 区县 Service 接口
*
* @author 芋道源码
*/
public interface HaoKaAddressService {
List<AddressVo> getSubAddressList(String code, AddressVo.Level level);
List<AddressVo> getAllAddress();
}

166
yudao-module-haoka/yudao-module-haoka-biz/src/main/java/cn/iocoder/yudao/module/haoka/service/address/HaokaAddressServiceImpl.java Normal file
View File

@ -0,0 +1,166 @@
package cn.iocoder.yudao.module.haoka.service.address;
import cn.hutool.core.collection.CollectionUtil;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.module.haoka.dal.dataobject.address.*;
import cn.iocoder.yudao.module.haoka.dal.mysql.address.*;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.springframework.stereotype.Service;
import jakarta.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import cn.iocoder.yudao.module.haoka.controller.admin.address.vo.*;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import java.util.*;
import java.util.stream.Collectors;
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.haoka.enums.ErrorCodeConstants.*;
/**
* 区县 Service 实现类
*
* @author 芋道源码
*/
@Service
@Validated
public class HaokaAddressServiceImpl implements HaoKaAddressService {
@Resource
private AddressAreaMapper addressAreaMapper;
@Resource
private AddressCityMapper addressCityMapper;
@Resource
private AddressProvinceMapper addressProvinceMapper;
@Resource
private AddressStreetMapper addressStreetMapper;
@Resource
private AddressVillageMapper addressVillageMapper;
@Override
public List<AddressVo> getSubAddressList(String code, AddressVo.Level level) {
List<AddressVo> addressVos = new ArrayList<>();
if (level.equals(AddressVo.Level.National)) {
List<AddressProvinceDO> addressProvinceDOS = addressProvinceMapper.selectList(
new LambdaQueryWrapperX<AddressProvinceDO>()
.orderByAsc(AddressProvinceDO::getCode)
);
addressVos = BeanUtils.toBean(addressProvinceDOS, AddressVo.class);
addressVos.forEach(o -> o.setLevel(AddressVo.Level.Province));
}
if (level.equals(AddressVo.Level.Province)) {
List<AddressCityDO> addressList = addressCityMapper.selectList(
new LambdaQueryWrapperX<AddressCityDO>()
.eqIfPresent(AddressCityDO::getProvinceCode, code)
.orderByAsc(AddressCityDO::getCode)
);
addressVos = BeanUtils.toBean(addressList, AddressVo.class);
addressVos.forEach(o -> o.setLevel(AddressVo.Level.City));
}
if (level.equals(AddressVo.Level.City)) {
List<AddressAreaDO> addressList = addressAreaMapper.selectList(
new LambdaQueryWrapperX<AddressAreaDO>()
.eqIfPresent(AddressAreaDO::getCityCode, code)
.orderByAsc(AddressAreaDO::getCode)
);
addressVos = BeanUtils.toBean(addressList, AddressVo.class);
addressVos.forEach(o -> o.setLevel(AddressVo.Level.Area));
}
if (level.equals(AddressVo.Level.Area)) {
List<AddressStreetDO> addressList = addressStreetMapper.selectList(
new LambdaQueryWrapperX<AddressStreetDO>()
.eqIfPresent(AddressStreetDO::getAreaCode, code)
.orderByAsc(AddressStreetDO::getCode)
);
addressVos = BeanUtils.toBean(addressList, AddressVo.class);
addressVos.forEach(o -> o.setLevel(AddressVo.Level.Street));
}
if (level.equals(AddressVo.Level.Street)) {
List<AddressVillageDO> addressList = addressVillageMapper.selectList(
new LambdaQueryWrapperX<AddressVillageDO>()
.eqIfPresent(AddressVillageDO::getStreetCode, code)
.orderByAsc(AddressVillageDO::getCode)
);
addressVos = BeanUtils.toBean(addressList, AddressVo.class);
addressVos.forEach(o -> o.setLevel(AddressVo.Level.Village));
}
return addressVos;
}
@Override
public List<AddressVo> getAllAddress() {
// 获取省、市、县的数据
List<AddressProvinceDO> addressProvinceDOS = addressProvinceMapper.selectList(new LambdaQueryWrapperX<AddressProvinceDO>()
.orderByAsc(AddressProvinceDO::getCode));
List<AddressCityDO> addressCityDOS = addressCityMapper.selectList(
new LambdaQueryWrapperX<AddressCityDO>()
.orderByAsc(AddressCityDO::getCode)
);
List<AddressAreaDO> addressAreaDOS = addressAreaMapper.selectList(
new LambdaQueryWrapperX<AddressAreaDO>()
.orderByAsc(AddressAreaDO::getCode)
);
// 县到市区里面
Map<String, List<AddressAreaDO>> areacMap = addressAreaDOS.stream()
.collect(Collectors.groupingBy(AddressAreaDO::getCityCode));
Map<String, List<AddressCityDO>> provCtysMap = addressCityDOS.stream().collect(Collectors.groupingBy(AddressCityDO::getProvinceCode));
// 是到 省
List<AddressVo> provinceList = new ArrayList<>();
addressProvinceDOS.forEach(p->{
AddressVo newP= BeanUtils.toBean(p,AddressVo.class);
newP.setLevel(AddressVo.Level.Province);
List<AddressCityDO> subCts = provCtysMap.get(p.getCode());
if (CollectionUtil.isNotEmpty(subCts) ){
List<AddressVo> cities = new ArrayList<>();
subCts.forEach(one -> {
AddressVo areaVo = BeanUtils.toBean(one, AddressVo.class);
areaVo.setLevel(AddressVo.Level.City);
List<AddressAreaDO> subArea = areacMap.get(one.getCode());
if (CollectionUtil.isNotEmpty(subArea)) {
List<AddressVo> collect = subArea.stream().map(o -> {
AddressVo bean = BeanUtils.toBean(o, AddressVo.class);
bean.setLevel(AddressVo.Level.Area);
return bean;
}).collect(Collectors.toList());
areaVo.setAddressList(collect);
}
cities.add(areaVo);
});
newP.setAddressList(cities);
}
provinceList.add(newP);
});
return provinceList;
}
}

12
yudao-module-haoka/yudao-module-haoka-biz/src/main/resources/mapper/address/AddressAreaMapper.xml Normal file
View File

@ -0,0 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.iocoder.yudao.module.haoka.dal.mysql.address.AddressAreaMapper">
<!--
一般情况下，尽可能使用 Mapper 进行 CRUD 增删改查即可。
无法满足的场景，例如说多表关联查询，才使用 XML 编写 SQL。
代码生成器暂时只生成 Mapper XML 文件本身，更多推荐 MybatisX 快速开发插件来生成查询。
文档可见：https://www.iocoder.cn/MyBatis/x-plugins/
-->
</mapper>

12
yudao-module-haoka/yudao-module-haoka-biz/src/main/resources/mapper/address/AddressCityMapper.xml Normal file
View File

@ -0,0 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.iocoder.yudao.module.haoka.dal.mysql.address.AddressCityMapper">
<!--
一般情况下，尽可能使用 Mapper 进行 CRUD 增删改查即可。
无法满足的场景，例如说多表关联查询，才使用 XML 编写 SQL。
代码生成器暂时只生成 Mapper XML 文件本身，更多推荐 MybatisX 快速开发插件来生成查询。
文档可见：https://www.iocoder.cn/MyBatis/x-plugins/
-->
</mapper>

12
yudao-module-haoka/yudao-module-haoka-biz/src/main/resources/mapper/address/AddressProvinceMapper.xml Normal file
View File

@ -0,0 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.iocoder.yudao.module.haoka.dal.mysql.address.AddressProvinceMapper">
<!--
一般情况下，尽可能使用 Mapper 进行 CRUD 增删改查即可。
无法满足的场景，例如说多表关联查询，才使用 XML 编写 SQL。
代码生成器暂时只生成 Mapper XML 文件本身，更多推荐 MybatisX 快速开发插件来生成查询。
文档可见：https://www.iocoder.cn/MyBatis/x-plugins/
-->
</mapper>

12
yudao-module-haoka/yudao-module-haoka-biz/src/main/resources/mapper/address/AddressStreetMapper.xml Normal file
View File

@ -0,0 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.iocoder.yudao.module.haoka.dal.mysql.address.AddressStreetMapper">
<!--
一般情况下，尽可能使用 Mapper 进行 CRUD 增删改查即可。
无法满足的场景，例如说多表关联查询，才使用 XML 编写 SQL。
代码生成器暂时只生成 Mapper XML 文件本身，更多推荐 MybatisX 快速开发插件来生成查询。
文档可见：https://www.iocoder.cn/MyBatis/x-plugins/
-->
</mapper>

12
yudao-module-haoka/yudao-module-haoka-biz/src/main/resources/mapper/address/AddressVillageMapper.xml Normal file
View File

@ -0,0 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.iocoder.yudao.module.haoka.dal.mysql.address.AddressVillageMapper">
<!--
一般情况下，尽可能使用 Mapper 进行 CRUD 增删改查即可。
无法满足的场景，例如说多表关联查询，才使用 XML 编写 SQL。
代码生成器暂时只生成 Mapper XML 文件本身，更多推荐 MybatisX 快速开发插件来生成查询。
文档可见：https://www.iocoder.cn/MyBatis/x-plugins/
-->
</mapper>

138
yudao-module-haoka/yudao-module-haoka-biz/src/test/java/cn/iocoder/yudao/module/haoka/service/address/AddressAreaServiceImplTest.java Normal file
View File

@ -0,0 +1,138 @@
package cn.iocoder.yudao.module.haoka.service.address;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.mock.mockito.MockBean;
import jakarta.annotation.Resource;
import cn.iocoder.yudao.framework.test.core.ut.BaseDbUnitTest;
import cn.iocoder.yudao.module.haoka.controller.admin.address.vo.*;
import cn.iocoder.yudao.module.haoka.dal.dataobject.address.AddressAreaDO;
import cn.iocoder.yudao.module.haoka.dal.mysql.address.AddressAreaMapper;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import jakarta.annotation.Resource;
import org.springframework.context.annotation.Import;
import java.util.*;
import java.time.LocalDateTime;
import static cn.hutool.core.util.RandomUtil.*;
import static cn.iocoder.yudao.module.haoka.enums.ErrorCodeConstants.*;
import static cn.iocoder.yudao.framework.test.core.util.AssertUtils.*;
import static cn.iocoder.yudao.framework.test.core.util.RandomUtils.*;
import static cn.iocoder.yudao.framework.common.util.date.LocalDateTimeUtils.*;
import static cn.iocoder.yudao.framework.common.util.object.ObjectUtils.*;
import static cn.iocoder.yudao.framework.common.util.date.DateUtils.*;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
/**
* {@link AddressAreaServiceImpl} 的单元测试类
*
* @author 芋道源码
*/
@Import(AddressAreaServiceImpl.class)
public class AddressAreaServiceImplTest extends BaseDbUnitTest {
@Resource
private AddressAreaServiceImpl addressAreaService;
@Resource
private AddressAreaMapper addressAreaMapper;
@Test
public void testCreateAddressArea_success() {
// 准备参数
AddressAreaSaveReqVO createReqVO = randomPojo(AddressAreaSaveReqVO.class).setId(null);
// 调用
String addressAreaId = addressAreaService.createAddressArea(createReqVO);
// 断言
assertNotNull(addressAreaId);
// 校验记录的属性是否正确
AddressAreaDO addressArea = addressAreaMapper.selectById(addressAreaId);
assertPojoEquals(createReqVO, addressArea, "id");
}
@Test
public void testUpdateAddressArea_success() {
// mock 数据
AddressAreaDO dbAddressArea = randomPojo(AddressAreaDO.class);
addressAreaMapper.insert(dbAddressArea);// @Sql: 先插入出一条存在的数据
// 准备参数
AddressAreaSaveReqVO updateReqVO = randomPojo(AddressAreaSaveReqVO.class, o -> {
o.setId(dbAddressArea.getId()); // 设置更新的 ID
});
// 调用
addressAreaService.updateAddressArea(updateReqVO);
// 校验是否更新正确
AddressAreaDO addressArea = addressAreaMapper.selectById(updateReqVO.getId()); // 获取最新的
assertPojoEquals(updateReqVO, addressArea);
}
@Test
public void testUpdateAddressArea_notExists() {
// 准备参数
AddressAreaSaveReqVO updateReqVO = randomPojo(AddressAreaSaveReqVO.class);
// 调用, 并断言异常
assertServiceException(() -> addressAreaService.updateAddressArea(updateReqVO), ADDRESS_AREA_NOT_EXISTS);
}
@Test
public void testDeleteAddressArea_success() {
// mock 数据
AddressAreaDO dbAddressArea = randomPojo(AddressAreaDO.class);
addressAreaMapper.insert(dbAddressArea);// @Sql: 先插入出一条存在的数据
// 准备参数
String id = dbAddressArea.getId();
// 调用
addressAreaService.deleteAddressArea(id);
// 校验数据不存在了
assertNull(addressAreaMapper.selectById(id));
}
@Test
public void testDeleteAddressArea_notExists() {
// 准备参数
String id = randomStringId();
// 调用, 并断言异常
assertServiceException(() -> addressAreaService.deleteAddressArea(id), ADDRESS_AREA_NOT_EXISTS);
}
@Test
@Disabled // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
public void testGetAddressAreaPage() {
// mock 数据
AddressAreaDO dbAddressArea = randomPojo(AddressAreaDO.class, o -> { // 等会查询到
o.setName(null);
o.setCityCode(null);
o.setProvinceCode(null);
});
addressAreaMapper.insert(dbAddressArea);
// 测试 name 不匹配
addressAreaMapper.insert(cloneIgnoreId(dbAddressArea, o -> o.setName(null)));
// 测试 cityCode 不匹配
addressAreaMapper.insert(cloneIgnoreId(dbAddressArea, o -> o.setCityCode(null)));
// 测试 provinceCode 不匹配
addressAreaMapper.insert(cloneIgnoreId(dbAddressArea, o -> o.setProvinceCode(null)));
// 准备参数
AddressAreaPageReqVO reqVO = new AddressAreaPageReqVO();
reqVO.setName(null);
reqVO.setCityCode(null);
reqVO.setProvinceCode(null);
// 调用
PageResult<AddressAreaDO> pageResult = addressAreaService.getAddressAreaPage(reqVO);
// 断言
assertEquals(1, pageResult.getTotal());
assertEquals(1, pageResult.getList().size());
assertPojoEquals(dbAddressArea, pageResult.getList().get(0));
}
}

134
yudao-module-haoka/yudao-module-haoka-biz/src/test/java/cn/iocoder/yudao/module/haoka/service/address/AddressCityServiceImplTest.java Normal file
View File

@ -0,0 +1,134 @@
package cn.iocoder.yudao.module.haoka.service.address;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.mock.mockito.MockBean;
import jakarta.annotation.Resource;
import cn.iocoder.yudao.framework.test.core.ut.BaseDbUnitTest;
import cn.iocoder.yudao.module.haoka.controller.admin.address.vo.*;
import cn.iocoder.yudao.module.haoka.dal.dataobject.address.AddressCityDO;
import cn.iocoder.yudao.module.haoka.dal.mysql.address.AddressCityMapper;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import jakarta.annotation.Resource;
import org.springframework.context.annotation.Import;
import java.util.*;
import java.time.LocalDateTime;
import static cn.hutool.core.util.RandomUtil.*;
import static cn.iocoder.yudao.module.haoka.enums.ErrorCodeConstants.*;
import static cn.iocoder.yudao.framework.test.core.util.AssertUtils.*;
import static cn.iocoder.yudao.framework.test.core.util.RandomUtils.*;
import static cn.iocoder.yudao.framework.common.util.date.LocalDateTimeUtils.*;
import static cn.iocoder.yudao.framework.common.util.object.ObjectUtils.*;
import static cn.iocoder.yudao.framework.common.util.date.DateUtils.*;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
/**
* {@link AddressCityServiceImpl} 的单元测试类
*
* @author 芋道源码
*/
@Import(AddressCityServiceImpl.class)
public class AddressCityServiceImplTest extends BaseDbUnitTest {
@Resource
private AddressCityServiceImpl addressCityService;
@Resource
private AddressCityMapper addressCityMapper;
@Test
public void testCreateAddressCity_success() {
// 准备参数
AddressCitySaveReqVO createReqVO = randomPojo(AddressCitySaveReqVO.class).setId(null);
// 调用
String addressCityId = addressCityService.createAddressCity(createReqVO);
// 断言
assertNotNull(addressCityId);
// 校验记录的属性是否正确
AddressCityDO addressCity = addressCityMapper.selectById(addressCityId);
assertPojoEquals(createReqVO, addressCity, "id");
}
@Test
public void testUpdateAddressCity_success() {
// mock 数据
AddressCityDO dbAddressCity = randomPojo(AddressCityDO.class);
addressCityMapper.insert(dbAddressCity);// @Sql: 先插入出一条存在的数据
// 准备参数
AddressCitySaveReqVO updateReqVO = randomPojo(AddressCitySaveReqVO.class, o -> {
o.setId(dbAddressCity.getId()); // 设置更新的 ID
});
// 调用
addressCityService.updateAddressCity(updateReqVO);
// 校验是否更新正确
AddressCityDO addressCity = addressCityMapper.selectById(updateReqVO.getId()); // 获取最新的
assertPojoEquals(updateReqVO, addressCity);
}
@Test
public void testUpdateAddressCity_notExists() {
// 准备参数
AddressCitySaveReqVO updateReqVO = randomPojo(AddressCitySaveReqVO.class);
// 调用, 并断言异常
assertServiceException(() -> addressCityService.updateAddressCity(updateReqVO), ADDRESS_CITY_NOT_EXISTS);
}
@Test
public void testDeleteAddressCity_success() {
// mock 数据
AddressCityDO dbAddressCity = randomPojo(AddressCityDO.class);
addressCityMapper.insert(dbAddressCity);// @Sql: 先插入出一条存在的数据
// 准备参数
String id = dbAddressCity.getId();
// 调用
addressCityService.deleteAddressCity(id);
// 校验数据不存在了
assertNull(addressCityMapper.selectById(id));
}
@Test
public void testDeleteAddressCity_notExists() {
// 准备参数
String id = randomStringId();
// 调用, 并断言异常
assertServiceException(() -> addressCityService.deleteAddressCity(id), ADDRESS_CITY_NOT_EXISTS);
}
@Test
@Disabled // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
public void testGetAddressCityPage() {
// mock 数据
AddressCityDO dbAddressCity = randomPojo(AddressCityDO.class, o -> { // 等会查询到
o.setName(null);
o.setProvinceCode(null);
});
addressCityMapper.insert(dbAddressCity);
// 测试 name 不匹配
addressCityMapper.insert(cloneIgnoreId(dbAddressCity, o -> o.setName(null)));
// 测试 provinceCode 不匹配
addressCityMapper.insert(cloneIgnoreId(dbAddressCity, o -> o.setProvinceCode(null)));
// 准备参数
AddressCityPageReqVO reqVO = new AddressCityPageReqVO();
reqVO.setName(null);
reqVO.setProvinceCode(null);
// 调用
PageResult<AddressCityDO> pageResult = addressCityService.getAddressCityPage(reqVO);
// 断言
assertEquals(1, pageResult.getTotal());
assertEquals(1, pageResult.getList().size());
assertPojoEquals(dbAddressCity, pageResult.getList().get(0));
}
}

130
yudao-module-haoka/yudao-module-haoka-biz/src/test/java/cn/iocoder/yudao/module/haoka/service/address/AddressProvinceServiceImplTest.java Normal file
View File

@ -0,0 +1,130 @@
package cn.iocoder.yudao.module.haoka.service.address;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.mock.mockito.MockBean;
import jakarta.annotation.Resource;
import cn.iocoder.yudao.framework.test.core.ut.BaseDbUnitTest;
import cn.iocoder.yudao.module.haoka.controller.admin.address.vo.*;
import cn.iocoder.yudao.module.haoka.dal.dataobject.address.AddressProvinceDO;
import cn.iocoder.yudao.module.haoka.dal.mysql.address.AddressProvinceMapper;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import jakarta.annotation.Resource;
import org.springframework.context.annotation.Import;
import java.util.*;
import java.time.LocalDateTime;
import static cn.hutool.core.util.RandomUtil.*;
import static cn.iocoder.yudao.module.haoka.enums.ErrorCodeConstants.*;
import static cn.iocoder.yudao.framework.test.core.util.AssertUtils.*;
import static cn.iocoder.yudao.framework.test.core.util.RandomUtils.*;
import static cn.iocoder.yudao.framework.common.util.date.LocalDateTimeUtils.*;
import static cn.iocoder.yudao.framework.common.util.object.ObjectUtils.*;
import static cn.iocoder.yudao.framework.common.util.date.DateUtils.*;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
/**
* {@link AddressProvinceServiceImpl} 的单元测试类
*
* @author 芋道源码
*/
@Import(AddressProvinceServiceImpl.class)
public class AddressProvinceServiceImplTest extends BaseDbUnitTest {
@Resource
private AddressProvinceServiceImpl addressProvinceService;
@Resource
private AddressProvinceMapper addressProvinceMapper;
@Test
public void testCreateAddressProvince_success() {
// 准备参数
AddressProvinceSaveReqVO createReqVO = randomPojo(AddressProvinceSaveReqVO.class).setId(null);
// 调用
String addressProvinceId = addressProvinceService.createAddressProvince(createReqVO);
// 断言
assertNotNull(addressProvinceId);
// 校验记录的属性是否正确
AddressProvinceDO addressProvince = addressProvinceMapper.selectById(addressProvinceId);
assertPojoEquals(createReqVO, addressProvince, "id");
}
@Test
public void testUpdateAddressProvince_success() {
// mock 数据
AddressProvinceDO dbAddressProvince = randomPojo(AddressProvinceDO.class);
addressProvinceMapper.insert(dbAddressProvince);// @Sql: 先插入出一条存在的数据
// 准备参数
AddressProvinceSaveReqVO updateReqVO = randomPojo(AddressProvinceSaveReqVO.class, o -> {
o.setId(dbAddressProvince.getId()); // 设置更新的 ID
});
// 调用
addressProvinceService.updateAddressProvince(updateReqVO);
// 校验是否更新正确
AddressProvinceDO addressProvince = addressProvinceMapper.selectById(updateReqVO.getId()); // 获取最新的
assertPojoEquals(updateReqVO, addressProvince);
}
@Test
public void testUpdateAddressProvince_notExists() {
// 准备参数
AddressProvinceSaveReqVO updateReqVO = randomPojo(AddressProvinceSaveReqVO.class);
// 调用, 并断言异常
assertServiceException(() -> addressProvinceService.updateAddressProvince(updateReqVO), ADDRESS_PROVINCE_NOT_EXISTS);
}
@Test
public void testDeleteAddressProvince_success() {
// mock 数据
AddressProvinceDO dbAddressProvince = randomPojo(AddressProvinceDO.class);
addressProvinceMapper.insert(dbAddressProvince);// @Sql: 先插入出一条存在的数据
// 准备参数
String id = dbAddressProvince.getId();
// 调用
addressProvinceService.deleteAddressProvince(id);
// 校验数据不存在了
assertNull(addressProvinceMapper.selectById(id));
}
@Test
public void testDeleteAddressProvince_notExists() {
// 准备参数
String id = randomStringId();
// 调用, 并断言异常
assertServiceException(() -> addressProvinceService.deleteAddressProvince(id), ADDRESS_PROVINCE_NOT_EXISTS);
}
@Test
@Disabled // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
public void testGetAddressProvincePage() {
// mock 数据
AddressProvinceDO dbAddressProvince = randomPojo(AddressProvinceDO.class, o -> { // 等会查询到
o.setName(null);
});
addressProvinceMapper.insert(dbAddressProvince);
// 测试 name 不匹配
addressProvinceMapper.insert(cloneIgnoreId(dbAddressProvince, o -> o.setName(null)));
// 准备参数
AddressProvincePageReqVO reqVO = new AddressProvincePageReqVO();
reqVO.setName(null);
// 调用
PageResult<AddressProvinceDO> pageResult = addressProvinceService.getAddressProvincePage(reqVO);
// 断言
assertEquals(1, pageResult.getTotal());
assertEquals(1, pageResult.getList().size());
assertPojoEquals(dbAddressProvince, pageResult.getList().get(0));
}
}

142
yudao-module-haoka/yudao-module-haoka-biz/src/test/java/cn/iocoder/yudao/module/haoka/service/address/AddressStreetServiceImplTest.java Normal file
View File

@ -0,0 +1,142 @@
package cn.iocoder.yudao.module.haoka.service.address;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.mock.mockito.MockBean;
import jakarta.annotation.Resource;
import cn.iocoder.yudao.framework.test.core.ut.BaseDbUnitTest;
import cn.iocoder.yudao.module.haoka.controller.admin.address.vo.*;
import cn.iocoder.yudao.module.haoka.dal.dataobject.address.AddressStreetDO;
import cn.iocoder.yudao.module.haoka.dal.mysql.address.AddressStreetMapper;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import jakarta.annotation.Resource;
import org.springframework.context.annotation.Import;
import java.util.*;
import java.time.LocalDateTime;
import static cn.hutool.core.util.RandomUtil.*;
import static cn.iocoder.yudao.module.haoka.enums.ErrorCodeConstants.*;
import static cn.iocoder.yudao.framework.test.core.util.AssertUtils.*;
import static cn.iocoder.yudao.framework.test.core.util.RandomUtils.*;
import static cn.iocoder.yudao.framework.common.util.date.LocalDateTimeUtils.*;
import static cn.iocoder.yudao.framework.common.util.object.ObjectUtils.*;
import static cn.iocoder.yudao.framework.common.util.date.DateUtils.*;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
/**
* {@link AddressStreetServiceImpl} 的单元测试类
*
* @author 芋道源码
*/
@Import(AddressStreetServiceImpl.class)
public class AddressStreetServiceImplTest extends BaseDbUnitTest {
@Resource
private AddressStreetServiceImpl addressStreetService;
@Resource
private AddressStreetMapper addressStreetMapper;
@Test
public void testCreateAddressStreet_success() {
// 准备参数
AddressStreetSaveReqVO createReqVO = randomPojo(AddressStreetSaveReqVO.class).setId(null);
// 调用
String addressStreetId = addressStreetService.createAddressStreet(createReqVO);
// 断言
assertNotNull(addressStreetId);
// 校验记录的属性是否正确
AddressStreetDO addressStreet = addressStreetMapper.selectById(addressStreetId);
assertPojoEquals(createReqVO, addressStreet, "id");
}
@Test
public void testUpdateAddressStreet_success() {
// mock 数据
AddressStreetDO dbAddressStreet = randomPojo(AddressStreetDO.class);
addressStreetMapper.insert(dbAddressStreet);// @Sql: 先插入出一条存在的数据
// 准备参数
AddressStreetSaveReqVO updateReqVO = randomPojo(AddressStreetSaveReqVO.class, o -> {
o.setId(dbAddressStreet.getId()); // 设置更新的 ID
});
// 调用
addressStreetService.updateAddressStreet(updateReqVO);
// 校验是否更新正确
AddressStreetDO addressStreet = addressStreetMapper.selectById(updateReqVO.getId()); // 获取最新的
assertPojoEquals(updateReqVO, addressStreet);
}
@Test
public void testUpdateAddressStreet_notExists() {
// 准备参数
AddressStreetSaveReqVO updateReqVO = randomPojo(AddressStreetSaveReqVO.class);
// 调用, 并断言异常
assertServiceException(() -> addressStreetService.updateAddressStreet(updateReqVO), ADDRESS_STREET_NOT_EXISTS);
}
@Test
public void testDeleteAddressStreet_success() {
// mock 数据
AddressStreetDO dbAddressStreet = randomPojo(AddressStreetDO.class);
addressStreetMapper.insert(dbAddressStreet);// @Sql: 先插入出一条存在的数据
// 准备参数
String id = dbAddressStreet.getId();
// 调用
addressStreetService.deleteAddressStreet(id);
// 校验数据不存在了
assertNull(addressStreetMapper.selectById(id));
}
@Test
public void testDeleteAddressStreet_notExists() {
// 准备参数
String id = randomStringId();
// 调用, 并断言异常
assertServiceException(() -> addressStreetService.deleteAddressStreet(id), ADDRESS_STREET_NOT_EXISTS);
}
@Test
@Disabled // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
public void testGetAddressStreetPage() {
// mock 数据
AddressStreetDO dbAddressStreet = randomPojo(AddressStreetDO.class, o -> { // 等会查询到
o.setName(null);
o.setAreaCode(null);
o.setProvinceCode(null);
o.setCityCode(null);
});
addressStreetMapper.insert(dbAddressStreet);
// 测试 name 不匹配
addressStreetMapper.insert(cloneIgnoreId(dbAddressStreet, o -> o.setName(null)));
// 测试 areaCode 不匹配
addressStreetMapper.insert(cloneIgnoreId(dbAddressStreet, o -> o.setAreaCode(null)));
// 测试 provinceCode 不匹配
addressStreetMapper.insert(cloneIgnoreId(dbAddressStreet, o -> o.setProvinceCode(null)));
// 测试 cityCode 不匹配
addressStreetMapper.insert(cloneIgnoreId(dbAddressStreet, o -> o.setCityCode(null)));
// 准备参数
AddressStreetPageReqVO reqVO = new AddressStreetPageReqVO();
reqVO.setName(null);
reqVO.setAreaCode(null);
reqVO.setProvinceCode(null);
reqVO.setCityCode(null);
// 调用
PageResult<AddressStreetDO> pageResult = addressStreetService.getAddressStreetPage(reqVO);
// 断言
assertEquals(1, pageResult.getTotal());
assertEquals(1, pageResult.getList().size());
assertPojoEquals(dbAddressStreet, pageResult.getList().get(0));
}
}

146
yudao-module-haoka/yudao-module-haoka-biz/src/test/java/cn/iocoder/yudao/module/haoka/service/address/AddressVillageServiceImplTest.java Normal file
View File

@ -0,0 +1,146 @@
package cn.iocoder.yudao.module.haoka.service.address;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.mock.mockito.MockBean;
import jakarta.annotation.Resource;
import cn.iocoder.yudao.framework.test.core.ut.BaseDbUnitTest;
import cn.iocoder.yudao.module.haoka.controller.admin.address.vo.*;
import cn.iocoder.yudao.module.haoka.dal.dataobject.address.AddressVillageDO;
import cn.iocoder.yudao.module.haoka.dal.mysql.address.AddressVillageMapper;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import jakarta.annotation.Resource;
import org.springframework.context.annotation.Import;
import java.util.*;
import java.time.LocalDateTime;
import static cn.hutool.core.util.RandomUtil.*;
import static cn.iocoder.yudao.module.haoka.enums.ErrorCodeConstants.*;
import static cn.iocoder.yudao.framework.test.core.util.AssertUtils.*;
import static cn.iocoder.yudao.framework.test.core.util.RandomUtils.*;
import static cn.iocoder.yudao.framework.common.util.date.LocalDateTimeUtils.*;
import static cn.iocoder.yudao.framework.common.util.object.ObjectUtils.*;
import static cn.iocoder.yudao.framework.common.util.date.DateUtils.*;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
/**
* {@link AddressVillageServiceImpl} 的单元测试类
*
* @author 芋道源码
*/
@Import(AddressVillageServiceImpl.class)
public class AddressVillageServiceImplTest extends BaseDbUnitTest {
@Resource
private AddressVillageServiceImpl addressVillageService;
@Resource
private AddressVillageMapper addressVillageMapper;
@Test
public void testCreateAddressVillage_success() {
// 准备参数
AddressVillageSaveReqVO createReqVO = randomPojo(AddressVillageSaveReqVO.class).setId(null);
// 调用
String addressVillageId = addressVillageService.createAddressVillage(createReqVO);
// 断言
assertNotNull(addressVillageId);
// 校验记录的属性是否正确
AddressVillageDO addressVillage = addressVillageMapper.selectById(addressVillageId);
assertPojoEquals(createReqVO, addressVillage, "id");
}
@Test
public void testUpdateAddressVillage_success() {
// mock 数据
AddressVillageDO dbAddressVillage = randomPojo(AddressVillageDO.class);
addressVillageMapper.insert(dbAddressVillage);// @Sql: 先插入出一条存在的数据
// 准备参数
AddressVillageSaveReqVO updateReqVO = randomPojo(AddressVillageSaveReqVO.class, o -> {
o.setId(dbAddressVillage.getId()); // 设置更新的 ID
});
// 调用
addressVillageService.updateAddressVillage(updateReqVO);
// 校验是否更新正确
AddressVillageDO addressVillage = addressVillageMapper.selectById(updateReqVO.getId()); // 获取最新的
assertPojoEquals(updateReqVO, addressVillage);
}
@Test
public void testUpdateAddressVillage_notExists() {
// 准备参数
AddressVillageSaveReqVO updateReqVO = randomPojo(AddressVillageSaveReqVO.class);
// 调用, 并断言异常
assertServiceException(() -> addressVillageService.updateAddressVillage(updateReqVO), ADDRESS_VILLAGE_NOT_EXISTS);
}
@Test
public void testDeleteAddressVillage_success() {
// mock 数据
AddressVillageDO dbAddressVillage = randomPojo(AddressVillageDO.class);
addressVillageMapper.insert(dbAddressVillage);// @Sql: 先插入出一条存在的数据
// 准备参数
String id = dbAddressVillage.getId();
// 调用
addressVillageService.deleteAddressVillage(id);
// 校验数据不存在了
assertNull(addressVillageMapper.selectById(id));
}
@Test
public void testDeleteAddressVillage_notExists() {
// 准备参数
String id = randomStringId();
// 调用, 并断言异常
assertServiceException(() -> addressVillageService.deleteAddressVillage(id), ADDRESS_VILLAGE_NOT_EXISTS);
}
@Test
@Disabled // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
public void testGetAddressVillagePage() {
// mock 数据
AddressVillageDO dbAddressVillage = randomPojo(AddressVillageDO.class, o -> { // 等会查询到
o.setName(null);
o.setStreetCode(null);
o.setProvinceCode(null);
o.setCityCode(null);
o.setAreaCode(null);
});
addressVillageMapper.insert(dbAddressVillage);
// 测试 name 不匹配
addressVillageMapper.insert(cloneIgnoreId(dbAddressVillage, o -> o.setName(null)));
// 测试 streetCode 不匹配
addressVillageMapper.insert(cloneIgnoreId(dbAddressVillage, o -> o.setStreetCode(null)));
// 测试 provinceCode 不匹配
addressVillageMapper.insert(cloneIgnoreId(dbAddressVillage, o -> o.setProvinceCode(null)));
// 测试 cityCode 不匹配
addressVillageMapper.insert(cloneIgnoreId(dbAddressVillage, o -> o.setCityCode(null)));
// 测试 areaCode 不匹配
addressVillageMapper.insert(cloneIgnoreId(dbAddressVillage, o -> o.setAreaCode(null)));
// 准备参数
AddressVillagePageReqVO reqVO = new AddressVillagePageReqVO();
reqVO.setName(null);
reqVO.setStreetCode(null);
reqVO.setProvinceCode(null);
reqVO.setCityCode(null);
reqVO.setAreaCode(null);
// 调用
PageResult<AddressVillageDO> pageResult = addressVillageService.getAddressVillagePage(reqVO);
// 断言
assertEquals(1, pageResult.getTotal());
assertEquals(1, pageResult.getList().size());
assertPojoEquals(dbAddressVillage, pageResult.getList().get(0));
}
}

14
yudao-server/src/main/resources/db/migration/V1.0.10__add_clunmeAllterVlue.sql Normal file
View File

@ -0,0 +1,14 @@
-- 为 haoka_province 表添加字段
UPDATE `haoka_province` set `tenant_id` = 1 ;
-- 为 haoka_city 表添加字段
UPDATE `haoka_city` set `tenant_id` = 1 ;
-- 为 haoka_area 表添加字段
UPDATE `haoka_area` set `tenant_id` = 1 ;
-- 为 haoka_street 表添加字段
UPDATE `haoka_street` set `tenant_id` = 1 ;
-- 为 haoka_village 表添加字段
UPDATE `haoka_village` set `tenant_id` = 1 ;