rczn001/rczn_center_control_web
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects 2 Releases Wiki Activity

2026-4-30:

Browse Source 
1.后端代码初始化
This commit is contained in:
朱春声99
2026-04-30 15:10:28 +08:00
parent 8bb8f4e30b
commit 0bc6dd7761
242 changed files with 27196 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
rc_autoplc_backend/rczn-admin/.mvn/wrapper/maven-wrapper.properties vendored Normal file
View File

@@ -0,0 +1,3 @@
wrapperVersion=3.3.4
distributionType=only-script
distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.11/apache-maven-3.9.11-bin.zip

123
rc_autoplc_backend/rczn-admin/pom.xml Normal file
View File

@@ -0,0 +1,123 @@
<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.rczn</groupId>
<artifactId>Rc-autoplc-backend</artifactId>
<version>0.0.1-SNAPSHOT</version>
<relativePath>../pom.xml</relativePath>
</parent>
<artifactId>rczn-admin</artifactId>
<name>rczn-admin</name>
<description>rczn-admin（后台管理模块）</description>
<packaging>jar</packaging>
<dependencies>
<!-- 依赖公共模块 -->
<dependency>
<groupId>com.rczn</groupId>
<artifactId>rczn-common</artifactId>
</dependency>
<!-- 依赖PLC模块 -->
<dependency>
<groupId>com.rczn</groupId>
<artifactId>rczn-autoplc</artifactId>
</dependency>
<!-- Spring Boot Web 依赖（包含Servlet API） -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- 如果 spring-boot-starter-web 仍然找不到，显式添加 -->
<dependency>
<groupId>jakarta.servlet</groupId>
<artifactId>jakarta.servlet-api</artifactId>
<scope>provided</scope>
</dependency>
<!-- Spring Boot 其他依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-validation</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<!-- 数据库相关 -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
<scope>runtime</scope>
</dependency>
<!-- <dependency>-->
<!-- <groupId>org.springdoc</groupId>-->
<!-- <artifactId>springdoc-openapi-starter-common</artifactId>-->
<!-- <version>2.3.0</version>-->
<!-- <scope>compile</scope>-->
<!-- </dependency>-->
<!-- 工具类 -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<!-- 其他依赖 -->
<dependency>
<groupId>com.auth0</groupId>
<artifactId>java-jwt</artifactId>
</dependency>
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper-spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.datatype</groupId>
<artifactId>jackson-datatype-jsr310</artifactId>
</dependency>
<!-- modbus4j 核心依赖（Java8+，Spring Boot2/3均兼容） -->
<!-- <dependency>-->
<!-- <groupId>com.infiniteautomation</groupId>-->
<!-- <artifactId>modbus4j</artifactId>-->
<!-- <version>3.0.3</version>-->
<!-- </dependency>-->
<!-- 测试依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<mainClass>com.rczn.RcznAdminApplication</mainClass>
</configuration>
</plugin>
</plugins>
</build>
</project>

17
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/RcznAdminApplication.java Normal file
View File

@@ -0,0 +1,17 @@
package com.rczn;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.scheduling.annotation.EnableScheduling;
@SpringBootApplication
@ComponentScan(value = "com.rczn.*")
@EnableScheduling
public class RcznAdminApplication {
public static void main(String[] args) {
SpringApplication.run(RcznAdminApplication.class, args);
}
}

45
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/config/CorsConfig.java Normal file
View File

@@ -0,0 +1,45 @@
package com.rczn.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class CorsConfig implements WebMvcConfigurer {
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**") // 所有接口允许跨域
// 替换allowedOrigins为allowedOriginPatterns，支持通配符*
.allowedOriginPatterns("*")
.allowedMethods("GET", "POST","PATCH", "PUT", "DELETE", "OPTIONS")
.allowedHeaders("*")
.allowCredentials(true) // 允许携带Cookie
.maxAge(3600); // 预检请求缓存1小时
}
@Bean
public CorsFilter corsFilter() {
CorsConfiguration config = new CorsConfiguration();
// 1. 允许前端源（不要用*，和withCredentials=true配合需指定具体源，或用allowedOriginPatterns）
config.addAllowedOriginPattern("*");
// 2. 允许携带凭证（和前端withCredentials=true对应）
config.setAllowCredentials(true);
// 3. 允许所有请求方法（包含OPTIONS）
config.addAllowedMethod("*");
// 4. 允许所有请求头（包含Authorization）
config.addAllowedHeader("*");
// 5. 预检请求缓存时间（减少OPTIONS请求次数）
config.setMaxAge(3600L);
// 配置生效路径
UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
source.registerCorsConfiguration("/**", config);
return new CorsFilter(source);
}
}

38
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/config/Knife4jConfig.java Normal file
View File

@@ -0,0 +1,38 @@
package com.rczn.config;
import io.swagger.v3.oas.models.Components;
import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.oas.models.info.Info;
import io.swagger.v3.oas.models.security.SecurityRequirement;
import io.swagger.v3.oas.models.security.SecurityScheme;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class Knife4jConfig {
@Bean
public OpenAPI customOpenAPI() {
// 1. 声明JWT认证规则
String securitySchemeName = "Authorization";
return new OpenAPI()
// 2. 文档基础信息（可选）
.info(new Info()
.title("XX自动化编程系统API")
.version("1.0.0")
.description("集成JWT认证的Knife4j接口文档"))
// 3. 配置全局认证规则（所有接口默认需要Token）
.addSecurityItem(new SecurityRequirement().addList(securitySchemeName))
// 4. 定义Token的传递方式（请求头+Bearer格式）
.components(new Components()
.addSecuritySchemes(securitySchemeName,
new SecurityScheme()
.name(securitySchemeName)
.type(SecurityScheme.Type.HTTP) // HTTP认证
.scheme("bearer") // Bearer格式
.bearerFormat("JWT") // Token类型为JWT
.in(SecurityScheme.In.HEADER) // 放在请求头
)
);
}
}

55
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/config/WebConfig.java Normal file
View File

@@ -0,0 +1,55 @@
package com.rczn.config;
import com.rczn.interceptors.LoginInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
// 必须启用@Configuration，让Spring扫描到
@Configuration
public class WebConfig implements WebMvcConfigurer {
// 必须注入拦截器（取消注释）
@Autowired
LoginInterceptor loginInterceptor;
// 注册拦截器
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(loginInterceptor)
// 拦截所有请求
.addPathPatterns("/**")
// 放行Swagger/Knife4j所有相关路径（关键补充/doc.html）
.excludePathPatterns(
// Knife4j自定义UI路径（核心！）
"/doc.html",
// Swagger UI页面相关
"/swagger-ui/**",
"/webjars/**",
// SpringDoc接口文档数据相关
"/v3/api-docs/**",
"/v3/api-docs.yaml",
// 旧版Swagger兼容
"/swagger-resources/**",
"/swagger-ui.html"
)
// 放行登录/注册接口
.excludePathPatterns("/user/login", "/user/register");
}
// 静态资源映射（适配Knife4j+SpringDoc）
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
// Knife4j静态资源（核心补充）
registry.addResourceHandler("/doc.html")
.addResourceLocations("classpath:/META-INF/resources/");
// Swagger UI静态资源
registry.addResourceHandler("/swagger-ui/**")
.addResourceLocations("classpath:/META-INF/resources/webjars/springdoc-openapi-ui/");
// Webjars通用资源
registry.addResourceHandler("/webjars/**")
.addResourceLocations("classpath:/META-INF/resources/webjars/");
}
}

120
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/controller/DepartmentController.java Normal file
View File

@@ -0,0 +1,120 @@
package com.rczn.controller;
import com.rczn.domain.PageBean;
import com.rczn.domain.Result;
import com.rczn.system.domain.Department;
import com.rczn.system.service.DepartmentService;
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.enums.ParameterIn;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/depart")
@Tag(name = "部门管理", description = "部门增删改查+分页查询接口")
public class DepartmentController {
@Autowired
private DepartmentService departmentService;
/**
* 分页查询部门
*/
@GetMapping(value = "/listPage", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "分页查询部门", description = "支持部门名称、编码、父ID模糊/精准查询")
@Parameters({
@Parameter(name = "pageNum", description = "页码（必填）", required = true, example = "1", in = ParameterIn.QUERY),
@Parameter(name = "pageSize", description = "每页条数（必填）", required = true, example = "10", in = ParameterIn.QUERY),
@Parameter(name = "deptName", description = "部门名称（可选，模糊查询）", required = false, example = "技术部", in = ParameterIn.QUERY),
@Parameter(name = "deptCode", description = "部门编码（可选，模糊查询）", required = false, example = "TECH", in = ParameterIn.QUERY),
@Parameter(name = "parentId", description = "父部门ID（可选，精准查询）", required = false, example = "1", in = ParameterIn.QUERY)
})
public Result<PageBean<Department>> getDeptPage(
@RequestParam Integer pageNum,
@RequestParam Integer pageSize,
@RequestParam(required = false) String deptName,
@RequestParam(required = false) String deptCode,
@RequestParam(required = false) Integer parentId) {
PageBean<Department> pageBean = departmentService.selectPage(pageNum, pageSize, deptName, deptCode, parentId);
return Result.success(pageBean);
}
/**
* 根据ID查询部门
*/
@GetMapping(value = "/getById/{id}", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "查询单个部门", description = "根据部门ID查询详情")
public Result getDeptById(@PathVariable Long id) {
Department department = departmentService.selectById(id);
return department != null ? Result.success(department) : Result.error("部门不存在");
}
/**
* 新增部门
*/
@PostMapping(value = "/add", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "新增部门", description = "部门名称和编码为必填项")
public Result addDept(@RequestBody Department department) {
try {
Long deptId = departmentService.insert(department);
return Result.success(deptId);
} catch (IllegalArgumentException e) {
return Result.error(e.getMessage());
}
}
/**
* 修改部门
*/
@PutMapping(value = "/update", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "修改部门", description = "需传入部门ID，其他字段可选（非空则更新）")
public Result updateDept(@RequestBody Department department) {
try {
Boolean success = departmentService.update(department);
return success ? Result.success(true) : Result.error("修改失败（部门不存在或已删除）");
} catch (IllegalArgumentException e) {
return Result.error(e.getMessage());
}
}
/**
* 删除部门（逻辑删除）
*/
@DeleteMapping(value = "/del/{id}", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "删除部门", description = "逻辑删除（设置delSign=1，不物理删除数据）")
public Result deleteDept(@PathVariable Long id) {
try {
Boolean success = departmentService.deleteById(id);
return success ? Result.success(true) : Result.error("删除失败（部门不存在或已删除）");
} catch (IllegalArgumentException e) {
return Result.error(e.getMessage());
}
}
/**
* 新增接口：获取完整部门树（包含所有字段）
*/
@GetMapping(value = "/tree", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "获取完整部门树", description = "返回包含所有字段的部门层级结构")
public Result getDeptTree() {
List<Department> deptTree = departmentService.getDeptTree();
return Result.success(deptTree);
}
/**
* 新增接口：获取简化部门树（仅ID、名称、子部门，用于下拉选择）
*/
@GetMapping(value = "/simple-tree", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "获取简化部门树", description = "仅返回ID、名称、子部门，适用于下拉选择框等场景")
public Result getSimpleDeptTree() {
List<Department> simpleDeptTree = departmentService.getSimpleDeptTree();
return Result.success(simpleDeptTree);
}
}

19
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/controller/HellowAdminController.java Normal file
View File

@@ -0,0 +1,19 @@
package com.rczn.controller;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/admin")
@Tag(name = "用户管理", description = "用户新增、查询、修改接口")
public class HellowAdminController {
@GetMapping("/hellow")
@Operation(summary = "查询用户", description = "根据ID查询用户详情") // 替代@ApiOperation
public String hellow(){
return "hellow admin!!!";
}
}

95
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/controller/PositionController.java Normal file
View File

@@ -0,0 +1,95 @@
package com.rczn.controller;
import com.rczn.domain.PageBean;
import com.rczn.domain.Result;
import com.rczn.system.domain.Position;
import com.rczn.system.service.PositionService;
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.enums.ParameterIn;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/position")
@Tag(name = "职位管理", description = "职位增删改查+分页查询接口")
public class PositionController {
@Autowired
private PositionService positionService;
@GetMapping(value = "/listPage", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "分页查询职位", description = "支持职位名称、编码模糊查询")
@Parameters({
@Parameter(name = "pageNum", description = "页码（必填）", required = true, example = "1", in = ParameterIn.QUERY),
@Parameter(name = "pageSize", description = "每页条数（必填）", required = true, example = "10", in = ParameterIn.QUERY),
@Parameter(name = "posiName", description = "职位名称（可选，模糊查询）", required = false, example = "工程师", in = ParameterIn.QUERY),
@Parameter(name = "posiCode", description = "职位编码（可选，模糊查询）", required = false, example = "ENG", in = ParameterIn.QUERY)
})
public Result<PageBean<Position>> getPosiPage(
@RequestParam Integer pageNum,
@RequestParam Integer pageSize,
@RequestParam(required = false) String posiName,
@RequestParam(required = false) String posiCode) {
PageBean<Position> pageBean = positionService.selectPage(pageNum, pageSize, posiName, posiCode);
return Result.success(pageBean);
}
@GetMapping(value = "/list", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "条件查询列表", description = "支持职位名称、编码模糊查询")
@Parameters({
@Parameter(name = "posiName", description = "职位名称（可选，模糊查询）", required = false, example = "工程师", in = ParameterIn.QUERY),
@Parameter(name = "posiCode", description = "职位编码（可选，模糊查询）", required = false, example = "ENG", in = ParameterIn.QUERY)
})
public Result getList(
@RequestParam(required = false) String posiName,
@RequestParam(required = false) String posiCode) {
List<Position> list = positionService.selectList( posiName, posiCode);
return Result.success(list);
}
@GetMapping(value = "/getById/{id}", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "查询单个职位", description = "根据职位ID查询详情")
public Result getPosiById(@PathVariable Long id) {
Position position = positionService.selectById(id);
return position != null ? Result.success(position) : Result.error("职位不存在");
}
@PostMapping(value = "/add", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "新增职位", description = "职位名称和编码为必填项")
public Result addPosi(@RequestBody Position position) {
try {
Long posiId = positionService.insert(position);
return Result.success(posiId);
} catch (IllegalArgumentException e) {
return Result.error(e.getMessage());
}
}
@PutMapping(value = "/update", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "修改职位", description = "需传入职位ID，其他字段可选（非空则更新）")
public Result updatePosi(@RequestBody Position position) {
try {
Boolean success = positionService.update(position);
return success ? Result.success(true) : Result.error("修改失败（职位不存在或已删除）");
} catch (IllegalArgumentException e) {
return Result.error(e.getMessage());
}
}
@DeleteMapping(value = "/del/{id}", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "删除职位", description = "逻辑删除（设置delSign=1）")
public Result deletePosi(@PathVariable Long id) {
try {
Boolean success = positionService.deleteById(id);
return success ? Result.success(true) : Result.error("删除失败（职位不存在或已删除）");
} catch (IllegalArgumentException e) {
return Result.error(e.getMessage());
}
}
}

145
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/controller/RoleController.java Normal file
View File

@@ -0,0 +1,145 @@
package com.rczn.controller;
import com.rczn.domain.PageBean;
import com.rczn.domain.Result;
import com.rczn.system.domain.Role;
import com.rczn.system.service.RoleService;
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.enums.ParameterIn;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 角色管理 CRUD API（MyBatis+PageHelper 实现）
*/
@RestController
@RequestMapping("/role") // RESTful 规范：复数形式
@Tag(name = "角色管理", description = "角色增删改查接口（支持分页+多条件查询+编码唯一性校验）")
public class RoleController {
@Autowired
RoleService roleService;
/**
* 1. 分页查询角色（多条件模糊查询）
*/
@GetMapping("/listPage")
@Operation(summary = "分页查询角色", description = "支持角色名、角色编码模糊查询，页码从1开始")
@Parameters({
@Parameter(name = "pageNum", description = "页码（必填，从1开始）", required = true, example = "1", in = ParameterIn.QUERY),
@Parameter(name = "pageSize", description = "每页条数（必填）", required = true, example = "10", in = ParameterIn.QUERY),
@Parameter(name = "roleName", description = "角色名（模糊查询，可选）", required = false, example = "管理员", in = ParameterIn.QUERY),
@Parameter(name = "roleCode", description = "角色编码（模糊查询，可选）", required = false, example = "ADMIN", in = ParameterIn.QUERY)
})
public Result<PageBean<Role>> getRolePage(
@RequestParam Integer pageNum,
@RequestParam Integer pageSize,
@RequestParam(required = false) String roleName,
@RequestParam(required = false) String roleCode) {
PageBean<Role> pageBean = roleService.selectRolePage(pageNum, pageSize, roleName, roleCode);
return Result.success(pageBean);
}
/**
* 1. 分页查询角色（多条件模糊查询）
*/
@GetMapping("/list")
@Operation(summary = "查询角色列表", description = "支持角色名、角色编码模糊查询")
@Parameters({
@Parameter(name = "roleName", description = "角色名（模糊查询，可选）", required = false, example = "管理员", in = ParameterIn.QUERY),
@Parameter(name = "roleCode", description = "角色编码（模糊查询，可选）", required = false, example = "ADMIN", in = ParameterIn.QUERY)
})
public Result getRoleList(
@RequestParam(required = false) String roleName,
@RequestParam(required = false) String roleCode) {
List<Role> list = roleService.selectRoleList( roleName, roleCode);
return Result.success(list);
}
/**
* 2. 根据ID查询单个角色
*/
@GetMapping("/getById/{id}")
@Operation(summary = "查询单个角色", description = "根据角色ID查询详情")
public Result getRoleById(
@Parameter(name = "id", description = "角色ID（必填）", required = true, example = "1", in = ParameterIn.PATH)
@PathVariable Long id) {
Role role = roleService.selectById(id);
if (role == null) {
return Result.error("角色ID：" + id + " 不存在");
}
return Result.success(role);
}
/**
* 3. 新增角色（校验编码唯一性）
*/
@PostMapping("/add")
@Operation(summary = "新增角色", description = "提交角色信息，角色编码不可重复（ID无需传入）")
public Result addRole(
@Parameter(name = "role", description = "角色信息（ID无需传入，roleName和roleCode必填）", required = true)
@RequestBody Role role) {
try {
// 校验必填字段（也可通过JSR-380注解+@Valid实现）
if (role.getRoleName() == null || role.getRoleName().trim().isEmpty()) {
return Result.error("角色名不能为空");
}
if (role.getRoleCode() == null || role.getRoleCode().trim().isEmpty()) {
return Result.error("角色编码不能为空");
}
Long roleId = roleService.insert(role);
return Result.success(roleId);
} catch (IllegalArgumentException e) {
return Result.error(e.getMessage());
}
}
/**
* 4. 修改角色（部分字段更新+编码唯一性校验）
*/
@PutMapping("/update")
@Operation(summary = "修改角色", description = "传入角色ID和需要修改的字段，角色编码不可重复")
public Result updateRole(
@Parameter(name = "role", description = "角色信息（ID必填，roleName/roleCode可选但至少传一个）", required = true)
@RequestBody Role role) {
try {
// 校验必填字段
if (role.getId() == null) {
return Result.error("角色ID不能为空");
}
if ((role.getRoleName() == null || role.getRoleName().trim().isEmpty())
&& (role.getRoleCode() == null || role.getRoleCode().trim().isEmpty())) {
return Result.error("至少需要修改角色名或角色编码");
}
Boolean success = roleService.update(role);
return success ? Result.success("修改角色成功") : Result.error("修改失败（角色不存在）");
} catch (IllegalArgumentException e) {
return Result.error(e.getMessage());
}
}
/**
* 5. 根据ID删除角色
*/
@DeleteMapping("/del/{id}")
@Operation(summary = "删除角色", description = "根据角色ID删除角色")
public Result deleteRole(
@Parameter(name = "id", description = "角色ID（必填）", required = true, example = "1", in = ParameterIn.PATH)
@PathVariable Long id) {
Boolean success = roleService.deleteById(id);
return success ? Result.success("删除角色成功") : Result.error("删除失败（角色不存在）");
}
}

