Compare commits

..

88 Commits

Author SHA1 Message Date
ccongli 48f9bdca7c Merge branch 'contract'
1 year ago
ccongli e08e65995f 前端项目修正初始化-2
1 year ago
ccongli 76d9a8bf86 前端项目修正初始化-1
1 year ago
ccongli 29d30c5581 前端项目修正初始化-1
1 year ago
ccongli 45a8e573e0 合同基础、详情信息业务开发v3
1 year ago
杨世强 42020ecc7b 1
1 year ago
杨世强 599015f6c1 Merge branch 'master' into ysq-dev-0811
1 year ago
qiuhongwu e320886ff7 Merge branch 'qhw-dev-1010'
1 year ago
qiuhongwu e955c98eab 企业中心业务组织配置
1 year ago
ccongli a5a703479a 合同基础、详情信息业务开发v2
1 year ago
杨世强 39135c13a8 Merge branch 'master' into ysq-dev-0811
1 year ago
杨世强 cbafb07278 部门列表
1 year ago
ccongli c79db68acb 合同基础、详情信息业务开发v1
1 year ago
17602169347 615a86d50a 个人中心提交
1 year ago
17602169347 2c16788d8f 代码提交
1 year ago
ccongli 39ad4dfb72 忽略文件更新
1 year ago
杨世强 f19083e8a7 Merge branch 'master' of http://222.71.165.188:3000/linkage/YX-SCM
1 year ago
杨世强 0350cdae6b 部门列表
1 year ago
qiuhongwu ba7c34ac0e ijiao
1 year ago
杨世强 d1ce48e28b Merge branch 'ysq-dev-0811'
1 year ago
杨世强 f95b8abb5d 部门树状列表
1 year ago
qiuhongwu 98a0015579 Merge branch 'master' of http://222.71.165.188:3000/linkage/YX-SCM
1 year ago
qiuhongwu e566c2bac7 11
1 year ago
mhsnet add9532e04 分支机构功能
1 year ago
杨世强 ccc73b1696 部门列表
1 year ago
ccongli 19a3825c62 前端项目名称变更
1 year ago
杨世强 d19160843e 部门人员信息
1 year ago
LI-CCONG\李聪聪 6d37489385 Merge branch 'ccongli-dev-0920'
1 year ago
huchuanhu 68f2af1d49 个人中心
1 year ago
tengxi 7fa223db42 后端个人加字段,个人设置提交
1 year ago
mhsnet dbc20379eb 企业信息静态页初始效果
1 year ago
杨世强 78f052b3ac Merge branch 'ysq-dev-0811'
1 year ago
杨世强 c31ed02f9b 业务组织配置
1 year ago
17602169347 c1f4520e85 客户供应商前端
1 year ago
mhsnet a871d77903 企业中心(基本信息|认证信息|分支机构|组织信息)
1 year ago
qiuhongwu 52df6c6b76 cun
1 year ago
17602169347 716df92a68 10.8权限和供应商和客户提交
1 year ago
qiuhongwu 1e104717cb Merge branch 'qhw-dev-0927'
1 year ago
qiuhongwu 43ea91d5f1 Merge branch 'master' of http://222.71.165.188:3000/linkage/YX-SCM
1 year ago
qiuhongwu 1393aa2810 ti
1 year ago
qiuhongwu 1ada243d7f ti
1 year ago
tengxi 5bb22e3c7a 新客户
1 year ago
tengxi 984d9b94a5 提交新客户管理
1 year ago
杨世强 7a83d4e067 Merge branch 'master' into ysq-dev-0811
1 year ago
杨世强 b517aec7d7 业务线修改
1 year ago
qiuhongwu fa8365f84e Merge branch 'qhw-dev-0927'
1 year ago
qiuhongwu c53a0fb0f1 mine
1 year ago
tengxi 30e63f041f Merge branch 'master' of http://222.71.165.188:3000/linkage/YX-SCM
1 year ago
tengxi 4ae74fe524 客户
1 year ago
LI-CCONG\李聪聪 9d8fa16a10 测试环境配置更新
1 year ago
杨世强 0edbecba34 业务线
1 year ago
tengxi 82a0445962 提交
1 year ago
Your Name 77b09bec49 Merge branch 'master' of http://222.71.165.188:3000/linkage/YX-SCM into dev
1 year ago
Your Name 3c2ec0a4e4 提交个人中心
1 year ago
tengxi 54b7c20332 1
1 year ago
tengxi cb79e228f8 提交
1 year ago
tengxi 13f7735e79 解决冲突
1 year ago
杨世强 7c77ddcfa6 业务线放到系统表
1 year ago
tengxi 505afe30a8 重新提交企业中心
1 year ago
杨世强 5e25306bf1 关系表
1 year ago
杨世强 8655c2ed97 业务线
1 year ago
tengxi 1a968ebe48 Merge branch 'master' of http://222.71.165.188:3000/linkage/YX-SCM into tx
1 year ago
tengxi 1fb627a2da 企业中心重新
1 year ago
tengxi 446912d834 提交登录记录
1 year ago
tengxi 9bfa16ad6d 资料设置
1 year ago
tengxi 91c3f4ba04 提交个人中心
1 year ago
杨世强 3e7b757943 Merge branch 'master' of http://222.71.165.188:3000/linkage/YX-SCM into ysq-dev-0811
1 year ago
杨世强 6a709b2a42 业务线/仓库
1 year ago
17602169347 6ee074f0b8 新增antd
1 year ago
LI-CCONG\李聪聪 b358c9989f 解决新建菜单目录时系统异常问题
1 year ago
tengxi 63b1b48d73 质检报告管理前端
1 year ago
tengxi 35076199ff Merge branch 'tx'
1 year ago
tengxi d254acfa37 提交质检
1 year ago
杨世强 adc915ade0 Merge branch 'ysq-dev-0811'
1 year ago
杨世强 6b110524d8 库存管理
1 year ago
17602169347 68166962e4 9.6tijiao
1 year ago
17602169347 32955adf13 9.6tijiao
1 year ago
杨世强 19f36ef0f3 入库单
1 year ago
杨世强 844e30ef25 Merge branch 'master' into ysq-dev-0811
1 year ago
tengxi 6371032fd9 Merge branch 'master' of http://222.71.165.188:3000/linkage/YX-SCM
1 year ago
tengxi 86f9109496 Merge branch 'tx'
1 year ago
杨世强 76bd34e994 业务线/仓库
1 year ago
杨世强 efc57aec55 业务线/仓库
1 year ago
杨世强 12e26128c4 业务线/仓库
1 year ago
tengxi 31a793480c 工单/客户/供应商
1 year ago
LI-CCONG\李聪聪 0a118be1b9 开启大屏报表功能、 logo图标替换
1 year ago
杨世强 7c6a76d3f3 增加产品模块
1 year ago
杨世强 16ddbe7ac0 增加产品模块
1 year ago

@ -17,14 +17,16 @@
<module>yunxi-module-system</module>
<module>yunxi-module-infra</module>
<!-- <module>yunxi-module-pay</module>-->
<!-- <module>yunxi-module-bpm</module>-->
<!-- <module>yunxi-module-report</module>-->
<!-- 大屏报表功能 -->
<module>yunxi-module-report</module>
<module>yunxi-module-bpm</module>
<!-- <module>yunxi-module-mp</module>-->
<!-- <module>yunxi-module-mall</module>-->
<!-- 示例项目 -->
<module>yunxi-example</module>
<!-- demo测试模块 -->
<module>yunxi-module-demo</module>
<module>yunxi-module-demo2</module>
<!-- 自定义业务功能模块 -->
<module>yunxi-module-xxjj</module>
</modules>

