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

动作参数取值范围+角色配置权限

Browse Source
This commit is contained in:
李向青
2026-04-30 15:16:48 +08:00
parent 0bc6dd7761
commit 05770f7e56
177 changed files with 13913 additions and 9863 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
rc_autoplc_backend/rczn-admin/pom.xml
View File

@@ -67,12 +67,6 @@
<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>
@@ -85,7 +79,10 @@
<groupId>com.auth0</groupId>
<artifactId>java-jwt</artifactId>
</dependency>
<dependency>
<groupId>com.github.xiaoymin</groupId>
<artifactId>knife4j-openapi3-jakarta-spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper-spring-boot-starter</artifactId>
@@ -95,12 +92,6 @@
<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>

2
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/RcznAdminApplication.java
View File

@@ -3,11 +3,9 @@ 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) {

25
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/config/CorsConfig.java
View File

@@ -1,10 +1,6 @@
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;
@@ -21,25 +17,4 @@ public class CorsConfig implements WebMvcConfigurer {
.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
View File

@@ -1,38 +0,0 @@
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
View File

@@ -1,55 +0,0 @@
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/");
}
}

115
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/controller/ManageLogController.java Normal file
View File

@@ -0,0 +1,115 @@
package com.rczn.controller;
import com.rczn.domain.PageBean;
import com.rczn.domain.Result;
import com.rczn.system.domain.ManageLog;
import com.rczn.system.service.ManageLogService;
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.time.LocalDateTime;
@RestController
@RequestMapping("/manage-log")
@Tag(name = "操作日志管理", description = "操作日志增删改查+分页查询接口")
public class ManageLogController {
@Autowired
private ManageLogService manageLogService;
/**
* 分页查询日志
*/
@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 = "logName", description = "日志名称（可选，模糊查询）", required = false, example = "登录操作", in = ParameterIn.QUERY),
@Parameter(name = "logType", description = "日志类型（可选，精准查询）", required = false, example = "LOGIN", in = ParameterIn.QUERY),
@Parameter(name = "createId", description = "创建人ID（可选）", required = false, example = "1", in = ParameterIn.QUERY),
@Parameter(name = "logWritetimeStart", description = "日志开始时间（可选，格式：yyyy-MM-dd HH:mm:ss）", required = false, example = "2025-01-01 00:00:00", in = ParameterIn.QUERY),
@Parameter(name = "logWritetimeEnd", description = "日志结束时间（可选，格式：yyyy-MM-dd HH:mm:ss）", required = false, example = "2025-12-31 23:59:59", in = ParameterIn.QUERY)
})
public Result<PageBean<ManageLog>> getLogPage(
@RequestParam Integer pageNum,
@RequestParam Integer pageSize,
@RequestParam(required = false) String logName,
@RequestParam(required = false) String logType,
@RequestParam(required = false) Long createId,
@RequestParam(required = false) LocalDateTime logWritetimeStart,
@RequestParam(required = false) LocalDateTime logWritetimeEnd) {
// 构建查询条件（空字段自动忽略）
ManageLog query = new ManageLog();
query.setLogName(logName);
query.setLogType(logType);
query.setCreateId(createId);
// 扩展字段：用于时间范围查询（实体类无需新增字段，MyBatis 支持直接取参）
query.setStartTime(logWritetimeStart); // 实际用 logWritetimeStart，这里仅为传递参数
query.setEndTime(logWritetimeEnd);
PageBean<ManageLog> pageBean = manageLogService.selectPage(pageNum, pageSize, query);
return Result.success(pageBean);
}
/**
* 按 ID 查询日志
*/
@GetMapping(value = "/getById/{id}", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "查询单个操作日志", description = "按日志ID查询详情")
public Result getLogById(@PathVariable Long id) {
ManageLog log = manageLogService.selectById(id);
return log != null ? Result.success(log) : Result.error("日志不存在或已删除");
}
/**
* 新增操作日志
*/
@PostMapping(value = "/add", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "新增操作日志", description = "日志名称、类型为必填项，其他字段可选")
public Result addLog(@RequestBody ManageLog manageLog) {
try {
Long logId = manageLogService.insert(manageLog);
return Result.success("日志新增成功");
} catch (IllegalArgumentException e) {
return Result.error(e.getMessage());
}
}
/**
* 更新操作日志
*/
@PutMapping(value = "/update", produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "更新操作日志", description = "需传入日志ID，其他字段非空则更新")
public Result updateLog(@RequestBody ManageLog manageLog) {
try {
Boolean success = manageLogService.update(manageLog);
return success ? Result.success( "日志更新成功") : 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 deleteLog(
@PathVariable Long id,
@RequestParam(required = false) Long updateId) {
try {
Boolean success = manageLogService.deleteById(id, updateId);
return success ? Result.success("日志删除成功") : Result.error("删除失败（日志不存在或已删除）");
} catch (IllegalArgumentException e) {
return Result.error(e.getMessage());
}
}
}

9
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/controller/RoleController.java
View File

@@ -9,7 +9,6 @@ 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;
@@ -22,8 +21,12 @@ import java.util.List;
@Tag(name = "角色管理", description = "角色增删改查接口（支持分页+多条件查询+编码唯一性校验）")
public class RoleController {
@Autowired
RoleService roleService;
private final RoleService roleService;
// 构造器注入
public RoleController(RoleService roleService) {
this.roleService = roleService;
}
/**
* 1. 分页查询角色（多条件模糊查询）

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

@@ -1,65 +0,0 @@
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
View File

@@ -1,109 +0,0 @@
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
View File

@@ -1,95 +0,0 @@
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
View File

@@ -1,128 +0,0 @@
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("删除失败（权限不存在）");
}
}

119
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/controller/UserController.java
View File

@@ -1,33 +1,18 @@
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 实现）
@@ -132,108 +117,4 @@ public class UserController {
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("密码错误！");
}
}
}
}

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

@@ -0,0 +1,65 @@
package com.rczn.system.domain;
import com.rczn.domain.BaseBean;
import java.time.LocalDateTime;
public class ManageLog extends BaseBean {
private String logName;
private String logType;
private LocalDateTime logWritetime;
private String logContent;
public ManageLog() {
}
public ManageLog(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 "ManageLog{" +
"logName='" + logName + '\'' +
", logType='" + logType + '\'' +
", logWritetime=" + logWritetime +
", logContent='" + logContent + '\'' +
'}';
}
public String getLogName() {
return logName;
}
public void setLogName(String logName) {
this.logName = logName;
}
public String getLogType() {
return logType;
}
public void setLogType(String logType) {
this.logType = logType;
}
public LocalDateTime getLogWritetime() {
return logWritetime;
}
public void setLogWritetime(LocalDateTime logWritetime) {
this.logWritetime = logWritetime;
}
public String getLogContent() {
return logContent;
}
public void setLogContent(String logContent) {
this.logContent = logContent;
}
}

35
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/domain/Permission.java
View File

@@ -1,31 +1,16 @@
package com.rczn.system.domain;
import com.rczn.domain.BaseBean;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import java.util.List;
public class Permission extends BaseBean{
private Integer parentId;
@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class Permission extends BaseBean {
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;
}
}
private String permissionCode;}

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

@@ -1,52 +0,0 @@
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
View File

@@ -1,41 +0,0 @@
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;
}
}

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

@@ -1,34 +0,0 @@
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;
}
}

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

@@ -0,0 +1,26 @@
package com.rczn.system.mapper;
import com.rczn.system.domain.ManageLog;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
@Mapper // 标记为 MyBatis Mapper 接口，确保被 Spring 扫描
public interface ManageLogMapper {
// 新增日志（支持空字段，空字段用数据库默认值）
int insert(ManageLog manageLog);
// 逻辑删除日志（按 ID，设置 delSign=1）
int deleteById(Long id);
// 更新日志（仅更新非空字段，空字段不更新）
int update(ManageLog manageLog);
// 按 ID 查询日志（仅查未删除数据）
ManageLog selectById(Long id);
// 分页查询日志（支持按字段筛选，空字段忽略条件）
List<ManageLog> selectPage(ManageLog manageLog);
// 查询分页总数（与分页查询条件一致）
Long selectTotal(ManageLog manageLog);
}

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

@@ -1,18 +0,0 @@
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
View File

@@ -1,39 +0,0 @@
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
View File

@@ -1,34 +0,0 @@
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
View File

@@ -1,52 +0,0 @@
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);
}

9
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/mapper/UserMapper.java
View File

@@ -1,11 +1,8 @@
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
@@ -34,10 +31,4 @@ public interface UserMapper {
@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);
}

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

@@ -0,0 +1,21 @@
package com.rczn.system.service;
import com.rczn.domain.PageBean;
import com.rczn.system.domain.ManageLog;
public interface ManageLogService {
// 新增日志
Long insert(ManageLog manageLog);
// 逻辑删除日志
Boolean deleteById(Long id, Long updateId);
// 更新日志（仅更新非空字段）
Boolean update(ManageLog manageLog);
// 按 ID 查询日志
ManageLog selectById(Long id);
// 分页查询日志（支持多条件筛选）
PageBean<ManageLog> selectPage(Integer pageNum, Integer pageSize, ManageLog manageLog);
}

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

@@ -1,15 +0,0 @@
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);
}

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

@@ -1,44 +0,0 @@
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
View File

@@ -1,40 +0,0 @@
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
View File

@@ -1,26 +0,0 @@
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);
}

7
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/service/UserRoleService.java
View File

@@ -11,13 +11,6 @@ public interface UserRoleService {
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);
}

22
rc_autoplc_backend/rczn-admin/src/main/java/com/rczn/system/service/UserService.java
View File

@@ -1,7 +1,6 @@
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;
@@ -54,25 +53,4 @@ public interface UserService {
* @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);
}

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

@@ -0,0 +1,86 @@
package com.rczn.system.service.impl;
import com.github.pagehelper.Page;
import com.rczn.domain.PageBean;
import com.rczn.system.domain.ManageLog;
import com.github.pagehelper.PageHelper;
import com.rczn.system.domain.Position;
import com.rczn.system.mapper.ManageLogMapper;
import com.rczn.system.service.ManageLogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.Assert;
import java.time.LocalDateTime;
import java.util.List;
@Service
public class ManageLogServiceImpl implements ManageLogService {
@Autowired
private ManageLogMapper manageLogMapper;
@Override
public Long insert(ManageLog manageLog) {
// 校验必填字段（日志名称和类型为必填）
Assert.notNull(manageLog.getLogName(), "日志名称不能为空");
Assert.notNull(manageLog.getLogType(), "日志类型不能为空");
//补充日志时间
if (manageLog.getLogWritetime() == null) {
manageLog.setLogWritetime(LocalDateTime.now());
}
// TODO 补充日志创建人信息
// manageLog.setCreateId(null);
manageLog.setCreateTime(LocalDateTime.now());
int rows = manageLogMapper.insert(manageLog);
return rows > 0 ? manageLog.getId() : null;
}
@Override
public Boolean deleteById(Long id, Long updateId) {
Assert.notNull(id, "日志ID不能为空");
int rows = manageLogMapper.deleteById(id);
return rows > 0;
}
@Override
public Boolean update(ManageLog manageLog) {
Assert.notNull(manageLog.getId(), "日志ID不能为空");
//如果更新时间为空，则自动更新
if (manageLog.getUpdateTime() == null) {
manageLog.setUpdateTime(LocalDateTime.now());
}
// TODO 补充日志更新人信息
// manageLog.setUpdateId(null);
int rows = manageLogMapper.update(manageLog);
return rows > 0;
}
@Override
public ManageLog selectById(Long id) {
Assert.notNull(id, "日志ID不能为空");
return manageLogMapper.selectById(id);
}
@Override
public PageBean<ManageLog> selectPage(Integer pageNum, Integer pageSize, ManageLog manageLog) {
// 校验分页参数
Assert.notNull(pageNum, "页码不能为空");
Assert.notNull(pageSize, "每页条数不能为空");
Assert.isTrue(pageNum > 0, "页码必须大于0");
Assert.isTrue(pageSize > 0 && pageSize <= 100000, "每页条数必须在1-10000之间");
// PageHelper 分页（自动拦截查询，添加 LIMIT 条件）
PageHelper.startPage(pageNum, pageSize);
List<ManageLog> logList = manageLogMapper.selectPage(manageLog);
Page<ManageLog> page = (Page<ManageLog>) logList;
PageBean<ManageLog> pageBean = new PageBean<>();
pageBean.setTotal(page.getTotal());
pageBean.setItems(page.getResult());
// 封装PageBean返回
return pageBean;
}
}

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

@@ -1,42 +0,0 @@
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);
}
}

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

@@ -1,97 +0,0 @@
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
View File

@@ -1,84 +0,0 @@
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
View File

@@ -1,140 +0,0 @@
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;
}
}

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

@@ -3,7 +3,6 @@ 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;

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

@@ -3,7 +3,6 @@ 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;
@@ -91,41 +90,4 @@ public class UserServiceImpl implements UserService {
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);
}
}

75
rc_autoplc_backend/rczn-admin/src/main/resources/application.yml
View File

@@ -14,7 +14,7 @@ spring:
# 数据源配置（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
url: jdbc:mysql://47.116.126.33:3306/rc_autoplc_program?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true
username: nianke
password: Jy@.niankeCrm2025
# 解决跨域（可选，配合之前的CorsConfig）
@@ -42,12 +42,11 @@ spring:
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 # 补充：实体类别名包（可选）
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # 关键：SQL 打印到控制台
log-prefix: "[MyBatis] " # 可选：日志前缀，便于区分 SQL 日志
default-statement-timeout: 30 # 可选：SQL 执行超时时间（秒）
# HikariCP 连接池配置（关键）
hikari:
@@ -67,22 +66,22 @@ pagehelper:
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文档基础信息（中文正常显示）
# 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文档
@@ -97,40 +96,6 @@ openapi:
- 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. 全局日志级别（可细化到包/类）

175
rc_autoplc_backend/rczn-admin/src/main/resources/mapper/ManageLogMapper.xml Normal file
View File

@@ -0,0 +1,175 @@
<?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.ManageLogMapper">
<!-- 公共字段（BaseBean 继承的字段） -->
<sql id="baseColumn">
id, create_id, create_time, update_id, update_time, del_sign, remark
</sql>
<!-- ManageLog 专属字段 -->
<sql id="logColumn">
log_name, log_type, log_writetime, log_content
</sql>
<!-- 结果集映射（关联数据库列与实体类字段） -->
<resultMap id="LogResultMap" type="com.rczn.system.domain.ManageLog">
<!-- 公共字段映射 -->
<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="log_name" property="logName"/>
<result column="log_type" property="logType"/>
<result column="log_writetime" property="logWritetime"/>
<result column="log_content" property="logContent"/>
</resultMap>
<!-- 1. 新增日志（空字段忽略，用数据库默认值） -->
<insert id="insert" useGeneratedKeys="true" keyProperty="id">
INSERT INTO sys_manage_log (
<trim suffixOverrides=",">
<!-- 专属字段 -->
<if test="logName != null and logName != ''"> log_name,</if>
<if test="logType != null and logType != ''"> log_type,</if>
<if test="logWritetime != null"> log_writetime,</if>
<if test="logContent != null and logContent != ''"> log_content,</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 and remark != ''"> remark,</if>
</trim>
) VALUES (
<trim suffixOverrides=",">
<!-- 专属字段：空字段传递 null，数据库设默认值 -->
<if test="logName != null and logName != ''">#{logName},</if>
<if test="logType != null and logType != ''">#{logType},</if>
<if test="logWritetime != null">#{logWritetime},</if>
<if test="logContent != null and logContent != ''">#{logContent},</if>
<!-- 公共字段：空字段传递 null，数据库设默认值 -->
<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 and remark != ''">#{remark},</if>
</trim>
)
</insert>
<!-- 2. 更新日志（仅更新非空字段） -->
<update id="update">
UPDATE sys_manage_log
<set>
<!-- 专属字段：非空才更新 -->
<if test="logName != null and logName != ''">log_name = #{logName},</if>
<if test="logType != null and logType != ''">log_type = #{logType},</if>
<if test="logWritetime != null">log_writetime = #{logWritetime},</if>
<if test="logContent != null and logContent != ''">log_content = #{logContent},</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}
AND del_sign = 0 <!-- 仅更新未删除的数据 -->
</update>
<!-- 3. 逻辑删除日志 -->
<delete id="deleteById">
UPDATE sys_manage_log
SET
del_sign = 1,
update_time = NOW(),
<if test="updateId != null">update_id = #{updateId}</if>
WHERE id = #{id}
AND del_sign = 0 <!-- 避免重复删除 -->
</delete>
<!-- 4. 按 ID 查询日志 -->
<select id="selectById" resultMap="LogResultMap">
SELECT
<include refid="baseColumn"/>,
<include refid="logColumn"/>
FROM sys_manage_log
WHERE id = #{id}
AND del_sign = 0 <!-- 仅查未删除数据 -->
</select>
<!-- 5. 分页查询日志（空字段忽略条件） -->
<select id="selectPage" resultMap="LogResultMap" parameterType="com.rczn.system.domain.ManageLog">
SELECT
<include refid="baseColumn"/>,
<include refid="logColumn"/>
FROM sys_manage_log
<where>
<!-- 默认查未删除数据，传 delSign=1 可查已删除 -->
<if test="delSign == null">
AND del_sign = 0
</if>
<if test="delSign != null">
AND del_sign = #{delSign}
</if>
<!-- 日志名称：模糊查询，空字段忽略 -->
<if test="logName != null and logName != ''">
AND log_name LIKE CONCAT('%', #{logName}, '%')
</if>
<!-- 日志类型：精准查询，空字段忽略 -->
<if test="logType != null and logType != ''">
AND log_type = #{logType}
</if>
<!-- 日志写入时间：范围查询（可选，空字段忽略） -->
<if test="startTime != null">
AND log_writetime >= #{startTime}
</if>
<if test="endTime != null">
AND log_writetime &lt;= #{endTime}
</if>
<!-- 创建人ID：精准查询，空字段忽略 -->
<if test="createId != null">
AND create_id = #{createId}
</if>
</where>
ORDER BY log_writetime DESC <!-- 按日志写入时间倒序 -->
</select>
<!-- 6. 查询分页总数（与分页查询条件一致） -->
<select id="selectTotal" resultType="java.lang.Long" parameterType="com.rczn.system.domain.ManageLog">
SELECT COUNT(*)
FROM sys_manage_log
<where>
<if test="delSign == null">
AND del_sign = 0
</if>
<if test="delSign != null">
AND del_sign = #{delSign}
</if>
<if test="logName != null and logName != ''">
AND log_name LIKE CONCAT('%', #{logName}, '%')
</if>
<if test="logType != null and logType != ''">
AND log_type = #{logType}
</if>
<if test="logWritetimeStart != null">
AND log_writetime >= #{logWritetimeStart}
</if>
<if test="logWritetimeEnd != null">
AND log_writetime &lt;= #{logWritetimeEnd}
</if>
<if test="createId != null">
AND create_id = #{createId}
</if>
</where>
</select>
</mapper>

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

@@ -1,45 +0,0 @@
<?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
View File

@@ -1,74 +0,0 @@
<?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
View File

@@ -1,62 +0,0 @@
<?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
View File

@@ -1,72 +0,0 @@
<?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>

19
rc_autoplc_backend/rczn-admin/src/main/resources/mapper/UserMapper.xml
View File

@@ -198,24 +198,5 @@
</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>

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

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