65
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/controller/RolePermissionController.java Normal file
View File

@@ -0,0 +1,65 @@
package com.rczn.controller;
import com.rczn.domain.Result;
import com.rczn.system.domain.RolePermission;
import com.rczn.system.domain.query.RolePermissionQuery;
import com.rczn.system.service.RolePermissionService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.enums.ParameterIn;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/rolePermission")
@Tag(name = "角色权限管理", description = "角色权限关联接口")
public class RolePermissionController {
@Autowired
RolePermissionService rolePermissionService;
@GetMapping("/listByRoleId/{roleId}")
@Operation(summary = "根据角色ID查询权限ID列表")
public Result getListByRoleId(
@Parameter(name = "roleId", required = true) @PathVariable Integer roleId) {
List<RolePermission> list = rolePermissionService.selectListByRoleId(roleId);
return Result.success(list);
}
@PostMapping("/add")
@Operation(summary = "给角色添加权限")
public Result add(@RequestBody RolePermissionQuery rolePermission) {
if (rolePermission.getRoleId() == null || rolePermission.getPermissionId() == null) {
return Result.error("角色ID和权限ID不能为空");
}
try {
RolePermission rolePermissionEntity = new RolePermission();
rolePermissionEntity.setRoleId(rolePermission.getRoleId());
rolePermissionEntity.setPermissionId(rolePermission.getPermissionId());
rolePermissionService.insert(rolePermissionEntity);
return Result.success("添加成功");
} catch (Exception e) {
return Result.error(e.getMessage());
}
}
@DeleteMapping("/del")
@Operation(summary = "删除角色权限关联")
public Result delete(
@RequestParam Integer roleId,
@RequestParam(required = false) Integer permissionId) {
boolean success = rolePermissionService.delete(roleId, permissionId);
return success ? Result.success("删除成功") : Result.error("删除失败");
}
@DeleteMapping("/clearByRoleId/{roleId}")
@Operation(summary = "清空某个角色的所有权限")
public Result clearByRoleId(
@Parameter(name = "roleId", required = true) @PathVariable Integer roleId) {
rolePermissionService.deleteByRoleId(roleId);
return Result.success("清空成功");
}
}

109
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/controller/SysDicDataController.java Normal file
View File

@@ -0,0 +1,109 @@
package com.rczn.controller;
import com.github.pagehelper.PageInfo;
import com.rczn.domain.Result;
import com.rczn.system.domain.SysDicData;
import com.rczn.system.service.SysDicDataService;
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.enums.ParameterIn;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/sysDicData")
@Tag(name = "字典数据管理", description = "字典数据增删改查+分页查询+按类型查询接口")
public class SysDicDataController {
@Autowired
private SysDicDataService sysDicDataService;
@GetMapping(value = "/listPage", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "分页查询字典数据", description = "支持字典类型ID、标签、值查询")
@Parameters({
@Parameter(name = "pageNum", description = "页码（必填）", required = true, example = "1", in = ParameterIn.QUERY),
@Parameter(name = "pageSize", description = "每页条数（必填）", required = true, example = "10", in = ParameterIn.QUERY),
@Parameter(name = "dicId", description = "字典类型ID（可选）", required = false, example = "1", in = ParameterIn.QUERY),
@Parameter(name = "dicLabel", description = "数据标签（可选，模糊查询）", required = false, example = "运行", in = ParameterIn.QUERY),
@Parameter(name = "dicValue", description = "数据值（可选，模糊查询）", required = false, example = "1", in = ParameterIn.QUERY)
})
public Result getDicDataPage(
@RequestParam Integer pageNum,
@RequestParam Integer pageSize,
@RequestParam(required = false) Integer dicId,
@RequestParam(required = false) String dicLabel,
@RequestParam(required = false) String dicValue) {
PageInfo<SysDicData> pageBean = sysDicDataService.selectPage(pageNum, pageSize, dicId, dicLabel, dicValue);
return Result.success(pageBean);
}
@GetMapping(value = "/list", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "查询字典数据", description = "支持字典类型ID、标签、值查询")
@Parameters({
@Parameter(name = "dicId", description = "字典类型ID（可选）", required = false, example = "1", in = ParameterIn.QUERY),
@Parameter(name = "dicLabel", description = "数据标签（可选，模糊查询）", required = false, example = "运行", in = ParameterIn.QUERY),
@Parameter(name = "dicValue", description = "数据值（可选，模糊查询）", required = false, example = "1", in = ParameterIn.QUERY)
})
public Result getList(
@RequestParam(required = false) Integer dicId,
@RequestParam(required = false) String dicLabel,
@RequestParam(required = false) String dicValue) {
List<SysDicData> list = sysDicDataService.selectList( dicId, dicLabel, dicValue);
return Result.success(list);
}
@GetMapping(value = "/getById/{id}", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "查询单个字典数据", description = "根据字典数据ID查询详情")
public Result getDicDataById(@PathVariable Long id) {
SysDicData sysDicData = sysDicDataService.selectById(id);
return sysDicData != null ? Result.success(sysDicData) : Result.error("字典数据不存在");
}
@GetMapping(value = "/listByDicId/{dicId}", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "按字典类型ID查询数据列表", description = "查询指定字典类型下的所有有效数据")
public Result getDicDataByDicId(@PathVariable Integer dicId) {
try {
List<SysDicData> list = sysDicDataService.selectByDicId(dicId);
return Result.success(list);
} catch (IllegalArgumentException e) {
return Result.error(e.getMessage());
}
}
@PostMapping(value = "/add", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "新增字典数据", description = "字典类型ID、数据标签为必填项")
public Result addDicData(@RequestBody SysDicData sysDicData) {
try {
Long dicDataId = sysDicDataService.insert(sysDicData);
return Result.success(dicDataId);
} catch (IllegalArgumentException e) {
return Result.error(e.getMessage());
}
}
@PutMapping(value = "/update", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "修改字典数据", description = "需传入字典数据ID，其他字段可选（非空则更新）")
public Result updateDicData(@RequestBody SysDicData sysDicData) {
try {
Boolean success = sysDicDataService.update(sysDicData);
return success ? Result.success(true) : Result.error("修改失败（字典数据不存在或已删除）");
} catch (IllegalArgumentException e) {
return Result.error(e.getMessage());
}
}
@DeleteMapping(value = "/del/{id}", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "删除字典数据", description = "逻辑删除（设置delSign=1，不物理删除数据）")
public Result deleteDicData(@PathVariable Long id) {
try {
Boolean success = sysDicDataService.deleteById(id);
return success ? Result.success(true) : Result.error("删除失败（字典数据不存在或已删除）");
} catch (IllegalArgumentException e) {
return Result.error(e.getMessage());
}
}
}

95
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/controller/SysDicTypeController.java Normal file
View File

@@ -0,0 +1,95 @@
package com.rczn.controller;
import com.github.pagehelper.PageInfo;
import com.rczn.domain.Result;
import com.rczn.system.domain.SysDicType;
import com.rczn.system.service.SysDicTypeService;
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.enums.ParameterIn;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/sysDicType")
@Tag(name = "字典类型管理", description = "字典类型增删改查+分页查询接口")
public class SysDicTypeController {
@Autowired
private SysDicTypeService sysDicTypeService;
@GetMapping(value = "/listPage", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "分页查询字典类型", description = "支持字典名称、编码模糊查询")
@Parameters({
@Parameter(name = "pageNum", description = "页码（必填）", required = true, example = "1", in = ParameterIn.QUERY),
@Parameter(name = "pageSize", description = "每页条数（必填）", required = true, example = "10", in = ParameterIn.QUERY),
@Parameter(name = "dicName", description = "字典名称（可选，模糊查询）", required = false, example = "设备状态", in = ParameterIn.QUERY),
@Parameter(name = "dicCode", description = "字典编码（可选，模糊查询）", required = false, example = "DEV_STATUS", in = ParameterIn.QUERY)
})
public Result getDicTypePage(
@RequestParam Integer pageNum,
@RequestParam Integer pageSize,
@RequestParam(required = false) String dicName,
@RequestParam(required = false) String dicCode) {
PageInfo<SysDicType> pageBean = sysDicTypeService.selectPage(pageNum, pageSize, dicName, dicCode);
return Result.success(pageBean);
}
@GetMapping(value = "/list", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "查询字典类型列表", description = "支持字典名称、编码模糊查询")
@Parameters({
@Parameter(name = "dicName", description = "字典名称（可选，模糊查询）", required = false, example = "设备状态", in = ParameterIn.QUERY),
@Parameter(name = "dicCode", description = "字典编码（可选，模糊查询）", required = false, example = "DEV_STATUS", in = ParameterIn.QUERY)
})
public Result getList(
@RequestParam(required = false) String dicName,
@RequestParam(required = false) String dicCode) {
List<SysDicType> list = sysDicTypeService.selectList( dicName, dicCode);
return Result.success(list);
}
@GetMapping(value = "/getById/{id}", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "查询单个字典类型", description = "根据字典类型ID查询详情")
public Result getDicTypeById(@PathVariable Long id) {
SysDicType sysDicType = sysDicTypeService.selectById(id);
return sysDicType != null ? Result.success(sysDicType) : Result.error("字典类型不存在");
}
@PostMapping(value = "/add", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "新增字典类型", description = "字典名称为必填项")
public Result addDicType(@RequestBody SysDicType sysDicType) {
try {
Long dicTypeId = sysDicTypeService.insert(sysDicType);
return Result.success(dicTypeId);
} catch (IllegalArgumentException e) {
return Result.error(e.getMessage());
}
}
@PutMapping(value = "/update", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "修改字典类型", description = "需传入字典类型ID，其他字段可选（非空则更新）")
public Result updateDicType(@RequestBody SysDicType sysDicType) {
try {
Boolean success = sysDicTypeService.update(sysDicType);
return success ? Result.success(true) : Result.error("修改失败（字典类型不存在或已删除）");
} catch (IllegalArgumentException e) {
return Result.error(e.getMessage());
}
}
@DeleteMapping(value = "/del/{id}", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "删除字典类型", description = "逻辑删除（设置delSign=1，不物理删除数据）")
public Result deleteDicType(@PathVariable Long id) {
try {
Boolean success = sysDicTypeService.deleteById(id);
return success ? Result.success(true) : Result.error("删除失败（字典类型不存在或已删除）");
} catch (IllegalArgumentException e) {
return Result.error(e.getMessage());
}
}
}

128
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/controller/SysPermissionController.java Normal file
View File

@@ -0,0 +1,128 @@
package com.rczn.controller;
import com.rczn.domain.PageBean;
import com.rczn.domain.Result;
import com.rczn.system.domain.Permission;
import com.rczn.system.domain.Role;
import com.rczn.system.service.SysPermissionService;
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.enums.ParameterIn;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 权限管理 API（MyBatis 树形结构实现）
*/
@RestController
@RequestMapping("/permission")
@Tag(name = "权限管理", description = "权限增删改查接口（树形结构）")
public class SysPermissionController {
@Autowired
private SysPermissionService sysPermissionService;
/**
* 1. 分页查询权限（多条件模糊查询）
*/
@GetMapping("/listPage")
@Operation(summary = "分页查询权限", description = "支持角色名、角色编码模糊查询，页码从1开始")
@Parameters({
@Parameter(name = "pageNum", description = "页码（必填，从1开始）", required = true, example = "1", in = ParameterIn.QUERY),
@Parameter(name = "pageSize", description = "每页条数（必填）", required = true, example = "10", in = ParameterIn.QUERY),
@Parameter(name = "parentId", description = "父级ID（可选）", required = false, example = "0", in = ParameterIn.QUERY),
@Parameter(name = "permissionName", description = "权限名称（模糊查询，可选）", required = false, example = "用户添加", in = ParameterIn.QUERY)
})
public Result<PageBean<Permission>> getRolePage(
@RequestParam Integer pageNum,
@RequestParam Integer pageSize,
@RequestParam(required = false) Integer parentId,
@RequestParam(required = false) String permissionName) {
PageBean<Permission> pageBean = sysPermissionService.selectRolePage(pageNum, pageSize, parentId,permissionName);
return Result.success(pageBean);
}
/**
* 1. 查询权限树形结构列表
*/
@GetMapping("/list")
@Operation(summary = "查询权限树形列表", description = "返回权限树形结构（parentId为0或null为顶级）")
public Result<List<Permission>> getPermissionList() {
List<Permission> treeList = sysPermissionService.getPermissionList();
return Result.success(treeList);
}
/**
* 1. 查询权限树形结构列表
*/
// @GetMapping("/listByParentId/{parentId}")
// @Operation(summary = "查询权限树形列表", description = "返回权限树形结构（parentId为0或null为顶级）")
// public Result<List<Permission>> getPermissionListByParentId(@PathVariable Integer parentId) {
// List<Permission> treeList = sysPermissionService.getPermissionListByParentId(parentId);
// return Result.success(treeList);
// }
/**
* 2. 根据ID查询单个权限
*/
@GetMapping("/getById/{id}")
@Operation(summary = "查询单个权限", description = "根据权限ID查询详情")
public Result getPermissionById(
@Parameter(name = "id", description = "权限ID", required = true, example = "1", in = ParameterIn.PATH)
@PathVariable Integer id) {
Permission permission = sysPermissionService.getPermissionById(id);
if (permission == null) {
return Result.error("权限ID：" + id + " 不存在");
}
return Result.success(permission);
}
/**
* 3. 新增权限
*/
@PostMapping("/add")
@Operation(summary = "新增权限", description = "提交权限信息创建新权限")
public Result addPermission(
@Parameter(name = "permission", description = "权限信息", required = true)
@RequestBody Permission permission) {
boolean success = sysPermissionService.addPermission(permission);
return success ? Result.success("新增权限成功") : Result.error("新增失败");
}
/**
* 4. 修改权限
*/
@PutMapping("/update")
@Operation(summary = "修改权限", description = "传入权限ID和需要修改的字段")
public Result updatePermission(
@Parameter(name = "permission", description = "权限信息（必须包含ID）", required = true)
@RequestBody Permission permission) {
try {
boolean success = sysPermissionService.updatePermission(permission);
return success ? Result.success("修改权限成功") : Result.error("修改失败（权限不存在）");
} catch (Exception e) {
return Result.error(e.getMessage());
}
}
/**
* 5. 根据ID删除权限（逻辑删除）
*/
@DeleteMapping("/del/{id}")
@Operation(summary = "删除权限", description = "根据权限ID逻辑删除")
public Result deletePermission(
@Parameter(name = "id", description = "权限ID", required = true, example = "1", in = ParameterIn.PATH)
@PathVariable Integer id) {
boolean success = sysPermissionService.deletePermission(id);
return success ? Result.success("删除权限成功") : Result.error("删除失败（权限不存在）");
}
}

239
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/controller/UserController.java Normal file
View File