@ -1,5 +1,6 @@
package com.yunxi.scm.framework.mybatis.core.mapper;
import com.github.yulichang.base.MPJBaseMapper;
import com.yunxi.scm.framework.common.pojo.PageParam;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.mybatis.core.util.MyBatisUtils;
@ -18,7 +19,7 @@ import java.util.List;
/**
* MyBatis Plus BaseMapper
*/
public interface BaseMapperX<T> extends BaseMapper<T> {
public interface BaseMapperX<T> extends MPJBaseMapper<T> {
default PageResult<T> selectPage(PageParam pageParam, @Param("ew") Wrapper<T> queryWrapper) {
// MyBatis Plus 查询

@ -1,24 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>yunxi</artifactId>
<groupId>com.yunxi.scm</groupId>
<version>${revision}</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>yunxi-module-demo2</artifactId>
<packaging>pom</packaging>
<name>${project.artifactId}</name>
<description>
demo2 模块,主要实现 XXX、YYY、ZZZ 等功能。
</description>
<modules>
<module>yunxi-module-demo2-api</module>
<module>yunxi-module-demo2-biz</module>
</modules>
</project>

@ -1,28 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>yunxi-module-demo2</artifactId>
<groupId>com.yunxi.scm</groupId>
<version>${revision}</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>yunxi-module-demo2-api</artifactId>
<packaging>jar</packaging>
<name>${project.artifactId}</name>
<description>
demo2 模块 API暴露给其它模块调用
</description>
<!-- 新增 yudao-common 依赖 -->
<dependencies>
<dependency>
<groupId>com.yunxi.scm</groupId>
<artifactId>yunxi-common</artifactId>
</dependency>
</dependencies>
</project>

@ -1,18 +0,0 @@
package com.yunxi.scm.module.demo2.enums;
/**
* System
*
* @author
*/
public interface DictTypeConstants {
String USER_TYPE = "user_type"; // 用户类型
String COMMON_STATUS = "common_status"; // 系统状态
String MATERIAL_STATUS = "material_status"; // 物料状态
// ========== SYSTEM 模块 ==========
String TRADE_ORDER_TYPE = "trade_order_type"; // 订单交易类型
}

@ -1,9 +0,0 @@
// TODO 待办:请将下面的错误码复制到 yunxi-module-demo-api 模块的 ErrorCodeConstants 类中。注意请给“TODO 补充编号”设置一个错误码编号!!!
// ========== 物料管理 TODO 补充编号 ==========
package com.yunxi.scm.module.demo2.enums;
import com.yunxi.scm.framework.common.exception.ErrorCode;
public interface ErrorCodeConstants {
ErrorCode MATERIAL_NOT_EXISTS = new ErrorCode(2023091001, "物料管理不存在");
}

@ -1,72 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>yunxi-module-demo2</artifactId>
<groupId>com.yunxi.scm</groupId>
<version>${revision}</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<packaging>jar</packaging>
<artifactId>yunxi-module-demo2-biz</artifactId>
<name>${project.artifactId}</name>
<description>
demo 模块,主要实现 XXX、YYY、ZZZ 等功能。
</description>
<!-- 新增依赖,这里引入的都是比较常用的业务组件、技术组件 -->
<dependencies>
<dependency>
<groupId>com.yunxi.scm</groupId>
<artifactId>yunxi-module-demo2-api</artifactId>
<version>${revision}</version>
</dependency>
<!-- 业务组件 -->
<dependency>
<groupId>com.yunxi.scm</groupId>
<artifactId>yunxi-spring-boot-starter-biz-operatelog</artifactId>
</dependency>
<!-- Web 相关 -->
<dependency>
<groupId>com.yunxi.scm</groupId>
<artifactId>yunxi-spring-boot-starter-web</artifactId>
</dependency>
<!-- 功能权限 相关 -->
<dependency>
<groupId>com.yunxi.scm</groupId>
<artifactId>yunxi-spring-boot-starter-security</artifactId>
</dependency>
<!-- 数据权限 相关 -->
<dependency>
<groupId>com.yunxi.scm</groupId>
<artifactId>yunxi-spring-boot-starter-biz-data-permission</artifactId>
</dependency>
<!-- DB 相关 -->
<dependency>
<groupId>com.yunxi.scm</groupId>
<artifactId>yunxi-spring-boot-starter-mybatis</artifactId>
</dependency>
<!-- Test 测试相关 -->
<dependency>
<groupId>com.yunxi.scm</groupId>
<artifactId>yunxi-spring-boot-starter-test</artifactId>
</dependency>
<!-- Excel 相关 -->
<dependency>
<groupId>com.yunxi.scm</groupId>
<artifactId>yunxi-spring-boot-starter-excel</artifactId>
</dependency>
</dependencies>
</project>

@ -1,119 +0,0 @@
package com.yunxi.scm.module.demo2.controller.admin;
import com.yunxi.scm.framework.common.pojo.CommonResult;
import com.yunxi.scm.framework.excel.core.util.ExcelUtils;
import com.yunxi.scm.framework.mybatis.core.query.LambdaQueryWrapperX;
import com.yunxi.scm.framework.operatelog.core.annotations.OperateLog;
import com.yunxi.scm.module.demo2.controller.admin.pmaterial.vo.PMaterialExportTestVO;
import com.yunxi.scm.module.demo2.controller.admin.pmaterial.vo.PMaterialImportTestVO;
import com.yunxi.scm.module.demo2.convert.pmaterial.PMaterialXConvert;
import com.yunxi.scm.module.demo2.dal.dataobject.pmaterial.PMaterialXDO;
import com.yunxi.scm.module.demo2.dal.mysql.pmaterial.PMaterialXMapper;
import com.yunxi.scm.module.demo2.enums.pmaterial.CategoryEnum;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Parameters;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import javax.annotation.security.PermitAll;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static com.yunxi.scm.framework.common.pojo.CommonResult.success;
import static com.yunxi.scm.framework.operatelog.core.enums.OperateTypeEnum.EXPORT;
import static com.yunxi.scm.framework.operatelog.core.enums.OperateTypeEnum.IMPORT;
@Tag(name = "管理后台 - Test2")
@RestController
@RequestMapping("/demo2/test")
@Validated
public class DemoTest88Controller {
@GetMapping("/get")
@Operation(summary = "获取 test 信息")
@PermitAll // 无需认证即可访问
public CommonResult<String> get() {
return success("无需认证即可访问的后台接口");
}
@GetMapping("/test_export")
@Operation(summary = "测试导出和字典转化")
@PermitAll
@OperateLog(type = EXPORT)
public void testExport(HttpServletResponse response) throws IOException {
PMaterialXDO xdo1 = new PMaterialXDO(1L,"80inu5yxl3",Arrays.asList("1","2"));
PMaterialXDO xdo2 = new PMaterialXDO(2L,"Q2ZY1I9cCBf0YKvDUlzCbw==",Arrays.asList("1","3"));
List<PMaterialXDO> xdos = new ArrayList<>();
xdos.add(xdo1);
xdos.add(xdo2);
List<PMaterialExportTestVO> datas = PMaterialXConvert.INSTANCE.convertList03(xdos);
ExcelUtils.write(response, "测试导出.xls", "数据", PMaterialExportTestVO.class, datas);
}
@PostMapping("/test_import")
@Operation(summary = "测试导入和转化为字典")
@PermitAll
@OperateLog(type = IMPORT)
@Parameters({
@Parameter(name = "file", description = "Excel 文件", required = true),
@Parameter(name = "updateSupport", description = "是否支持更新,默认为 false", example = "true")
})
public CommonResult<List<PMaterialImportTestVO>> testImport(@RequestParam("file") MultipartFile file,
@RequestParam(value = "updateSupport", required = false, defaultValue = "false") Boolean updateSupport) throws IOException {
List<PMaterialImportTestVO> list = ExcelUtils.read(file, PMaterialImportTestVO.class);
return success(list);
}
@GetMapping("/get-import-template")
@PermitAll
@Operation(summary = "获得导入模板")
public void importTemplate(HttpServletResponse response) throws IOException {
List<String> values = Stream.of(CategoryEnum.COMMON.getCode(),CategoryEnum.KANJIA.getCode())
.map(String::valueOf).collect(Collectors.toList());
// 手动创建导出 demo
List<PMaterialImportTestVO> list = Arrays.asList(
PMaterialImportTestVO.builder().category(values).build()
);
// 输出
ExcelUtils.write(response, "导入模板.xls", "物料标准模版", PMaterialImportTestVO.class, list);
}
@Resource
PMaterialXMapper materialXMapper;
@GetMapping("/test_encrypt")
@Operation(summary = "测试字段加密")
@PermitAll
public CommonResult<String> testEncrypt() {
PMaterialXDO xdo1 = new PMaterialXDO(1L,"80inu5yxl3",Arrays.asList("1","2"));
PMaterialXDO xdo2 = new PMaterialXDO(2L,"80inu5yxl3",Arrays.asList("1","3"));
List<PMaterialXDO> xdos = new ArrayList<>();
xdos.add(xdo1);
xdos.add(xdo2);
materialXMapper.insertBatch(xdos);
return success("ok");
}
@GetMapping("/test_decrypt")
@Operation(summary = "测试字段解密")
@PermitAll
public CommonResult<PMaterialExportTestVO> testDecrypt() {
LambdaQueryWrapperX<PMaterialXDO> wrapperX = new LambdaQueryWrapperX<>();
wrapperX.eq(PMaterialXDO::getId, 1);
PMaterialXDO xdo = materialXMapper.selectOne(wrapperX);
return success(PMaterialXConvert.INSTANCE.convert(xdo));
}
}

@ -1,103 +0,0 @@
package com.yunxi.scm.module.demo2.controller.admin.pmaterial;
import com.yunxi.scm.framework.common.pojo.CommonResult;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.datapermission.core.annotation.DataPermission;
import com.yunxi.scm.framework.excel.core.util.ExcelUtils;
import com.yunxi.scm.framework.operatelog.core.annotations.OperateLog;
import com.yunxi.scm.module.demo2.convert.pmaterial.PMaterialConvert;
import com.yunxi.scm.module.demo2.dal.dataobject.pmaterial.PMaterialDO;
import com.yunxi.scm.module.demo2.service.pmaterial.PMaterialService;
import com.yunxi.scm.module.demo2.controller.admin.pmaterial.vo.*;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.annotation.security.PermitAll;
import javax.servlet.http.HttpServletResponse;
import javax.validation.Valid;
import java.io.IOException;
import java.util.Collection;
import java.util.List;
import static com.yunxi.scm.framework.common.pojo.CommonResult.success;
import static com.yunxi.scm.framework.operatelog.core.enums.OperateTypeEnum.EXPORT;
@Tag(name = "管理后台 - 物料管理")
@RestController("PMaterialController2")
@RequestMapping("/demo2/material")
@Validated
public class PMaterialController {
@Resource // 先ByName,找不到再ByType如果指定了name属性ByName找不到则报错
private PMaterialService materialService;
@PostMapping("/create")
@Operation(summary = "创建物料管理")
@PreAuthorize("@ss.hasPermission('demo:material:create')")
public CommonResult<Long> createMaterial(@Valid @RequestBody PMaterialCreateReqVO createReqVO) {
return success(materialService.createMaterial(createReqVO));
}
@PutMapping("/update")
@Operation(summary = "更新物料管理")
@PreAuthorize("@ss.hasPermission('demo:material:update')")
public CommonResult<Boolean> updateMaterial(@Valid @RequestBody PMaterialUpdateReqVO updateReqVO) {
materialService.updateMaterial(updateReqVO);
return success(true);
}
@DeleteMapping("/delete")
@Operation(summary = "删除物料管理")
@Parameter(name = "id", description = "编号", required = true)
@PreAuthorize("@ss.hasPermission('demo:material:delete')")
public CommonResult<Boolean> deleteMaterial(@RequestParam("id") Long id) {
materialService.deleteMaterial(id);
return success(true);
}
@GetMapping("/get")
@Operation(summary = "获得物料管理")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('demo:material:query')")
public CommonResult<PMaterialRespVO> getMaterial(@RequestParam("id") Long id) {
PMaterialDO material = materialService.getMaterial(id);
return success(PMaterialConvert.INSTANCE.convert(material));
}
@GetMapping("/list")
@Operation(summary = "获得物料管理列表")
@Parameter(name = "ids", description = "编号列表", required = true, example = "1024,2048")
// @PreAuthorize("@ss.hasPermission('demo:material:query')")
@PermitAll
public CommonResult<List<PMaterialRespVO>> getMaterialList(@RequestParam("ids") Collection<Long> ids) {
List<PMaterialDO> list = materialService.getMaterialList(ids);
return success(PMaterialConvert.INSTANCE.convertList(list));
}
@GetMapping("/page")
@Operation(summary = "获得物料管理分页")
@PreAuthorize("@ss.hasPermission('demo:material:query')")
@DataPermission // 数据权限功能,默认是开启的
public CommonResult<PageResult<PMaterialRespVO>> getMaterialPage(@Valid PMaterialPageReqVO pageVO) {
PageResult<PMaterialDO> pageResult = materialService.getMaterialPage(pageVO);
return success(PMaterialConvert.INSTANCE.convertPage(pageResult));
}
@GetMapping("/export-excel")
@Operation(summary = "导出物料管理 Excel")
@PreAuthorize("@ss.hasPermission('demo:material:export')")
@OperateLog(type = EXPORT)
public void exportMaterialExcel(@Valid PMaterialExportReqVO exportReqVO,
HttpServletResponse response) throws IOException {
List<PMaterialDO> list = materialService.getMaterialList(exportReqVO);
// 导出 Excel
List<PMaterialExcelVO> datas = PMaterialConvert.INSTANCE.convertList02(list);
ExcelUtils.write(response, "物料管理.xls", "数据", PMaterialExcelVO.class, datas);
}
}

@ -1,48 +0,0 @@
package com.yunxi.scm.module.demo2.controller.admin.pmaterial.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import javax.validation.constraints.NotNull;
import java.math.BigDecimal;
import java.util.List;
/**
* Base VO VO 使
* VO Swagger
*/
@Data
public class PMaterialBaseVO {
@Schema(description = "名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "李四")
@NotNull(message = "名称不能为空")
private String name;
@Schema(description = "状态", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
@NotNull(message = "状态不能为空")
private Byte status;
@Schema(description = "类型", requiredMode = Schema.RequiredMode.REQUIRED, example = "2")
@NotNull(message = "类型不能为空")
private Byte type;
@Schema(description = "分类", requiredMode = Schema.RequiredMode.REQUIRED, example = "1,2")
@NotNull(message = "分类不能为空")
private List<String> categories;
@Schema(description = "图片", requiredMode = Schema.RequiredMode.REQUIRED, example = "https://www.iocoder.cn")
@NotNull(message = "图片不能为空")
private String imgurl;
@Schema(description = "库存数量", requiredMode = Schema.RequiredMode.REQUIRED)
@NotNull(message = "库存数量不能为空")
private Integer stock;
@Schema(description = "单价", requiredMode = Schema.RequiredMode.REQUIRED, example = "18.00")
@NotNull(message = "单价不能为空")
private BigDecimal price;
@Schema(description = "备注", example = "物料备注")
private String remark;
}

@ -1,12 +0,0 @@
package com.yunxi.scm.module.demo2.controller.admin.pmaterial.vo;
import lombok.*;
import io.swagger.v3.oas.annotations.media.Schema;
@Schema(description = "管理后台 - 物料管理创建 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class PMaterialCreateReqVO extends PMaterialBaseVO {
}

@ -1,56 +0,0 @@
package com.yunxi.scm.module.demo2.controller.admin.pmaterial.vo;
import com.alibaba.excel.annotation.ExcelProperty;
import com.yunxi.scm.framework.excel.core.annotations.DictFormat;
import com.yunxi.scm.framework.excel.core.convert.DictConvert;
import com.yunxi.scm.framework.excel.core.convert.JsonConvert;
import com.yunxi.scm.module.demo2.enums.DictTypeConstants;
import lombok.Data;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;
/**
* Excel VO
*
* @author ccongli
*/
@Data
public class PMaterialExcelVO {
@ExcelProperty("编号")
private Long id;
@ExcelProperty("名称")
private String name;
@ExcelProperty(value = "状态", converter = DictConvert.class)
@DictFormat(DictTypeConstants.MATERIAL_STATUS)
private Byte status;
@ExcelProperty(value = "类型", converter = DictConvert.class)
@DictFormat(DictTypeConstants.TRADE_ORDER_TYPE)
private Byte type;
@ExcelProperty(value = "分类", converter = JsonConvert.class)
private List<String> categories;
@ExcelProperty("图片")
private String imgurl;
@ExcelProperty("库存数量")
private Integer stock;
@ExcelProperty("单价")
private BigDecimal price;
@ExcelProperty("备注")
private String remark;
@ExcelProperty("创建时间")
private LocalDateTime createTime;
}

@ -1,31 +0,0 @@
package com.yunxi.scm.module.demo2.controller.admin.pmaterial.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 物料管理 Excel 导出 Request VO参数和 PMaterialPageReqVO 是一致的")
@Data
public class PMaterialExportReqVO {
@Schema(description = "名称", example = "李四")
private String name;
@Schema(description = "状态", example = "1")
private Byte status;
@Schema(description = "类型", example = "2")
private Byte type;
@Schema(description = "分类", example = "1")
private String category;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -1,21 +0,0 @@
package com.yunxi.scm.module.demo2.controller.admin.pmaterial.vo;
import com.alibaba.excel.annotation.ExcelProperty;
import com.yunxi.scm.framework.excel.core.annotations.DictFormat;
import com.yunxi.scm.framework.excel.core.convert.MutilDictConvert;
import com.yunxi.scm.module.demo2.enums.DictTypeConstants;
import lombok.Data;
import java.util.List;
// 测试转换
@Data
public class PMaterialExportTestVO {
@ExcelProperty(value = "密码")
private String password;
@ExcelProperty(value = "分类测试", converter = MutilDictConvert.class)
@DictFormat(DictTypeConstants.TRADE_ORDER_TYPE)
private List<String> category;
}

@ -1,27 +0,0 @@
package com.yunxi.scm.module.demo2.controller.admin.pmaterial.vo;
import com.alibaba.excel.annotation.ExcelProperty;
import com.yunxi.scm.framework.excel.core.annotations.DictFormat;
import com.yunxi.scm.framework.excel.core.convert.MutilDictConvert;
import com.yunxi.scm.module.demo2.enums.DictTypeConstants;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import java.util.List;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = false) // 设置 chain = false避免用户导入有问题
public class PMaterialImportTestVO {
@ExcelProperty(value = "分类测试", converter = MutilDictConvert.class)
@DictFormat(DictTypeConstants.TRADE_ORDER_TYPE)
private List<String> category;
}

@ -1,36 +0,0 @@
package com.yunxi.scm.module.demo2.controller.admin.pmaterial.vo;
import com.yunxi.scm.framework.common.pojo.PageParam;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.ToString;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 物料管理分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class PMaterialPageReqVO extends PageParam {
@Schema(description = "名称", example = "李四")
private String name;
@Schema(description = "状态", example = "1")
private Byte status;
@Schema(description = "类型", example = "2")
private Byte type;
@Schema(description = "分类", example = "2")
private String category;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -1,18 +0,0 @@
package com.yunxi.scm.module.demo2.controller.admin.pmaterial.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 物料管理更新 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class PMaterialUpdateReqVO extends PMaterialBaseVO {
@Schema(description = "ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "14541")
@NotNull(message = "ID不能为空")
private Long id;
}

@ -1,37 +0,0 @@
package com.yunxi.scm.module.demo2.convert.pmaterial;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.module.demo2.controller.admin.pmaterial.vo.*;
import com.yunxi.scm.module.demo2.dal.dataobject.pmaterial.PMaterialDO;
import com.yunxi.scm.module.demo2.dal.dataobject.pmaterial.PMaterialXDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
* Convert
*
* @author ccongli
*/
@Mapper
public interface PMaterialConvert {
PMaterialConvert INSTANCE = Mappers.getMapper(PMaterialConvert.class);
PMaterialDO convert(PMaterialCreateReqVO bean);
PMaterialDO convert(PMaterialUpdateReqVO bean);
PMaterialRespVO convert(PMaterialDO bean);
List<PMaterialRespVO> convertList(List<PMaterialDO> list);
PageResult<PMaterialRespVO> convertPage(PageResult<PMaterialDO> page);
List<PMaterialExcelVO> convertList02(List<PMaterialDO> list);
List<PMaterialExportTestVO> convertList03(List<PMaterialXDO> list);
}

@ -1,24 +0,0 @@
package com.yunxi.scm.module.demo2.convert.pmaterial;
import com.yunxi.scm.module.demo2.controller.admin.pmaterial.vo.PMaterialExportTestVO;
import com.yunxi.scm.module.demo2.dal.dataobject.pmaterial.PMaterialXDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
* Convert
*
* @author ccongli
*/
@Mapper
public interface PMaterialXConvert {
PMaterialXConvert INSTANCE = Mappers.getMapper(PMaterialXConvert.class);
PMaterialExportTestVO convert(PMaterialXDO xdo);
List<PMaterialExportTestVO> convertList03(List<PMaterialXDO> list);
}

@ -1,73 +0,0 @@
package com.yunxi.scm.module.demo2.dal.dataobject.pmaterial;
import com.baomidou.mybatisplus.annotation.KeySequence;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.yunxi.scm.framework.mybatis.core.dataobject.BaseDO;
import com.yunxi.scm.framework.mybatis.core.type.StringListTypeHandler;
import lombok.*;
import org.apache.ibatis.type.Alias;
import java.math.BigDecimal;
import java.util.List;
/**
* DO
*
* @author ccongli
*/
@TableName(value = "demo_material",autoResultMap = true)
@KeySequence("demo_material_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库,可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Alias("PMaterialDO2") // 解决实体类名重复映射问题
public class PMaterialDO extends BaseDO {
/**
* ID
*/
@TableId
private Long id;
/**
*
*/
private String name;
/**
*
*
* {@link TODO material_status }
*/
private Byte status;
/**
*
*/
private Byte type;
/**
*
*/
// @TableField(typeHandler = JacksonTypeHandler.class)
@TableField(typeHandler = StringListTypeHandler.class)
private List<String> categories;
/**
*
*/
private String imgurl;
/**
*
*/
private Integer stock;
/**
*
*/
private BigDecimal price;
/**
*
*/
private String remark;
}

@ -1,32 +0,0 @@
package com.yunxi.scm.module.demo2.dal.dataobject.pmaterial;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.yunxi.scm.framework.mybatis.core.type.EncryptTypeHandler;
import com.yunxi.scm.framework.mybatis.core.type.StringListTypeHandler;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.ibatis.type.Alias;
import java.io.Serializable;
import java.util.List;
@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName(value = "demo_xxx", autoResultMap = true)
@Alias("PMaterialXDO2")
public class PMaterialXDO implements Serializable {
@TableId
private Long id;
// 字段加密注解
@TableField(typeHandler = EncryptTypeHandler.class)
private String password;
@TableField(typeHandler = StringListTypeHandler.class)
private List<String> category;
}

@ -1,43 +0,0 @@
package com.yunxi.scm.module.demo2.dal.mysql.pmaterial;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.mybatis.core.mapper.BaseMapperX;
import com.yunxi.scm.framework.mybatis.core.query.LambdaQueryWrapperX;
import com.yunxi.scm.module.demo2.controller.admin.pmaterial.vo.PMaterialExportReqVO;
import com.yunxi.scm.module.demo2.controller.admin.pmaterial.vo.PMaterialPageReqVO;
import com.yunxi.scm.module.demo2.dal.dataobject.pmaterial.PMaterialDO;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* Mapper
*
* @author ccongli
*/
@Mapper // 启动类加了MapperScan注解扫描之后可以不用再写Mapper注解
@Repository("PMaterialMapper2")
public interface PMaterialMapper extends BaseMapperX<PMaterialDO> {
default PageResult<PMaterialDO> selectPage(PMaterialPageReqVO reqVO) {
return selectPage(reqVO, new LambdaQueryWrapperX<PMaterialDO>()
.likeIfPresent(PMaterialDO::getName, reqVO.getName())
.eqIfPresent(PMaterialDO::getStatus, reqVO.getStatus())
.eqIfPresent(PMaterialDO::getType, reqVO.getType())
.likeIfPresent(PMaterialDO::getCategories, reqVO.getCategory())
.betweenIfPresent(PMaterialDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(PMaterialDO::getId));
}
default List<PMaterialDO> selectList(PMaterialExportReqVO reqVO) {
return selectList(new LambdaQueryWrapperX<PMaterialDO>()
.likeIfPresent(PMaterialDO::getName, reqVO.getName())
.eqIfPresent(PMaterialDO::getStatus, reqVO.getStatus())
.eqIfPresent(PMaterialDO::getType, reqVO.getType())
.likeIfPresent(PMaterialDO::getCategories, reqVO.getCategory())
.betweenIfPresent(PMaterialDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(PMaterialDO::getId));
}
}

@ -1,17 +0,0 @@
package com.yunxi.scm.module.demo2.dal.mysql.pmaterial;
import com.yunxi.scm.framework.mybatis.core.mapper.BaseMapperX;
import com.yunxi.scm.module.demo2.dal.dataobject.pmaterial.PMaterialXDO;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;
/**
* Mapper
*
* @author ccongli
*/
@Mapper
@Repository("PMaterialXMapper2")
public interface PMaterialXMapper extends BaseMapperX<PMaterialXDO> {
}

@ -1,34 +0,0 @@
package com.yunxi.scm.module.demo2.enums.pmaterial;
import com.yunxi.scm.framework.common.core.IntArrayValuable;
import lombok.AllArgsConstructor;
import lombok.Getter;
import java.util.Arrays;
@Getter
@AllArgsConstructor
public enum CategoryEnum implements IntArrayValuable {
COMMON(0, "普通"),
MIAOSHA(1, "秒杀"),
PINTUAN(2,"拼团"),
KANJIA(3, "砍价");
public static final int[] ARRAYS = Arrays.stream(values()).mapToInt(CategoryEnum::getCode).toArray();
/**
*
*/
private final Integer code;
/**
*
*/
private final String name;
@Override
public int[] array() {
return ARRAYS;
}
}

@ -1,73 +0,0 @@
package com.yunxi.scm.module.demo2.service.pmaterial;
import java.util.*;
import javax.validation.*;
import com.yunxi.scm.module.demo2.dal.dataobject.pmaterial.PMaterialDO;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.module.demo2.controller.admin.pmaterial.vo.PMaterialCreateReqVO;
import com.yunxi.scm.module.demo2.controller.admin.pmaterial.vo.PMaterialExportReqVO;
import com.yunxi.scm.module.demo2.controller.admin.pmaterial.vo.PMaterialPageReqVO;
import com.yunxi.scm.module.demo2.controller.admin.pmaterial.vo.PMaterialUpdateReqVO;
/**
* Service
*
* @author ccongli
*/
public interface PMaterialService {
/**
*
*
* @param createReqVO
* @return
*/
Long createMaterial(@Valid PMaterialCreateReqVO createReqVO);
/**
*
*
* @param updateReqVO
*/
void updateMaterial(@Valid PMaterialUpdateReqVO updateReqVO);
/**
*
*
* @param id
*/
void deleteMaterial(Long id);
/**
*
*
* @param id
* @return
*/
PMaterialDO getMaterial(Long id);
/**
*
*
* @param ids
* @return
*/
List<PMaterialDO> getMaterialList(Collection<Long> ids);
/**
*
*
* @param pageReqVO
* @return
*/
PageResult<PMaterialDO> getMaterialPage(PMaterialPageReqVO pageReqVO);
/**
* , Excel
*
* @param exportReqVO
* @return
*/
List<PMaterialDO> getMaterialList(PMaterialExportReqVO exportReqVO);
}

@ -1,85 +0,0 @@
package com.yunxi.scm.module.demo2.service.pmaterial;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.module.demo2.controller.admin.pmaterial.vo.PMaterialCreateReqVO;
import com.yunxi.scm.module.demo2.controller.admin.pmaterial.vo.PMaterialExportReqVO;
import com.yunxi.scm.module.demo2.controller.admin.pmaterial.vo.PMaterialPageReqVO;
import com.yunxi.scm.module.demo2.controller.admin.pmaterial.vo.PMaterialUpdateReqVO;
import com.yunxi.scm.module.demo2.convert.pmaterial.PMaterialConvert;
import com.yunxi.scm.module.demo2.dal.dataobject.pmaterial.PMaterialDO;
import com.yunxi.scm.module.demo2.dal.mysql.pmaterial.PMaterialMapper;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
import javax.annotation.Resource;
import java.util.Collection;
import java.util.List;
import static com.yunxi.scm.framework.common.exception.util.ServiceExceptionUtil.exception;
import static com.yunxi.scm.module.demo2.enums.ErrorCodeConstants.MATERIAL_NOT_EXISTS;
/**
* Service
*
* @author ccongli
*/
@Service("PMaterialServiceImpl2")
@Validated
public class PMaterialServiceImpl implements PMaterialService {
@Resource
private PMaterialMapper pMaterialMapper;
@Override
public Long createMaterial(PMaterialCreateReqVO createReqVO) {
// 插入
PMaterialDO material = PMaterialConvert.INSTANCE.convert(createReqVO);
pMaterialMapper.insert(material);
// 返回
return material.getId();
}
@Override
public void updateMaterial(PMaterialUpdateReqVO updateReqVO) {
// 校验存在
validateMaterialExists(updateReqVO.getId());
// 更新
PMaterialDO updateObj = PMaterialConvert.INSTANCE.convert(updateReqVO);
pMaterialMapper.updateById(updateObj);
}
@Override
public void deleteMaterial(Long id) {
// 校验存在
validateMaterialExists(id);
// 删除
pMaterialMapper.deleteById(id);
}
private void validateMaterialExists(Long id) {
if (pMaterialMapper.selectById(id) == null) {
throw exception(MATERIAL_NOT_EXISTS);
}
}
@Override
public PMaterialDO getMaterial(Long id) {
return pMaterialMapper.selectById(id);
}
@Override
public List<PMaterialDO> getMaterialList(Collection<Long> ids) {
return pMaterialMapper.selectBatchIds(ids);
}
@Override
public PageResult<PMaterialDO> getMaterialPage(PMaterialPageReqVO pageReqVO) {
return pMaterialMapper.selectPage(pageReqVO);
}
@Override
public List<PMaterialDO> getMaterialList(PMaterialExportReqVO exportReqVO) {
return pMaterialMapper.selectList(exportReqVO);
}
}

@ -1,179 +0,0 @@
package com.yunxi.scm.module.demo2.service.pmaterial;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.test.core.ut.BaseDbUnitTest;
import com.yunxi.scm.module.demo2.controller.admin.pmaterial.vo.PMaterialCreateReqVO;
import com.yunxi.scm.module.demo2.controller.admin.pmaterial.vo.PMaterialExportReqVO;
import com.yunxi.scm.module.demo2.controller.admin.pmaterial.vo.PMaterialPageReqVO;
import com.yunxi.scm.module.demo2.controller.admin.pmaterial.vo.PMaterialUpdateReqVO;
import com.yunxi.scm.module.demo2.dal.dataobject.pmaterial.PMaterialDO;
import com.yunxi.scm.module.demo2.dal.mysql.pmaterial.PMaterialMapper;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.springframework.context.annotation.Import;
import javax.annotation.Resource;
import java.util.List;
import static com.yunxi.scm.framework.common.util.date.LocalDateTimeUtils.buildBetweenTime;
import static com.yunxi.scm.framework.common.util.object.ObjectUtils.cloneIgnoreId;
import static com.yunxi.scm.framework.test.core.util.AssertUtils.assertPojoEquals;
import static com.yunxi.scm.framework.test.core.util.AssertUtils.assertServiceException;
import static com.yunxi.scm.framework.test.core.util.RandomUtils.randomLongId;
import static com.yunxi.scm.framework.test.core.util.RandomUtils.randomPojo;
import static com.yunxi.scm.module.demo2.enums.ErrorCodeConstants.MATERIAL_NOT_EXISTS;
import static org.junit.jupiter.api.Assertions.*;
/**
* {@link PMaterialServiceImpl}
*
* @author ccongli
*/
@Import(PMaterialServiceImpl.class)
public class MaterialServiceImplTest extends BaseDbUnitTest {
@Resource
private PMaterialServiceImpl materialService;
@Resource
private PMaterialMapper materialMapper;
@Test
public void testCreateMaterial_success() {
// 准备参数
PMaterialCreateReqVO reqVO = randomPojo(PMaterialCreateReqVO.class);
// 调用
Long materialId = materialService.createMaterial(reqVO);
// 断言
assertNotNull(materialId);
// 校验记录的属性是否正确
PMaterialDO material = materialMapper.selectById(materialId);
assertPojoEquals(reqVO, material);
}
@Test
public void testUpdateMaterial_success() {
// mock 数据
PMaterialDO dbMaterial = randomPojo(PMaterialDO.class);
materialMapper.insert(dbMaterial);// @Sql: 先插入出一条存在的数据
// 准备参数
PMaterialUpdateReqVO reqVO = randomPojo(PMaterialUpdateReqVO.class, o -> {
o.setId(dbMaterial.getId()); // 设置更新的 ID
});
// 调用
materialService.updateMaterial(reqVO);
// 校验是否更新正确
PMaterialDO material = materialMapper.selectById(reqVO.getId()); // 获取最新的
assertPojoEquals(reqVO, material);
}
@Test
public void testUpdateMaterial_notExists() {
// 准备参数
PMaterialUpdateReqVO reqVO = randomPojo(PMaterialUpdateReqVO.class);
// 调用, 并断言异常
assertServiceException(() -> materialService.updateMaterial(reqVO), MATERIAL_NOT_EXISTS);
}
@Test
public void testDeleteMaterial_success() {
// mock 数据
PMaterialDO dbMaterial = randomPojo(PMaterialDO.class);
materialMapper.insert(dbMaterial);// @Sql: 先插入出一条存在的数据
// 准备参数
Long id = dbMaterial.getId();
// 调用
materialService.deleteMaterial(id);
// 校验数据不存在了
assertNull(materialMapper.selectById(id));
}
@Test
public void testDeleteMaterial_notExists() {
// 准备参数
Long id = randomLongId();
// 调用, 并断言异常
assertServiceException(() -> materialService.deleteMaterial(id), MATERIAL_NOT_EXISTS);
}
@Test
@Disabled // TODO 请修改 null 为需要的值,然后删除 @Disabled 注解
public void testGetMaterialPage() {
// mock 数据
PMaterialDO dbMaterial = randomPojo(PMaterialDO.class, o -> { // 等会查询到
o.setName(null);
o.setStatus(null);
o.setType(null);
o.setCategories(null);
o.setCreateTime(null);
});
materialMapper.insert(dbMaterial);
// 测试 name 不匹配
materialMapper.insert(cloneIgnoreId(dbMaterial, o -> o.setName(null)));
// 测试 status 不匹配
materialMapper.insert(cloneIgnoreId(dbMaterial, o -> o.setStatus(null)));
// 测试 type 不匹配
materialMapper.insert(cloneIgnoreId(dbMaterial, o -> o.setType(null)));
// 测试 category 不匹配
materialMapper.insert(cloneIgnoreId(dbMaterial, o -> o.setCategories(null)));
// 测试 createTime 不匹配
materialMapper.insert(cloneIgnoreId(dbMaterial, o -> o.setCreateTime(null)));
// 准备参数
PMaterialPageReqVO reqVO = new PMaterialPageReqVO();
reqVO.setName(null);
reqVO.setStatus(null);
reqVO.setType(null);
reqVO.setCategory(null);
reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
// 调用
PageResult<PMaterialDO> pageResult = materialService.getMaterialPage(reqVO);
// 断言
assertEquals(1, pageResult.getTotal());
assertEquals(1, pageResult.getList().size());
assertPojoEquals(dbMaterial, pageResult.getList().get(0));
}
@Test
@Disabled // TODO 请修改 null 为需要的值,然后删除 @Disabled 注解
public void testGetMaterialList() {
// mock 数据
PMaterialDO dbMaterial = randomPojo(PMaterialDO.class, o -> { // 等会查询到
o.setName(null);
o.setStatus(null);
o.setType(null);
o.setCategories(null);
o.setCreateTime(null);
});
materialMapper.insert(dbMaterial);
// 测试 name 不匹配
materialMapper.insert(cloneIgnoreId(dbMaterial, o -> o.setName(null)));
// 测试 status 不匹配
materialMapper.insert(cloneIgnoreId(dbMaterial, o -> o.setStatus(null)));
// 测试 type 不匹配
materialMapper.insert(cloneIgnoreId(dbMaterial, o -> o.setType(null)));
// 测试 category 不匹配
materialMapper.insert(cloneIgnoreId(dbMaterial, o -> o.setCategories(null)));
// 测试 createTime 不匹配
materialMapper.insert(cloneIgnoreId(dbMaterial, o -> o.setCreateTime(null)));
// 准备参数
PMaterialExportReqVO reqVO = new PMaterialExportReqVO();
reqVO.setName(null);
reqVO.setStatus(null);
reqVO.setType(null);
reqVO.setCategory(null);
reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
// 调用
List<PMaterialDO> list = materialService.getMaterialList(reqVO);
// 断言
assertEquals(1, list.size());
assertPojoEquals(dbMaterial, list.get(0));
}
}

@ -1,2 +0,0 @@
-- SQL yunxi-module-demo-biz test/resources/sql/clean.sql
DELETE FROM "demo_material";

@ -1,19 +0,0 @@
-- SQL yunxi-module-demo-biz test/resources/sql/create_tables.sql
CREATE TABLE IF NOT EXISTS "demo_material" (
"id" bigint NOT NULL GENERATED BY DEFAULT AS IDENTITY,
"name" varchar NOT NULL,
"status" varchar NOT NULL,
"type" varchar NOT NULL,
"category" varchar NOT NULL,
"imgurl" varchar NOT NULL,
"stock" int NOT NULL,
"price" varchar NOT NULL,
"remark" varchar,
"creator" varchar DEFAULT '',
"create_time" datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
"updater" varchar DEFAULT '',
"update_time" datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
"deleted" bit NOT NULL DEFAULT FALSE,
"tenant_id" bigint NOT NULL,
PRIMARY KEY ("id")
) COMMENT '';

@ -1,55 +0,0 @@
-- SQL
INSERT INTO system_menu(
name, permission, type, sort, parent_id,
path, icon, component, status, component_name
)
VALUES (
'', '', 2, 0, 1,
'material', '', 'demo/material/index', 0, 'Material'
);
-- ID
-- MySQL OraclePostgreSQLSQLServer @parentId
SELECT @parentId := LAST_INSERT_ID();
-- SQL
INSERT INTO system_menu(
name, permission, type, sort, parent_id,
path, icon, component, status
)
VALUES (
'', 'demo:material:query', 3, 1, @parentId,
'', '', '', 0
);
INSERT INTO system_menu(
name, permission, type, sort, parent_id,
path, icon, component, status
)
VALUES (
'', 'demo:material:create', 3, 2, @parentId,
'', '', '', 0
);
INSERT INTO system_menu(
name, permission, type, sort, parent_id,
path, icon, component, status
)
VALUES (
'', 'demo:material:update', 3, 3, @parentId,
'', '', '', 0
);
INSERT INTO system_menu(
name, permission, type, sort, parent_id,
path, icon, component, status
)
VALUES (
'', 'demo:material:delete', 3, 4, @parentId,
'', '', '', 0
);
INSERT INTO system_menu(
name, permission, type, sort, parent_id,
path, icon, component, status
)
VALUES (
'', 'demo:material:export', 3, 5, @parentId,
'', '', '', 0
);

@ -163,4 +163,15 @@ public interface ErrorCodeConstants {
// ========== 站内信发送 1002028000 ==========
ErrorCode NOTIFY_SEND_TEMPLATE_PARAM_MISS = new ErrorCode(1002028000, "模板参数({})缺失");
// ========== 企业信息 TODO 补充编号 ==========
ErrorCode ENTERPRISE_NOT_EXISTS = new ErrorCode(1002004015, "企业信息不存在");
// ========== 业务线表 TODO 补充编号 ==========
ErrorCode BUSINESS_WAREHOUSE_NOT_EXISTS = new ErrorCode(1002025019, "业务线表不存在");
// ========== 业务线和用户关联 TODO 补充编号 ==========
ErrorCode BUSINESS_USER_RELATIONAL_NOT_EXISTS = new ErrorCode(1002025020, "业务线和用户关联不存在");
// ========== 业务线和机构关联 TODO 补充编号 ==========
ErrorCode BUSINESS_ENTERPRISE_RELATIONAL_NOT_EXISTS = new ErrorCode(1002025021, "业务线和机构关联不存在");
}

@ -0,0 +1,18 @@
package com.yunxi.scm.module.system.enums.business;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public enum BusinessEnum {
ENABLE("0"), // 启用
DISABLE("1"); // 禁用
/**
*
*/
private final String status;
}

@ -22,4 +22,10 @@ public enum MenuTypeEnum {
*/
private final Integer type;
// 判断是否不为目录类型
public static boolean isNoDIR(Integer type) {
return !DIR.getType().equals(type);
}
}

@ -27,4 +27,7 @@ public class AuthLoginRespVO {
@Schema(description = "过期时间", requiredMode = Schema.RequiredMode.REQUIRED)
private LocalDateTime expiresTime;
@Schema(description = "租户id", requiredMode = Schema.RequiredMode.REQUIRED)
private Long tenantId;
}

@ -1,5 +1,9 @@
package com.yunxi.scm.module.system.controller.admin.auth.vo;
import com.baomidou.mybatisplus.annotation.TableField;
import com.yunxi.scm.module.system.dal.dataobject.businesswarehouse.BusinessWarehouseDO;
import com.yunxi.scm.module.system.dal.dataobject.enterprise.EnterpriseDO;
import com.yunxi.scm.module.system.dal.dataobject.tenant.TenantDO;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.Builder;
@ -44,6 +48,15 @@ public class AuthPermissionInfoRespVO {
@Schema(description = "用户头像", requiredMode = Schema.RequiredMode.REQUIRED, example = "https://www.iocoder.cn/xx.jpg")
private String avatar;
private List<EnterpriseDO> enterpriseList;
private List<BusinessWarehouseDO> businessWarehouseList;
private EnterpriseDO enterprise;
private List<TenantDO> tenantDOList;
private TenantDO tenantDO;
}
@Schema(description = "管理后台 - 登录用户的菜单信息 Response VO")

@ -0,0 +1,102 @@
package com.yunxi.scm.module.system.controller.admin.businessenterpriserelational;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.security.access.prepost.PreAuthorize;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import javax.validation.constraints.*;
import javax.validation.*;
import javax.servlet.http.*;
import java.util.*;
import java.io.IOException;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.common.pojo.CommonResult;
import static com.yunxi.scm.framework.common.pojo.CommonResult.success;
import com.yunxi.scm.framework.excel.core.util.ExcelUtils;
import com.yunxi.scm.framework.operatelog.core.annotations.OperateLog;
import static com.yunxi.scm.framework.operatelog.core.enums.OperateTypeEnum.*;
import com.yunxi.scm.module.system.controller.admin.businessenterpriserelational.vo.*;
import com.yunxi.scm.module.system.dal.dataobject.businessenterpriserelational.BusinessEnterpriseRelationalDO;
import com.yunxi.scm.module.system.convert.businessenterpriserelational.BusinessEnterpriseRelationalConvert;
import com.yunxi.scm.module.system.service.businessenterpriserelational.BusinessEnterpriseRelationalService;
@Tag(name = "管理后台 - 业务线和机构关联")
@RestController
@RequestMapping("/system/business-enterprise-relational")
@Validated
public class BusinessEnterpriseRelationalController {
@Resource
private BusinessEnterpriseRelationalService businessEnterpriseRelationalService;
@PostMapping("/create")
@Operation(summary = "创建业务线和机构关联")
@PreAuthorize("@ss.hasPermission('system:business-enterprise-relational:create')")
public CommonResult<Long> createBusinessEnterpriseRelational(@Valid @RequestBody BusinessEnterpriseRelationalCreateReqVO createReqVO) {
return success(businessEnterpriseRelationalService.createBusinessEnterpriseRelational(createReqVO));
}
@PutMapping("/update")
@Operation(summary = "更新业务线和机构关联")
@PreAuthorize("@ss.hasPermission('system:business-enterprise-relational:update')")
public CommonResult<Boolean> updateBusinessEnterpriseRelational(@Valid @RequestBody BusinessEnterpriseRelationalUpdateReqVO updateReqVO) {
businessEnterpriseRelationalService.updateBusinessEnterpriseRelational(updateReqVO);
return success(true);
}
@DeleteMapping("/delete")
@Operation(summary = "删除业务线和机构关联")
@Parameter(name = "id", description = "编号", required = true)
@PreAuthorize("@ss.hasPermission('system:business-enterprise-relational:delete')")
public CommonResult<Boolean> deleteBusinessEnterpriseRelational(@RequestParam("id") Long id) {
businessEnterpriseRelationalService.deleteBusinessEnterpriseRelational(id);
return success(true);
}
@GetMapping("/get")
@Operation(summary = "获得业务线和机构关联")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('system:business-enterprise-relational:query')")
public CommonResult<BusinessEnterpriseRelationalRespVO> getBusinessEnterpriseRelational(@RequestParam("id") Long id) {
BusinessEnterpriseRelationalDO businessEnterpriseRelational = businessEnterpriseRelationalService.getBusinessEnterpriseRelational(id);
return success(BusinessEnterpriseRelationalConvert.INSTANCE.convert(businessEnterpriseRelational));
}
@GetMapping("/list")
@Operation(summary = "获得业务线和机构关联列表")
@Parameter(name = "ids", description = "编号列表", required = true, example = "1024,2048")
@PreAuthorize("@ss.hasPermission('system:business-enterprise-relational:query')")
public CommonResult<List<BusinessEnterpriseRelationalRespVO>> getBusinessEnterpriseRelationalList(@RequestParam("ids") Collection<Long> ids) {
List<BusinessEnterpriseRelationalDO> list = businessEnterpriseRelationalService.getBusinessEnterpriseRelationalList(ids);
return success(BusinessEnterpriseRelationalConvert.INSTANCE.convertList(list));
}
@GetMapping("/page")
@Operation(summary = "获得业务线和机构关联分页")
@PreAuthorize("@ss.hasPermission('system:business-enterprise-relational:query')")
public CommonResult<PageResult<BusinessEnterpriseRelationalRespVO>> getBusinessEnterpriseRelationalPage(@Valid BusinessEnterpriseRelationalPageReqVO pageVO) {
PageResult<BusinessEnterpriseRelationalDO> pageResult = businessEnterpriseRelationalService.getBusinessEnterpriseRelationalPage(pageVO);
return success(BusinessEnterpriseRelationalConvert.INSTANCE.convertPage(pageResult));
}
@GetMapping("/export-excel")
@Operation(summary = "导出业务线和机构关联 Excel")
@PreAuthorize("@ss.hasPermission('system:business-enterprise-relational:export')")
@OperateLog(type = EXPORT)
public void exportBusinessEnterpriseRelationalExcel(@Valid BusinessEnterpriseRelationalExportReqVO exportReqVO,
HttpServletResponse response) throws IOException {
List<BusinessEnterpriseRelationalDO> list = businessEnterpriseRelationalService.getBusinessEnterpriseRelationalList(exportReqVO);
// 导出 Excel
List<BusinessEnterpriseRelationalExcelVO> datas = BusinessEnterpriseRelationalConvert.INSTANCE.convertList02(list);
ExcelUtils.write(response, "业务线和机构关联.xls", "数据", BusinessEnterpriseRelationalExcelVO.class, datas);
}
}

@ -0,0 +1,25 @@
package com.yunxi.scm.module.system.controller.admin.businessenterpriserelational.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import javax.validation.constraints.*;
/**
* 线 Base VO VO 使
* VO Swagger
*/
@Data
public class BusinessEnterpriseRelationalBaseVO {
@Schema(description = "业务线id", requiredMode = Schema.RequiredMode.REQUIRED, example = "3256")
@NotNull(message = "业务线id不能为空")
private Long businessId;
@Schema(description = "企业id", requiredMode = Schema.RequiredMode.REQUIRED, example = "15640")
@NotNull(message = "企业id不能为空")
private Long enterpriseId;
}

@ -0,0 +1,14 @@
package com.yunxi.scm.module.system.controller.admin.businessenterpriserelational.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 业务线和机构关联创建 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class BusinessEnterpriseRelationalCreateReqVO extends BusinessEnterpriseRelationalBaseVO {
}

@ -0,0 +1,31 @@
package com.yunxi.scm.module.system.controller.admin.businessenterpriserelational.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.alibaba.excel.annotation.ExcelProperty;
/**
* 线 Excel VO
*
* @author
*/
@Data
public class BusinessEnterpriseRelationalExcelVO {
@ExcelProperty("主键id")
private Long id;
@ExcelProperty("业务线id")
private Long businessId;
@ExcelProperty("企业id")
private Long enterpriseId;
@ExcelProperty("创建时间")
private LocalDateTime createTime;
}

@ -0,0 +1,26 @@
package com.yunxi.scm.module.system.controller.admin.businessenterpriserelational.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.yunxi.scm.framework.common.pojo.PageParam;
import java.time.LocalDateTime;
import org.springframework.format.annotation.DateTimeFormat;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 业务线和机构关联 Excel 导出 Request VO参数和 BusinessEnterpriseRelationalPageReqVO 是一致的")
@Data
public class BusinessEnterpriseRelationalExportReqVO {
@Schema(description = "业务线id", example = "3256")
private Long businessId;
@Schema(description = "企业id", example = "15640")
private Long enterpriseId;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,28 @@
package com.yunxi.scm.module.system.controller.admin.businessenterpriserelational.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.yunxi.scm.framework.common.pojo.PageParam;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 业务线和机构关联分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class BusinessEnterpriseRelationalPageReqVO extends PageParam {
@Schema(description = "业务线id", example = "3256")
private Long businessId;
@Schema(description = "企业id", example = "15640")
private Long enterpriseId;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,19 @@
package com.yunxi.scm.module.system.controller.admin.businessenterpriserelational.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.time.LocalDateTime;
@Schema(description = "管理后台 - 业务线和机构关联 Response VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class BusinessEnterpriseRelationalRespVO extends BusinessEnterpriseRelationalBaseVO {
@Schema(description = "主键id", requiredMode = Schema.RequiredMode.REQUIRED, example = "21519")
private Long id;
@Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
private LocalDateTime createTime;
}

@ -0,0 +1,18 @@
package com.yunxi.scm.module.system.controller.admin.businessenterpriserelational.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 业务线和机构关联更新 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class BusinessEnterpriseRelationalUpdateReqVO extends BusinessEnterpriseRelationalBaseVO {
@Schema(description = "主键id", requiredMode = Schema.RequiredMode.REQUIRED, example = "21519")
@NotNull(message = "主键id不能为空")
private Long id;
}

@ -0,0 +1,102 @@
package com.yunxi.scm.module.system.controller.admin.businessuserrelational;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.security.access.prepost.PreAuthorize;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import javax.validation.constraints.*;
import javax.validation.*;
import javax.servlet.http.*;
import java.util.*;
import java.io.IOException;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.common.pojo.CommonResult;
import static com.yunxi.scm.framework.common.pojo.CommonResult.success;
import com.yunxi.scm.framework.excel.core.util.ExcelUtils;
import com.yunxi.scm.framework.operatelog.core.annotations.OperateLog;
import static com.yunxi.scm.framework.operatelog.core.enums.OperateTypeEnum.*;
import com.yunxi.scm.module.system.controller.admin.businessuserrelational.vo.*;
import com.yunxi.scm.module.system.dal.dataobject.businessuserrelational.BusinessUserRelationalDO;
import com.yunxi.scm.module.system.convert.businessuserrelational.BusinessUserRelationalConvert;
import com.yunxi.scm.module.system.service.businessuserrelational.BusinessUserRelationalService;
@Tag(name = "管理后台 - 业务线和用户关联")
@RestController
@RequestMapping("/system/business-user-relational")
@Validated
public class BusinessUserRelationalController {
@Resource
private BusinessUserRelationalService businessUserRelationalService;
@PostMapping("/create")
@Operation(summary = "创建业务线和用户关联")
@PreAuthorize("@ss.hasPermission('system:business-user-relational:create')")
public CommonResult<Long> createBusinessUserRelational(@Valid @RequestBody BusinessUserRelationalCreateReqVO createReqVO) {
return success(businessUserRelationalService.createBusinessUserRelational(createReqVO));
}
@PutMapping("/update")
@Operation(summary = "更新业务线和用户关联")
@PreAuthorize("@ss.hasPermission('system:business-user-relational:update')")
public CommonResult<Boolean> updateBusinessUserRelational(@Valid @RequestBody BusinessUserRelationalUpdateReqVO updateReqVO) {
businessUserRelationalService.updateBusinessUserRelational(updateReqVO);
return success(true);
}
@DeleteMapping("/delete")
@Operation(summary = "删除业务线和用户关联")
@Parameter(name = "id", description = "编号", required = true)
@PreAuthorize("@ss.hasPermission('system:business-user-relational:delete')")
public CommonResult<Boolean> deleteBusinessUserRelational(@RequestParam("id") Long id) {
businessUserRelationalService.deleteBusinessUserRelational(id);
return success(true);
}
@GetMapping("/get")
@Operation(summary = "获得业务线和用户关联")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('system:business-user-relational:query')")
public CommonResult<BusinessUserRelationalRespVO> getBusinessUserRelational(@RequestParam("id") Long id) {
BusinessUserRelationalDO businessUserRelational = businessUserRelationalService.getBusinessUserRelational(id);
return success(BusinessUserRelationalConvert.INSTANCE.convert(businessUserRelational));
}
@GetMapping("/list")
@Operation(summary = "获得业务线和用户关联列表")
@Parameter(name = "ids", description = "编号列表", required = true, example = "1024,2048")
@PreAuthorize("@ss.hasPermission('system:business-user-relational:query')")
public CommonResult<List<BusinessUserRelationalRespVO>> getBusinessUserRelationalList(@RequestParam("ids") Collection<Long> ids) {
List<BusinessUserRelationalDO> list = businessUserRelationalService.getBusinessUserRelationalList(ids);
return success(BusinessUserRelationalConvert.INSTANCE.convertList(list));
}
@GetMapping("/page")
@Operation(summary = "获得业务线和用户关联分页")
@PreAuthorize("@ss.hasPermission('system:business-user-relational:query')")
public CommonResult<PageResult<BusinessUserRelationalRespVO>> getBusinessUserRelationalPage(@Valid BusinessUserRelationalPageReqVO pageVO) {
PageResult<BusinessUserRelationalDO> pageResult = businessUserRelationalService.getBusinessUserRelationalPage(pageVO);
return success(BusinessUserRelationalConvert.INSTANCE.convertPage(pageResult));
}
@GetMapping("/export-excel")
@Operation(summary = "导出业务线和用户关联 Excel")
@PreAuthorize("@ss.hasPermission('system:business-user-relational:export')")
@OperateLog(type = EXPORT)
public void exportBusinessUserRelationalExcel(@Valid BusinessUserRelationalExportReqVO exportReqVO,
HttpServletResponse response) throws IOException {
List<BusinessUserRelationalDO> list = businessUserRelationalService.getBusinessUserRelationalList(exportReqVO);
// 导出 Excel
List<BusinessUserRelationalExcelVO> datas = BusinessUserRelationalConvert.INSTANCE.convertList02(list);
ExcelUtils.write(response, "业务线和用户关联.xls", "数据", BusinessUserRelationalExcelVO.class, datas);
}
}

@ -0,0 +1,25 @@
package com.yunxi.scm.module.system.controller.admin.businessuserrelational.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import javax.validation.constraints.*;
/**
* 线 Base VO VO 使
* VO Swagger
*/
@Data
public class BusinessUserRelationalBaseVO {
@Schema(description = "业务线/仓库id", requiredMode = Schema.RequiredMode.REQUIRED, example = "29863")
@NotNull(message = "业务线/仓库id不能为空")
private Long businessId;
@Schema(description = "用户id", requiredMode = Schema.RequiredMode.REQUIRED, example = "2593")
@NotNull(message = "用户id不能为空")
private Long userId;
}

@ -0,0 +1,14 @@
package com.yunxi.scm.module.system.controller.admin.businessuserrelational.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 业务线和用户关联创建 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class BusinessUserRelationalCreateReqVO extends BusinessUserRelationalBaseVO {
}

@ -0,0 +1,31 @@
package com.yunxi.scm.module.system.controller.admin.businessuserrelational.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.alibaba.excel.annotation.ExcelProperty;
/**
* 线 Excel VO
*
* @author
*/
@Data
public class BusinessUserRelationalExcelVO {
@ExcelProperty("主键id")
private Long id;
@ExcelProperty("业务线/仓库id")
private Long businessId;
@ExcelProperty("用户id")
private Long userId;
@ExcelProperty("创建时间")
private LocalDateTime createTime;
}

@ -0,0 +1,26 @@
package com.yunxi.scm.module.system.controller.admin.businessuserrelational.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.yunxi.scm.framework.common.pojo.PageParam;
import java.time.LocalDateTime;
import org.springframework.format.annotation.DateTimeFormat;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 业务线和用户关联 Excel 导出 Request VO参数和 BusinessUserRelationalPageReqVO 是一致的")
@Data
public class BusinessUserRelationalExportReqVO {
@Schema(description = "业务线/仓库id", example = "29863")
private Long businessId;
@Schema(description = "用户id", example = "2593")
private Long userId;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,28 @@
package com.yunxi.scm.module.system.controller.admin.businessuserrelational.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.yunxi.scm.framework.common.pojo.PageParam;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 业务线和用户关联分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class BusinessUserRelationalPageReqVO extends PageParam {
@Schema(description = "业务线/仓库id", example = "29863")
private Long businessId;
@Schema(description = "用户id", example = "2593")
private Long userId;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,19 @@
package com.yunxi.scm.module.system.controller.admin.businessuserrelational.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.time.LocalDateTime;
@Schema(description = "管理后台 - 业务线和用户关联 Response VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class BusinessUserRelationalRespVO extends BusinessUserRelationalBaseVO {
@Schema(description = "主键id", requiredMode = Schema.RequiredMode.REQUIRED, example = "17732")
private Long id;
@Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
private LocalDateTime createTime;
}

@ -0,0 +1,18 @@
package com.yunxi.scm.module.system.controller.admin.businessuserrelational.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 业务线和用户关联更新 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class BusinessUserRelationalUpdateReqVO extends BusinessUserRelationalBaseVO {
@Schema(description = "主键id", requiredMode = Schema.RequiredMode.REQUIRED, example = "17732")
@NotNull(message = "主键id不能为空")
private Long id;
}

@ -0,0 +1,137 @@
package com.yunxi.scm.module.system.controller.admin.businesswarehouse;
import com.yunxi.scm.framework.common.enums.CommonStatusEnum;
import com.yunxi.scm.module.system.controller.admin.dept.vo.dept.DeptListReqVO;
import com.yunxi.scm.module.system.controller.admin.dept.vo.dept.DeptSimpleRespVO;
import com.yunxi.scm.module.system.convert.dept.DeptConvert;
import com.yunxi.scm.module.system.dal.dataobject.dept.DeptDO;
import com.yunxi.scm.module.system.enums.business.BusinessEnum;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.security.access.prepost.PreAuthorize;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import javax.validation.constraints.*;
import javax.validation.*;
import javax.servlet.http.*;
import java.util.*;
import java.io.IOException;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.common.pojo.CommonResult;
import static com.yunxi.scm.framework.common.pojo.CommonResult.success;
import com.yunxi.scm.framework.excel.core.util.ExcelUtils;
import com.yunxi.scm.framework.operatelog.core.annotations.OperateLog;
import static com.yunxi.scm.framework.operatelog.core.enums.OperateTypeEnum.*;
import com.yunxi.scm.module.system.controller.admin.businesswarehouse.vo.*;
import com.yunxi.scm.module.system.dal.dataobject.businesswarehouse.BusinessWarehouseDO;
import com.yunxi.scm.module.system.convert.businesswarehouse.BusinessWarehouseConvert;
import com.yunxi.scm.module.system.service.businesswarehouse.BusinessWarehouseService;
@Tag(name = "管理后台 - 业务线表")
@RestController
@RequestMapping("/system/business-warehouse")
@Validated
public class BusinessWarehouseController {
@Resource
private BusinessWarehouseService businessWarehouseService;
@PostMapping("/create")
@Operation(summary = "创建业务线表")
@PreAuthorize("@ss.hasPermission('system:business-warehouse:create')")
public CommonResult<Long> createBusinessWarehouse(@Valid @RequestBody BusinessWarehouseCreateReqVO createReqVO) {
return success(businessWarehouseService.createBusinessWarehouse(createReqVO));
}
@PutMapping("/update")
@Operation(summary = "更新业务线表")
@PreAuthorize("@ss.hasPermission('system:business-warehouse:update')")
public CommonResult<Boolean> updateBusinessWarehouse(@Valid @RequestBody BusinessWarehouseUpdateReqVO updateReqVO) {
businessWarehouseService.updateBusinessWarehouse(updateReqVO);
return success(true);
}
@DeleteMapping("/delete")
@Operation(summary = "删除业务线表")
@Parameter(name = "id", description = "编号", required = true)
@PreAuthorize("@ss.hasPermission('system:business-warehouse:delete')")
public CommonResult<Boolean> deleteBusinessWarehouse(@RequestParam("id") Long id) {
businessWarehouseService.deleteBusinessWarehouse(id);
return success(true);
}
@GetMapping("/get")
@Operation(summary = "获得业务线表")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('system:business-warehouse:query')")
public CommonResult<BusinessWarehouseRespVO> getBusinessWarehouse(@RequestParam("id") Long id) {
BusinessWarehouseDO businessWarehouse = businessWarehouseService.getBusinessWarehouse(id);
return success(BusinessWarehouseConvert.INSTANCE.convert(businessWarehouse));
}
@GetMapping("/list")
@Operation(summary = "获得业务线表列表")
@Parameter(name = "ids", description = "编号列表", required = true, example = "1024,2048")
@PreAuthorize("@ss.hasPermission('system:business-warehouse:query')")
public CommonResult<List<BusinessWarehouseRespVO>> getBusinessWarehouseList(@RequestParam("ids") Collection<Long> ids) {
List<BusinessWarehouseDO> list = businessWarehouseService.getBusinessWarehouseList(ids);
return success(BusinessWarehouseConvert.INSTANCE.convertList(list));
}
@GetMapping("/page")
@Operation(summary = "获得业务线表分页")
@PreAuthorize("@ss.hasPermission('system:business-warehouse:query')")
public CommonResult<PageResult<BusinessWarehouseRespVO>> getBusinessWarehousePage(@Valid BusinessWarehousePageReqVO pageVO) {
PageResult<BusinessWarehouseDO> pageResult = businessWarehouseService.getBusinessWarehousePage(pageVO);
return success(BusinessWarehouseConvert.INSTANCE.convertPage(pageResult));
}
@GetMapping("/business")
@Operation(summary = "获得业务线分页")
@PreAuthorize("@ss.hasPermission('system:business-warehouse:business')")
public CommonResult<PageResult<BusinessWarehouseRespVO>> getBusinessPage(@Valid BusinessWarehousePageReqVO pageVO) {
PageResult<BusinessWarehouseDO> pageResult = businessWarehouseService.getBusinessPage(pageVO);
return success(BusinessWarehouseConvert.INSTANCE.convertPage(pageResult));
}
@GetMapping("/export-excel")
@Operation(summary = "导出业务线表 Excel")
@PreAuthorize("@ss.hasPermission('system:business-warehouse:export')")
@OperateLog(type = EXPORT)
public void exportBusinessWarehouseExcel(@Valid BusinessWarehouseExportReqVO exportReqVO,
HttpServletResponse response) throws IOException {
List<BusinessWarehouseDO> list = businessWarehouseService.getBusinessWarehouseList(exportReqVO);
// 导出 Excel
List<BusinessWarehouseExcelVO> datas = BusinessWarehouseConvert.INSTANCE.convertList02(list);
ExcelUtils.write(response, "业务线表.xls", "数据", BusinessWarehouseExcelVO.class, datas);
}
@GetMapping("/list-all-simple")
@Operation(summary = "获取业务线精简信息列表", description = "只包含被开启的业务线,主要用于前端的下拉选项")
@PreAuthorize("@ss.hasPermission('system:business-warehouse:list-all-simple')")
public CommonResult<List<BusinessSimpleRespVo>> getSimpleBusinessList() {
// 获得业务线列表,只要开启状态的
BusinessWarehousePageReqVO pageReqVO = new BusinessWarehousePageReqVO();
// pageReqVO.setStatus(BusinessEnum.ENABLE.getStatus());
// pageReqVO.setDiffFlag("0");
List<BusinessWarehouseDO> list = businessWarehouseService.getBusinessSimpleList(pageReqVO);
return success(BusinessWarehouseConvert.INSTANCE.convertList03(list));
}
@GetMapping("/business-user")
@Operation(summary = "获得业务线分页")
@PreAuthorize("@ss.hasPermission('system:business-warehouse:business-user')")
public CommonResult<PageResult<BusinessUserVO>> getBusinessUserPage(BusinessUserVO reqVO) {
PageResult<BusinessUserVO> pageResult = businessWarehouseService.getBusinessUserList(reqVO);
return success(pageResult);
}
}

@ -0,0 +1,21 @@
package com.yunxi.scm.module.system.controller.admin.businesswarehouse.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
@Schema(description = "管理后台 - 业务线表精简信息 Response VO")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class BusinessSimpleRespVo {
@Schema(description = "业务线编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "1024")
private Long id;
@Schema(description = "业务线名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "芋道")
private String name;
@Schema(description = "父部门 ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "1024")
private Long parentId;
}

@ -0,0 +1,44 @@
package com.yunxi.scm.module.system.controller.admin.businesswarehouse.vo;
import com.yunxi.scm.framework.common.pojo.PageParam;
import com.yunxi.scm.module.system.dal.dataobject.businesswarehouse.BusinessWarehouseDO;
import com.yunxi.scm.module.system.dal.dataobject.user.AdminUserDO;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 业务线员工信息 Response VO")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class BusinessUserVO extends AdminUserDO {
@Schema(description = "帐号状态")
private Integer accountStatus;
@Schema(description = "业务编号")
private Integer businessId;
@Schema(description = "业务名称")
private String businessName;
@Schema(description = "员工编号")
private Integer userId;
@Schema(description = "分页")
private Integer pageNo;
@Schema(description = "分页")
private Integer pageSize;
@Schema(description = "部门名称")
private String deptName;
@Schema(description = "职务名称")
private String postName;
@Schema(description = "创建时间", example = "[2022-07-01 00:00:00, 2022-07-01 23:59:59]")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] loginTime;
}

@ -0,0 +1,82 @@
package com.yunxi.scm.module.system.controller.admin.businesswarehouse.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import javax.validation.constraints.*;
import org.springframework.format.annotation.DateTimeFormat;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
/**
* 线 Base VO VO 使
* VO Swagger
*/
@Data
public class BusinessWarehouseBaseVO {
@Schema(description = "业务线编号", requiredMode = Schema.RequiredMode.REQUIRED)
@NotNull(message = "业务线编号不能为空")
private String businessCode;
@Schema(description = "业务线名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "赵六")
@NotNull(message = "业务线名称不能为空")
private String name;
@Schema(description = "业务线简称")
private String businessSimple;
@Schema(description = "业务线LOGO")
private String businessLogo;
@Schema(description = "父id", example = "3408")
private Long parentId;
@Schema(description = "类型", example = "1")
private String type;
@Schema(description = "状态", example = "1")
private String status;
@Schema(description = "关联机构")
private Integer institutionNum;
@Schema(description = "成员数量")
private Integer employeeNum;
@Schema(description = "所属分类")
private String industry;
@Schema(description = "所在城市")
private String city;
@Schema(description = "成立时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime establishDate;
@Schema(description = "归属人员", example = "26257")
private Long belongUserId;
@Schema(description = "品牌/业务线/事业群名称", example = "芋艿")
private String brandName;
@Schema(description = "电话")
private Integer phone;
@Schema(description = "业务线仓库区分(0业务线,1仓库)", requiredMode = Schema.RequiredMode.REQUIRED)
@NotNull(message = "业务线仓库区分(0业务线,1仓库)不能为空")
private String diffFlag;
@Schema(description = "传真")
private String fax;
@Schema(description = "网址", example = "https://www.iocoder.cn")
private String url;
@Schema(description = "介绍", example = "随便")
private String description;
}

@ -0,0 +1,14 @@
package com.yunxi.scm.module.system.controller.admin.businesswarehouse.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 业务线表创建 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class BusinessWarehouseCreateReqVO extends BusinessWarehouseBaseVO {
}

@ -0,0 +1,90 @@
package com.yunxi.scm.module.system.controller.admin.businesswarehouse.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.alibaba.excel.annotation.ExcelProperty;
import com.yunxi.scm.framework.excel.core.annotations.DictFormat;
import com.yunxi.scm.framework.excel.core.convert.DictConvert;
/**
* 线 Excel VO
*
* @author
*/
@Data
public class BusinessWarehouseExcelVO {
@ExcelProperty("业务id")
private Long id;
@ExcelProperty("业务线编号")
private String businessCode;
@ExcelProperty("业务线名称")
private String name;
@ExcelProperty("业务线简称")
private String businessSimple;
@ExcelProperty("业务线LOGO")
private String businessLogo;
@ExcelProperty("父id")
private Long parentId;
@ExcelProperty(value = "类型", converter = DictConvert.class)
@DictFormat("business_type") // TODO 代码优化:建议设置到对应的 XXXDictTypeConstants 枚举类中
private String type;
@ExcelProperty(value = "状态", converter = DictConvert.class)
@DictFormat("class_status") // TODO 代码优化:建议设置到对应的 XXXDictTypeConstants 枚举类中
private String status;
@ExcelProperty("关联机构")
private Integer institutionNum;
@ExcelProperty("成员数量")
private Integer employeeNum;
@ExcelProperty(value = "所属分类", converter = DictConvert.class)
@DictFormat("duty_type") // TODO 代码优化:建议设置到对应的 XXXDictTypeConstants 枚举类中
private String industry;
@ExcelProperty("所在城市")
private String city;
@ExcelProperty("成立时间")
private LocalDateTime establishDate;
@ExcelProperty("归属人员")
private Long belongUserId;
@ExcelProperty("品牌/业务线/事业群名称")
private String brandName;
@ExcelProperty("电话")
private Integer phone;
@ExcelProperty(value = "业务线仓库区分(0业务线,1仓库)", converter = DictConvert.class)
@DictFormat("diff_flag") // TODO 代码优化:建议设置到对应的 XXXDictTypeConstants 枚举类中
private String diffFlag;
@ExcelProperty("传真")
private String fax;
@ExcelProperty("网址")
private String url;
@ExcelProperty("介绍")
private String description;
@ExcelProperty("创建时间")
private LocalDateTime createTime;
}

@ -0,0 +1,78 @@
package com.yunxi.scm.module.system.controller.admin.businesswarehouse.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.yunxi.scm.framework.common.pojo.PageParam;
import java.time.LocalDateTime;
import org.springframework.format.annotation.DateTimeFormat;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 业务线表 Excel 导出 Request VO参数和 BusinessWarehousePageReqVO 是一致的")
@Data
public class BusinessWarehouseExportReqVO {
@Schema(description = "业务线编号")
private String businessCode;
@Schema(description = "业务线名称", example = "赵六")
private String name;
@Schema(description = "业务线简称")
private String businessSimple;
@Schema(description = "业务线LOGO")
private String businessLogo;
@Schema(description = "父id", example = "3408")
private Long parentId;
@Schema(description = "类型", example = "1")
private String type;
@Schema(description = "状态", example = "1")
private String status;
@Schema(description = "关联机构")
private Integer institutionNum;
@Schema(description = "成员数量")
private Integer employeeNum;
@Schema(description = "所属分类")
private String industry;
@Schema(description = "所在城市")
private String city;
@Schema(description = "成立时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] establishDate;
@Schema(description = "归属人员", example = "26257")
private Long belongUserId;
@Schema(description = "品牌/业务线/事业群名称", example = "芋艿")
private String brandName;
@Schema(description = "电话")
private Integer phone;
@Schema(description = "业务线仓库区分(0业务线,1仓库)")
private String diffFlag;
@Schema(description = "传真")
private String fax;
@Schema(description = "网址", example = "https://www.iocoder.cn")
private String url;
@Schema(description = "介绍", example = "随便")
private String description;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,80 @@
package com.yunxi.scm.module.system.controller.admin.businesswarehouse.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.yunxi.scm.framework.common.pojo.PageParam;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 业务线表分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class BusinessWarehousePageReqVO extends PageParam {
@Schema(description = "业务线编号")
private String businessCode;
@Schema(description = "业务线名称", example = "赵六")
private String name;
@Schema(description = "业务线简称")
private String businessSimple;
@Schema(description = "业务线LOGO")
private String businessLogo;
@Schema(description = "父id", example = "3408")
private Long parentId;
@Schema(description = "类型", example = "1")
private String type;
@Schema(description = "状态", example = "1")
private String status;
@Schema(description = "关联机构")
private Integer institutionNum;
@Schema(description = "成员数量")
private Integer employeeNum;
@Schema(description = "所属分类")
private String industry;
@Schema(description = "所在城市")
private String city;
@Schema(description = "成立时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] establishDate;
@Schema(description = "归属人员", example = "26257")
private Long belongUserId;
@Schema(description = "品牌/业务线/事业群名称", example = "芋艿")
private String brandName;
@Schema(description = "电话")
private Integer phone;
@Schema(description = "业务线仓库区分(0业务线,1仓库)")
private String diffFlag;
@Schema(description = "传真")
private String fax;
@Schema(description = "网址", example = "https://www.iocoder.cn")
private String url;
@Schema(description = "介绍", example = "随便")
private String description;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,22 @@
package com.yunxi.scm.module.system.controller.admin.businesswarehouse.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.time.LocalDateTime;
@Schema(description = "管理后台 - 业务线表 Response VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class BusinessWarehouseRespVO extends BusinessWarehouseBaseVO {
@Schema(description = "业务id", requiredMode = Schema.RequiredMode.REQUIRED, example = "20782")
private Long id;
@Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
private LocalDateTime createTime;
@Schema(description = "更新时间", requiredMode = Schema.RequiredMode.REQUIRED)
private LocalDateTime updateTime;
}

@ -0,0 +1,18 @@
package com.yunxi.scm.module.system.controller.admin.businesswarehouse.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 业务线表更新 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class BusinessWarehouseUpdateReqVO extends BusinessWarehouseBaseVO {
@Schema(description = "业务id", requiredMode = Schema.RequiredMode.REQUIRED, example = "20782")
@NotNull(message = "业务id不能为空")
private Long id;
}

@ -1,20 +1,28 @@
package com.yunxi.scm.module.system.controller.admin.dept;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.yunxi.scm.framework.common.enums.CommonStatusEnum;
import com.yunxi.scm.framework.common.pojo.CommonResult;
import com.yunxi.scm.framework.security.core.util.SecurityFrameworkUtils;
import com.yunxi.scm.module.system.controller.admin.dept.vo.dept.*;
import com.yunxi.scm.module.system.convert.dept.DeptConvert;
import com.yunxi.scm.module.system.dal.dataobject.dept.DeptDO;
import com.yunxi.scm.module.system.dal.dataobject.user.AdminUserDO;
import com.yunxi.scm.module.system.dal.mysql.user.AdminUserMapper;
import com.yunxi.scm.module.system.service.dept.DeptService;
import com.yunxi.scm.module.system.service.user.AdminUserService;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import org.apache.commons.lang3.StringUtils;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.validation.Valid;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
@ -28,11 +36,15 @@ public class DeptController {
@Resource
private DeptService deptService;
@Resource
private AdminUserService userService;
@PostMapping("create")
@Operation(summary = "创建部门")
@PreAuthorize("@ss.hasPermission('system:dept:create')")
public CommonResult<Long> createDept(@Valid @RequestBody DeptCreateReqVO reqVO) {
AdminUserDO adminUserDO = userService.getUser(SecurityFrameworkUtils.getLoginUserId());
reqVO.setEnterpriseId(adminUserDO.getEnterpriseId());
Long deptId = deptService.createDept(reqVO);
return success(deptId);
}
@ -41,6 +53,8 @@ public class DeptController {
@Operation(summary = "更新部门")
@PreAuthorize("@ss.hasPermission('system:dept:update')")
public CommonResult<Boolean> updateDept(@Valid @RequestBody DeptUpdateReqVO reqVO) {
AdminUserDO adminUserDO = userService.getUser(SecurityFrameworkUtils.getLoginUserId());
reqVO.setEnterpriseId(adminUserDO.getEnterpriseId());
deptService.updateDept(reqVO);
return success(true);
}
@ -58,6 +72,11 @@ public class DeptController {
@Operation(summary = "获取部门列表")
@PreAuthorize("@ss.hasPermission('system:dept:query')")
public CommonResult<List<DeptRespVO>> getDeptList(DeptListReqVO reqVO) {
AdminUserDO adminUserDO = userService.getUser(SecurityFrameworkUtils.getLoginUserId());
//是子机构,根据机构过滤
if(adminUserDO.getEnterprise() != null && StringUtils.equals(adminUserDO.getEnterprise().getEnterpriseType(), "1")){
reqVO.setEnterpriseId(adminUserDO.getEnterpriseId());
}
List<DeptDO> list = deptService.getDeptList(reqVO);
list.sort(Comparator.comparing(DeptDO::getSort));
return success(DeptConvert.INSTANCE.convertList(list));
@ -69,12 +88,18 @@ public class DeptController {
// 获得部门列表,只要开启状态的
DeptListReqVO reqVO = new DeptListReqVO();
reqVO.setStatus(CommonStatusEnum.ENABLE.getStatus());
AdminUserDO adminUserDO = userService.getUser(SecurityFrameworkUtils.getLoginUserId());
//是子机构,根据机构过滤
if(adminUserDO.getEnterprise() != null && StringUtils.equals(adminUserDO.getEnterprise().getEnterpriseType(), "1")){
reqVO.setEnterpriseId(adminUserDO.getEnterpriseId());
}
List<DeptDO> list = deptService.getDeptList(reqVO);
// 排序后,返回给前端
list.sort(Comparator.comparing(DeptDO::getSort));
return success(DeptConvert.INSTANCE.convertList02(list));
}
@GetMapping("/get")
@Operation(summary = "获得部门信息")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@ -83,4 +108,41 @@ public class DeptController {
return success(DeptConvert.INSTANCE.convert(deptService.getDept(id)));
}
@GetMapping("/list-user-simple")
@Operation(summary = "获取部门用户精简信息列表", description = "只包含被开启的部门,主要用于前端的下拉选项")
public CommonResult<List<DeptSimpleRespVO>> getSimpleDeptUserList() {
// 获得部门列表,只要开启状态的
DeptListReqVO reqVO = new DeptListReqVO();
reqVO.setStatus(CommonStatusEnum.ENABLE.getStatus());
List<DeptDO> list = deptService.getDeptList(reqVO);
// 排序后,返回给前端
list.sort(Comparator.comparing(DeptDO::getSort));
return success(DeptConvert.INSTANCE.convertList02(list));
}
@GetMapping("/list-dept-user")
@Operation(summary = "获取部门和人员列表")
@PreAuthorize("@ss.hasPermission('system:dept:user')")
public CommonResult<List<DeptSimpleRespVO>> getDeptUserList() {
// 获得部门列表,只要开启状态的
DeptListReqVO deptListReqVO = new DeptListReqVO();
deptListReqVO.setStatus(CommonStatusEnum.ENABLE.getStatus());
List<DeptDO> deptDOList = deptService.getDeptList(deptListReqVO);
//将Dept转化为简单的Dept
List<DeptSimpleRespVO> simpleDeptList = new ArrayList<>(DeptConvert.INSTANCE.convertList02(deptDOList));
deptDOList.forEach(deptDO -> {
List<AdminUserDO> adminUserList = userService.getUserListByDeptIds(Collections.singleton(deptDO.getId()));
for (AdminUserDO adminUserDO : adminUserList){
DeptSimpleRespVO deptSimpleRespVO = new DeptSimpleRespVO();
deptSimpleRespVO.setId(adminUserDO.getId());
deptSimpleRespVO.setParentId(adminUserDO.getDeptId());
deptSimpleRespVO.setName(adminUserDO.getNickname());
simpleDeptList.add(deptSimpleRespVO);
}
});
//将list转为树状
List<DeptSimpleRespVO> list = deptService.buildTree(simpleDeptList,0);
return success(list);
}
}

@ -5,13 +5,18 @@ import com.yunxi.scm.framework.common.pojo.CommonResult;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.excel.core.util.ExcelUtils;
import com.yunxi.scm.framework.operatelog.core.annotations.OperateLog;
import com.yunxi.scm.framework.security.core.util.SecurityFrameworkUtils;
import com.yunxi.scm.module.system.controller.admin.dept.vo.dept.DeptListReqVO;
import com.yunxi.scm.module.system.controller.admin.dept.vo.post.*;
import com.yunxi.scm.module.system.convert.dept.PostConvert;
import com.yunxi.scm.module.system.dal.dataobject.dept.PostDO;
import com.yunxi.scm.module.system.dal.dataobject.user.AdminUserDO;
import com.yunxi.scm.module.system.service.dept.PostService;
import com.yunxi.scm.module.system.service.user.AdminUserService;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import org.apache.commons.lang3.StringUtils;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
@ -35,11 +40,15 @@ public class PostController {
@Resource
private PostService postService;
@Resource
private AdminUserService userService;
@PostMapping("/create")
@Operation(summary = "创建岗位")
@PreAuthorize("@ss.hasPermission('system:post:create')")
public CommonResult<Long> createPost(@Valid @RequestBody PostCreateReqVO reqVO) {
AdminUserDO adminUserDO = userService.getUser(SecurityFrameworkUtils.getLoginUserId());
reqVO.setEnterpriseId(adminUserDO.getEnterpriseId());
Long postId = postService.createPost(reqVO);
return success(postId);
}
@ -48,6 +57,8 @@ public class PostController {
@Operation(summary = "修改岗位")
@PreAuthorize("@ss.hasPermission('system:post:update')")
public CommonResult<Boolean> updatePost(@Valid @RequestBody PostUpdateReqVO reqVO) {
AdminUserDO adminUserDO = userService.getUser(SecurityFrameworkUtils.getLoginUserId());
reqVO.setEnterpriseId(adminUserDO.getEnterpriseId());
postService.updatePost(reqVO);
return success(true);
}
@ -71,8 +82,15 @@ public class PostController {
@GetMapping("/list-all-simple")
@Operation(summary = "获取岗位精简信息列表", description = "只包含被开启的岗位,主要用于前端的下拉选项")
public CommonResult<List<PostSimpleRespVO>> getSimplePostList() {
PostExportReqVO reqVO = new PostExportReqVO();
reqVO.setStatus(CommonStatusEnum.ENABLE.getStatus());
AdminUserDO adminUserDO = userService.getUser(SecurityFrameworkUtils.getLoginUserId());
//是子机构,根据机构过滤
if(adminUserDO.getEnterprise() != null && StringUtils.equals(adminUserDO.getEnterprise().getEnterpriseType(), "1")){
reqVO.setEnterpriseId(adminUserDO.getEnterpriseId());
}
// 获得岗位列表,只要开启状态的
List<PostDO> list = postService.getPostList(null, Collections.singleton(CommonStatusEnum.ENABLE.getStatus()));
List<PostDO> list = postService.getPostList(reqVO);
// 排序后,返回给前端
list.sort(Comparator.comparing(PostDO::getSort));
return success(PostConvert.INSTANCE.convertList02(list));
@ -82,6 +100,11 @@ public class PostController {
@Operation(summary = "获得岗位分页列表")
@PreAuthorize("@ss.hasPermission('system:post:query')")
public CommonResult<PageResult<PostRespVO>> getPostPage(@Validated PostPageReqVO reqVO) {
AdminUserDO adminUserDO = userService.getUser(SecurityFrameworkUtils.getLoginUserId());
//是子机构,根据机构过滤
if(adminUserDO.getEnterprise() != null && StringUtils.equals(adminUserDO.getEnterprise().getEnterpriseType(), "1")){
reqVO.setEnterpriseId(adminUserDO.getEnterpriseId());
}
return success(PostConvert.INSTANCE.convertPage(postService.getPostPage(reqVO)));
}
@ -90,6 +113,11 @@ public class PostController {
@PreAuthorize("@ss.hasPermission('system:post:export')")
@OperateLog(type = EXPORT)
public void export(HttpServletResponse response, @Validated PostExportReqVO reqVO) throws IOException {
AdminUserDO adminUserDO = userService.getUser(SecurityFrameworkUtils.getLoginUserId());
//是子机构,根据机构过滤
if(adminUserDO.getEnterprise() != null && StringUtils.equals(adminUserDO.getEnterprise().getEnterpriseType(), "1")){
reqVO.setEnterpriseId(adminUserDO.getEnterpriseId());
}
List<PostDO> posts = postService.getPostList(reqVO);
List<PostExcelVO> data = PostConvert.INSTANCE.convertList03(posts);
// 输出

@ -44,4 +44,6 @@ public class DeptBaseVO {
// @InEnum(value = CommonStatusEnum.class, message = "修改状态必须是 {value}")
private Integer status;
@Schema(description = "企业ID", example = "1024")
private Long enterpriseId;
}

@ -13,4 +13,6 @@ public class DeptListReqVO {
@Schema(description = "展示状态,参见 CommonStatusEnum 枚举类", example = "1")
private Integer status;
@Schema(description = "企业id", example = "1")
private Long enterpriseId;
}

@ -1,10 +1,14 @@
package com.yunxi.scm.module.system.controller.admin.dept.vo.dept;
import com.baomidou.mybatisplus.annotation.TableField;
import com.yunxi.scm.module.system.dal.dataobject.user.AdminUserDO;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
@Schema(description = "管理后台 - 部门精简信息 Response VO")
@Data
@NoArgsConstructor
@ -20,4 +24,7 @@ public class DeptSimpleRespVO {
@Schema(description = "父部门 ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "1024")
private Long parentId;
@Schema(description = "子集" )
private List<DeptSimpleRespVO> children;
}

@ -33,4 +33,6 @@ public class PostBaseVO {
@Schema(description = "备注", example = "快乐的备注")
private String remark;
@Schema(description = "企业ID", example = "1024")
private Long enterpriseId;
}

@ -4,6 +4,7 @@ import com.yunxi.scm.framework.excel.core.annotations.DictFormat;
import com.yunxi.scm.framework.excel.core.convert.DictConvert;
import com.yunxi.scm.module.system.enums.DictTypeConstants;
import com.alibaba.excel.annotation.ExcelProperty;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
/**
@ -28,4 +29,6 @@ public class PostExcelVO {
@DictFormat(DictTypeConstants.COMMON_STATUS)
private String status;
@Schema(description = "企业id", example = "1")
private Long enterpriseId;
}

@ -16,4 +16,6 @@ public class PostExportReqVO {
@Schema(description = "展示状态,参见 CommonStatusEnum 枚举类", example = "1")
private Integer status;
@Schema(description = "企业id", example = "1")
private Long enterpriseId;
}

@ -15,4 +15,6 @@ public class PostListReqVO extends PostBaseVO {
@Schema(description = "展示状态,参见 CommonStatusEnum 枚举类", example = "1")
private Integer status;
@Schema(description = "企业id", example = "1")
private Long enterpriseId;
}

@ -19,4 +19,6 @@ public class PostPageReqVO extends PageParam {
@Schema(description = "展示状态,参见 CommonStatusEnum 枚举类", example = "1")
private Integer status;
@Schema(description = "企业id", example = "1")
private Long enterpriseId;
}

@ -0,0 +1,113 @@
package com.yunxi.scm.module.system.controller.admin.enterprise;
import com.yunxi.scm.module.system.controller.admin.user.vo.user.UserUpdateStatusReqVO;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.security.access.prepost.PreAuthorize;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import javax.validation.constraints.*;
import javax.validation.*;
import javax.servlet.http.*;
import java.util.*;
import java.io.IOException;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.common.pojo.CommonResult;
import static com.yunxi.scm.framework.common.pojo.CommonResult.success;
import com.yunxi.scm.framework.excel.core.util.ExcelUtils;
import com.yunxi.scm.framework.operatelog.core.annotations.OperateLog;
import static com.yunxi.scm.framework.operatelog.core.enums.OperateTypeEnum.*;
import com.yunxi.scm.module.system.controller.admin.enterprise.vo.*;
import com.yunxi.scm.module.system.dal.dataobject.enterprise.EnterpriseDO;
import com.yunxi.scm.module.system.convert.enterprise.EnterpriseConvert;
import com.yunxi.scm.module.system.service.enterprise.EnterpriseService;
@Tag(name = "管理后台 - 企业信息")
@RestController
@RequestMapping("/system/enterprise")
@Validated
public class EnterpriseController {
@Resource
private EnterpriseService enterpriseService;
@PostMapping("/create")
@Operation(summary = "创建企业信息")
@PreAuthorize("@ss.hasPermission('system:enterprise:create')")
public CommonResult<Long> createEnterprise(@Valid @RequestBody EnterpriseCreateReqVO createReqVO) {
return success(enterpriseService.createEnterprise(createReqVO));
}
@PutMapping("/update")
@Operation(summary = "更新企业信息")
@PreAuthorize("@ss.hasPermission('system:enterprise:update')")
public CommonResult<Boolean> updateEnterprise(@Valid @RequestBody EnterpriseUpdateReqVO updateReqVO) {
enterpriseService.updateEnterprise(updateReqVO);
return success(true);
}
@PutMapping("/updateStatus")
@Operation(summary = "更新企业状态")
@PreAuthorize("@ss.hasPermission('system:enterprise:updateStatus')")
public CommonResult<Boolean> updateEnterpriseStatus(@Valid @RequestBody EnterpriseUpdateReqVO updateReqVO) {
updateReqVO.setEnterpriseStatus("1");
enterpriseService.updateEnterprise(updateReqVO);
return success(true);
}
@DeleteMapping("/delete")
@Operation(summary = "删除企业信息")
@Parameter(name = "id", description = "编号", required = true)
@PreAuthorize("@ss.hasPermission('system:enterprise:delete')")
public CommonResult<Boolean> deleteEnterprise(@RequestParam("id") Long id) {
enterpriseService.deleteEnterprise(id);
return success(true);
}
@GetMapping("/get")
@Operation(summary = "获得企业信息")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('system:enterprise:query')")
public CommonResult<EnterpriseRespVO> getEnterprise(@RequestParam("id") Long id) {
EnterpriseDO enterprise = enterpriseService.getEnterprise(id);
return success(EnterpriseConvert.INSTANCE.convert(enterprise));
}
@GetMapping("/list")
@Operation(summary = "获得企业信息列表")
@Parameter(name = "ids", description = "编号列表", required = true, example = "1024,2048")
@PreAuthorize("@ss.hasPermission('system:enterprise:query')")
public CommonResult<List<EnterpriseRespVO>> getEnterpriseList(@RequestParam("ids") Collection<Long> ids) {
List<EnterpriseDO> list = enterpriseService.getEnterpriseList(ids);
return success(EnterpriseConvert.INSTANCE.convertList(list));
}
@GetMapping("/page")
@Operation(summary = "获得企业信息分页")
@PreAuthorize("@ss.hasPermission('system:enterprise:query')")
public CommonResult<PageResult<EnterpriseRespVO>> getEnterprisePage(@Valid EnterprisePageReqVO pageVO) {
PageResult<EnterpriseDO> pageResult = enterpriseService.getEnterprisePage(pageVO);
return success(EnterpriseConvert.INSTANCE.convertPage(pageResult));
}
@GetMapping("/export-excel")
@Operation(summary = "导出企业信息 Excel")
@PreAuthorize("@ss.hasPermission('system:enterprise:export')")
@OperateLog(type = EXPORT)
public void exportEnterpriseExcel(@Valid EnterpriseExportReqVO exportReqVO,
HttpServletResponse response) throws IOException {
List<EnterpriseDO> list = enterpriseService.getEnterpriseList(exportReqVO);
// 导出 Excel
List<EnterpriseExcelVO> datas = EnterpriseConvert.INSTANCE.convertList02(list);
ExcelUtils.write(response, "企业信息.xls", "数据", EnterpriseExcelVO.class, datas);
}
}

@ -0,0 +1,82 @@
package com.yunxi.scm.module.system.controller.admin.enterprise.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import org.springframework.format.annotation.DateTimeFormat;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import javax.validation.constraints.*;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
/**
* Base VO VO 使
* VO Swagger
*/
@Data
public class EnterpriseBaseVO {
@Schema(description = "企业名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "赵六")
@NotNull(message = "企业名称不能为空")
private String name;
@Schema(description = "企业简称", example = "李四")
private String shortName;
@Schema(description = "主体类型", example = "2")
private String mainType;
@Schema(description = "企业代码")
private String code;
@Schema(description = "社会统一信息代码")
private String societyCode;
@Schema(description = "办理人(0法人 1代办人)")
private String transactors;
@Schema(description = "实际操作人(0法人 1代办人)")
private String operator;
@Schema(description = "法人证件有效期类型(0长期 1非长期)")
private String legalOperator;
@Schema(description = "代办人证件类型(0身份证 1护照)", example = "1")
private String commissionCertificateType;
@Schema(description = "代办人证件有效期类型(0长期 1非长期)")
private String commissionOperator;
@Schema(description = "总公司,子公司机构类型", example = "1")
private String enterpriseType;
@Schema(description = "企业父id", example = "26924")
private Long parentId;
@Schema(description = "更新时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime updateTime;
@Schema(description = "首联系人")
private String firstConcat;
@Schema(description = "联系电话")
private String phone;
@Schema(description = "描述")
private String description;
@Schema(description = "企业状态")
private String enterpriseStatus;
}

@ -0,0 +1,150 @@
package com.yunxi.scm.module.system.controller.admin.enterprise.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import javax.validation.constraints.*;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 企业信息创建 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class EnterpriseCreateReqVO extends EnterpriseBaseVO {
@Schema(description = "所在城市")
private String city;
@Schema(description = "行业类型", example = "1")
private String dutyType;
@Schema(description = "首联系人")
private String firstConcat;
@Schema(description = "职位")
private String position;
@Schema(description = "手机号码")
private String phone;
@Schema(description = "logo图片")
private String logo;
@Schema(description = "地址")
private String address;
@Schema(description = "企业电话")
private String enterprisePhone;
@Schema(description = "企业传真")
private String enterpriseFax;
@Schema(description = "企业网址")
private String enterpriseWebsite;
@Schema(description = "企业简介", example = "你猜")
private String enterpriseRemark;
@Schema(description = "税号")
private String dutyParagraph;
@Schema(description = "发票抬头")
private String invoiceHeader;
@Schema(description = "开户银行")
private String openBank;
@Schema(description = "银行卡号", example = "17664")
private String bankAccount;
@Schema(description = "银行电话")
private String bankPhone;
@Schema(description = "注册地址")
private String registerAddress;
@Schema(description = "经营开始时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime startDate;
@Schema(description = "经营结束时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime endDate;
@Schema(description = "证件照")
private String photo;
@Schema(description = "经营范围")
private String businessScope;
@Schema(description = "邮箱")
private String email;
@Schema(description = "法人证件照1")
private String legalPersonPhoto1;
@Schema(description = "法人证件照2")
private String legalPersonPhoto2;
@Schema(description = "法人证件照3")
private String legalPersonPhoto3;
@Schema(description = "法人证件类型(0身份证 1护照)", example = "1")
private String legalCertificateType;
@Schema(description = "法人姓名", example = "王五")
private String legalPersonName;
@Schema(description = "法人证件号")
private String legalCardNo;
@Schema(description = "法人生日")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime legalBirthday;
@Schema(description = "法人证件有效开始时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime legalCardStart;
@Schema(description = "法人证件有效结束时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime legalCardEnd;
@Schema(description = "代办人证件照1")
private String commissionPersonPhoto1;
@Schema(description = "代办人证件照2")
private String commissionPersonPhoto2;
@Schema(description = "代办人证件照3")
private String commissionPersonPhoto3;
@Schema(description = "代办人证件照4")
private String commissionPersonPhoto4;
@Schema(description = "代办人姓名", example = "芋艿")
private String commissionPersonName;
@Schema(description = "代办人证件号")
private String commissionCardNo;
@Schema(description = "代办人生日")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime commissionBirthday;
@Schema(description = "代办人证件有效开始时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime commissionCardStart;
@Schema(description = "代办人证件有效结束时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime commissionCardEnd;
@Schema(description = "描述", example = "你猜")
private String description;
@Schema(description = "企业状态")
private String enterpriseStatus;
}

@ -0,0 +1,89 @@
package com.yunxi.scm.module.system.controller.admin.enterprise.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.alibaba.excel.annotation.ExcelProperty;
import com.yunxi.scm.framework.excel.core.annotations.DictFormat;
import com.yunxi.scm.framework.excel.core.convert.DictConvert;
import org.springframework.format.annotation.DateTimeFormat;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
/**
* Excel VO
*
* @author
*/
@Data
public class EnterpriseExcelVO {
@ExcelProperty("编号")
private Long id;
@ExcelProperty("企业名称")
private String name;
@ExcelProperty("企业简称")
private String shortName;
@ExcelProperty(value = "主体类型", converter = DictConvert.class)
@DictFormat("main_type") // TODO 代码优化:建议设置到对应的 XXXDictTypeConstants 枚举类中
private String mainType;
@ExcelProperty("企业代码")
private String code;
@ExcelProperty("社会统一信息代码")
private String societyCode;
@ExcelProperty("办理人(0法人 1代办人)")
private String transactors;
@ExcelProperty("实际操作人(0法人 1代办人)")
private String operator;
@ExcelProperty("法人证件有效期类型(0长期 1非长期)")
private String legalOperator;
@ExcelProperty("代办人证件类型(0身份证 1护照)")
private String commissionCertificateType;
@ExcelProperty("代办人证件有效期类型(0长期 1非长期)")
private String commissionOperator;
@ExcelProperty("创建时间")
private LocalDateTime createTime;
@ExcelProperty(value = "总公司,子公司机构类型", converter = DictConvert.class)
@DictFormat("enterprise_type") // TODO 代码优化:建议设置到对应的 XXXDictTypeConstants 枚举类中
private String enterpriseType;
@ExcelProperty("企业父id")
private Long parentId;
@Schema(description = "更新时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime updateTime;
@Schema(description = "首联系人")
private String firstConcat;
@Schema(description = "联系电话")
private String phone;
@Schema(description = "描述")
private String description;
}

@ -0,0 +1,68 @@
package com.yunxi.scm.module.system.controller.admin.enterprise.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.yunxi.scm.framework.common.pojo.PageParam;
import java.time.LocalDateTime;
import org.springframework.format.annotation.DateTimeFormat;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 企业信息 Excel 导出 Request VO参数和 EnterprisePageReqVO 是一致的")
@Data
public class EnterpriseExportReqVO {
@Schema(description = "企业名称", example = "赵六")
private String name;
@Schema(description = "主体类型", example = "2")
private String mainType;
@Schema(description = "企业代码")
private String code;
@Schema(description = "社会统一信息代码")
private String societyCode;
@Schema(description = "办理人(0法人 1代办人)")
private String transactors;
@Schema(description = "实际操作人(0法人 1代办人)")
private String operator;
@Schema(description = "法人证件有效期类型(0长期 1非长期)")
private String legalOperator;
@Schema(description = "代办人证件类型(0身份证 1护照)", example = "1")
private String commissionCertificateType;
@Schema(description = "代办人证件有效期类型(0长期 1非长期)")
private String commissionOperator;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
@Schema(description = "总公司,子公司机构类型", example = "1")
private String enterpriseType;
@Schema(description = "企业父id", example = "26924")
private Long parentId;
@Schema(description = "更新时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime updateTime;
@Schema(description = "首联系人")
private String firstConcat;
@Schema(description = "联系电话")
private String phone;
@Schema(description = "描述")
private String description;
@Schema(description = "企业状态")
private String enterpriseStatus;
}

@ -0,0 +1,70 @@
package com.yunxi.scm.module.system.controller.admin.enterprise.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.yunxi.scm.framework.common.pojo.PageParam;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 企业信息分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class EnterprisePageReqVO extends PageParam {
@Schema(description = "企业名称", example = "赵六")
private String name;
@Schema(description = "主体类型", example = "2")
private String mainType;
@Schema(description = "企业代码")
private String code;
@Schema(description = "社会统一信息代码")
private String societyCode;
@Schema(description = "办理人(0法人 1代办人)")
private String transactors;
@Schema(description = "实际操作人(0法人 1代办人)")
private String operator;
@Schema(description = "法人证件有效期类型(0长期 1非长期)")
private String legalOperator;
@Schema(description = "代办人证件类型(0身份证 1护照)", example = "1")
private String commissionCertificateType;
@Schema(description = "代办人证件有效期类型(0长期 1非长期)")
private String commissionOperator;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
@Schema(description = "总公司,子公司机构类型", example = "1")
private String enterpriseType;
@Schema(description = "企业父id", example = "26924")
private Long parentId;
@Schema(description = "更新时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime updateTime;
@Schema(description = "首联系人")
private String firstConcat;
@Schema(description = "联系电话")
private String phone;
@Schema(description = "描述")
private String description;
@Schema(description = "企业状态")
private String enterpriseStatus;
}

@ -0,0 +1,19 @@
package com.yunxi.scm.module.system.controller.admin.enterprise.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.time.LocalDateTime;
@Schema(description = "管理后台 - 企业信息 Response VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class EnterpriseRespVO extends EnterpriseBaseVO {
@Schema(description = "编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "7480")
private Long id;
@Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
private LocalDateTime createTime;
}

@ -0,0 +1,154 @@
package com.yunxi.scm.module.system.controller.admin.enterprise.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import javax.validation.constraints.*;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 企业信息更新 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class EnterpriseUpdateReqVO extends EnterpriseBaseVO {
@Schema(description = "编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "7480")
@NotNull(message = "编号不能为空")
private Long id;
@Schema(description = "所在城市")
private String city;
@Schema(description = "行业类型", example = "1")
private String dutyType;
@Schema(description = "首联系人")
private String firstConcat;
@Schema(description = "职位")
private String position;
@Schema(description = "手机号码")
private String phone;
@Schema(description = "logo图片")
private String logo;
@Schema(description = "地址")
private String address;
@Schema(description = "企业电话")
private String enterprisePhone;
@Schema(description = "企业传真")
private String enterpriseFax;
@Schema(description = "企业网址")
private String enterpriseWebsite;
@Schema(description = "企业简介", example = "你猜")
private String enterpriseRemark;
@Schema(description = "税号")
private String dutyParagraph;
@Schema(description = "发票抬头")
private String invoiceHeader;
@Schema(description = "开户银行")
private String openBank;
@Schema(description = "银行卡号", example = "17664")
private String bankAccount;
@Schema(description = "银行电话")
private String bankPhone;
@Schema(description = "注册地址")
private String registerAddress;
@Schema(description = "经营开始时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime startDate;
@Schema(description = "经营结束时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime endDate;
@Schema(description = "证件照")
private String photo;
@Schema(description = "经营范围")
private String businessScope;
@Schema(description = "邮箱")
private String email;
@Schema(description = "法人证件照1")
private String legalPersonPhoto1;
@Schema(description = "法人证件照2")
private String legalPersonPhoto2;
@Schema(description = "法人证件照3")
private String legalPersonPhoto3;
@Schema(description = "法人证件类型(0身份证 1护照)", example = "1")
private String legalCertificateType;
@Schema(description = "法人姓名", example = "王五")
private String legalPersonName;
@Schema(description = "法人证件号")
private String legalCardNo;
@Schema(description = "法人生日")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime legalBirthday;
@Schema(description = "法人证件有效开始时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime legalCardStart;
@Schema(description = "法人证件有效结束时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime legalCardEnd;
@Schema(description = "代办人证件照1")
private String commissionPersonPhoto1;
@Schema(description = "代办人证件照2")
private String commissionPersonPhoto2;
@Schema(description = "代办人证件照3")
private String commissionPersonPhoto3;
@Schema(description = "代办人证件照4")
private String commissionPersonPhoto4;
@Schema(description = "代办人姓名", example = "芋艿")
private String commissionPersonName;
@Schema(description = "代办人证件号")
private String commissionCardNo;
@Schema(description = "代办人生日")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime commissionBirthday;
@Schema(description = "代办人证件有效开始时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime commissionCardStart;
@Schema(description = "代办人证件有效结束时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime commissionCardEnd;
@Schema(description = "描述", example = "你猜")
private String description;
@Schema(description = "企业状态")
private String enterpriseStatus;
}

@ -5,13 +5,18 @@ import com.yunxi.scm.framework.common.pojo.CommonResult;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.excel.core.util.ExcelUtils;
import com.yunxi.scm.framework.operatelog.core.annotations.OperateLog;
import com.yunxi.scm.framework.security.core.util.SecurityFrameworkUtils;
import com.yunxi.scm.module.system.controller.admin.dept.vo.dept.DeptListReqVO;
import com.yunxi.scm.module.system.controller.admin.permission.vo.role.*;
import com.yunxi.scm.module.system.convert.permission.RoleConvert;
import com.yunxi.scm.module.system.dal.dataobject.permission.RoleDO;
import com.yunxi.scm.module.system.dal.dataobject.user.AdminUserDO;
import com.yunxi.scm.module.system.service.permission.RoleService;
import com.yunxi.scm.module.system.service.user.AdminUserService;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import org.apache.commons.lang3.StringUtils;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
@ -35,11 +40,15 @@ public class RoleController {
@Resource
private RoleService roleService;
@Resource
private AdminUserService userService;
@PostMapping("/create")
@Operation(summary = "创建角色")
@PreAuthorize("@ss.hasPermission('system:role:create')")
public CommonResult<Long> createRole(@Valid @RequestBody RoleCreateReqVO reqVO) {
AdminUserDO adminUserDO = userService.getUser(SecurityFrameworkUtils.getLoginUserId());
reqVO.setEnterpriseId(adminUserDO.getEnterpriseId());
return success(roleService.createRole(reqVO, null));
}
@ -47,6 +56,8 @@ public class RoleController {
@Operation(summary = "修改角色")
@PreAuthorize("@ss.hasPermission('system:role:update')")
public CommonResult<Boolean> updateRole(@Valid @RequestBody RoleUpdateReqVO reqVO) {
AdminUserDO adminUserDO = userService.getUser(SecurityFrameworkUtils.getLoginUserId());
reqVO.setEnterpriseId(adminUserDO.getEnterpriseId());
roleService.updateRole(reqVO);
return success(true);
}
@ -80,14 +91,26 @@ public class RoleController {
@Operation(summary = "获得角色分页")
@PreAuthorize("@ss.hasPermission('system:role:query')")
public CommonResult<PageResult<RoleDO>> getRolePage(RolePageReqVO reqVO) {
AdminUserDO adminUserDO = userService.getUser(SecurityFrameworkUtils.getLoginUserId());
//是子机构,根据机构过滤
if(adminUserDO.getEnterprise() != null && StringUtils.equals(adminUserDO.getEnterprise().getEnterpriseType(), "1")){
reqVO.setEnterpriseId(adminUserDO.getEnterpriseId());
}
return success(roleService.getRolePage(reqVO));
}
@GetMapping("/list-all-simple")
@Operation(summary = "获取角色精简信息列表", description = "只包含被开启的角色,主要用于前端的下拉选项")
public CommonResult<List<RoleSimpleRespVO>> getSimpleRoleList() {
RoleExportReqVO reqVO = new RoleExportReqVO();
reqVO.setStatus(CommonStatusEnum.ENABLE.getStatus());
AdminUserDO adminUserDO = userService.getUser(SecurityFrameworkUtils.getLoginUserId());
//是子机构,根据机构过滤
if(adminUserDO.getEnterprise() != null && StringUtils.equals(adminUserDO.getEnterprise().getEnterpriseType(), "1")){
reqVO.setEnterpriseId(adminUserDO.getEnterpriseId());
}
// 获得角色列表,只要开启状态的
List<RoleDO> list = roleService.getRoleListByStatus(singleton(CommonStatusEnum.ENABLE.getStatus()));
List<RoleDO> list = roleService.getRoleList(reqVO);
// 排序后,返回给前端
list.sort(Comparator.comparing(RoleDO::getSort));
return success(RoleConvert.INSTANCE.convertList02(list));
@ -97,6 +120,11 @@ public class RoleController {
@OperateLog(type = EXPORT)
@PreAuthorize("@ss.hasPermission('system:role:export')")
public void export(HttpServletResponse response, @Validated RoleExportReqVO reqVO) throws IOException {
AdminUserDO adminUserDO = userService.getUser(SecurityFrameworkUtils.getLoginUserId());
//是子机构,根据机构过滤
if(adminUserDO.getEnterprise() != null && StringUtils.equals(adminUserDO.getEnterprise().getEnterpriseType(), "1")){
reqVO.setEnterpriseId(adminUserDO.getEnterpriseId());
}
List<RoleDO> list = roleService.getRoleList(reqVO);
List<RoleExcelVO> data = RoleConvert.INSTANCE.convertList03(list);
// 输出

@ -31,4 +31,7 @@ public class RoleBaseVO {
@Schema(description = "备注", example = "我是一个角色")
private String remark;
@Schema(description = "企业ID", example = "1024")
private Long enterpriseId;
}

@ -4,6 +4,7 @@ import com.yunxi.scm.framework.excel.core.annotations.DictFormat;
import com.yunxi.scm.framework.excel.core.convert.DictConvert;
import com.yunxi.scm.module.system.enums.DictTypeConstants;
import com.alibaba.excel.annotation.ExcelProperty;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
/**
@ -31,4 +32,5 @@ public class RoleExcelVO {
@DictFormat(DictTypeConstants.COMMON_STATUS)
private String status;
private Long enterpriseId;
}

@ -25,4 +25,5 @@ public class RoleExportReqVO {
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
private Long enterpriseId;
}

@ -28,4 +28,5 @@ public class RolePageReqVO extends PageParam {
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
private Long enterpriseId;
}

@ -34,4 +34,6 @@ public class RoleRespVO extends RoleBaseVO {
@Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED, example = "时间戳格式")
private LocalDateTime createTime;
@Schema(description = "企业ID", example = "1024")
private Long enterpriseId;
}

@ -7,7 +7,9 @@ import com.yunxi.scm.framework.operatelog.core.annotations.OperateLog;
import com.yunxi.scm.module.system.controller.admin.tenant.vo.tenant.*;
import com.yunxi.scm.module.system.convert.tenant.TenantConvert;
import com.yunxi.scm.module.system.dal.dataobject.tenant.TenantDO;
import com.yunxi.scm.module.system.dal.dataobject.user.AdminUserDO;
import com.yunxi.scm.module.system.service.tenant.TenantService;
import com.yunxi.scm.module.system.service.user.AdminUserService;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
@ -23,6 +25,7 @@ import java.util.List;
import static com.yunxi.scm.framework.common.pojo.CommonResult.success;
import static com.yunxi.scm.framework.operatelog.core.enums.OperateTypeEnum.EXPORT;
import static com.yunxi.scm.framework.security.core.util.SecurityFrameworkUtils.getLoginUserId;
@Tag(name = "管理后台 - 租户")
@RestController
@ -31,6 +34,8 @@ public class TenantController {
@Resource
private TenantService tenantService;
@Resource
private AdminUserService userService;
@GetMapping("/get-id-by-name")
@PermitAll
@ -41,6 +46,16 @@ public class TenantController {
return success(tenantDO != null ? tenantDO.getId() : null);
}
@GetMapping("/get-tenantId-by-userName")
@PermitAll
@Operation(summary = "使用租户名,获得租户编号", description = "登录界面,根据用户的租户名,获得租户编号")
@Parameter(name = "name", description = "租户名", required = true, example = "1024")
public CommonResult<Long> getTenantIdByUserName(@RequestParam("name") String name) {
AdminUserDO user = userService.getUserByUsername(name);
TenantDO tenantDO = tenantService.getTenant(user.getTenantId());
return success(tenantDO != null ? tenantDO.getId() : null);
}
@PostMapping("/create")
@Operation(summary = "创建租户")
@PreAuthorize("@ss.hasPermission('system:tenant:create')")

@ -1,7 +1,11 @@
package com.yunxi.scm.module.system.controller.admin.user;
import cn.hutool.core.collection.CollUtil;
import com.yunxi.scm.framework.security.core.util.SecurityFrameworkUtils;
import com.yunxi.scm.module.system.controller.admin.dept.vo.dept.DeptListReqVO;
import com.yunxi.scm.module.system.controller.admin.dept.vo.dept.DeptSimpleRespVO;
import com.yunxi.scm.module.system.controller.admin.user.vo.user.*;
import com.yunxi.scm.module.system.convert.dept.DeptConvert;
import com.yunxi.scm.module.system.convert.user.UserConvert;
import com.yunxi.scm.module.system.dal.dataobject.dept.DeptDO;
import com.yunxi.scm.module.system.dal.dataobject.user.AdminUserDO;
@ -18,6 +22,7 @@ import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Parameters;
import io.swagger.v3.oas.annotations.Operation;
import org.apache.commons.lang3.StringUtils;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
@ -91,6 +96,7 @@ public class UserController {
@PreAuthorize("@ss.hasPermission('system:user:list')")
public CommonResult<PageResult<UserPageItemRespVO>> getUserPage(@Valid UserPageReqVO reqVO) {
// 获得用户分页列表
AdminUserDO adminUserDO = userService.getUser(SecurityFrameworkUtils.getLoginUserId());
PageResult<AdminUserDO> pageResult = userService.getUserPage(reqVO);
if (CollUtil.isEmpty(pageResult.getList())) {
return success(new PageResult<>(pageResult.getTotal())); // 返回空
@ -188,4 +194,15 @@ public class UserController {
return success(userService.importUserList(list, updateSupport));
}
@GetMapping("/list-all-simpleuser")
@Operation(summary = "获取部门人员精简信息列表", description = "只包含被开启的部门人员,主要用于前端的下拉选项")
public CommonResult<List<UserSimpleRespVO>> getSimpleDeptListuser() {
// 获得部门列表,只要开启状态的
UserRespVO reqVO = new UserRespVO();
reqVO.setStatus(CommonStatusEnum.ENABLE.getStatus());
List<AdminUserDO> list = userService.getselectuser(reqVO);
// 排序后,返回给前端
list.sort(Comparator.comparing(AdminUserDO::getId));
return success(UserConvert.INSTANCE.convertList04(list));
}
}

@ -65,16 +65,30 @@ public class UserProfileController {
// 获得用户角色
List<RoleDO> userRoles = roleService.getRoleListFromCache(permissionService.getUserRoleIdListByUserId(user.getId()));
resp.setRoles(UserConvert.INSTANCE.convertList(userRoles));
String deptNames = "";
// 获得部门信息
if (user.getDeptId() != null) {
DeptDO dept = deptService.getDept(user.getDeptId());
resp.setDept(UserConvert.INSTANCE.convert02(dept));
deptNames = deptNames + dept.getName() + ",";
}
if(deptNames.length() > 0){
deptNames = deptNames.substring(0, deptNames.length() - 1);
}
resp.setDeptNames(deptNames);
String postNames = "";
// 获得岗位信息
if (CollUtil.isNotEmpty(user.getPostIds())) {
List<PostDO> posts = postService.getPostList(user.getPostIds());
resp.setPosts(UserConvert.INSTANCE.convertList02(posts));
for (PostDO postDO : posts) {
postNames = postNames + postDO.getName() + ",";
}
}
if(postNames.length() > 0){
postNames = postNames.substring(0, postNames.length() - 1);
}
resp.setPostNames(postNames);
// 获得社交用户信息
List<SocialUserDO> socialUsers = socialService.getSocialUserList(user.getId(), UserTypeEnum.ADMIN.getValue());
resp.setSocialUsers(UserConvert.INSTANCE.convertList03(socialUsers));

@ -33,6 +33,41 @@ public class UserProfileRespVO extends UserBaseVO {
@Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED, example = "时间戳格式")
private LocalDateTime createTime;
@Schema(description = "部门名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "事业部,传感部")
private String deptNames;
@Schema(description = "职务名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "董事长,周经理")
private String postNames;
/**
*
*/
private String nativePlace;
/**
*
*/
private String education;
/**
*
*/
private String speciality;
/**
*
*/
private String graduationInstitution;
/**
*
*/
private LocalDateTime institutionDatatime;
/**
*
*/
private LocalDateTime birthDatetime;
/**
*
*/
private String personalProfile;
/**
*
*/

@ -10,7 +10,7 @@ import javax.validation.constraints.Size;
@Schema(description = "管理后台 - 用户个人信息更新 Request VO")
@Data
public class UserProfileUpdateReqVO {
public class UserProfileUpdateReqVO extends UserProfileRespVO{
@Schema(description = "用户昵称", requiredMode = Schema.RequiredMode.REQUIRED, example = "芋艿")
@Size(max = 30, message = "用户昵称长度不能超过 30 个字符")

@ -8,6 +8,7 @@ import javax.validation.constraints.Email;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Pattern;
import javax.validation.constraints.Size;
import java.time.LocalDateTime;
import java.util.Set;
/**
@ -51,4 +52,31 @@ public class UserBaseVO {
@Schema(description = "用户头像", example = "https://www.iocoder.cn/xxx.png")
private String avatar;
@Schema(description = "员工工号", example = "123")
private String jobNumber;
@Schema(description = "微信账号", example = "123")
private String wechatAccount;
@Schema(description = "出生日期", example = "123")
private LocalDateTime birthDatetime;
@Schema(description = "籍贯", example = "123")
private String nativePlace;
@Schema(description = "学历", example = "123")
private String education;
@Schema(description = "专业", example = "123")
private String speciality;
@Schema(description = "毕业院校", example = "123")
private String graduationInstitution;
@Schema(description = "毕业时间", example = "123")
private LocalDateTime institutionDatatime;
@Schema(description = "个人简介", example = "123")
private String personalProfile;
}

@ -28,4 +28,7 @@ public class UserRespVO extends UserBaseVO {
@Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED, example = "时间戳格式")
private LocalDateTime createTime;
@Schema(description = "部门ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "1024")
private Long deptId;
}

@ -17,4 +17,7 @@ public class UserSimpleRespVO {
@Schema(description = "用户昵称", requiredMode = Schema.RequiredMode.REQUIRED, example = "芋道")
private String nickname;
@Schema(description = "部门ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "1024")
private Long deptId;
}

@ -28,7 +28,7 @@ public interface AuthConvert {
default AuthPermissionInfoRespVO convert(AdminUserDO user, List<RoleDO> roleList, List<MenuDO> menuList) {
return AuthPermissionInfoRespVO.builder()
.user(AuthPermissionInfoRespVO.UserVO.builder().id(user.getId()).nickname(user.getNickname()).avatar(user.getAvatar()).build())
.user(AuthPermissionInfoRespVO.UserVO.builder().id(user.getId()).nickname(user.getNickname()).avatar(user.getAvatar()).enterprise(user.getEnterprise()).businessWarehouseList(user.getBusinessWarehouseList()).tenantDO(user.getTenantDO()).tenantDOList(user.getTenantDOList()).enterpriseList(user.getEnterpriseList()).build())
.roles(convertSet(roleList, RoleDO::getCode))
// 权限标识信息
.permissions(convertSet(menuList, MenuDO::getPermission))

@ -0,0 +1,34 @@
package com.yunxi.scm.module.system.convert.businessenterpriserelational;
import java.util.*;
import com.yunxi.scm.framework.common.pojo.PageResult;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import com.yunxi.scm.module.system.controller.admin.businessenterpriserelational.vo.*;
import com.yunxi.scm.module.system.dal.dataobject.businessenterpriserelational.BusinessEnterpriseRelationalDO;
/**
* 线 Convert
*
* @author
*/
@Mapper
public interface BusinessEnterpriseRelationalConvert {
BusinessEnterpriseRelationalConvert INSTANCE = Mappers.getMapper(BusinessEnterpriseRelationalConvert.class);
BusinessEnterpriseRelationalDO convert(BusinessEnterpriseRelationalCreateReqVO bean);
BusinessEnterpriseRelationalDO convert(BusinessEnterpriseRelationalUpdateReqVO bean);
BusinessEnterpriseRelationalRespVO convert(BusinessEnterpriseRelationalDO bean);
List<BusinessEnterpriseRelationalRespVO> convertList(List<BusinessEnterpriseRelationalDO> list);
PageResult<BusinessEnterpriseRelationalRespVO> convertPage(PageResult<BusinessEnterpriseRelationalDO> page);
List<BusinessEnterpriseRelationalExcelVO> convertList02(List<BusinessEnterpriseRelationalDO> list);
}

@ -0,0 +1,34 @@
package com.yunxi.scm.module.system.convert.businessuserrelational;
import java.util.*;
import com.yunxi.scm.framework.common.pojo.PageResult;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import com.yunxi.scm.module.system.controller.admin.businessuserrelational.vo.*;
import com.yunxi.scm.module.system.dal.dataobject.businessuserrelational.BusinessUserRelationalDO;
/**
* 线 Convert
*
* @author
*/
@Mapper
public interface BusinessUserRelationalConvert {
BusinessUserRelationalConvert INSTANCE = Mappers.getMapper(BusinessUserRelationalConvert.class);
BusinessUserRelationalDO convert(BusinessUserRelationalCreateReqVO bean);
BusinessUserRelationalDO convert(BusinessUserRelationalUpdateReqVO bean);
BusinessUserRelationalRespVO convert(BusinessUserRelationalDO bean);
List<BusinessUserRelationalRespVO> convertList(List<BusinessUserRelationalDO> list);
PageResult<BusinessUserRelationalRespVO> convertPage(PageResult<BusinessUserRelationalDO> page);
List<BusinessUserRelationalExcelVO> convertList02(List<BusinessUserRelationalDO> list);
}

@ -0,0 +1,38 @@
package com.yunxi.scm.module.system.convert.businesswarehouse;
import java.util.*;
import com.yunxi.scm.framework.common.pojo.PageResult;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import com.yunxi.scm.module.system.controller.admin.businesswarehouse.vo.*;
import com.yunxi.scm.module.system.dal.dataobject.businesswarehouse.BusinessWarehouseDO;
/**
* 线 Convert
*
* @author
*/
@Mapper
public interface BusinessWarehouseConvert {
BusinessWarehouseConvert INSTANCE = Mappers.getMapper(BusinessWarehouseConvert.class);
BusinessWarehouseDO convert(BusinessWarehouseCreateReqVO bean);
BusinessWarehouseDO convert(BusinessWarehouseUpdateReqVO bean);
BusinessWarehouseRespVO convert(BusinessWarehouseDO bean);
BusinessSimpleRespVo convert03(BusinessWarehouseDO bean);
List<BusinessWarehouseRespVO> convertList(List<BusinessWarehouseDO> list);
List<BusinessSimpleRespVo> convertList03(List<BusinessWarehouseDO> list);
PageResult<BusinessWarehouseRespVO> convertPage(PageResult<BusinessWarehouseDO> page);
List<BusinessWarehouseExcelVO> convertList02(List<BusinessWarehouseDO> list);
}

@ -1,16 +1,23 @@
package com.yunxi.scm.module.system.convert.dept;
import com.yunxi.scm.module.system.api.dept.dto.DeptRespDTO;
import com.yunxi.scm.module.system.controller.admin.auth.vo.AuthPermissionInfoRespVO;
import com.yunxi.scm.module.system.controller.admin.dept.vo.dept.DeptCreateReqVO;
import com.yunxi.scm.module.system.controller.admin.dept.vo.dept.DeptRespVO;
import com.yunxi.scm.module.system.controller.admin.dept.vo.dept.DeptSimpleRespVO;
import com.yunxi.scm.module.system.controller.admin.dept.vo.dept.DeptUpdateReqVO;
import com.yunxi.scm.module.system.convert.auth.AuthConvert;
import com.yunxi.scm.module.system.dal.dataobject.dept.DeptDO;
import com.yunxi.scm.module.system.dal.dataobject.permission.MenuDO;
import com.yunxi.scm.module.system.enums.permission.MenuTypeEnum;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import org.slf4j.LoggerFactory;
import java.util.List;
import java.util.Map;
import java.util.*;
import static com.yunxi.scm.framework.common.util.collection.CollectionUtils.filterList;
import static com.yunxi.scm.module.system.dal.dataobject.permission.MenuDO.ID_ROOT;
@Mapper
public interface DeptConvert {

@ -0,0 +1,34 @@
package com.yunxi.scm.module.system.convert.enterprise;
import java.util.*;
import com.yunxi.scm.framework.common.pojo.PageResult;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import com.yunxi.scm.module.system.controller.admin.enterprise.vo.*;
import com.yunxi.scm.module.system.dal.dataobject.enterprise.EnterpriseDO;
/**
* Convert
*
* @author
*/
@Mapper
public interface EnterpriseConvert {
EnterpriseConvert INSTANCE = Mappers.getMapper(EnterpriseConvert.class);
EnterpriseDO convert(EnterpriseCreateReqVO bean);
EnterpriseDO convert(EnterpriseUpdateReqVO bean);
EnterpriseRespVO convert(EnterpriseDO bean);
List<EnterpriseRespVO> convertList(List<EnterpriseDO> list);
PageResult<EnterpriseRespVO> convertPage(PageResult<EnterpriseDO> page);
List<EnterpriseExcelVO> convertList02(List<EnterpriseDO> list);
}

@ -0,0 +1,39 @@
package com.yunxi.scm.module.system.dal.dataobject.businessenterpriserelational;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.baomidou.mybatisplus.annotation.*;
import com.yunxi.scm.framework.mybatis.core.dataobject.BaseDO;
/**
* 线 DO
*
* @author
*/
@TableName("system_business_enterprise_relational")
@KeySequence("system_business_enterprise_relational_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库,可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class BusinessEnterpriseRelationalDO extends BaseDO {
/**
* id
*/
@TableId
private Long id;
/**
* 线id
*/
private Long businessId;
/**
* id
*/
private Long enterpriseId;
}

Some files were not shown because too many files have changed in this diff Show More

Loading…
Cancel
Save