@@ -0,0 +1,239 @@
package com.rczn.controller;
import com.fasterxml.jackson.databind.annotation.JsonAppend;
import com.rczn.domain.PageBean;
import com.rczn.domain.Result;
import com.rczn.rcznautoplc.domain.ManageLog;
import com.rczn.rcznautoplc.domain.RecordInfo;
import com.rczn.rcznautoplc.service.ManageLogService;
import com.rczn.rcznautoplc.service.RecordInfoService;
import com.rczn.system.domain.Permission;
import com.rczn.system.domain.User;
import com.rczn.system.service.UserService;
import com.rczn.utils.JwtUtil;
import com.rczn.utils.Md5Util;
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.enums.ParameterIn;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.constraints.Pattern;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* 用户管理 CRUD API（MyBatis+PageHelper 实现）
*/
@RestController
@RequestMapping("/user") // RESTful 规范：复数形式+api前缀
@Tag(name = "用户管理", description = "用户增删改查接口（支持分页+模糊查询）")
public class UserController {
// 注入 Service 层（构造器注入，推荐）
@Autowired
UserService userService;
/**
* 1. 分页查询用户（支持用户名模糊查询）
*/
@GetMapping("/listPage")
@Operation(summary = "分页查询用户", description = "支持分页、用户名模糊查询，页码从1开始")
@Parameters({
@Parameter(name = "pageNum", description = "页码（从1开始）", required = true, example = "1", in = ParameterIn.QUERY),
@Parameter(name = "pageSize", description = "每页条数", required = true, example = "10", in = ParameterIn.QUERY),
@Parameter(name = "userName", description = "用户名（模糊查询，可选）", required = false, example = "张三", in = ParameterIn.QUERY)
})
public Result<PageBean<User>> getUserPage(
@RequestParam Integer pageNum,
@RequestParam Integer pageSize,
@RequestParam(required = false) String userName) {
// 调用 Service 分页查询
PageBean<User> pageBean = userService.selectUserPage(pageNum, pageSize, userName);
return Result.success(pageBean);
}
@GetMapping("/list")
@Operation(summary = "查询用户列表", description = "用户名模糊查询，查询全部")
@Parameters({
@Parameter(name = "userName", description = "用户名（模糊查询，可选）", required = false, example = "张三", in = ParameterIn.QUERY)
})
public Result<List<User>> getUserList(
@RequestParam(required = false) String userName) {
// 调用 Service 查询列表
List<User> userList = userService.selectUserList(userName);
return Result.success(userList);
}
/**
* 2. 根据ID查询单个用户
*/
@GetMapping("/getById/{id}")
@Operation(summary = "查询单个用户", description = "根据用户ID查询详情")
public Result getUserById(
@Parameter(name = "id", description = "用户ID", required = true, example = "1", in = ParameterIn.PATH)
@PathVariable Long id) {
User user = userService.selectById(id);
if (user == null) {
return Result.error("用户ID：" + id + " 不存在");
}
return Result.success(user);
}
/**
* 3. 新增用户
*/
@PostMapping("/add")
@Operation(summary = "新增用户", description = "提交用户完整信息创建新用户（ID无需传入）")
public Result addUser(
@Parameter(name = "user", description = "用户信息（ID无需传入）", required = true)
@RequestBody User user) {
Long userId = userService.insert(user);
return Result.success("新增用户成功");
}
/**
* 4. 修改用户（支持部分字段更新）
*/
@PutMapping("/update")
@Operation(summary = "修改用户", description = "传入用户ID和需要修改的字段（非空字段才会更新）")
public Result updateUser(
@Parameter(name = "user", description = "用户信息（必须包含ID）", required = true)
@RequestBody User user) {
try {
Boolean success = userService.update(user);
return success ? Result.success("修改用户成功") : Result.error("修改失败（用户不存在或无字段更新）");
} catch (IllegalArgumentException e) {
return Result.error(e.getMessage());
}
}
/**
* 5. 根据ID删除用户
*/
@DeleteMapping("/del/{id}")
@Operation(summary = "删除用户", description = "根据用户ID删除用户")
public Result deleteUser(
@Parameter(name = "id", description = "用户ID", required = true, example = "1", in = ParameterIn.PATH)
@PathVariable Long id) {
Boolean success = userService.deleteById(id);
return success ? Result.success("删除用户成功") : Result.error("删除失败（用户不存在）");
}
@PostMapping("/register")
@Operation(summary = "注册", description = "用户名必须是2-16位的字母、数字、下划线或减号")
public Result register(@Pattern(regexp = "^[a-zA-Z0-9_-]{2,16}$", message = "用户名必须是2-16位的字母、数字、下划线或减号")
@Parameter(
name = "username",
description = "用户名"
)
@RequestParam
String username,
@Parameter(
name = "password",
description = "密码..."
)
@RequestParam
String password) {
//查询数据库是否有该用户
User user = userService.findeUserByUsername(username);
//注册
if (user == null) {
//如果用户不存在，则注册
int result = userService.register(username, password);
return Result.success("用户注册成功");
} else {
//用户存在，返回错误信息
return Result.error("该用户名已存在！");
}
}
@GetMapping("/getUserByUsername")
public Result getUserByUsername(String username) {
User user = userService.findeUserByUsername(username);
if (user == null) {
return Result.error("该用户不存在！");
} else {
return Result.success(user);
}
}
@Autowired
ManageLogService manageLogService;
@PostMapping("/login")
@Operation(summary = "用户登录接口",description = "根据用户名和密码登录，返回JWT Token")
public Result login(
@Parameter(
name = "username",
description = "登录用户名（2-16位的字母、数字、下划线或减号）",
required = true, // 标记为必填参数
example = "string"
)
@RequestParam
String username,
@Parameter(
name = "password",
description = "登录密码",
required = true
)
@RequestParam
String password) {
//TODO 登录逻辑
//查询数据库是否有该用户
User user = userService.findeUserByUsername(username);
//登录
if (user == null) {
//如果用户不存在，返回错误信息
return Result.error("该用户不存在！");
} else {
//校验密码:
String encryptPassword = user.getPassword();
if (encryptPassword.equals(password)) {
//登录成功，增加登录日志：
LocalDateTime loginTime = LocalDateTime.now();
ManageLog info = new ManageLog();
info.setCreateId(user.getId());
info.setLogName("登录日志");
info.setLogType("登录日志");//1：登录日志、2：SOP操作日志、3：基础数据操作日志
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("用户名：").append(user.getUserName()).append("，登录操作时间：").append(loginTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
info.setLogContent(stringBuilder.toString());
info.setCreateTime(loginTime);
manageLogService.insert(info);
// if (Md5Util.checkPassword(password, encryptPassword)) {
//生产token
Map<String, Object> claims = new HashMap<>();
claims.put("id", user.getId());
claims.put("username", user.getUserName());
//获取权限列表：
List<Permission> permissions = userService.findUserPermissions(user.getId());
List<String> permissionList = permissions.stream().map(Permission::getPermissionCode).collect(Collectors.toList());
claims.put("permissions", permissionList);
String jwtToken = JwtUtil.genToken(claims);
//密码正确，返回成功信息
return Result.success(jwtToken);
} else {
//密码错误，返回错误信息
return Result.error("密码错误！");
}
}
}
}

100
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/controller/UserRoleController.java Normal file
View File

@@ -0,0 +1,100 @@
package com.rczn.controller;
import com.rczn.domain.PageBean;
import com.rczn.domain.Result;
import com.rczn.system.domain.UserRole;
import com.rczn.system.service.UserRoleService;
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.enums.ParameterIn;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/user-role")
@Tag(name = "用户角色关联管理", description = "用户与角色的关联增删改查接口")
public class UserRoleController {
@Autowired
private UserRoleService userRoleService;
@GetMapping(value = "/listPage", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "分页查询关联", description = "支持用户ID、角色ID精准查询")
@Parameters({
@Parameter(name = "pageNum", description = "页码（必填）", required = true, example = "1", in = ParameterIn.QUERY),
@Parameter(name = "pageSize", description = "每页条数（必填）", required = true, example = "10", in = ParameterIn.QUERY),
@Parameter(name = "userId", description = "用户ID（可选）", required = false, example = "1", in = ParameterIn.QUERY),
@Parameter(name = "roleId", description = "角色ID（可选）", required = false, example = "2", in = ParameterIn.QUERY)
})
public Result<PageBean<UserRole>> getUserRolePage(
@RequestParam Integer pageNum,
@RequestParam Integer pageSize,
@RequestParam(required = false) Integer userId,
@RequestParam(required = false) Integer roleId) {
PageBean<UserRole> pageBean = userRoleService.selectPage(pageNum, pageSize, userId, roleId);
return Result.success(pageBean);
}
@GetMapping(value = "/user/{userId}", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "根据用户ID查询关联角色", description = "查询指定用户的所有关联角色")
public Result<List<UserRole>> getByUserId(@PathVariable Integer userId) {
List<UserRole> userRoles = userRoleService.selectByUserId(userId);
return Result.success(userRoles);
}
@GetMapping(value = "/role/{roleId}", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "根据角色ID查询关联用户", description = "查询指定角色的所有关联用户")
public Result<List<UserRole>> getByRoleId(@PathVariable Integer roleId) {
List<UserRole> userRoles = userRoleService.selectByRoleId(roleId);
return Result.success(userRoles);
}
@PostMapping(value = "/add", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "新增用户角色关联", description = "用户ID和角色ID为必填项")
public Result addUserRole(@RequestBody UserRole userRole) {
try {
Long id = userRoleService.insert(userRole);
return Result.success(id);
} catch (IllegalArgumentException e) {
return Result.error(e.getMessage());
}
}
@DeleteMapping(value = "/del/{id}", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "根据关联ID删除", description = "删除单个用户-角色关联")
public Result deleteById(@PathVariable Long id) {
try {
Boolean success = userRoleService.deleteById(id);
return success ? Result.success(true) : Result.error("删除失败（关联不存在）");
} catch (IllegalArgumentException e) {
return Result.error(e.getMessage());
}
}
@DeleteMapping(value = "/user/{userId}", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "根据用户ID删除所有关联", description = "删除指定用户的所有角色关联")
public Result deleteByUserId(@PathVariable Integer userId) {
try {
Boolean success = userRoleService.deleteByUserId(userId);
return success ? Result.success(true) : Result.error("删除失败（无关联数据）");
} catch (IllegalArgumentException e) {
return Result.error(e.getMessage());
}
}
@DeleteMapping(value = "/role/{roleId}", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "根据角色ID删除所有关联", description = "删除指定角色的所有用户关联")
public Result deleteByRoleId(@PathVariable Integer roleId) {
try {
Boolean success = userRoleService.deleteByRoleId(roleId);
return success ? Result.success(true) : Result.error("删除失败（无关联数据）");
} catch (IllegalArgumentException e) {
return Result.error(e.getMessage());
}
}
}

88
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/domain/Department.java Normal file
View File

@@ -0,0 +1,88 @@
package com.rczn.system.domain;
import com.rczn.domain.BaseBean;
import java.time.LocalDateTime;
import java.util.List;
public class Department extends BaseBean {
private String deptName;
private String deptCode;
private Integer parentId;
private Integer leaderId;
private User leader;
// 新增：子部门列表（核心字段，用于存储树形结构）
private List<Department> children;
public Department() {
}
public Department(Long id, Long createId, LocalDateTime createTime, Long updateId, LocalDateTime updateTime, boolean delSign, String remark) {
super(id, createId, createTime, updateId, updateTime, delSign, remark);
}
public String getDeptName() {
return deptName;
}
public void setDeptName(String deptName) {
this.deptName = deptName;
}
public String getDeptCode() {
return deptCode;
}
public void setDeptCode(String deptCode) {
this.deptCode = deptCode;
}
public Integer getParentId() {
return parentId;
}
public void setParentId(Integer parentId) {
this.parentId = parentId;
}
public Integer getLeaderId() {
return leaderId;
}
public void setLeaderId(Integer leaderId) {
this.leaderId = leaderId;
}
public User getLeader() {
return leader;
}
public void setLeader(User leader) {
this.leader = leader;
}
public List<Department> getChildren() {
return children;
}
public void setChildren(List<Department> children) {
this.children = children;
}
@Override
public String toString() {
return "Department{" +
"deptName='" + deptName + '\'' +
", deptCode='" + deptCode + '\'' +
", parentId=" + parentId +
", leaderId=" + leaderId +
", leader=" + leader +
", children=" + children +
'}';
}
}

31
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/domain/Permission.java Normal file
View File

@@ -0,0 +1,31 @@
package com.rczn.system.domain;
import com.rczn.domain.BaseBean;
import java.util.List;
public class Permission extends BaseBean{
private Integer parentId;
private String permissionName;
private String permissionCode;
// 树形结构子节点 ✅
private List<Permission> children;
// getter & setter
public Integer getParentId() { return parentId; }
public void setParentId(Integer parentId) { this.parentId = parentId; }
public String getPermissionName() { return permissionName; }
public void setPermissionName(String permissionName) { this.permissionName = permissionName; }
public String getPermissionCode() { return permissionCode; }
public void setPermissionCode(String permissionCode) { this.permissionCode = permissionCode; }
// children
public List<Permission> getChildren() {
return children;
}
public void setChildren(List<Permission> children) {
this.children = children;
}
}

42
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/domain/Position.java Normal file
View File

@@ -0,0 +1,42 @@
package com.rczn.system.domain;
import com.rczn.domain.BaseBean;
import java.time.LocalDateTime;
public class Position extends BaseBean {
private String posiName;
private String posiCode;
public Position() {
}
public Position(Long id, Long createId, LocalDateTime createTime, Long updateId, LocalDateTime updateTime, boolean delSign, String remark) {
super(id, createId, createTime, updateId, updateTime, delSign, remark);
}
@Override
public String toString() {
return "Position{" +
"posiName='" + posiName + '\'' +
", posiCode='" + posiCode + '\'' +
'}';
}
public String getPosiName() {
return posiName;
}
public void setPosiName(String posiName) {
this.posiName = posiName;
}
public String getPosiCode() {
return posiCode;
}
public void setPosiCode(String posiCode) {
this.posiCode = posiCode;
}
}

27
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/domain/Role.java Normal file
View File

@@ -0,0 +1,27 @@
package com.rczn.system.domain;
import com.rczn.domain.BaseBean;
import java.time.LocalDateTime;
public class Role extends BaseBean {
private String roleName;
private String roleCode;
// 全参构造器同步修改 delSign 类型（Boolean → boolean）
public Role(Long id, Long createId, LocalDateTime createTime, Long updateId, LocalDateTime updateTime, boolean delSign, String remark, String roleName, String roleCode) {
super(id, createId, createTime, updateId, updateTime, delSign, remark); // 父类参数类型同步
this.roleName = roleName;
this.roleCode = roleCode;
}
// 其他构造器、getter/setter 保持不变
public Role() { }
public Role(String roleName, String roleCode) {
this.roleName = roleName;
this.roleCode = roleCode;
}
public String getRoleName() { return roleName; }
public void setRoleName(String roleName) { this.roleName = roleName; }
public String getRoleCode() { return roleCode; }
public void setRoleCode(String roleCode) { this.roleCode = roleCode; }
}

56
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/domain/RolePermission.java Normal file
View File

@@ -0,0 +1,56 @@
package com.rczn.system.domain;
import com.rczn.domain.BaseBean;
import java.time.LocalDateTime;
public class RolePermission extends BaseBean {
private Integer roleId;
private Integer permissionId;
private Role role;
private Permission permission;
public RolePermission() {
}
public RolePermission(Long id, Long createId, LocalDateTime createTime, Long updateId, LocalDateTime updateTime, boolean delSign, String remark) {
super(id, createId, createTime, updateId, updateTime, delSign, remark);
}
public Integer getRoleId() {
return roleId;
}
public void setRoleId(Integer roleId) {
this.roleId = roleId;
}
public Integer getPermissionId() {
return permissionId;
}
public void setPermissionId(Integer permissionId) {
this.permissionId = permissionId;
}
public Role getRole() {
return role;
}
public void setRole(Role role) {
this.role = role;
}
public Permission getPermission() {
return permission;
}
public void setPermission(Permission permission) {
this.permission = permission;
}
}

52
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/domain/SysDicData.java Normal file
View File

@@ -0,0 +1,52 @@
package com.rczn.system.domain;
import com.rczn.domain.BaseBean;
import java.time.LocalDateTime;
/**
* 字典数据实体类
* 对应表：sys_dic_data
*/
public class SysDicData extends BaseBean {
// 字典类型id（外键）
private Integer dicId;
// 数据标签
private String dicLabel;
// 数据字典值
private String dicValue;
public SysDicData() {
}
public SysDicData(Long id, Long createId, LocalDateTime createTime, Long updateId, LocalDateTime updateTime, boolean delSign, String remark) {
super(id, createId, createTime, updateId, updateTime, delSign, remark);
}
// getter/setter
public Integer getDicId() {
return dicId;
}
public void setDicId(Integer dicId) {
this.dicId = dicId;
}
public String getDicLabel() {
return dicLabel;
}
public void setDicLabel(String dicLabel) {
this.dicLabel = dicLabel;
}
public String getDicValue() {
return dicValue;
}
public void setDicValue(String dicValue) {
this.dicValue = dicValue;
}
}

41
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/domain/SysDicType.java Normal file
View File

@@ -0,0 +1,41 @@
package com.rczn.system.domain;
import com.rczn.domain.BaseBean;
import java.time.LocalDateTime;
/**
* 字典类型实体类
* 对应表：sys_dic_type
*/
public class SysDicType extends BaseBean {
// 字典名称（必填）
private String dicName;
// 字典编码
private String dicCode;
public SysDicType() {
}
public SysDicType(Long id, Long createId, LocalDateTime createTime, Long updateId, LocalDateTime updateTime, boolean delSign, String remark) {
super(id, createId, createTime, updateId, updateTime, delSign, remark);
}
// getter/setter
public String getDicName() {
return dicName;
}
public void setDicName(String dicName) {
this.dicName = dicName;
}
public String getDicCode() {
return dicCode;
}
public void setDicCode(String dicCode) {
this.dicCode = dicCode;
}
}

152
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/domain/User.java Normal file
View File

@@ -0,0 +1,152 @@
package com.rczn.system.domain;
import com.rczn.domain.BaseBean;
import java.time.LocalDateTime;
public class User extends BaseBean {
private String userName;
private String password;
private String salt;
private String nicke;
private Boolean sex; // 0-女, 1-男
private String emailAddr;
private String address;
private String telephone;
private Integer depId;
private Integer posId;
private Department department;
private Position position;
public User() {
}
public User(Long id, Long createId, LocalDateTime createTime, Long updateId, LocalDateTime updateTime, boolean delSign, String remark) {
super(id, createId, createTime, updateId, updateTime, delSign, remark);
}
@Override
public String toString() {
return "User{" +
"userName='" + userName + '\'' +
", password='" + password + '\'' +
", salt='" + salt + '\'' +
", nicke='" + nicke + '\'' +
", sex=" + sex +
", emailAddr='" + emailAddr + '\'' +
", address='" + address + '\'' +
", telephone='" + telephone + '\'' +
", depId=" + depId +
", posId=" + posId +
", department=" + department +
", position=" + position +
'}';
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getSalt() {
return salt;
}
public void setSalt(String salt) {
this.salt = salt;
}
public String getNicke() {
return nicke;
}
public void setNicke(String nicke) {
this.nicke = nicke;
}
public Boolean getSex() {
return sex;
}
public void setSex(Boolean sex) {
this.sex = sex;
}
public String getEmailAddr() {
return emailAddr;
}
public void setEmailAddr(String emailAddr) {
this.emailAddr = emailAddr;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getTelephone() {
return telephone;
}
public void setTelephone(String telephone) {
this.telephone = telephone;
}
public Integer getDepId() {
return depId;
}
public void setDepId(Integer depId) {
this.depId = depId;
}
public Integer getPosId() {
return posId;
}
public void setPosId(Integer posId) {
this.posId = posId;
}
public Department getDepartment() {
return department;
}
public void setDepartment(Department department) {
this.department = department;
}
public Position getPosition() {
return position;
}
public void setPosition(Position position) {
this.position = position;
}
}

89
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/domain/UserRole.java Normal file
View File

@@ -0,0 +1,89 @@
package com.rczn.system.domain;
import com.rczn.domain.BaseBean;
import java.time.LocalDateTime;
public class UserRole extends BaseBean {
private Long id;
private Integer userId;
private Integer roleId;
private User user;
private Role role;
@Override
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Integer getUserId() {
return userId;
}
public void setUserId(Integer userId) {
this.userId = userId;
}
public Integer getRoleId() {
return roleId;
}
public void setRoleId(Integer roleId) {
this.roleId = roleId;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
public Role getRole() {
return role;
}
public void setRole(Role role) {
this.role = role;
}
public UserRole() {
}
public UserRole(Long id, Integer userId, Integer roleId, User user, Role role) {
this.id = id;
this.userId = userId;
this.roleId = roleId;
this.user = user;
this.role = role;
}
public UserRole(Long id, Long createId, LocalDateTime createTime, Long updateId, LocalDateTime updateTime, boolean delSign, String remark, Long id1, Integer userId, Integer roleId, User user, Role role) {
super(id, createId, createTime, updateId, updateTime, delSign, remark);
this.id = id1;
this.userId = userId;
this.roleId = roleId;
this.user = user;
this.role = role;
}
@Override
public String toString() {
return "UserRole{" +
"id=" + id +
", userId=" + userId +
", roleId=" + roleId +
", user=" + user +
", role=" + role +
'}';
}
}

27
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/domain/UserTest.java Normal file
View File

@@ -0,0 +1,27 @@
package com.rczn.system.domain;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
/**
* 用户实体类
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
@Schema(description = "用户实体类") // 替代@ApiModel
public class UserTest {
@Schema(description = "用户ID", example = "1001") // 替代@ApiModelProperty
private Long id;
@Schema(description = "用户名", required = true, example = "张三")
private String name;
@Schema(description = "年龄", example = "25")
private Integer age;
}

34
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/domain/query/RolePermissionQuery.java Normal file
View File

@@ -0,0 +1,34 @@
package com.rczn.system.domain.query;
public class RolePermissionQuery {
//角色id
private Integer roleId;
//权限id
private Integer permissionId;
public RolePermissionQuery(Integer roleId, Integer permissionId) {
this.roleId = roleId;
this.permissionId = permissionId;
}
public RolePermissionQuery() {
}
public Integer getRoleId() {
return roleId;
}
public void setRoleId(Integer roleId) {
this.roleId = roleId;
}
public Integer getPermissionId() {
return permissionId;
}
public void setPermissionId(Integer permissionId) {
this.permissionId = permissionId;
}
}

44
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/mapper/DepartmentMapper.java Normal file
View File

@@ -0,0 +1,44 @@
package com.rczn.system.mapper;
import com.rczn.system.domain.Department;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
@Mapper
public interface DepartmentMapper {
// 新增部门
int insert(Department department);
// 根据ID删除部门（逻辑删除：更新delSign=1）
int deleteById(Long id);
// 根据ID更新部门
int updateById(Department department);
// 根据ID查询部门
Department selectById(Long id);
// 分页查询部门（支持模糊查询）
List<Department> selectPage(
@Param("deptName") String deptName,
@Param("deptCode") String deptCode,
@Param("parentId") Integer parentId
);
// 查询分页总数（配合分页查询）
int selectTotal(
@Param("deptName") String deptName,
@Param("deptCode") String deptCode,
@Param("parentId") Integer parentId
);
// 新增：查询所有未删除的部门（用于递归组装树）
List<Department> selectAllDept();
// 新增：按父部门ID查询子部门（用于递归查询）
List<Department> selectChildrenByParentId(@Param("parentId") Integer parentId);
// 新增：查询顶级部门（parent_id IS NULL）
List<Department> selectTopDept();
}

26
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/mapper/PositionMapper.java Normal file
View File

@@ -0,0 +1,26 @@
package com.rczn.system.mapper;
import com.rczn.system.domain.Position;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
@Mapper
public interface PositionMapper {
int insert(Position position);
int deleteById(Long id);
int updateById(Position position);
Position selectById(Long id);
List<Position> selectPage(
@Param("posiName") String posiName,
@Param("posiCode") String posiCode
);
int selectTotal(
@Param("posiName") String posiName,
@Param("posiCode") String posiCode
);
List<Position> selectList(
@Param("posiName") String posiName,
@Param("posiCode") String posiCode
);
}

55
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/mapper/RoleMapper.java Normal file
View File

@@ -0,0 +1,55 @@
package com.rczn.system.mapper;
import com.rczn.system.domain.Role;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* Role MyBatis Mapper 接口
*/
@Mapper
public interface RoleMapper {
/**
* 分页查询角色（支持角色名/角色编码模糊查询）
*/
List<Role> selectRolePage(
@Param("roleName") String roleName,
@Param("roleCode") String roleCode);
/**
* 根据ID查询单个角色
*/
Role selectById(@Param("id") Long id);
/**
* 新增角色
*/
int insert(Role role);
/**
* 修改角色（部分字段更新）
*/
int update(Role role);
/**
* 根据ID删除角色
*/
int deleteById(@Param("id") Long id);
/**
* 查询总条数（支持模糊查询条件）
*/
Long selectTotal(
@Param("roleName") String roleName,
@Param("roleCode") String roleCode);
/**
* 校验角色编码唯一性（新增/修改时使用）
*/
Integer checkRoleCodeUnique(
@Param("roleCode") String roleCode,
@Param("id") Long id);
}

18
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/mapper/RolePermissionMapper.java Normal file
View File

@@ -0,0 +1,18 @@
package com.rczn.system.mapper;
import com.rczn.system.domain.RolePermission;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
@Mapper
public interface RolePermissionMapper {
List<RolePermission> selectListByRoleId(@Param("roleId") Integer roleId);
int insert(RolePermission rolePermission);
int delete(@Param("roleId") Integer roleId, @Param("permissionId") Integer permissionId);
int deleteByRoleId(@Param("roleId") Integer roleId);
}

39
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/mapper/SysDicDataMapper.java Normal file
View File

@@ -0,0 +1,39 @@
package com.rczn.system.mapper;
import com.rczn.system.domain.SysDicData;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
@Mapper
public interface SysDicDataMapper {
/**
* 新增字典数据
*/
int insert(SysDicData sysDicData);
/**
* 修改字典数据
*/
int update(SysDicData sysDicData);
/**
* 逻辑删除字典数据
*/
int deleteById(Long id);
/**
* 根据ID查询字典数据
*/
SysDicData selectById(Long id);
/**
* 分页查询字典数据（参数可选）
*/
List<SysDicData> selectPage(SysDicData sysDicData);
/**
* 根据字典类型ID查询字典数据列表
*/
List<SysDicData> selectByDicId(Integer dicId);
}

34
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/mapper/SysDicTypeMapper.java Normal file
View File

@@ -0,0 +1,34 @@
package com.rczn.system.mapper;
import com.rczn.system.domain.SysDicType;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
@Mapper
public interface SysDicTypeMapper {
/**
* 新增字典类型
*/
int insert(SysDicType sysDicType);
/**
* 修改字典类型
*/
int update(SysDicType sysDicType);
/**
* 逻辑删除字典类型
*/
int deleteById(Long id);
/**
* 根据ID查询字典类型
*/
SysDicType selectById(Long id);
/**
* 分页查询字典类型（参数可选）
*/
List<SysDicType> selectPage(SysDicType sysDicType);
}

52
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/mapper/SysPermissionMapper.java Normal file
View File

@@ -0,0 +1,52 @@
package com.rczn.system.mapper;
import com.rczn.system.domain.Permission;
import com.rczn.system.domain.Role;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
@Mapper
public interface SysPermissionMapper {
/**
* 分页查询角色（支持角色名/角色编码模糊查询）
*/
List<Permission> selectPermissionPage(
@Param("parentId") Integer parentId,
@Param("permissionName") String permissionName);
/**
* 查询总条数（支持模糊查询条件）
*/
Long selectTotal(
@Param("parentId") Integer parentId,
@Param("permissionName") String permissionName);
/**
* 查询所有权限（未删除）
*/
List<Permission> selectPermissionList();
/**
* 根据ID查询
*/
Permission selectPermissionById(Integer id);
/**
* 新增
*/
int insertPermission(Permission permission);
/**
* 修改
*/
int updatePermission(Permission permission);
/**
* 逻辑删除
*/
int deletePermissionById(Integer id);
}

43
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/mapper/UserMapper.java Normal file
View File

@@ -0,0 +1,43 @@
package com.rczn.system.mapper;
import com.rczn.system.domain.Permission;
import com.rczn.system.domain.User;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import java.util.List;
@Mapper
public interface UserMapper {
// 分页查询（参数支持空值，为空时忽略该条件）
List<User> selectUserPage(User user);
// 根据ID查询（支持传delSign筛选状态）
User selectById(@Param("id") Long id, @Param("delSign") Boolean delSign);
// 新增用户（空参数会插入默认值或null）
int insert(User user);
// 修改用户（仅更新非空字段）
int update(User user);
// 逻辑删除用户
int deleteById(@Param("id") Long id, @Param("updateId") Long updateId);
// 查询总条数（与分页查询参数一致）
Long selectTotal(
@Param("userName") String userName,
@Param("depId") Integer depId,
@Param("posId") Integer posId,
@Param("createId") Long createId,
@Param("sex") Integer sex,
@Param("delSign") Boolean delSign
);
@Select("SELECT * FROM sys_user WHERE user_name = #{userName}")
User selectByUsername(String userName);
//根据用户id，查询出对应的权限列表
List<Permission> findUserPermissions(Long userId);
}

42
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/mapper/UserRoleMapper.java Normal file
View File

@@ -0,0 +1,42 @@
package com.rczn.system.mapper;
import com.rczn.system.domain.UserRole;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
@Mapper
public interface UserRoleMapper {
// 新增用户-角色关联
int insert(UserRole userRole);
// 根据ID删除关联
int deleteById(Long id);
// 根据用户ID删除所有关联
int deleteByUserId(Integer userId);
// 根据角色ID删除所有关联
int deleteByRoleId(Integer roleId);
// 根据ID查询关联
UserRole selectById(Long id);
// 根据用户ID查询关联的角色列表
List<UserRole> selectByUserId(Integer userId);
// 根据角色ID查询关联的用户列表
List<UserRole> selectByRoleId(Integer roleId);
// 分页查询所有关联
List<UserRole> selectPage(
@Param("userId") Integer userId,
@Param("roleId") Integer roleId
);
// 查询分页总数
int selectTotal(
@Param("userId") Integer userId,
@Param("roleId") Integer roleId
);
}

35
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/service/DepartmentService.java Normal file
View File

@@ -0,0 +1,35 @@
package com.rczn.system.service;
import com.rczn.domain.PageBean;
import com.rczn.system.domain.Department;
import java.util.List;
public interface DepartmentService {
// 新增部门
Long insert(Department department);
// 根据ID删除部门
Boolean deleteById(Long id);
// 根据ID更新部门
Boolean update(Department department);
// 根据ID查询部门
Department selectById(Long id);
// 分页查询部门
PageBean<Department> selectPage(
Integer pageNum,
Integer pageSize,
String deptName,
String deptCode,
Integer parentId
);
// 新增：获取完整部门树（递归组装）
List<Department> getDeptTree();
// 新增：获取简化版部门树（仅包含ID、名称、子部门，用于下拉选择）
List<Department> getSimpleDeptTree();
}

15
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/service/PositionService.java Normal file
View File

@@ -0,0 +1,15 @@
package com.rczn.system.service;
import com.rczn.domain.PageBean;
import com.rczn.system.domain.Position;
import java.util.List;
public interface PositionService {
Long insert(Position position);
Boolean deleteById(Long id);
Boolean update(Position position);
Position selectById(Long id);
PageBean<Position> selectPage(Integer pageNum, Integer pageSize, String posiName, String posiCode);
List<Position> selectList(String posiName, String posiCode);
}

15
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/service/RolePermissionService.java Normal file
View File

@@ -0,0 +1,15 @@
package com.rczn.system.service;
import com.rczn.system.domain.RolePermission;
import java.util.List;
public interface RolePermissionService {
List<RolePermission> selectListByRoleId(Integer roleId);
void insert(RolePermission rolePermission);
boolean delete(Integer roleId, Integer permissionId);
void deleteByRoleId(Integer roleId);
}

60
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/service/RoleService.java Normal file
View File

@@ -0,0 +1,60 @@
package com.rczn.system.service;
import com.rczn.domain.PageBean;
import com.rczn.system.domain.Role;
import java.util.List;
/**
* Role 业务逻辑层接口
*/
public interface RoleService {
/**
* 分页查询角色（支持多条件模糊查询）
* @param pageNum 页码（从1开始）
* @param pageSize 每页条数
* @param roleName 角色名（可选）
* @param roleCode 角色编码（可选）
* @return 分页结果
*/
PageBean<Role> selectRolePage(Integer pageNum, Integer pageSize, String roleName, String roleCode);
/**
* 根据ID查询单个角色
* @param id 角色ID
* @return 角色实体
*/
Role selectById(Long id);
/**
* 新增角色（校验角色编码唯一性）
* @param role 角色实体
* @return 新增成功的角色ID
* @throws IllegalArgumentException 角色编码已存在时抛出
*/
Long insert(Role role);
/**
* 修改角色（校验角色编码唯一性+部分字段更新）
* @param role 角色实体（需包含ID）
* @return 是否修改成功
* @throws IllegalArgumentException 角色编码已存在或未传ID时抛出
*/
Boolean update(Role role);
/**
* 根据ID删除角色
* @param id 角色ID
* @return 是否删除成功
*/
Boolean deleteById(Long id);
/**
* 根据角色名或角色编码模糊查询角色列表
* @param roleName 角色名（可选）
* @param roleCode 角色编码（可选）
* @return 角色列表
*/
List<Role> selectRoleList(String roleName, String roleCode);
}

44
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/service/SysDicDataService.java Normal file
View File

@@ -0,0 +1,44 @@
package com.rczn.system.service;
import com.github.pagehelper.PageInfo;
import com.rczn.system.domain.SysDicData;
import java.util.List;
public interface SysDicDataService {
/**
* 分页查询字典数据
*/
PageInfo<SysDicData> selectPage(Integer pageNum, Integer pageSize, Integer dicId, String dicLabel, String dicValue);
/**
* 查询字典数据列表
*/
List<SysDicData> selectList(Integer dicId, String dicLabel, String dicValue);
/**
* 根据ID查询字典数据
*/
SysDicData selectById(Long id);
/**
* 根据字典类型ID查询字典数据列表
*/
List<SysDicData> selectByDicId(Integer dicId);
/**
* 新增字典数据
*/
Long insert(SysDicData sysDicData);
/**
* 修改字典数据
*/
Boolean update(SysDicData sysDicData);
/**
* 逻辑删除字典数据
*/
Boolean deleteById(Long id);
}

40
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/service/SysDicTypeService.java Normal file
View File

@@ -0,0 +1,40 @@
package com.rczn.system.service;
import com.github.pagehelper.PageInfo;
import com.rczn.system.domain.SysDicType;
import java.util.List;
public interface SysDicTypeService {
/**
* 分页查询字典类型
*/
PageInfo<SysDicType> selectPage(Integer pageNum, Integer pageSize, String dicName, String dicCode);
/**
* 查询字典类型列表
*/
List<SysDicType> selectList( String dicName, String dicCode);
/**
* 根据ID查询字典类型
*/
SysDicType selectById(Long id);
/**
* 新增字典类型
*/
Long insert(SysDicType sysDicType);
/**
* 修改字典类型
*/
Boolean update(SysDicType sysDicType);
/**
* 逻辑删除字典类型
*/
Boolean deleteById(Long id);
}

26
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/service/SysPermissionService.java Normal file
View File

@@ -0,0 +1,26 @@
package com.rczn.system.service;
import com.rczn.domain.PageBean;
import com.rczn.system.domain.Permission;
import com.rczn.system.domain.Role;
import java.util.List;
public interface SysPermissionService {
List<Permission> getPermissionList();
//根据父ID查询权限列表：
List<Permission> getPermissionListByParentId(Integer parentId);
Permission getPermissionById(Integer id);
boolean addPermission(Permission permission);
boolean updatePermission(Permission permission);
boolean deletePermission(Integer id);
/**
* 1. 分页查询角色（多条件模糊查询）
* @param pageNum
* @param pageSize
* @param permissionName
* @return
*/
PageBean<Permission> selectRolePage(Integer pageNum, Integer pageSize,Integer parentId, String permissionName);
}

23
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/service/UserRoleService.java Normal file
View File

@@ -0,0 +1,23 @@
package com.rczn.system.service;
import com.rczn.domain.PageBean;
import com.rczn.system.domain.UserRole;
import java.util.List;
public interface UserRoleService {
Long insert(UserRole userRole);
Boolean deleteById(Long id);
Boolean deleteByUserId(Integer userId);
Boolean deleteByRoleId(Integer roleId);
UserRole selectById(Long id);
List<UserRole> selectByUserId(Integer userId);
/**
* Selects user roles by the given role ID
*
* @param roleId The ID of the role to search for
* @return List of UserRole objects associated with the given role ID
*/
List<UserRole> selectByRoleId(Integer roleId);
PageBean<UserRole> selectPage(Integer pageNum, Integer pageSize, Integer userId, Integer roleId);
}

78
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/service/UserService.java Normal file
View File

@@ -0,0 +1,78 @@
package com.rczn.system.service;
import com.rczn.domain.PageBean;
import com.rczn.system.domain.Permission;
import com.rczn.system.domain.User;
import java.util.List;
/**
* User 业务逻辑层接口
*/
public interface UserService {
/**
* 1. 分页查询用户（支持用户名模糊查询）
* @param pageNum 页码（从1开始）
* @param pageSize 每页条数
* @param userName 用户名（模糊查询，可选）
* @return 分页结果（PageBean）
*/
PageBean<User> selectUserPage(Integer pageNum, Integer pageSize, String userName);
/**
* 1. 查询用户列表（支持用户名模糊查询）
* @param userName 用户名（模糊查询，可选）
* @return 结果（listUser）
*/
List<User> selectUserList(String userName);
/**
* 2. 根据ID查询单个用户
* @param id 用户ID
* @return 单个用户实体
*/
User selectById(Long id);
/**
* 3. 新增用户
* @param user 用户实体
* @return 新增成功的用户ID
*/
Long insert(User user);
/**
* 4. 修改用户（部分字段更新）
* @param user 用户实体（需包含ID，仅更新非空字段）
* @return 是否修改成功（true/false）
*/
Boolean update(User user);
/**
* 5. 根据ID删除用户
* @param id 用户ID
* @return 是否删除成功（true/false）
*/
Boolean deleteById(Long id);
/**
* 6. 根据用户名查询用户
* @param username 用户名
* @return 用户实体
*/
User findeUserByUsername(String username);
/**
* 7. 注册用户
* @param username 用户名
* @param password 密码
*/
int register(String username, String password);
/**
* 根据用户id查询出关联的用户权限对象列表，
* 表直接的关系是：
* 用户表（user）--用户权限表（user_role）--权限表（role）-- 权限资源表（role_resource）--资源表（resource）
*/
List<Permission> findUserPermissions(Long userId);
}

186
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/service/impl/DepartmentServiceImpl.java Normal file
View File

@@ -0,0 +1,186 @@
package com.rczn.system.service.impl;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.rczn.domain.PageBean;
import com.rczn.system.domain.Department;
import com.rczn.system.mapper.DepartmentMapper;
import com.rczn.system.service.DepartmentService;
import jakarta.annotation.Resource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.Assert;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
@Service
public class DepartmentServiceImpl implements DepartmentService {
@Autowired
private DepartmentMapper departmentMapper;
@Override
public Long insert(Department department) {
// 校验必填字段
Assert.notNull(department.getDeptName(), "部门名称不能为空");
Assert.notNull(department.getDeptCode(), "部门编码不能为空");
// 补充创建时间字段
// department.setCreateId(getCurrentUserId());
if (department.getCreateTime() == null) {
department.setCreateTime(LocalDateTime.now());
}
int rows = departmentMapper.insert(department);
return rows > 0 ? department.getId() : null;
}
@Override
public Boolean deleteById(Long id) {
Assert.notNull(id, "部门ID不能为空");
int rows = departmentMapper.deleteById(id);
return rows > 0;
}
@Override
public Boolean update(Department department) {
Assert.notNull(department.getId(), "部门ID不能为空");
// department.setUpdateId(null);
if (department.getUpdateTime() == null) {
department.setUpdateTime(LocalDateTime.now());
}
int rows = departmentMapper.updateById(department);
return rows > 0;
}
@Override
public Department selectById(Long id) {
Assert.notNull(id, "部门ID不能为空");
return departmentMapper.selectById(id);
}
@Override
public PageBean<Department> selectPage(Integer pageNum, Integer pageSize, String deptName, String deptCode, Integer parentId) {
// 校验分页参数
Assert.notNull(pageNum, "页码不能为空");
Assert.notNull(pageSize, "每页条数不能为空");
Assert.isTrue(pageNum > 0, "页码必须大于0");
Assert.isTrue(pageSize > 0 && pageSize <= 100000, "每页条数必须在1-10000之间");
// 1. 设置分页参数（PageHelper 自动拦截后续的 SQL 进行分页）
PageHelper.startPage(pageNum, pageSize);
// 查询分页数据和总数
List<Department> items = departmentMapper.selectPage(deptName, deptCode, parentId);
Page<Department> page = (Page<Department>) items;
PageBean<Department> pageBean = new PageBean<>();
pageBean.setTotal(page.getTotal());
pageBean.setItems(page.getResult());
// 封装PageBean返回
return pageBean;
}
/**
* 核心：获取完整部门树（包含所有字段和层级关系）
*/
@Override
public List<Department> getDeptTree() {
// 1. 查询所有未删除的部门（一次性查询，减少数据库交互）
List<Department> allDept = departmentMapper.selectAllDept();
// 2. 递归组装树形结构（从顶级部门开始）
return buildDeptTree(allDept, null);
}
/**
* 核心：获取简化版部门树（仅ID、名称、子部门，用于下拉选择框等场景）
*/
@Override
public List<Department> getSimpleDeptTree() {
List<Department> allDept = departmentMapper.selectAllDept();
List<Department> deptTree = buildDeptTree(allDept, null);
// 简化部门树字段（仅保留必要字段，减少返回数据量）
return simplifyDeptTree(deptTree);
}
/**
* 递归组装部门树
* @param allDept 所有部门列表
* @param parentId 父部门ID（null 表示查询顶级部门）
* @return 组装后的子部门列表
*/
private List<Department> buildDeptTree(List<Department> allDept, Integer parentId) {
// 筛选当前父部门的所有子部门
List<Department> childrenDept = allDept.stream()
.filter(dept -> {
// 父部门ID为null时，筛选parent_id IS NULL的顶级部门；否则筛选parent_id等于当前parentId的部门
if (parentId == null) {
return dept.getParentId() == null;
} else {
return parentId.equals(dept.getParentId());
}
})
.collect(Collectors.toList());
// 递归为每个子部门设置下属子部门
for (Department dept : childrenDept) {
List<Department> children = buildDeptTree(allDept, dept.getId().intValue()); // dept.id是Long，转Integer匹配parentId类型
dept.setLeader(null); // 简化场景可清空负责人，如需保留可删除此句
dept.setChildren(children); // 给当前部门设置子部门
}
return childrenDept;
}
/**
* 简化部门树字段（仅保留ID、名称、子部门）
* @param deptTree 完整部门树
* @return 简化后的部门树
*/
private List<Department> simplifyDeptTree(List<Department> deptTree) {
List<Department> simpleTree = new ArrayList<>();
for (Department dept : deptTree) {
Department simpleDept = new Department();
simpleDept.setId(dept.getId());
simpleDept.setDeptName(dept.getDeptName());
simpleDept.setDeptCode(dept.getDeptCode());
// 递归简化子部门
if (dept.getChildren() != null && !dept.getChildren().isEmpty()) {
simpleDept.setChildren(simplifyDeptTree(dept.getChildren()));
}
simpleTree.add(simpleDept);
}
return simpleTree;
}
/**
* 辅助方法：获取当前登录用户ID（需替换为你的实际获取逻辑，如从Token中解析）
*/
private Long getCurrentUserId() {
// 示例：临时返回1，实际项目中需替换为真实的用户ID获取逻辑（如SecurityContext、ThreadLocal等）
return 1L;
}
// 为Department实体类添加children字段的setter（因为原实体类没有，需动态设置子部门）
// 注意：这里是通过反射或直接在实体类中添加children字段，推荐在实体类中显式添加！
// 下面是临时解决方案，实际需修改Department实体类（见步骤六）
private void setChildren(Department dept, List<Department> children) {
try {
// 通过反射给Department设置children字段（若实体类已添加，可直接调用setChildren）
java.lang.reflect.Field field = Department.class.getDeclaredField("children");
field.setAccessible(true);
field.set(dept, children);
} catch (Exception e) {
throw new RuntimeException("设置部门子节点失败", e);
}
}
}

83
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/service/impl/PositionServiceImpl.java Normal file
View File

@@ -0,0 +1,83 @@
package com.rczn.system.service.impl;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.rczn.domain.PageBean;
import com.rczn.system.domain.Department;
import com.rczn.system.domain.Position;
import com.rczn.system.mapper.PositionMapper;
import com.rczn.system.service.PositionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.Assert;
import java.util.List;
@Service
public class PositionServiceImpl implements PositionService {
@Autowired
private PositionMapper positionMapper;
@Override
public Long insert(Position position) {
Assert.notNull(position.getPosiName(), "职位名称不能为空");
Assert.notNull(position.getPosiCode(), "职位编码不能为空");
int rows = positionMapper.insert(position);
return rows > 0 ? position.getId() : null;
}
@Override
public Boolean deleteById(Long id) {
Assert.notNull(id, "职位ID不能为空");
int rows = positionMapper.deleteById(id);
return rows > 0;
}
@Override
public Boolean update(Position position) {
Assert.notNull(position.getId(), "职位ID不能为空");
int rows = positionMapper.updateById(position);
return rows > 0;
}
@Override
public Position selectById(Long id) {
Assert.notNull(id, "职位ID不能为空");
return positionMapper.selectById(id);
}
@Override
public PageBean<Position> selectPage(Integer pageNum, Integer pageSize, String posiName, String posiCode) {
Assert.notNull(pageNum, "页码不能为空");
Assert.notNull(pageSize, "每页条数不能为空");
Assert.isTrue(pageNum > 0, "页码必须大于0");
Assert.isTrue(pageSize > 0 && pageSize <= 100000, "每页条数必须在1-10000之间");
// 1. 设置分页参数（PageHelper 自动拦截后续的 SQL 进行分页）
PageHelper.startPage(pageNum, pageSize);
// 查询分页数据和总数
List<Position> items = positionMapper.selectPage(posiName, posiCode);
Page<Position> page = (Page<Position>) items;
PageBean<Position> pageBean = new PageBean<>();
pageBean.setTotal(page.getTotal());
pageBean.setItems(page.getResult());
// 封装PageBean返回
return pageBean;
}
/**
* 条件查询职位列表
* @param posiName 职位名称
* @param posiCode 职位编码
* @return 职位列表
*/
@Override
public List<Position> selectList(String posiName, String posiCode) {
return positionMapper.selectList(posiName, posiCode);
}
}

42
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/service/impl/RolePermissionServiceImpl.java Normal file
View File

@@ -0,0 +1,42 @@
package com.rczn.system.service.impl;
import com.rczn.system.domain.RolePermission;
import com.rczn.system.mapper.RolePermissionMapper;
import com.rczn.system.service.RolePermissionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDateTime;
import java.util.List;
@Service
public class RolePermissionServiceImpl implements RolePermissionService {
@Autowired
RolePermissionMapper rolePermissionMapper;
@Override
public List<RolePermission> selectListByRoleId(Integer roleId) {
return rolePermissionMapper.selectListByRoleId(roleId);
}
@Override
@Transactional
public void insert(RolePermission rolePermission) {
rolePermission.setCreateTime(LocalDateTime.now());
rolePermissionMapper.insert(rolePermission);
}
@Override
@Transactional
public boolean delete(Integer roleId, Integer permissionId) {
return rolePermissionMapper.delete(roleId, permissionId) > 0;
}
@Override
@Transactional
public void deleteByRoleId(Integer roleId) {
rolePermissionMapper.deleteByRoleId(roleId);
}
}

110
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/service/impl/RoleServiceImpl.java Normal file
View File

@@ -0,0 +1,110 @@
package com.rczn.system.service.impl;
import com.github.pagehelper.PageHelper;
import com.rczn.domain.PageBean;
import com.rczn.system.domain.Role;
import com.rczn.system.mapper.RoleMapper;
import com.rczn.system.service.RoleService;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDateTime;
import java.util.List;
/**
* Role 业务逻辑层实现
*/
@Service
@Transactional
public class RoleServiceImpl implements RoleService {
@Autowired
RoleMapper roleMapper;
@Override
public PageBean<Role> selectRolePage(Integer pageNum, Integer pageSize, String roleName, String roleCode) {
// 1. PageHelper 设置分页参数
PageHelper.startPage(pageNum, pageSize);
// 2. 执行查询
List<Role> roleList = roleMapper.selectRolePage(roleName, roleCode);
// 3. 查询总条数
Long total = roleMapper.selectTotal(roleName, roleCode);
// 4. 封装分页结果
return new PageBean<Role>() {{
setTotal(total);
setItems(roleList);
}};
}
@Override
public Role selectById(Long id) {
return roleMapper.selectById(id);
}
@Override
public Long insert(Role role) {
// 校验角色编码唯一性
Integer count = roleMapper.checkRoleCodeUnique(role.getRoleCode(), null);
if (count != null && count > 0) {
throw new IllegalArgumentException("角色编码：" + role.getRoleCode() + " 已存在");
}
// 更新创建时间、创建者
// TODO 待实现
// role.setCreateId(1L);
if (role.getCreateTime() == null) {
role.setCreateTime(LocalDateTime.now());
}
// 执行新增（自动回填ID）
roleMapper.insert(role);
return role.getId();
}
@Override
public Boolean update(Role role) {
// 校验ID是否存在
if (role.getId() == null) {
throw new IllegalArgumentException("修改角色必须传入ID");
}
// 校验角色编码唯一性（排除自身）
Integer count = roleMapper.checkRoleCodeUnique(role.getRoleCode(), role.getId());
if (count != null && count > 0) {
throw new IllegalArgumentException("角色编码：" + role.getRoleCode() + " 已存在");
}
// 更新更新时间、更新者
// TODO 待实现
// role.setUpdateId(1L);
if (role.getUpdateTime() == null) {
role.setUpdateTime(LocalDateTime.now());
}
// 执行修改
int rows = roleMapper.update(role);
return rows > 0;
}
@Override
public Boolean deleteById(Long id) {
// 先校验角色是否存在
Role role = roleMapper.selectById(id);
if (role == null) {
return false;
}
// 执行删除
int rows = roleMapper.deleteById(id);
return rows > 0;
}
/**
* 根据角色名或角色编码模糊查询角色列表
*
* @param roleName 角色名（可选）
* @param roleCode 角色编码（可选）
* @return 角色列表
*/
@Override
public List<Role> selectRoleList(String roleName, String roleCode) {
return roleMapper.selectRolePage(roleName, roleCode);
}
}

97
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/service/impl/SysDicDataServiceImpl.java Normal file
View File

@@ -0,0 +1,97 @@
package com.rczn.system.service.impl;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.rczn.system.domain.SysDicData;
import com.rczn.system.mapper.SysDicDataMapper;
import com.rczn.system.service.SysDicDataService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class SysDicDataServiceImpl implements SysDicDataService {
@Autowired
private SysDicDataMapper sysDicDataMapper;
@Override
public PageInfo<SysDicData> selectPage(Integer pageNum, Integer pageSize, Integer dicId, String dicLabel, String dicValue) {
PageHelper.startPage(pageNum, pageSize);
SysDicData query = new SysDicData();
query.setDicId(dicId);
query.setDicLabel(dicLabel);
query.setDicValue(dicValue);
return new PageInfo<>(sysDicDataMapper.selectPage(query));
}
/**
* 查询字典数据列表
*
* @param dicId
* @param dicLabel
* @param dicValue
*/
@Override
public List<SysDicData> selectList(Integer dicId, String dicLabel, String dicValue) {
SysDicData query = new SysDicData();
query.setDicId(dicId);
query.setDicLabel(dicLabel);
query.setDicValue(dicValue);
return sysDicDataMapper.selectPage(query);
}
@Override
public SysDicData selectById(Long id) {
return sysDicDataMapper.selectById(id);
}
@Override
public List<SysDicData> selectByDicId(Integer dicId) {
if (dicId == null) {
throw new IllegalArgumentException("字典类型ID不能为空");
}
return sysDicDataMapper.selectByDicId(dicId);
}
@Override
public Long insert(SysDicData sysDicData) {
// 校验必填项
if (sysDicData.getDicId() == null) {
throw new IllegalArgumentException("字典类型ID不能为空");
}
if (sysDicData.getDicLabel() == null || sysDicData.getDicLabel().trim().isEmpty()) {
throw new IllegalArgumentException("数据标签不能为空");
}
int count = sysDicDataMapper.insert(sysDicData);
return count > 0 ? sysDicData.getId() : null;
}
@Override
public Boolean update(SysDicData sysDicData) {
if (sysDicData.getId() == null) {
throw new IllegalArgumentException("字典数据ID不能为空");
}
// 校验是否存在
SysDicData exist = sysDicDataMapper.selectById(sysDicData.getId());
if (exist == null) {
return false;
}
int count = sysDicDataMapper.update(sysDicData);
return count > 0;
}
@Override
public Boolean deleteById(Long id) {
if (id == null) {
throw new IllegalArgumentException("字典数据ID不能为空");
}
// 校验是否存在
SysDicData exist = sysDicDataMapper.selectById(id);
if (exist == null) {
return false;
}
int count = sysDicDataMapper.deleteById(id);
return count > 0;
}
}

84
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/service/impl/SysDicTypeServiceImpl.java Normal file
View File

@@ -0,0 +1,84 @@
package com.rczn.system.service.impl;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.rczn.system.domain.SysDicType;
import com.rczn.system.mapper.SysDicTypeMapper;
import com.rczn.system.service.SysDicTypeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class SysDicTypeServiceImpl implements SysDicTypeService {
@Autowired
private SysDicTypeMapper sysDicTypeMapper;
@Override
public PageInfo<SysDicType> selectPage(Integer pageNum, Integer pageSize, String dicName, String dicCode) {
PageHelper.startPage(pageNum, pageSize);
SysDicType query = new SysDicType();
query.setDicName(dicName);
query.setDicCode(dicCode);
return new PageInfo<>(sysDicTypeMapper.selectPage(query));
}
/**
* 查询字典类型列表
*
* @param dicName
* @param dicCode
*/
@Override
public List<SysDicType> selectList(String dicName, String dicCode) {
SysDicType query = new SysDicType();
query.setDicName(dicName);
query.setDicCode(dicCode);
return sysDicTypeMapper.selectPage(query);
}
@Override
public SysDicType selectById(Long id) {
return sysDicTypeMapper.selectById(id);
}
@Override
public Long insert(SysDicType sysDicType) {
// 校验必填项
if (sysDicType.getDicName() == null || sysDicType.getDicName().trim().isEmpty()) {
throw new IllegalArgumentException("字典名称不能为空");
}
int count = sysDicTypeMapper.insert(sysDicType);
return count > 0 ? sysDicType.getId() : null;
}
@Override
public Boolean update(SysDicType sysDicType) {
if (sysDicType.getId() == null) {
throw new IllegalArgumentException("字典类型ID不能为空");
}
// 校验是否存在
SysDicType exist = sysDicTypeMapper.selectById(sysDicType.getId());
if (exist == null) {
return false;
}
int count = sysDicTypeMapper.update(sysDicType);
return count > 0;
}
@Override
public Boolean deleteById(Long id) {
if (id == null) {
throw new IllegalArgumentException("字典类型ID不能为空");
}
// 校验是否存在
SysDicType exist = sysDicTypeMapper.selectById(id);
if (exist == null) {
return false;
}
int count = sysDicTypeMapper.deleteById(id);
return count > 0;
}
}

140
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/service/impl/SysPermissionServiceImpl.java Normal file
View File

@@ -0,0 +1,140 @@
package com.rczn.system.service.impl;
import com.github.pagehelper.PageHelper;
import com.rczn.domain.PageBean;
import com.rczn.system.domain.Permission;
import com.rczn.system.domain.Role;
import com.rczn.system.mapper.SysPermissionMapper;
import com.rczn.system.service.SysPermissionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
@Service
public class SysPermissionServiceImpl implements SysPermissionService {
@Autowired
private SysPermissionMapper sysPermissionMapper;
@Override
public Permission getPermissionById(Integer id) {
return sysPermissionMapper.selectPermissionById(id);
}
@Override
public boolean addPermission(Permission permission) {
return sysPermissionMapper.insertPermission(permission) > 0;
}
@Override
public boolean updatePermission(Permission permission) {
return sysPermissionMapper.updatePermission(permission) > 0;
}
@Override
public boolean deletePermission(Integer id) {
return sysPermissionMapper.deletePermissionById(id) > 0;
}
/**
* 1. 分页查询角色（多条件模糊查询）
*
* @param pageNum
* @param pageSize
* @param permissionName
* @return
*/
@Override
public PageBean<Permission> selectRolePage(Integer pageNum, Integer pageSize,Integer parentId, String permissionName) {
// 1. PageHelper 设置分页参数
PageHelper.startPage(pageNum, pageSize);
//加一层过滤：
if(parentId == 0){
parentId = null;
}
// 2. 执行查询
List<Permission> permissionList = sysPermissionMapper.selectPermissionPage(parentId,permissionName);
// 3. 查询总条数
Long total = sysPermissionMapper.selectTotal(parentId,permissionName);
// 4. 封装分页结果
return new PageBean<Permission>() {{
setTotal(total);
setItems(permissionList);
}};
}
@Override
public List<Permission> getPermissionList() {
// 1. 查询所有平级权限
List<Permission> allPermissions = sysPermissionMapper.selectPermissionList();
// 2. 找到顶层节点（parentId = null 或 0）
List<Permission> topNodes = new ArrayList<>();
for (Permission p : allPermissions) {
if (p.getParentId() == null || p.getParentId() == 0) {
topNodes.add(p);
}
}
// 3. 循环给每个顶层节点设置子节点（递归）
for (Permission node : topNodes) {
node.setChildren(findChildren(node, allPermissions));
}
return topNodes;
}
/***
* 根据父ID查询权限列表
* @param parentId
* @return
*/
@Override
public List<Permission> getPermissionListByParentId(Integer parentId) {
// 1. 查询所有平级权限
List<Permission> allPermissions = sysPermissionMapper.selectPermissionList();
// 2. 找到顶层节点（parentId = null 或 0）
List<Permission> topNodes = new ArrayList<>();
for (Permission p : allPermissions) {
if(parentId == null || parentId == 0){
if (p.getParentId() == null || p.getParentId() == 0) {
topNodes.add(p);
}
}else {
if (p.getParentId() == parentId) {
topNodes.add(p);
}
}
}
// 3. 循环给每个顶层节点设置子节点（递归）
for (Permission node : topNodes) {
node.setChildren(findChildren(node, allPermissions));
}
return topNodes;
}
/**
* 递归查找子节点（最稳妥、最清晰、不会漏）
*/
private List<Permission> findChildren(Permission parent, List<Permission> allList) {
List<Permission> children = new ArrayList<>();
for (Permission p : allList) {
// 子节点的 parentId == 父节点 id
if (parent.getId().equals(p.getParentId()==null?0:p.getParentId().longValue())) {
children.add(p);
// 递归给子节点设置孙子节点
p.setChildren(findChildren(p, allList));
}
}
return children;
}
}

88
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/service/impl/UserRoleServiceImpl.java Normal file
View File

@@ -0,0 +1,88 @@
package com.rczn.system.service.impl;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.rczn.domain.PageBean;
import com.rczn.system.domain.Permission;
import com.rczn.system.domain.Position;
import com.rczn.system.domain.UserRole;
import com.rczn.system.mapper.UserRoleMapper;
import com.rczn.system.service.UserRoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.Assert;
import java.util.List;
@Service
public class UserRoleServiceImpl implements UserRoleService {
@Autowired
private UserRoleMapper userRoleMapper;
@Override
public Long insert(UserRole userRole) {
Assert.notNull(userRole.getUserId(), "用户ID不能为空");
Assert.notNull(userRole.getRoleId(), "角色ID不能为空");
int rows = userRoleMapper.insert(userRole);
return rows > 0 ? userRole.getId() : null;
}
@Override
public Boolean deleteById(Long id) {
Assert.notNull(id, "关联ID不能为空");
int rows = userRoleMapper.deleteById(id);
return rows > 0;
}
@Override
public Boolean deleteByUserId(Integer userId) {
Assert.notNull(userId, "用户ID不能为空");
int rows = userRoleMapper.deleteByUserId(userId);
return rows > 0;
}
@Override
public Boolean deleteByRoleId(Integer roleId) {
Assert.notNull(roleId, "角色ID不能为空");
int rows = userRoleMapper.deleteByRoleId(roleId);
return rows > 0;
}
@Override
public UserRole selectById(Long id) {
Assert.notNull(id, "关联ID不能为空");
return userRoleMapper.selectById(id);
}
@Override
public List<UserRole> selectByUserId(Integer userId) {
Assert.notNull(userId, "用户ID不能为空");
return userRoleMapper.selectByUserId(userId);
}
@Override
public List<UserRole> selectByRoleId(Integer roleId) {
Assert.notNull(roleId, "角色ID不能为空");
return userRoleMapper.selectByRoleId(roleId);
}
@Override
public PageBean<UserRole> selectPage(Integer pageNum, Integer pageSize, Integer userId, Integer roleId) {
Assert.notNull(pageNum, "页码不能为空");
Assert.notNull(pageSize, "每页条数不能为空");
Assert.isTrue(pageNum > 0, "页码必须大于0");
Assert.isTrue(pageSize > 0 && pageSize <= 100000, "每页条数必须在1-10000之间");
PageHelper.startPage(pageNum,pageSize);
List<UserRole> items = userRoleMapper.selectPage(userId, roleId);
Page<UserRole> page = (Page<UserRole>) items;
PageBean<UserRole> pageBean = new PageBean<>();
pageBean.setTotal(page.getTotal());
pageBean.setItems(page.getResult());
// 封装PageBean返回
return pageBean;
}
}

131
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/service/impl/UserServiceImpl.java Normal file
View File

@@ -0,0 +1,131 @@
package com.rczn.system.service.impl;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.rczn.domain.PageBean;
import com.rczn.system.domain.Permission;
import com.rczn.system.domain.User;
import com.rczn.system.mapper.UserMapper;
import com.rczn.system.service.UserService;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
/**
* User 业务逻辑层实现
*/
@Service
@Transactional // 事务管理（增删改操作需事务）
public class UserServiceImpl implements UserService {
// 注入 Mapper（Lombok @RequiredArgsConstructor 自动生成构造器）
@Autowired
UserMapper userMapper;
@Override
public PageBean<User> selectUserPage(Integer pageNum, Integer pageSize, String userName) {
// 1. 设置分页参数（PageHelper 自动拦截后续的 SQL 进行分页）
PageHelper.startPage(pageNum, pageSize);
// 2. 执行查询（MyBatis 会自动添加 LIMIT 分页）
User user = new User();
user.setUserName(userName);
List<User> userList = userMapper.selectUserPage(user);
Page<User> userPage = (Page<User>) userList;
// 3. 查询总条数（支持模糊查询条件）
PageBean<User> pageBean = new PageBean<>();
pageBean.setTotal(userPage.getTotal());
pageBean.setItems(userPage);
// 4. 封装分页结果（使用你的自定义 PageBean）
return pageBean;
}
/**
* 1. 查询用户列表（支持用户名模糊查询）
*
* @param userName 用户名（模糊查询，可选）
* @return 结果（listUser）
*/
@Override
public List<User> selectUserList(String userName) {
// 2. 执行查询（MyBatis 会自动添加 LIMIT 分页）
User user = new User();
user.setUserName(userName);
List<User> userList = userMapper.selectUserPage(user);
return userList;
}
@Override
public User selectById(Long id) {
// 查询不到返回 null（后续 Controller 处理）
return userMapper.selectById(id, false);
}
@Override
public Long insert(User user) {
// 执行新增（XML 中已配置 useGeneratedKeys，会自动回填 ID 到 user 对象）
userMapper.insert(user);
return user.getId(); // 返回新增用户的 ID
}
@Override
public Boolean update(User user) {
if (user.getId() == null) {
throw new IllegalArgumentException("修改用户必须传入 ID");
}
// 执行修改（返回影响行数，>0 表示修改成功）
int rows = userMapper.update(user);
return rows > 0;
}
@Override
public Boolean deleteById(Long id) {
// 执行删除（返回影响行数，>0 表示删除成功）
int rows = userMapper.deleteById(id,null);
return rows > 0;
}
/**
* 6. 根据用户名查询用户
*
* @param username 用户名
* @return 用户实体
*/
@Override
public User findeUserByUsername(String username) {
return userMapper.selectByUsername(username);
}
/**
* 7. 注册用户
*
* @param username 用户名
* @param password 密码
*/
@Override
public int register(String username, String password) {
User user = new User();
user.setUserName(username);
user.setPassword(password);
return userMapper.insert(user);
}
/**
* 根据用户id查询出关联的用户权限对象列表，
* 表直接的关系是：
* 用户表（user）--用户权限表（user_role）--权限表（role）-- 权限资源表（role_resource）--资源表（resource）
*
* @param userId
*/
@Override
public List<Permission> findUserPermissions(Long userId) {
return userMapper.findUserPermissions(userId);
}
}

163
rc_autoplc_backend/rczn-admin/src/main/resources/application.yml Normal file
View File

@@ -0,0 +1,163 @@
# 服务器配置
server:
port: 9090 # 项目端口
servlet:
encoding:
charset: UTF-8 # 解决中文乱码（含接口文档/响应）
enabled: true
force: true
# Spring核心配置
spring:
application:
name: rczn-admin # 应用名称
# 数据源配置（MySQL 8.x）
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://47.116.126.33:3306/rc_autoplc_program?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true&allowMultiQueries=true
username: nianke
password: Jy@.niankeCrm2025
# 解决跨域（可选，配合之前的CorsConfig）
web:
cors:
allowed-origins: false # 禁用默认CORS，使用自定义CorsConfig
# 关键：Jackson 序列化配置（替代 JacksonConfig）
jackson:
# 允许空对象序列化（解决 HttpMediaTypeNotAcceptableException 核心）
serialization:
fail-on-empty-beans: false
# 格式化 JSON 输出（可选，便于调试）
indent-output: true
# 忽略未知字段（避免前端传多余字段报错）
deserialization:
fail-on-unknown-properties: false
# 支持 Java 8 日期类型（LocalDateTime）
modules:
- com.fasterxml.jackson.datatype.jsr310.JavaTimeModule
# 日期格式化（可选，统一日期返回格式）
date-format: yyyy-MM-dd HH:mm:ss
time-zone: GMT+8
# MyBatis配置
mybatis:
configuration:
map-underscore-to-camel-case: true # 下划线转驼峰
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # 关键：SQL 打印到控制台
log-prefix: "[MyBatis] " # 可选：日志前缀，便于区分 SQL 日志
default-statement-timeout: 30 # 可选：SQL 执行超时时间（秒）
mapper-locations: classpath:mapper/**/*.xml # 补充：指定Mapper.xml文件路径（必加）
type-aliases-package: com.rczn.**.domain # 补充：实体类别名包（可选）
# HikariCP 连接池配置（关键）
hikari:
max-lifetime: 1800000 # 连接最大生命周期（30 分钟，必须小于 MySQL wait_timeout，默认 8 小时）
idle-timeout: 600000 # 连接空闲超时时间（10 分钟）
connection-timeout: 30000 # 连接超时时间（30 秒）
minimum-idle: 5 # 最小空闲连接数
maximum-pool-size: 10 # 最大连接池大小
test-while-idle: true # 空闲时检测连接有效性
validation-timeout: 5000 # 连接校验超时时间（5 秒）
connection-test-query: SELECT 1 # 连接校验 SQL（MySQL 可用此简单查询）
# PageHelper 分页插件配置
pagehelper:
helper-dialect: mysql # 数据库方言（适配 MySQL）
reasonable: true # 合理化分页（页码≤0时查第1页，页码超出总页数时查最后1页）
support-methods-arguments: true # 支持通过 Mapper 接口参数传递分页参数
params: count=countSql # 分页参数名映射
#
## SpringDoc OpenAPI 3 核心配置（适配Spring Boot 3.x）
#springdoc:
# packages-to-scan: com.rczn # 扫描的基础包（Controller所在包）
# api-docs:
# enabled: true # 启用/v3/api-docs接口
# path: /v3/api-docs # OpenAPI JSON数据路径（默认）
# swagger-ui:
# path: /swagger-ui.html # 自定义Swagger UI访问路径（兼容Spring Boot 2.x习惯）
# tags-sorter: alpha # 标签字母排序
# operations-sorter: alpha # 接口字母排序
# disable-swagger-default-url: true # 禁用默认PetStore示例
# default-flat-param-object: false # 禁用扁平参数对象
# paths-to-exclude: /error, /actuator/** # 排除错误接口/监控接口（可选）
#
## OpenAPI文档基础信息（中文正常显示）
openapi:
info:
title: XX自动化编程系统API文档
description: SpringBoot 3.x + SpringDoc OpenAPI 3 接口文档
version: 1.0.0
contact:
name: 研发组
email: xxx@xxx.com
servers:
- url: http://localhost:9090 # 开发环境地址
description: 本地开发环境
- url: http://47.116.126.33:9090 # 测试环境地址
description: 测试环境
# SpringDoc + Knife4j 核心配置
springdoc:
packages-to-scan: com.rczn # 扫描Controller所在包
api-docs:
enabled: true
path: /v3/api-docs
swagger-ui:
tags-sorter: alpha
operations-sorter: alpha
paths-to-exclude: /error, /actuator/**
# Knife4j增强配置（可选，开启中文UI）
knife4j:
enable: true
setting:
language: zh_cn # 中文界面
enable-swagger-models: true # 显示模型
enable-document-manage: false # 关闭文档管理（开发环境）
# OpenAPI文档信息
#openapi:
# info:
# title: XX自动化编程系统API文档
# description: SpringBoot 3.x + Knife4j + OpenAPI 3 接口文档
# version: 1.0.0
# contact:
# name: 研发组
# email: xxx@xxx.com
# servers:
# - url: http://localhost:9090
# description: 本地开发环境
# - url: http://47.116.126.33:9090
# description: 测试环境
# Spring Boot 日志核心配置
logging:
# 1. 全局日志级别（可细化到包/类）
level:
root: INFO # 根日志级别（默认）
com.rczn.rcznautoplc: DEBUG # 自定义包级别（调试业务代码）
org.springframework: INFO # Spring 框架日志级别（减少冗余）
com.zaxxer.hikari: ERROR # 数据库连接池日志级别（仅输出错误）
mybatis: DEBUG # MyBatis SQL 日志级别（输出执行的 SQL）
# 2. 日志输出配置（控制台 + 文件）
pattern:
# console: "%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n" # 控制台格式
file: "%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n" # 文件格式
# 3. 文件输出配置
file:
name: ./logs/rczn-autoplc.log # 日志文件路径（相对路径/绝对路径）
max-size: 10MB # 单个日志文件大小上限（超过则分割）
max-history: 30 # 日志文件保留天数
total-size-cap: 1GB # 日志文件总大小上限
clean-history-on-start: false # 启动时是否清理历史日志
# 4. 日志分割（按大小/时间，Logback 原生支持）
logback:
rollingpolicy:
file-name-pattern: ./logs/rczn-autoplc-%d{yyyy-MM-dd}.%i.log # 分割后的文件名（%i 是序号，处理同天多文件）
max-file-size: 100MB # 单个文件大小（覆盖上面的 max-size）
max-history: 30 # 保留天数
total-size-cap: 1GB # 总大小

179
rc_autoplc_backend/rczn-admin/src/main/resources/mapper/DepartmentMapper.xml Normal file
View File

@@ -0,0 +1,179 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.rczn.system.mapper.DepartmentMapper">
<!-- 通用字段：BaseBean继承的字段 -->
<sql id="baseColumn">
id, create_id, create_time, update_id, update_time, del_sign, remark
</sql>
<!-- Department专属字段 -->
<sql id="deptColumn">
dept_name, dept_code, parent_id, leader_id
</sql>
<!-- 新增部门（修复多余逗号问题，支持空字段忽略） -->
<insert id="insert" useGeneratedKeys="true" keyProperty="id">
INSERT INTO sys_department (
<!-- 用 trim 标签：prefix="(" suffix=")" suffixOverrides="," 去除末尾多余逗号 -->
<trim prefix="" suffix="" suffixOverrides=",">
<!-- 通用字段：非空才添加字段 -->
<if test="createId != null">create_id,</if>
<if test="createTime != null">create_time,</if>
<if test="remark != null and remark != ''">remark,</if>
<!-- 部门专属字段：非空才添加字段 -->
<if test="deptName != null and deptName != ''">dept_name,</if>
<if test="deptCode != null and deptCode != ''">dept_code,</if>
<if test="parentId != null">parent_id,</if>
<if test="leaderId != null">leader_id,</if>
</trim>
) VALUES (
<!-- 用 trim 标签去除值列表末尾多余逗号 -->
<trim prefix="" suffix="" suffixOverrides=",">
<!-- 通用字段：非空才添加值 -->
<if test="createId != null">#{createId},</if>
<if test="createTime != null">#{createTime},</if>
<if test="remark != null and remark != ''">#{remark},</if>
<!-- 部门专属字段：非空才添加值 -->
<if test="deptName != null and deptName != ''">#{deptName},</if>
<if test="deptCode != null and deptCode != ''">#{deptCode},</if>
<if test="parentId != null">#{parentId},</if>
<if test="leaderId != null">#{leaderId},</if>
</trim>
)
</insert>
<!-- 逻辑删除部门 -->
<update id="deleteById">
UPDATE sys_department
SET del_sign = 1, update_time = NOW()
WHERE id = #{id} AND del_sign = 0
</update>
<!-- 更新部门 -->
<update id="updateById">
UPDATE sys_department
<set>
<if test="deptName != null and deptName != ''">dept_name = #{deptName},</if>
<if test="deptCode != null and deptCode != ''">dept_code = #{deptCode},</if>
<if test="parentId != null">parent_id = #{parentId},</if>
<if test="leaderId != null">leader_id = #{leaderId},</if>
<if test="updateId != null">update_id = #{updateId},</if>
<if test="remark != null">remark = #{remark},</if>
update_time = NOW()
</set>
WHERE id = #{id} AND del_sign = 0
</update>
<!-- 根据ID查询部门 -->
<select id="selectById" resultType="com.rczn.system.domain.Department">
SELECT
<include refid="baseColumn"/>, <include refid="deptColumn"/>
FROM sys_department
WHERE id = #{id} AND del_sign = 0
</select>
<!-- 分页查询部门 -->
<select id="selectPage" resultType="com.rczn.system.domain.Department">
SELECT
<include refid="baseColumn"/>, <include refid="deptColumn"/>
FROM sys_department
WHERE del_sign = 0
<if test="deptName != null and deptName != ''">
AND dept_name LIKE CONCAT('%', #{deptName}, '%')
</if>
<if test="deptCode != null and deptCode != ''">
AND dept_code LIKE CONCAT('%', #{deptCode}, '%')
</if>
<if test="parentId != null">
AND parent_id = #{parentId}
</if>
ORDER BY id DESC
</select>
<!-- 查询分页总数 -->
<select id="selectTotal" resultType="java.lang.Integer">
SELECT COUNT(id)
FROM sys_department
WHERE del_sign = 0
<if test="deptName != null and deptName != ''">
AND dept_name LIKE CONCAT('%', #{deptName}, '%')
</if>
<if test="deptCode != null and deptCode != ''">
AND dept_code LIKE CONCAT('%', #{deptCode}, '%')
</if>
<if test="parentId != null">
AND parent_id = #{parentId}
</if>
</select>
<!-- 公共字段映射（复用原有resultMap，新增parent/leader关联） -->
<resultMap id="DeptResultMap" type="com.rczn.system.domain.Department">
<!-- 基础字段（继承BaseBean） -->
<id column="id" property="id"/>
<result column="create_id" property="createId"/>
<result column="create_time" property="createTime"/>
<result column="update_id" property="updateId"/>
<result column="update_time" property="updateTime"/>
<result column="del_sign" property="delSign"/>
<result column="remark" property="remark"/>
<!-- 部门专属字段 -->
<result column="dept_name" property="deptName"/>
<result column="dept_code" property="deptCode"/>
<result column="parent_id" property="parentId"/>
<result column="leader_id" property="leaderId"/>
<!-- &lt;!&ndash; 关联父部门（可选，用于显示父部门名称） &ndash;&gt;-->
<!-- <association property="parent" javaType="com.rczn.system.domain.Department">-->
<!-- <id column="parent_id" property="id"/>-->
<!-- <result column="parent_dept_name" property="deptName"/>-->
<!-- </association>-->
<!-- &lt;!&ndash; 关联部门负责人（可选，用于显示负责人名称） &ndash;&gt;-->
<!-- <association property="leader" javaType="com.rczn.system.domain.User">-->
<!-- <id column="leader_id" property="id"/>-->
<!-- <result column="leader_name" property="userName"/>-->
<!-- </association>-->
</resultMap>
<!-- 1. 查询所有未删除的部门（用于递归组装树） -->
<select id="selectAllDept" resultMap="DeptResultMap">
SELECT
d.id, d.dept_name, d.dept_code, d.parent_id, d.leader_id,
d.create_id, d.create_time, d.update_id, d.update_time, d.del_sign, d.remark
-- p.dept_name AS parent_dept_name, -- 父部门名称（关联查询）
-- u.user_name AS leader_name -- 负责人名称（关联查询）
FROM sys_department d
-- LEFT JOIN sys_department p ON d.parent_id = p.id AND p.del_sign = 0 -- 关联父部门（未删除）
-- LEFT JOIN sys_user u ON d.leader_id = u.id AND u.del_sign = 0 -- 关联负责人（未删除）
WHERE d.del_sign = 0 -- 仅查询未删除的部门
ORDER BY d.id ASC
</select>
<!-- 2. 按父部门ID查询子部门（用于递归查询） -->
<select id="selectChildrenByParentId" resultMap="DeptResultMap" parameterType="java.lang.Integer">
SELECT
d.id, d.dept_name, d.dept_code, d.parent_id, d.leader_id,
d.create_id, d.create_time, d.update_id, d.update_time, d.del_sign, d.remark
-- p.dept_name AS parent_dept_name,
-- u.user_name AS leader_name
FROM sys_department d
-- LEFT JOIN sys_department p ON d.parent_id = p.id AND p.del_sign = 0
-- LEFT JOIN sys_user u ON d.leader_id = u.id AND u.del_sign = 0
WHERE d.del_sign = 0
AND d.parent_id = #{parentId} -- 按父部门ID筛选
ORDER BY d.id ASC
</select>
<!-- 3. 查询顶级部门（parent_id IS NULL） -->
<select id="selectTopDept" resultMap="DeptResultMap">
SELECT
d.id, d.dept_name, d.dept_code, d.parent_id, d.leader_id,
d.create_id, d.create_time, d.update_id, d.update_time, d.del_sign, d.remark
-- p.dept_name AS parent_dept_name,
-- u.user_name AS leader_name
FROM sys_department d
-- LEFT JOIN sys_department p ON d.parent_id = p.id AND p.del_sign = 0
-- LEFT JOIN sys_user u ON d.leader_id = u.id AND u.del_sign = 0
WHERE d.del_sign = 0
AND d.parent_id IS NULL -- 顶级部门（无父部门）
ORDER BY d.id ASC
</select>
</mapper>

82
rc_autoplc_backend/rczn-admin/src/main/resources/mapper/PositionMapper.xml Normal file
View File

@@ -0,0 +1,82 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.rczn.system.mapper.PositionMapper">
<sql id="baseColumn">
id, create_id, create_time, update_id, update_time, del_sign, remark
</sql>
<sql id="posiColumn">
posi_name, posi_code
</sql>
<insert id="insert" useGeneratedKeys="true" keyProperty="id">
INSERT INTO sys_position (
<include refid="posiColumn"/>, create_time, update_time, del_sign
) VALUES (
#{posiName}, #{posiCode}, NOW(), NOW(), 0
)
</insert>
<update id="deleteById">
UPDATE sys_position
SET del_sign = 1, update_time = NOW()
WHERE id = #{id} AND del_sign = 0
</update>
<update id="updateById">
UPDATE sys_position
<set>
<if test="posiName != null and posiName != ''">posi_name = #{posiName},</if>
<if test="posiCode != null and posiCode != ''">posi_code = #{posiCode},</if>
<if test="updateId != null">update_id = #{updateId},</if>
<if test="remark != null">remark = #{remark},</if>
update_time = NOW()
</set>
WHERE id = #{id} AND del_sign = 0
</update>
<select id="selectById" resultType="com.rczn.system.domain.Position">
SELECT
<include refid="baseColumn"/>, <include refid="posiColumn"/>
FROM sys_position
WHERE id = #{id} AND del_sign = 0
</select>
<select id="selectPage" resultType="com.rczn.system.domain.Position">
SELECT
<include refid="baseColumn"/>, <include refid="posiColumn"/>
FROM sys_position
WHERE del_sign = 0
<if test="posiName != null and posiName != ''">
AND posi_name LIKE CONCAT('%', #{posiName}, '%')
</if>
<if test="posiCode != null and posiCode != ''">
AND posi_code LIKE CONCAT('%', #{posiCode}, '%')
</if>
ORDER BY id DESC
</select>
<select id="selectTotal" resultType="java.lang.Integer">
SELECT COUNT(id)
FROM sys_position
WHERE del_sign = 0
<if test="posiName != null and posiName != ''">
AND posi_name LIKE CONCAT('%', #{posiName}, '%')
</if>
<if test="posiCode != null and posiCode != ''">
AND posi_code LIKE CONCAT('%', #{posiCode}, '%')
</if>
</select>
<select id="selectList" resultType="com.rczn.system.domain.Position">
SELECT
<include refid="baseColumn"/>, <include refid="posiColumn"/>
FROM sys_position
WHERE del_sign = 0
<if test="posiName != null and posiName != ''">
AND posi_name LIKE CONCAT('%', #{posiName}, '%')
</if>
<if test="posiCode != null and posiCode != ''">
AND posi_code LIKE CONCAT('%', #{posiCode}, '%')
</if>
ORDER BY id DESC
</select>
</mapper>

107
rc_autoplc_backend/rczn-admin/src/main/resources/mapper/RoleMapper.xml Normal file
View File

@@ -0,0 +1,107 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.rczn.system.mapper.RoleMapper">
<!-- 通用结果集映射 -->
<resultMap id="RoleResultMap" type="com.rczn.system.domain.Role">
<id column="id" property="id"/>
<result column="role_name" property="roleName"/>
<result column="role_code" property="roleCode"/>
</resultMap>
<sql id="baseColumn">
id, create_id, create_time, update_id, update_time, del_sign, remark
</sql>
<!-- 1. 分页查询角色（支持多条件模糊查询） -->
<select id="selectRolePage" resultMap="RoleResultMap">
SELECT id, role_name, role_code
FROM sys_role
<where>
<if test="roleName != null and roleName != ''">
AND role_name LIKE CONCAT('%', #{roleName}, '%')
</if>
<if test="roleCode != null and roleCode != ''">
AND role_code LIKE CONCAT('%', #{roleCode}, '%')
</if>
</where>
ORDER BY id DESC
</select>
<!-- 2. 根据ID查询角色 -->
<select id="selectById" resultMap="RoleResultMap">
SELECT <include refid="baseColumn"></include>, role_name, role_code
FROM sys_role
WHERE id = #{id}
</select>
<!-- 3. 新增角色 -->
<insert id="insert" useGeneratedKeys="true" keyProperty="id">
INSERT INTO sys_role (
<trim suffixOverrides=",">
<if test="roleName != null ">role_name,</if>
<if test="roleCode != null ">role_code,</if>
<if test="createId != null ">create_id,</if>
<if test="createTime != null ">create_time,</if>
<if test="updateId != null ">update_id,</if>
<if test="updateTime != null ">update_time,</if>
<if test="delSign != null ">del_sign,</if>
<if test="remark != null ">remark,</if>
</trim>
)
VALUES (
<trim suffixOverrides=",">
<if test="roleName != null ">#{roleName},</if>
<if test="roleCode != null ">#{roleCode},</if>
<if test="createId != null ">#{createId},</if>
<if test="createTime != null ">#{createTime},</if>
<if test="updateId != null ">#{updateId},</if>
<if test="updateTime != null ">#{updateTime},</if>
<if test="delSign != null ">#{delSign},</if>
<if test="remark != null ">#{remark},</if>
</trim>
)
</insert>
<!-- 4. 修改角色（仅更新非空字段） -->
<update id="update">
UPDATE sys_role
<set>
<if test="roleName != null ">role_name = #{roleName},</if>
<if test="roleCode != null ">role_code = #{roleCode},</if>
<if test="updateId != null ">update_id = #{updateId},</if>
<if test="updateTime != null ">update_time = now(),</if>
<if test="remark != null ">remark = #{remark},</if>
</set>
WHERE id = #{id}
</update>
<!-- 5. 根据ID删除角色 -->
<delete id="deleteById">
DELETE FROM sys_role WHERE id = #{id}
</delete>
<!-- 6. 查询总条数（支持多条件模糊查询） -->
<select id="selectTotal" resultType="java.lang.Long">
SELECT COUNT(*) FROM sys_role
<where>
<if test="roleName != null and roleName != ''">
AND role_name LIKE CONCAT('%', #{roleName}, '%')
</if>
<if test="roleCode != null and roleCode != ''">
AND role_code LIKE CONCAT('%', #{roleCode}, '%')
</if>
</where>
</select>
<!-- 7. 校验角色编码唯一性 -->
<select id="checkRoleCodeUnique" resultType="java.lang.Integer">
SELECT COUNT(*) FROM sys_role
WHERE role_code = #{roleCode}
<if test="id != null">
AND id != #{id} <!-- 修改时排除自身ID -->
</if>
</select>
</mapper>

45
rc_autoplc_backend/rczn-admin/src/main/resources/mapper/RolePermissionMapper.xml Normal file
View File

@@ -0,0 +1,45 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.rczn.system.mapper.RolePermissionMapper">
<resultMap id="RolePermissionResultMap" type="com.rczn.system.domain.RolePermission">
<id column="id" property="id"/>
<result column="role_id" property="roleId"/>
<result column="permission_id" property="permissionId"/>
</resultMap>
<sql id="baseColumn">
id, role_id, permission_id
</sql>
<select id="selectListByRoleId" resultMap="RolePermissionResultMap">
SELECT <include refid="baseColumn"/>
FROM sys_role_permission
WHERE role_id = #{roleId}
</select>
<insert id="insert">
INSERT INTO sys_role_permission (role_id, permission_id)
VALUES (#{roleId}, #{permissionId})
</insert>
<delete id="delete">
DELETE FROM sys_role_permission
<where>
<if test="roleId != null">
role_id = #{roleId}
</if>
<if test="permissionId != null">
AND permission_id = #{permissionId}
</if>
</where>
</delete>
<delete id="deleteByRoleId">
DELETE FROM sys_role_permission
WHERE role_id = #{roleId}
</delete>
</mapper>

74
rc_autoplc_backend/rczn-admin/src/main/resources/mapper/SysDicDataMapper.xml Normal file
View File

@@ -0,0 +1,74 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.rczn.system.mapper.SysDicDataMapper">
<sql id="baseColumn">
id, create_by, create_time, update_by, update_time, del_sign, remark
</sql>
<sql id="dicDataColumn">
dic_id, dic_label, dic_value
</sql>
<!-- 新增字典数据 -->
<insert id="insert" useGeneratedKeys="true" keyProperty="id">
INSERT INTO sys_dic_data (
<include refid="dicDataColumn"/>,
create_by, create_time, update_by, update_time, del_sign
) VALUES (
#{dicId}, #{dicLabel}, #{dicValue},
#{createId}, NOW(), #{updateId}, NOW(), 0
)
</insert>
<!-- 修改字典数据 -->
<update id="update">
UPDATE sys_dic_data
<set>
<if test="dicId != null">dic_id = #{dicId},</if>
<if test="dicLabel != null and dicLabel != ''">dic_label = #{dicLabel},</if>
<if test="dicValue != null and dicValue != ''">dic_value = #{dicValue},</if>
<if test="updateId != null">update_by = #{updateId},</if>
update_time = NOW()
</set>
WHERE id = #{id} AND del_sign = 0
</update>
<!-- 逻辑删除字典数据 -->
<update id="deleteById">
UPDATE sys_dic_data
SET del_sign = 1, update_time = NOW()
WHERE id = #{id} AND del_sign = 0
</update>
<!-- 根据ID查询字典数据 -->
<select id="selectById" resultType="com.rczn.system.domain.SysDicData">
SELECT
<include refid="baseColumn"/>,
<include refid="dicDataColumn"/>
FROM sys_dic_data
WHERE id = #{id} AND del_sign = 0
</select>
<!-- 分页查询字典数据（支持按字典类型ID、标签、值查询） -->
<select id="selectPage" resultType="com.rczn.system.domain.SysDicData">
SELECT
<include refid="baseColumn"/>,
<include refid="dicDataColumn"/>
FROM sys_dic_data
WHERE del_sign = 0
<if test="dicId != null">AND dic_id = #{dicId}</if>
<if test="dicLabel != null and dicLabel != ''">AND dic_label LIKE CONCAT('%', #{dicLabel}, '%')</if>
<if test="dicValue != null and dicValue != ''">AND dic_value LIKE CONCAT('%', #{dicValue}, '%')</if>
ORDER BY create_time DESC
</select>
<!-- 根据字典类型ID查询字典数据列表 -->
<select id="selectByDicId" resultType="com.rczn.system.domain.SysDicData">
SELECT
<include refid="baseColumn"/>,
<include refid="dicDataColumn"/>
FROM sys_dic_data
WHERE dic_id = #{dicId} AND del_sign = 0
ORDER BY create_time DESC
</select>
</mapper>

62
rc_autoplc_backend/rczn-admin/src/main/resources/mapper/SysDicTypeMapper.xml Normal file
View File

@@ -0,0 +1,62 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.rczn.system.mapper.SysDicTypeMapper">
<sql id="baseColumn">
id, create_by, create_time, update_by, update_time, del_sign, remark
</sql>
<sql id="dicTypeColumn">
dic_name, dic_code
</sql>
<!-- 新增字典类型 -->
<insert id="insert" useGeneratedKeys="true" keyProperty="id">
INSERT INTO sys_dic_type (
<include refid="dicTypeColumn"/>,
create_by, create_time, update_by, update_time, del_sign
) VALUES (
#{dicName}, #{dicCode},
#{createId}, NOW(), #{updateId}, NOW(), 0
)
</insert>
<!-- 修改字典类型 -->
<update id="update">
UPDATE sys_dic_type
<set>
<if test="dicName != null and dicName != ''">dic_name = #{dicName},</if>
<if test="dicCode != null and dicCode != ''">dic_code = #{dicCode},</if>
<if test="updateId != null">update_by = #{updateId},</if>
update_time = NOW()
</set>
WHERE id = #{id} AND del_sign = 0
</update>
<!-- 逻辑删除字典类型 -->
<update id="deleteById">
UPDATE sys_dic_type
SET del_sign = 1, update_time = NOW()
WHERE id = #{id} AND del_sign = 0
</update>
<!-- 根据ID查询字典类型 -->
<select id="selectById" resultType="com.rczn.system.domain.SysDicType">
SELECT
<include refid="baseColumn"/>,
<include refid="dicTypeColumn"/>
FROM sys_dic_type
WHERE id = #{id} AND del_sign = 0
</select>
<!-- 分页查询字典类型 -->
<select id="selectPage" resultType="com.rczn.system.domain.SysDicType">
SELECT
<include refid="baseColumn"/>,
<include refid="dicTypeColumn"/>
FROM sys_dic_type
WHERE del_sign = 0
<if test="dicName != null and dicName != ''">AND dic_name LIKE CONCAT('%', #{dicName}, '%')</if>
<if test="dicCode != null and dicCode != ''">AND dic_code LIKE CONCAT('%', #{dicCode}, '%')</if>
ORDER BY create_time DESC
</select>
</mapper>

72
rc_autoplc_backend/rczn-admin/src/main/resources/mapper/SysPermissionMapper.xml Normal file
View File

@@ -0,0 +1,72 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.rczn.system.mapper.SysPermissionMapper">
<resultMap id="PermissionResultMap" type="com.rczn.system.domain.Permission">
<id column="id" property="id"/>
<result column="parent_id" property="parentId"/>
<result column="permission_name" property="permissionName"/>
<result column="permission_code" property="permissionCode"/>
<result column="create_id" property="createId"/>
<result column="create_time" property="createTime"/>
<result column="update_id" property="updateId"/>
<result column="update_time" property="updateTime"/>
<result column="del_sign" property="delSign"/>
<result column="remark" property="remark"/>
</resultMap>
<!-- 查询所有 -->
<select id="selectPermissionList" resultMap="PermissionResultMap">
SELECT * FROM sys_permission
WHERE del_sign = 0
</select>
<!-- 根据ID查询 -->
<select id="selectPermissionById" resultMap="PermissionResultMap">
SELECT * FROM sys_permission
WHERE id = #{id} AND del_sign = 0
</select>
<!-- 查询总数量 -->
<select id="selectTotal" resultType="java.lang.Long">
SELECT COUNT(*) FROM sys_permission
WHERE del_sign = 0
<if test="parentId != null "> and parent_id = #{parentId}</if>
<if test="permissionName != null and permissionName != ''"> AND permission_name LIKE CONCAT('%', #{permissionName}, '%')</if>
</select>
<!-- 根据条件分页查询权限数据： -->
<select id="selectPermissionPage" resultType="com.rczn.system.domain.Permission">
SELECT * FROM sys_permission
WHERE del_sign = 0
<if test="parentId != null "> and parent_id = #{parentId}</if>
<if test="permissionName != null and permissionName != ''"> AND permission_name LIKE CONCAT('%', #{permissionName}, '%')</if>
</select>
<!-- 新增 -->
<insert id="insertPermission">
INSERT INTO sys_permission
(parent_id, permission_name, permission_code, create_id, remark, del_sign)
VALUES
(#{parentId}, #{permissionName}, #{permissionCode}, #{createId}, #{remark}, 0)
</insert>
<!-- 修改 -->
<update id="updatePermission">
UPDATE sys_permission
SET
parent_id = #{parentId},
permission_name = #{permissionName},
permission_code = #{permissionCode},
update_id = #{updateId},
remark = #{remark}
WHERE id = #{id}
</update>
<!-- 逻辑删除 -->
<update id="deletePermissionById">
UPDATE sys_permission SET del_sign = 1 WHERE id = #{id}
</update>
</mapper>

221
rc_autoplc_backend/rczn-admin/src/main/resources/mapper/UserMapper.xml Normal file
View File

@@ -0,0 +1,221 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 对应 Mapper 接口全路径 -->
<mapper namespace="com.rczn.system.mapper.UserMapper">
<!-- 通用结果集映射（复用，避免重复编写） -->
<resultMap id="UserResultMap" type="com.rczn.system.domain.User">
<id column="id" property="id"/>
<result column="create_id" property="createId"/>
<result column="create_time" property="createTime"/>
<result column="update_id" property="updateId"/>
<result column="update_time" property="updateTime"/>
<result column="del_sign" property="delSign"/>
<result column="remark" property="remark"/>
<result column="user_name" property="userName"/>
<result column="password" property="password"/>
<result column="salt" property="salt"/>
<result column="nicke" property="nicke"/>
<result column="sex" property="sex"/>
<result column="email_addr" property="emailAddr"/>
<result column="address" property="address"/>
<result column="telephone" property="telephone"/>
<result column="dep_id" property="depId"/>
<result column="pos_id" property="posId"/>
</resultMap>
<!-- 公共字段（BaseBean 继承的字段） -->
<sql id="baseColumn">
id, create_id, create_time, update_id, update_time, del_sign, remark
</sql>
<!-- 用户专属字段 -->
<sql id="userColumn">
user_name, password, salt, nicke, sex, email_addr, address, telephone, dep_id, pos_id
</sql>
<!-- 1. 分页查询用户（所有传参为空时忽略该条件） -->
<select id="selectUserPage" resultMap="UserResultMap" parameterType="com.rczn.system.domain.User">
SELECT
<include refid="baseColumn"/>,
<include refid="userColumn"/>
FROM sys_user
<where>
<!-- 逻辑删除标识：默认查未删除（del_sign=0），传参不为空时按传参筛选 -->
<if test="delSign == null">
AND del_sign = 0
</if>
<if test="delSign != null">
AND del_sign = #{delSign}
</if>
<!-- 用户名：为空时忽略模糊查询 -->
<if test="userName != null and userName != ''">
AND user_name LIKE CONCAT('%', #{userName}, '%')
</if>
<!-- 部门ID：为空时忽略 -->
<if test="depId != null">
AND dep_id = #{depId}
</if>
<!-- 职位ID：为空时忽略 -->
<if test="posId != null">
AND pos_id = #{posId}
</if>
<!-- 创建人ID：为空时忽略 -->
<if test="createId != null">
AND create_id = #{createId}
</if>
<!-- 性别：为空时忽略 -->
<if test="sex != null">
AND sex = #{sex}
</if>
</where>
ORDER BY id DESC
</select>
<!-- 2. 根据ID查询用户（支持查询已删除数据，传参为空时返回null） -->
<select id="selectById" resultMap="UserResultMap">
SELECT
<include refid="baseColumn"/>,
<include refid="userColumn"/>
FROM sys_user
WHERE id = #{id}
<!-- 可选：添加删除标识筛选（为空时查所有状态，不为空时按状态筛选） -->
<if test="delSign != null">
AND del_sign = #{delSign}
</if>
</select>
<!-- 3. 新增用户（传参为空时用默认值，非空时用传参值） -->
<insert id="insert" useGeneratedKeys="true" keyProperty="id">
INSERT INTO sys_user (
<trim suffixOverrides=",">
<if test="userName != null and userName != ''"> user_name,</if>
<if test="password != null and password != ''"> password,</if>
<if test="salt != null and salt != ''"> salt,</if>
<if test="nicke != null and nicke != ''"> nicke,</if>
<if test="sex != null"> sex,</if>
<if test="emailAddr != null and emailAddr != ''"> email_addr,</if>
<if test="address != null and address != ''"> address,</if>
<if test="telephone != null and telephone != ''"> telephone,</if>
<if test="depId != null"> dep_id,</if>
<if test="posId != null"> pos_id,</if>
<!-- 公共字段：为空时用默认值，非空时用传参 -->
<if test="createId != null"> create_id,</if>
<if test="createTime != null"> create_time,</if>
<if test="updateId != null"> update_id,</if>
<if test="updateTime != null"> update_time,</if>
<!-- 方案1：delSign 为空时设为 0 -->
<if test="delSign != null"> del_sign,</if>
<if test="remark != null and remark != ''"> remark,</if>
</trim>
) VALUES (
<trim suffixOverrides=",">
<if test="userName != null and userName != ''"> #{userName},</if>
<if test="password != null and password != ''"> #{password},</if>
<if test="salt != null and salt != ''"> #{salt},</if>
<if test="nicke != null and nicke != ''"> #{nicke},</if>
<if test="sex != null"> #{sex},</if>
<if test="emailAddr != null and emailAddr != ''"> #{emailAddr},</if>
<if test="address != null and address != ''"> #{address},</if>
<if test="telephone != null and telephone != ''"> #{telephone},</if>
<if test="depId != null"> #{depId},</if>
<if test="posId != null"> #{posId},</if>
<!-- 公共字段：为空时用默认值，非空时用传参 -->
<if test="createId != null"> #{createId},</if>
<if test="createTime != null"> #{createTime},</if>
<if test="updateId != null"> #{updateId},</if>
<if test="updateTime != null"> #{updateTime},</if>
<!-- 方案1：delSign 为空时设为 0 -->
<if test="delSign != null"> #{delSign},</if>
<if test="remark != null and remark != ''"> #{remark},</if>
</trim>
)
</insert>
<!-- 4. 修改用户（仅更新非空字段，空字段不更新） -->
<update id="update">
UPDATE sys_user
<set>
<!-- 用户专属字段：非空才更新 -->
<if test="userName != null and userName != ''">user_name = #{userName},</if>
<if test="password != null and password != ''">password = #{password},</if>
<if test="salt != null and salt != ''">salt = #{salt},</if>
<if test="nicke != null and nicke != ''">nicke = #{nicke},</if>
<if test="sex != null">sex = #{sex},</if>
<if test="emailAddr != null and emailAddr != ''">email_addr = #{emailAddr},</if>
<if test="address != null and address != ''">address = #{address},</if>
<if test="telephone != null and telephone != ''">telephone = #{telephone},</if>
<if test="depId != null">dep_id = #{depId},</if>
<if test="posId != null">pos_id = #{posId},</if>
<!-- 公共字段：非空才更新 -->
<if test="updateId != null">update_id = #{updateId},</if>
<if test="remark != null and remark != ''">remark = #{remark},</if>
<if test="delSign != null">del_sign = #{delSign},</if>
<!-- 更新时间：强制更新为当前时间（无论是否传参） -->
update_time = NOW()
</set>
WHERE id = #{id}
</update>
<!-- 5. 根据ID删除用户（逻辑删除，替代物理删除，传参为空时不执行） -->
<delete id="deleteById">
UPDATE sys_user
SET
del_sign = 1,
update_time = NOW()
<if test="updateId != null">, update_id = #{updateId}</if>
WHERE id = #{id}
AND del_sign = 0 <!-- 避免重复删除 -->
</delete>
<!-- 6. 查询总条数（与分页查询条件一致，传参为空时忽略） -->
<select id="selectTotal" resultType="java.lang.Long">
SELECT COUNT(*)
FROM sys_user
<where>
<if test="delSign == null">
AND del_sign = 0
</if>
<if test="delSign != null">
AND del_sign = #{delSign}
</if>
<if test="userName != null and userName != ''">
AND user_name LIKE CONCAT('%', #{userName}, '%')
</if>
<if test="depId != null">
AND dep_id = #{depId}
</if>
<if test="posId != null">
AND pos_id = #{posId}
</if>
<if test="createId != null">
AND create_id = #{createId}
</if>
<if test="sex != null">
AND sex = #{sex}
</if>
</where>
</select>
<select id="findUserPermissions" resultType="com.rczn.system.domain.Permission">
SELECT
p.*
FROM
sys_user u
JOIN
sys_user_role ur ON u.id = ur.user_id
JOIN
sys_role r ON ur.role_id = r.id
JOIN
sys_role_permission rp ON r.id = rp.role_id
JOIN
sys_permission p ON rp.permission_id = p.id
WHERE
u.id = #{userId}
AND u.del_sign = 0
AND r.del_sign = 0
AND p.del_sign = 0;
</select>
</mapper>

69
rc_autoplc_backend/rczn-admin/src/main/resources/mapper/UserRoleMapper.xml Normal file
View File

@@ -0,0 +1,69 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.rczn.system.mapper.UserRoleMapper">
<sql id="baseColumn">
id, create_id, create_time, update_id, update_time, del_sign, remark
</sql>
<sql id="userRoleColumn">
user_id, role_id
</sql>
<insert id="insert" useGeneratedKeys="true" keyProperty="id">
INSERT INTO sys_user_role (
<include refid="userRoleColumn"/>,remark, create_time, del_sign
) VALUES (
#{userId}, #{roleId}, #{remark},NOW(), 0
)
</insert>
<delete id="deleteById">
DELETE FROM sys_user_role WHERE id = #{id}
</delete>
<delete id="deleteByUserId">
DELETE FROM sys_user_role WHERE user_id = #{userId}
</delete>
<delete id="deleteByRoleId">
DELETE FROM sys_user_role WHERE role_id = #{roleId}
</delete>
<select id="selectById" resultType="com.rczn.system.domain.UserRole">
SELECT
<include refid="baseColumn"/>, <include refid="userRoleColumn"/>
FROM sys_user_role
WHERE id = #{id}
</select>
<select id="selectByUserId" resultType="com.rczn.system.domain.UserRole">
SELECT
<include refid="baseColumn"/>, <include refid="userRoleColumn"/>
FROM sys_user_role
WHERE user_id = #{userId}
</select>
<select id="selectByRoleId" resultType="com.rczn.system.domain.UserRole">
SELECT
<include refid="baseColumn"/>, <include refid="userRoleColumn"/>
FROM sys_user_role
WHERE role_id = #{roleId}
</select>
<select id="selectPage" resultType="com.rczn.system.domain.UserRole">
SELECT
<include refid="baseColumn"/>, <include refid="userRoleColumn"/>
FROM sys_user_role
WHERE 1=1
<if test="userId != null">AND user_id = #{userId}</if>
<if test="roleId != null">AND role_id = #{roleId}</if>
ORDER BY id DESC
</select>
<select id="selectTotal" resultType="java.lang.Integer">
SELECT COUNT(id)
FROM sys_user_role
WHERE 1=1
<if test="userId != null">AND user_id = #{userId}</if>
<if test="roleId != null">AND role_id = #{roleId}</if>
</select>
</mapper>

13
rc_autoplc_backend/rczn-admin/src/test/java/com/rczn/RcznAdminApplicationTests.java Normal file
View File

@@ -0,0 +1,13 @@
package com.rczn;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class RcznAdminApplicationTests {
// @Test
void contextLoads() {
}
}