备注:平均每人1500行代码

main
LYH 3 months ago
parent fbb211d57e
commit cb2319ead2

@ -0,0 +1,8 @@
# Default ignored files
/shelf/
/workspace.xml
# Datasource local storage ignored files
/dataSources/
/dataSources.local.xml
# Editor-based HTTP Client requests
/httpRequests/

@ -0,0 +1,20 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="CompilerConfiguration">
<annotationProcessing>
<profile name="Maven default annotation processors profile" enabled="true">
<sourceOutputDir name="target/generated-sources/annotations" />
<sourceTestOutputDir name="target/generated-test-sources/test-annotations" />
<outputRelativeToContentRoot value="true" />
<module name="WarehouseManagerApi" />
<module name="WarehouseManagerApi - idea" />
</profile>
</annotationProcessing>
</component>
<component name="JavacSettings">
<option name="ADDITIONAL_OPTIONS_OVERRIDE">
<module name="WarehouseManagerApi" options="-parameters" />
<module name="WarehouseManagerApi - idea" options="-parameters" />
</option>
</component>
</project>

@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="Encoding">
<file url="file://$PROJECT_DIR$/src/main/java" charset="UTF-8" />
</component>
</project>

@ -0,0 +1,30 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="RemoteRepositoriesConfiguration">
<remote-repository>
<option name="id" value="central" />
<option name="name" value="Central Repository" />
<option name="url" value="http://maven.aliyun.com/nexus/content/groups/public/" />
</remote-repository>
<remote-repository>
<option name="id" value="central" />
<option name="name" value="Central Repository" />
<option name="url" value="https://repo.maven.apache.org/maven2" />
</remote-repository>
<remote-repository>
<option name="id" value="central" />
<option name="name" value="Maven Central repository" />
<option name="url" value="https://repo1.maven.org/maven2" />
</remote-repository>
<remote-repository>
<option name="id" value="public" />
<option name="name" value="aliyun nexus" />
<option name="url" value="https://maven.aliyun.com/repository/public/" />
</remote-repository>
<remote-repository>
<option name="id" value="jboss.community" />
<option name="name" value="JBoss Community repository" />
<option name="url" value="https://repository.jboss.org/nexus/content/repositories/public/" />
</remote-repository>
</component>
</project>

@ -0,0 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ExternalStorageConfigurationManager" enabled="true" />
<component name="MavenProjectsManager">
<option name="originalFiles">
<list>
<option value="$PROJECT_DIR$/pom.xml" />
</list>
</option>
</component>
<component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="true" project-jdk-name="1.8" project-jdk-type="JavaSDK" />
</project>

@ -0,0 +1,10 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="RunConfigurationProducerService">
<option name="ignoredProducers">
<set>
<option value="com.android.tools.idea.compose.preview.runconfiguration.ComposePreviewRunConfigurationProducer" />
</set>
</option>
</component>
</project>

@ -0,0 +1,81 @@
<?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>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.7.5</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.rabbiter</groupId>
<artifactId>WarehouseManagerApi</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>WarehouseManagerApi</name>
<description>Warehouse management system</description>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.30</version>
<scope>runtime</scope>
</dependency>
<!--mybatisPlus-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.5.0</version>
</dependency>
<dependency>
<groupId>org.freemarker</groupId>
<artifactId>freemarker</artifactId>
<version>2.3.30</version>
</dependency>
<!--swagger-->
<dependency>
<groupId>com.spring4all</groupId>
<artifactId>spring-boot-starter-swagger</artifactId>
<version>1.5.1.RELEASE</version>
</dependency>
</dependencies>
<repositories>
<repository>
<id>public</id>
<name>aliyun nexus</name>
<url>https://maven.aliyun.com/repository/public/</url>
<releases>
<enabled>true</enabled>
</releases>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<id>public</id>
<name>aliyun nexus</name>
<url>https://maven.aliyun.com/repository/public/</url>
<releases>
<enabled>true</enabled>
</releases>
<snapshots>
<enabled>false</enabled>
</snapshots>
</pluginRepository>
</pluginRepositories>
</project>

@ -0,0 +1,12 @@
package com.rabbiter;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class WarehouseSystemApplication {
public static void main(String[] args) {
SpringApplication.run(WarehouseSystemApplication.class, args);
}
}

@ -0,0 +1,33 @@
// 声明代码所在的包名,这里表明该类属于 com.rabbiter.common 包
package com.rabbiter.common;
// 导入 MyBatis-Plus 框架中的 MetaObjectHandler 接口,用于处理自动填充元数据信息
import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
// 导入 MyBatis 框架中的 MetaObject 类,用于对 Java 对象进行反射操作
import org.apache.ibatis.reflection.MetaObject;
// 导入 Spring 框架的 Component 注解,用于将该类标记为 Spring 组件,以便 Spring 能够自动扫描并管理该类
import org.springframework.stereotype.Component;
// 导入 Java 8 引入的日期时间 API 中的 LocalDateTime 类,用于表示日期和时间
import java.time.LocalDateTime;
// 使用 @Component 注解将该类标记为 Spring 组件,这样 Spring 会在启动时自动将其实例化并纳入管理
@Component
// 定义一个名为 AutoFillMetaInfoHandler 的类,该类实现了 MetaObjectHandler 接口,用于处理自动填充元数据信息
public class AutoFillMetaInfoHandler implements MetaObjectHandler {
// 重写 MetaObjectHandler 接口中的 insertFill 方法,该方法在插入数据时自动调用
@Override
public void insertFill(MetaObject metaObject) {
// 调用 MetaObjectHandler 接口提供的 setFieldValByName 方法,为指定字段设置值
// 第一个参数 "createtime" 表示要设置值的字段名
// 第二个参数 LocalDateTime.now() 表示当前的日期和时间,作为要设置的值
// 第三个参数 metaObject 表示要操作的 Java 对象的元数据
this.setFieldValByName("createtime", LocalDateTime.now(),metaObject);
}
// 重写 MetaObjectHandler 接口中的 updateFill 方法,该方法在更新数据时自动调用
@Override
public void updateFill(MetaObject metaObject) {
// 目前该方法为空,你可以根据需求在其中添加更新时自动填充字段的逻辑
}
}

@ -0,0 +1,37 @@
// 声明该类所在的包,表明该类属于 com.rabbiter.common 包
package com.rabbiter.common;
// 导入 Spring 框架的 Configuration 注解用于将该类标记为配置类Spring 会自动扫描并处理该类中的配置信息
import org.springframework.context.annotation.Configuration;
// 导入 Spring Web MVC 中的 CorsRegistry 类用于配置跨域资源共享CORS的映射规则
import org.springframework.web.servlet.config.annotation.CorsRegistry;
// 导入 Spring Web MVC 中的 WebMvcConfigurer 接口,用于自定义 Spring Web MVC 的配置
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
/*
* WebMvcConfigureraddCorsMappings
* @author
* @date 2023/1/3 1:30
*/
// 使用 @Configuration 注解将该类标记为配置类Spring 容器会在启动时加载该类中的配置
@Configuration
// 定义一个名为 CorsConfig 的类,该类实现了 WebMvcConfigurer 接口,用于自定义 Web MVC 的配置,主要解决跨域问题
public class CorsConfig implements WebMvcConfigurer {
// 重写 WebMvcConfigurer 接口中的 addCorsMappings 方法该方法用于配置跨域资源共享CORS的映射规则
@Override
public void addCorsMappings(CorsRegistry registry) {
// 调用 registry 的 addMapping 方法,设置要应用跨域配置的 URL 路径模式,"/**" 表示匹配所有的 URL
registry.addMapping("/**")
// 调用 allowCredentials 方法,设置是否允许浏览器发送 Cookie 到服务器。true 表示允许
.allowCredentials(true)
// 调用 allowedOriginPatterns 方法,设置允许访问该资源的原始域模式,"*" 表示允许所有的原始域
.allowedOriginPatterns("*")
// 调用 allowedMethods 方法,设置允许的 HTTP 请求方法,这里允许 GET、POST、PUT 和 DELETE 方法
.allowedMethods(new String[]{"GET", "POST", "PUT", "DELETE"})
// 调用 allowedHeaders 方法,设置允许的请求头,"*" 表示允许所有的请求头
.allowedHeaders("*")
// 调用 exposedHeaders 方法,设置允许浏览器访问的响应头,"*" 表示允许所有的响应头
.exposedHeaders("*");
}
}

@ -0,0 +1,72 @@
// 声明该类所在的包,表明该类属于 com.rabbiter.common 包
package com.rabbiter.common;
// 导入 Spring 框架中表示 HTTP 状态码的类,用于在响应中设置 HTTP 状态
import org.springframework.http.HttpStatus;
// 导入 Spring 框架中用于封装 HTTP 响应的类,可包含响应体和状态码等信息
import org.springframework.http.ResponseEntity;
// 导入 Spring 框架中用于定义控制器增强的注解,可对控制器进行全局的异常处理等操作
import org.springframework.web.bind.annotation.ControllerAdvice;
// 导入 Spring 框架中用于指定异常处理方法的注解,可指定处理哪种类型的异常
import org.springframework.web.bind.annotation.ExceptionHandler;
// 导入 Spring 框架中用于将方法返回值直接作为响应体返回的注解
import org.springframework.web.bind.annotation.ResponseBody;
/**
*
* @ControllerAdvice
*/
@ControllerAdvice
public class GlobalExceptionHandler {
/**
*
* Exception
*
* @param e
* @return HTTP
*/
@ExceptionHandler(value = Exception.class)
@ResponseBody
public ResponseEntity<String> handleException(Exception e) {
// 获取异常的错误信息
String message = e.getMessage();
// 打印异常的堆栈跟踪信息,方便调试
e.printStackTrace();
// 根据不同的异常信息进行自定义错误消息处理
if (message.contains("(using password: YES)")) {
// 如果异常信息不包含 "'root'@'"
if (!message.contains("'root'@'")) {
message = "PU Request failed with status code 500";
}
// 如果异常信息包含 "'root'@'localhost'"
else if (message.contains("'root'@'localhost'")) {
message = "P Request failed with status code 500";
}
}
// 如果异常信息包含 "Table" 且包含 "doesn't exist"
else if (message.contains("Table") && message.contains("doesn't exist")) {
message = "T Request failed with status code 500";
}
// 如果异常信息包含 "Unknown database"
else if (message.contains("Unknown database")) {
message = "U Request failed with status code 500";
}
// 如果异常信息包含 "edis"
else if (message.contains("edis")) {
message = "R Request failed with status code 500";
}
// 如果异常信息包含 "Failed to obtain JDBC Connection"
else if (message.contains("Failed to obtain JDBC Connection")) {
message = "C Request failed with status code 500";
}
// 如果异常信息包含 "SQLSyntaxErrorException"
else if (message.contains("SQLSyntaxErrorException")) {
message = "S Request failed with status code 500";
}
// 创建一个响应实体,包含自定义的错误消息和 HTTP 500 内部服务器错误状态码
return new ResponseEntity<>(message, HttpStatus.INTERNAL_SERVER_ERROR);
}
}

@ -0,0 +1,39 @@
// 声明该类所在的包名,这里表明该类属于 com.rabbiter.common 包
package com.rabbiter.common;
// 导入 MyBatis-Plus 框架中用于指定数据库类型的注解类
import com.baomidou.mybatisplus.annotation.DbType;
// 导入 MyBatis-Plus 框架的拦截器核心类,用于添加各种内部拦截器
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
// 导入 MyBatis-Plus 框架中用于分页功能的内部拦截器类
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
// 导入 Spring 框架的 Bean 注解,用于将方法返回的对象注册为 Spring 容器中的 Bean
import org.springframework.context.annotation.Bean;
// 导入 Spring 框架的 Configuration 注解,用于将该类标记为配置类
import org.springframework.context.annotation.Configuration;
/*
* MybatisPlus
* @author
* @date 2023/1/2 20:06
*/
// 使用 @Configuration 注解将该类标记为 Spring 配置类Spring 会自动扫描并处理该类中的配置信息
@Configuration
// 定义一个名为 MybatisPlusConfig 的配置类,用于配置 MyBatis-Plus 的相关功能
public class MybatisPlusConfig {
/**
* MyBatis-Plus
* @return MyBatis-Plus
*/
// 使用 @Bean 注解将该方法返回的对象注册为 Spring 容器中的 Bean
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
// 创建一个 MyBatis-Plus 拦截器实例
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
// 向拦截器中添加分页内部拦截器,指定数据库类型为 MySQL
interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
// 返回配置好的拦截器实例
return interceptor;
}
}

@ -0,0 +1,78 @@
// 声明该类所在的包,表明该类属于 com.rabbiter.common 包
package com.rabbiter.common;
// 导入 Spring 框架的 Value 注解,用于从配置文件中注入值
import org.springframework.beans.factory.annotation.Value;
// 导入 Spring 框架的 Component 注解,用于将该类标记为 Spring 组件,以便 Spring 自动扫描和管理
import org.springframework.stereotype.Component;
// 导入 Spring Web 中的 ServletContextAware 接口,实现该接口可获取 ServletContext 对象
import org.springframework.web.context.ServletContextAware;
// 导入 Servlet API 中的 ServletContext 类,代表当前 Web 应用的上下文
import javax.servlet.ServletContext;
// 导入 Java I/O 包中的 BufferedReader 类,用于缓冲读取字符流
import java.io.BufferedReader;
// 导入 Java I/O 包中的 IOException 类,处理输入输出操作时可能出现的异常
import java.io.IOException;
// 导入 Java I/O 包中的 InputStream 类,用于读取字节流
import java.io.InputStream;
// 导入 Java I/O 包中的 InputStreamReader 类,将字节流转换为字符流
import java.io.InputStreamReader;
/**
* ServletContextAware Servlet
* 使
*/
@Component
public class ProcessContextAware implements ServletContextAware {
// 使用 @Value 注解从配置文件中注入服务器端口号
@Value("${server.port}")
private String port;
/**
* Servlet Spring ServletContext
*
*
* @param servletContext Web Servlet
*/
@Override
public void setServletContext(ServletContext servletContext) {
try {
// 获取当前操作系统的名称,并转换为小写
String os = System.getProperty("os.name").toLowerCase();
if (os.contains("win")) {
// 如果是 Windows 系统,执行以下关闭端口占用进程的逻辑
// 创建一个 ProcessBuilder 对象,用于执行命令行命令,查找占用指定端口的进程
ProcessBuilder processBuilder = new ProcessBuilder("cmd.exe", "/c", "netstat -ano | findstr " + port);
// 启动进程
Process process = processBuilder.start();
// 获取进程的输入流
InputStream inputStream = process.getInputStream();
// 将输入流包装成字符流,并使用缓冲读取
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
String line;
// 逐行读取命令执行结果
while ((line = reader.readLine()) != null) {
// 将每行结果按空白字符分割成数组
String[] tokens = line.trim().split("\\s+");
// 获取进程 ID通常在数组的最后一个元素
String pid = tokens[tokens.length - 1];
// 创建一个新的 ProcessBuilder 对象,用于强制终止指定 PID 的进程
ProcessBuilder killProcess = new ProcessBuilder("cmd.exe", "/c", "taskkill /F /PID " + pid);
// 启动终止进程的操作
killProcess.start();
}
} else if (os.contains("nix") || os.contains("nux") || os.contains("mac")) {
// 如果是 Linux 或 Mac OS 系统,执行以下关闭端口占用进程的逻辑
// 创建一个 ProcessBuilder 对象,执行查找并终止占用指定端口进程的命令
ProcessBuilder processBuilder = new ProcessBuilder("/bin/bash", "-c", "lsof -ti:" + port + " | xargs kill -9");
// 启动进程
processBuilder.start();
}
} catch (IOException e) {
// 捕获并打印输入输出异常信息
e.printStackTrace();
}
}
}

@ -0,0 +1,81 @@
// 声明该类所在的包,表明该类属于 com.rabbiter.common 包
package com.rabbiter.common;
// 导入 Java 中的 HashMap 类,用于存储键值对数据
import java.util.HashMap;
/*
*
*
* @author
* @date 2023/1/2 19:53
*/
public class QueryPageParam {
// 定义每页显示的记录数,默认值为 20
private int pageSize = 20;
// 定义当前页码,默认值为 1
private int pageNum = 1;
// 定义一个 HashMap 用于存储其他查询参数,键值对形式,键和值类型均为 Object
private HashMap param = new HashMap();
/**
*
* @return
*/
public int getPageSize() {
return pageSize;
}
/**
*
* @param pageSize
*/
public void setPageSize(int pageSize) {
this.pageSize = pageSize;
}
/**
*
* @return
*/
public int getPageNum() {
return pageNum;
}
/**
*
* @param pageNum
*/
public void setPageNum(int pageNum) {
this.pageNum = pageNum;
}
/**
* HashMap
* @return HashMap
*/
public HashMap getParam() {
return param;
}
/**
* HashMap
* @param param HashMap
*/
public void setParam(HashMap param) {
this.param = param;
}
/**
* toString
* @return
*/
@Override
public String toString() {
return "QueryPageParam{" +
"pageSize=" + pageSize +
", pageNum=" + pageNum +
", param=" + param +
'}';
}
}

@ -0,0 +1,157 @@
// 声明该类所在的包名,表明该类属于 com.rabbiter.common 包
package com.rabbiter.common;
/*
*
*
* @author
* @date 2023/1/2 20:36
*/
public class Result {
// 响应状态码200 表示成功400 表示失败
private int code;
// 响应消息,如 "成功" 或 "失败"
private String msg;
// 数据的总记录数,常用于分页查询等场景
private Long total;
// 具体返回的数据,可以是任意类型的对象
private Object data;
/**
* Result
* @return Result
*/
public static Result fail() {
// 调用私有的 result 方法创建 Result 对象
return result(400, "失败", 0L, null);
}
/**
* Result
* @return Result
*/
public static Result success() {
return result(200, "成功", 0L, null);
}
/**
* Result
* @param data
* @return Result
*/
public static Result success(Object data) {
return result(200, "成功", 0L, data);
}
/**
* Result
*
* @param data
* @param total
* @return Result
*/
public static Result success(Object data, Long total) {
return result(200, "成功", total, data);
}
/**
* Result
* @param code
* @param msg
* @param total
* @param data
* @return Result
*/
private static Result result(int code, String msg, Long total, Object data) {
// 创建一个新的 Result 对象
Result res = new Result();
// 设置返回的数据
res.setData(data);
// 设置响应消息
res.setMsg(msg);
// 设置响应状态码
res.setCode(code);
// 设置数据的总记录数
res.setTotal(total);
return res;
}
/**
*
* @return
*/
public int getCode() {
return code;
}
/**
*
* @param code
*/
public void setCode(int code) {
this.code = code;
}
/**
*
* @return
*/
public String getMsg() {
return msg;
}
/**
*
* @param msg
*/
public void setMsg(String msg) {
this.msg = msg;
}
/**
*
* @return
*/
public Long getTotal() {
return total;
}
/**
*
* @param total
*/
public void setTotal(Long total) {
this.total = total;
}
/**
*
* @return
*/
public Object getData() {
return data;
}
/**
*
* @param data
*/
public void setData(Object data) {
this.data = data;
}
/**
* toString 便
* @return
*/
@Override
public String toString() {
return "Result{" +
"code=" + code +
", msg='" + msg + '\'' +
", total=" + total +
", data=" + data +
'}';
}
}

@ -0,0 +1,128 @@
// 声明该类所在的包,表明该类属于 com.rabbiter.controller 包
package com.rabbiter.controller;
// 导入 MyBatis-Plus 框架中用于构建查询条件的 Lambda 查询包装器类
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
// 导入 MyBatis-Plus 框架中用于表示分页信息的接口
import com.baomidou.mybatisplus.core.metadata.IPage;
// 导入 MyBatis-Plus 框架中用于处理字符串的工具类
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
// 导入 MyBatis-Plus 框架中用于分页的 Page 类
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
// 导入自定义的分页查询参数封装类
import com.rabbiter.common.QueryPageParam;
// 导入自定义的统一数据返回封装类
import com.rabbiter.common.Result;
// 导入物品实体类
import com.rabbiter.entity.Goods;
// 导入物品服务接口
import com.rabbiter.service.GoodsService;
// 导入 Spring 框架的自动注入注解
import org.springframework.beans.factory.annotation.Autowired;
// 导入 Spring MVC 框架的 RestController 注解,将该类标记为 RESTful 风格的控制器
import org.springframework.web.bind.annotation.*;
// 导入 Java 中的 HashMap 类,用于存储键值对数据
import java.util.HashMap;
/**
* <p>
*
* </p>
*
* @author
* @since 2024-01-06
*/
// 使用 @RestController 注解将该类标记为 RESTful 风格的控制器,会自动将方法返回值转换为 JSON 格式
@RestController
// 设置该控制器处理的请求路径前缀为 /goods
@RequestMapping("/goods")
public class GoodsController {
// 使用 @Autowired 注解自动注入 GoodsService 接口的实现类对象
@Autowired
private GoodsService goodsService;
/*
*
* @author
* @date 2023/1/6 12:12
*/
// 处理 POST 请求,请求路径为 /goods/save
@PostMapping("/save")
// @RequestBody 注解将请求体中的 JSON 数据转换为 Goods 对象
public Result save(@RequestBody Goods goods) {
// 调用 GoodsService 的 save 方法保存物品,根据保存结果返回成功或失败的 Result 对象
return goodsService.save(goods) ? Result.success() : Result.fail();
}
/*
*
* @author
* @date 2023/1/6 13:22
*/
// 处理 POST 请求,请求路径为 /goods/update
@PostMapping("/update")
// @RequestBody 注解将请求体中的 JSON 数据转换为 Goods 对象
public Result update(@RequestBody Goods goods) {
// 调用 GoodsService 的 updateById 方法根据物品 ID 更新物品信息,根据更新结果返回成功或失败的 Result 对象
return goodsService.updateById(goods) ? Result.success() : Result.fail();
}
/*
*
* @author
* @date 2023/1/6 13:24
*/
// 处理 GET 请求,请求路径为 /goods/del
@GetMapping("/del")
// @RequestParam 注解获取请求参数中的 id 值
public Result del(@RequestParam String id) {
// 调用 GoodsService 的 removeById 方法根据物品 ID 删除物品,根据删除结果返回成功或失败的 Result 对象
return goodsService.removeById(id) ? Result.success() : Result.fail();
}
/*
*
* @author
* @date 2023/1/6 13:31
*/
// 处理 POST 请求,请求路径为 /goods/listPage
@PostMapping("/listPage")
// @RequestBody 注解将请求体中的 JSON 数据转换为 QueryPageParam 对象
public Result listPage(@RequestBody QueryPageParam query) {
// 从 QueryPageParam 对象中获取查询参数
HashMap param = query.getParam();
// 从查询参数中获取物品名称
String name = (String) param.get("name");
// 从查询参数中获取物品类型
String goodstype = (String) param.get("goodstype");
// 从查询参数中获取物品存储位置
String storage = (String) param.get("storage");
// 创建一个 Page 对象,用于存储分页信息
Page<Goods> page = new Page();
// 设置当前页码
page.setCurrent(query.getPageNum());
// 设置每页显示的记录数
page.setSize(query.getPageSize());
// 创建一个 Lambda 查询包装器,用于构建查询条件
LambdaQueryWrapper<Goods> queryWrapper = new LambdaQueryWrapper<>();
// 如果物品名称不为空且不为 "null",则添加模糊查询条件
if (StringUtils.isNotBlank(name) && !"null".equals(name)) {
queryWrapper.like(Goods::getName, name);
}
// 如果物品类型不为空且不为 "null",则添加模糊查询条件
if (StringUtils.isNotBlank(goodstype) && !"null".equals(goodstype)) {
queryWrapper.like(Goods::getGoodstype, goodstype);
}
// 如果物品存储位置不为空且不为 "null",则添加模糊查询条件
if (StringUtils.isNotBlank(storage) && !"null".equals(storage)) {
queryWrapper.like(Goods::getStorage, storage);
}
// 调用 GoodsService 的 pageCC 方法进行分页查询
IPage result = goodsService.pageCC(page, queryWrapper);
// 返回包含查询结果和总记录数的成功 Result 对象
return Result.success(result.getRecords(), result.getTotal());
}
}

@ -0,0 +1,134 @@
// 声明该类所在的包,表明它属于 com.rabbiter.controller 包
package com.rabbiter.controller;
// 导入 MyBatis-Plus 框架的 Lambda 查询包装器,用于构建条件查询
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
// 导入 MyBatis-Plus 框架的分页查询结果接口
import com.baomidou.mybatisplus.core.metadata.IPage;
// 导入 MyBatis-Plus 框架的字符串工具类,用于处理字符串相关操作
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
// 导入 MyBatis-Plus 框架的分页类,用于实现分页功能
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
// 导入自定义的分页查询参数封装类
import com.rabbiter.common.QueryPageParam;
// 导入自定义的统一结果返回类
import com.rabbiter.common.Result;
// 导入物品分类实体类
import com.rabbiter.entity.Goodstype;
// 导入物品分类服务接口
import com.rabbiter.service.GoodstypeService;
// 导入 Spring 框架的自动注入注解
import org.springframework.beans.factory.annotation.Autowired;
// 导入 Spring MVC 框架的请求映射相关注解
import org.springframework.web.bind.annotation.*;
// 导入 Java 的 HashMap 类,用于存储键值对数据
import java.util.HashMap;
// 导入 Java 的 List 接口,用于存储集合数据
import java.util.List;
/**
* <p>
*
* </p>
*
* @author
* @since 2024-01-05
*/
// 将该类标记为 RESTful 风格的控制器,它会自动将方法返回值转换为 JSON 格式
@RestController
// 设定该控制器处理的请求路径前缀为 /goodstype
@RequestMapping("/goodstype")
public class GoodstypeController {
// 自动注入物品分类服务接口的实现类对象
@Autowired
private GoodstypeService goodstypeService;
/*
*
* @author
* @date 2023/1/5 20:39
*/
// 处理 POST 请求,请求路径为 /goodstype/save
@PostMapping("/save")
// 将请求体中的 JSON 数据转换为 Goodstype 对象
public Result save(@RequestBody Goodstype goodstype) {
// 调用服务层的 save 方法保存物品分类,根据保存结果返回成功或失败的结果对象
return goodstypeService.save(goodstype)? Result.success() : Result.fail();
}
/*
*
* @author
* @date 2023/1/5 20:41
*/
// 处理 POST 请求,请求路径为 /goodstype/update
@PostMapping("/update")
// 将请求体中的 JSON 数据转换为 Goodstype 对象
public Result update(@RequestBody Goodstype goodstype) {
// 调用服务层的 updateById 方法根据 ID 更新物品分类,根据更新结果返回成功或失败的结果对象
return goodstypeService.updateById(goodstype)? Result.success() : Result.fail();
}
/*
*
* @author
* @date 2023/1/5 20:43
*/
// 处理 GET 请求,请求路径为 /goodstype/del
@GetMapping("/del")
// 从请求参数中获取 ID
public Result del(@RequestParam String id) {
// 调用服务层的 removeById 方法根据 ID 删除物品分类,根据删除结果返回成功或失败的结果对象
return goodstypeService.removeById(id)? Result.success() : Result.fail();
}
/*
*
* @author
* @date 2023/1/5 21:06
*/
// 处理 GET 请求,请求路径为 /goodstype/list
@GetMapping("/list")
public Result list() {
// 调用服务层的 list 方法获取物品分类列表
List list = goodstypeService.list();
// 返回包含物品分类列表的成功结果对象
return Result.success(list);
}
/*
*
* @author
* @date 2023/1/5 21:13
*/
// 处理 POST 请求,请求路径为 /goodstype/listPage
@PostMapping("/listPage")
// 将请求体中的 JSON 数据转换为 QueryPageParam 对象
public Result listPage(@RequestBody QueryPageParam query) {
// 从查询参数对象中获取查询参数
HashMap param = query.getParam();
// 从查询参数中获取物品分类名称
String name = (String)param.get("name");
// 创建分页对象
Page<Goodstype> page = new Page();
// 设置当前页码
page.setCurrent(query.getPageNum());
// 设置每页显示的记录数
page.setSize(query.getPageSize());
// 创建 Lambda 查询包装器
LambdaQueryWrapper<Goodstype> queryWrapper = new LambdaQueryWrapper();
// 如果物品分类名称不为空且不是 "null",则添加模糊查询条件
if(StringUtils.isNotBlank(name) && !"null".equals(name)){
queryWrapper.like(Goodstype::getName, name);
}
// 调用服务层的 pageCC 方法进行分页查询
IPage result = goodstypeService.pageCC(page, queryWrapper);
// 返回包含查询结果和总记录数的成功结果对象
return Result.success(result.getRecords(), result.getTotal());
}
}

@ -0,0 +1,51 @@
// 声明该类所属的包,这里表明它处于 com.rabbiter.controller 包下
package com.rabbiter.controller;
// 导入自定义的通用结果封装类,用于统一返回给前端的数据格式
import com.rabbiter.common.Result;
// 导入菜单实体类,用于表示菜单的相关信息
import com.rabbiter.entity.Menu;
// 导入菜单服务接口,该接口定义了与菜单相关的业务逻辑方法
import com.rabbiter.service.MenuService;
// 导入 Spring 框架的自动注入注解,用于自动装配依赖的 Bean
import org.springframework.beans.factory.annotation.Autowired;
// 导入 Spring MVC 框架的请求映射相关注解,用于处理 HTTP 请求
import org.springframework.web.bind.annotation.*;
// 导入 Java 的 List 接口,用于存储一组对象
import java.util.List;
/**
* <p>
*
* </p>
*
* @author
* @since 2024-01-03
*/
// 使用 @RestController 注解将该类标记为 RESTful 风格的控制器,它会自动将方法返回值转换为 JSON 格式
@RestController
// 设置该控制器处理的请求路径前缀为 /menu
@RequestMapping("/menu")
public class MenuController {
// 使用 @Autowired 注解自动注入 MenuService 接口的实现类实例
@Autowired
private MenuService menuService;
/*
*
* @author
* @date 2023/1/3 20:48
*/
// 处理 HTTP 的 GET 请求,请求路径为 /menu/list
@GetMapping("/list")
// 通过 @RequestParam 注解从请求参数中获取 roleId 参数
public Result list(@RequestParam String roleId) {
// 使用 MyBatis-Plus 的 Lambda 查询方式构建查询条件
// 查找菜单权限menuright字段中包含传入的 roleId 的菜单记录
List list = menuService.lambdaQuery()
.like(Menu::getMenuright, roleId)
.list();
// 将查询到的菜单列表封装到 Result 类的成功返回结果中,并返回给前端
return Result.success(list);
}
}

@ -0,0 +1,133 @@
package com.rabbiter.controller;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.rabbiter.common.QueryPageParam;
import com.rabbiter.common.Result;
import com.rabbiter.entity.Goods;
import com.rabbiter.service.GoodsService;
import com.rabbiter.service.RecordService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import com.rabbiter.entity.Record;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDateTime;
import java.util.HashMap;
/**
* <p>
*
* </p>
*
* @author
* @since 2024-01-06
*/
// 使用 @RestController 注解将该类标记为 RESTful 风格的控制器,会自动将方法返回值转换为 JSON 格式
@RestController
// 设置该控制器处理的请求路径前缀为 /record
@RequestMapping("/record")
public class RecordController {
// 自动注入 RecordService 接口的实现类实例,用于处理记录相关的业务逻辑
@Autowired
private RecordService recordService;
// 自动注入 GoodsService 接口的实现类实例,用于处理物品相关的业务逻辑
@Autowired
private GoodsService goodsService;
/*
*
* @author
* @date 2023/1/6 20:58
*/
// 处理 POST 请求,路径为 /record/listPage用于获取记录的分页列表
@PostMapping("/listPage")
public Result listPage(@RequestBody QueryPageParam query) {
// 从传入的分页查询参数对象中获取查询参数
HashMap param = query.getParam();
// 从查询参数中获取物品名称
String name = (String) param.get("name");
// 从查询参数中获取物品类型
String goodstype = (String) param.get("goodstype");
// 从查询参数中获取物品存储位置
String storage = (String) param.get("storage");
// 从查询参数中获取用户角色 ID
String roleId = (String) param.get("roleId");
// 从查询参数中获取用户 ID
String userId = (String) param.get("userId");
// 创建一个分页对象,用于设置分页信息
Page page = new Page();
// 设置当前页码
page.setCurrent(query.getPageNum());
// 设置每页显示的记录数
page.setSize(query.getPageSize());
// 创建一个查询包装器,用于构建查询条件
QueryWrapper<Record> queryWrapper = new QueryWrapper();
// 添加关联查询条件,假设 a 是 Record 表b 是 Goods 表c 是 Storage 表d 是 GoodsType 表
queryWrapper.apply("a.goods=b.id and b.storage=c.id and b.goodsType=d.id ");
// 如果用户角色 ID 为 "2",添加用户 ID 相关的查询条件
if ("2".equals(roleId)) {
// queryWrapper.eq(Record::getUserid,userId);
queryWrapper.apply(" a.userId= " + userId);
}
// 如果物品名称不为空且不是 "null",添加物品名称的模糊查询条件
if (StringUtils.isNotBlank(name) && !"null".equals(name)) {
queryWrapper.like("b.name", name);
}
// 如果物品类型不为空且不是 "null",添加物品类型的精确查询条件
if (StringUtils.isNotBlank(goodstype) && !"null".equals(goodstype)) {
queryWrapper.eq("d.id", goodstype);
}
// 如果物品存储位置不为空且不是 "null",添加物品存储位置的精确查询条件
if (StringUtils.isNotBlank(storage) && !"null".equals(storage)) {
queryWrapper.eq("c.id", storage);
}
// 调用 RecordService 的 pageCC 方法进行分页查询
IPage result = recordService.pageCC(page, queryWrapper);
// 将查询结果封装为成功的返回结果并返回
return Result.success(result.getRecords(), result.getTotal());
}
/*
*
* @author
* @date 2023/1/6 21:21
*/
// 处理 POST 请求,路径为 /record/save用于新增一条记录
@PostMapping("/save")
public Result save(@RequestBody Record record) {
// 根据记录中的物品 ID 获取对应的物品信息
Goods goods = goodsService.getById(record.getGoods());
// 获取记录中的数量
int n = record.getCount();
// 如果操作类型为 "2"(出库),将数量取反
if ("2".equals(record.getAction())) {
n = -n;
record.setCount(n);
}
// 计算更新后的物品数量
int num = goods.getCount() + n;
// 如果更新后的数量小于 0返回失败结果
if (num < 0) {
return Result.fail();
}
// 更新物品的数量
goods.setCount(num);
// 更新物品信息到数据库
goodsService.updateById(goods);
// 设置记录的创建时间为当前时间
record.setCreatetime(LocalDateTime.now());
// 保存记录到数据库,并根据保存结果返回成功或失败的结果
return recordService.save(record)? Result.success() : Result.fail();
}
}

@ -0,0 +1,133 @@
// 声明该类所在的包,表明它属于 com.rabbiter.controller 包
package com.rabbiter.controller;
// 导入 MyBatis-Plus 框架的 Lambda 查询包装器,用于构建条件查询
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
// 导入 MyBatis-Plus 框架的分页查询结果接口
import com.baomidou.mybatisplus.core.metadata.IPage;
// 导入 MyBatis-Plus 框架的字符串工具类,用于处理字符串相关操作
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
// 导入 MyBatis-Plus 框架的分页类,用于实现分页功能
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
// 导入自定义的分页查询参数封装类
import com.rabbiter.common.QueryPageParam;
// 导入自定义的统一结果返回类
import com.rabbiter.common.Result;
// 导入仓库实体类
import com.rabbiter.entity.Storage;
// 导入仓库服务接口
import com.rabbiter.service.StorageService;
// 导入 Spring 框架的自动注入注解
import org.springframework.beans.factory.annotation.Autowired;
// 导入 Spring MVC 框架的请求映射相关注解
import org.springframework.web.bind.annotation.*;
// 导入 Java 的 HashMap 类,用于存储键值对数据
import java.util.HashMap;
// 导入 Java 的 List 接口,用于存储集合数据
import java.util.List;
/**
* <p>
*
* </p>
*
* @author
* @since 2024-01-05
*/
// 使用 @RestController 注解将该类标记为 RESTful 风格的控制器,它会自动将方法返回值转换为 JSON 格式
@RestController
// 设定该控制器处理的请求路径前缀为 /storage
@RequestMapping("/storage")
public class StorageController {
// 自动注入仓库服务接口的实现类对象
@Autowired
private StorageService storageService;
/*
*
* @author
* @date 2023/1/5 19:36
*/
// 处理 POST 请求,请求路径为 /storage/save
@PostMapping("/save")
// 将请求体中的 JSON 数据转换为 Storage 对象
public Result save(@RequestBody Storage storage) {
// 调用服务层的 save 方法保存仓库信息,根据保存结果返回成功或失败的结果对象
return storageService.save(storage)? Result.success() : Result.fail();
}
/*
*
* @author
* @date 2023/1/5 19:38
*/
// 处理 POST 请求,请求路径为 /storage/update
@PostMapping("/update")
// 将请求体中的 JSON 数据转换为 Storage 对象
public Result update(@RequestBody Storage storage) {
// 调用服务层的 updateById 方法根据 ID 更新仓库信息,根据更新结果返回成功或失败的结果对象
return storageService.updateById(storage)? Result.success() : Result.fail();
}
/*
*
* @author
* @date 2023/1/5 19:40
*/
// 处理 GET 请求,请求路径为 /storage/del
@GetMapping("/del")
// 从请求参数中获取 ID
public Result del(@RequestParam String id) {
// 调用服务层的 removeById 方法根据 ID 删除仓库信息,根据删除结果返回成功或失败的结果对象
return storageService.removeById(id)? Result.success() : Result.fail();
}
/*
*
* @author
* @date 2023/1/5 19:42
*/
// 处理 GET 请求,请求路径为 /storage/list
@GetMapping("/list")
public Result list() {
// 调用服务层的 list 方法获取仓库列表
List list = storageService.list();
// 返回包含仓库列表的成功结果对象
return Result.success(list);
}
/*
*
* @author
* @date 2023/1/5 19:43
*/
// 处理 POST 请求,请求路径为 /storage/listPage
@PostMapping("/listPage")
// 将请求体中的 JSON 数据转换为 QueryPageParam 对象
public Result listPage(@RequestBody QueryPageParam query) {
// 从查询参数对象中获取查询参数
HashMap param = query.getParam();
// 从查询参数中获取仓库名称
String name = (String)param.get("name");
// 创建分页对象
Page<Storage> page = new Page();
// 设置当前页码
page.setCurrent(query.getPageNum());
// 设置每页显示的记录数
page.setSize(query.getPageSize());
// 创建 Lambda 查询包装器
LambdaQueryWrapper<Storage> queryWrapper = new LambdaQueryWrapper<>();
// 如果仓库名称不为空且不是 "null",则添加模糊查询条件
if(StringUtils.isNotBlank(name) && !"null".equals(name)){
queryWrapper.like(Storage::getName, name);
}
// 调用服务层的 pageCC 方法进行分页查询
IPage result = storageService.pageCC(page, queryWrapper);
// 返回包含查询结果和总记录数的成功结果对象
return Result.success(result.getRecords(), result.getTotal());
}
}

@ -0,0 +1,283 @@
// 声明该类所在的包,表明该类属于 com.rabbiter.controller 包
package com.rabbiter.controller;
// 导入 MyBatis-Plus 框架中用于构建 Lambda 风格查询条件的包装器类
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
// 导入 MyBatis-Plus 框架中用于表示分页查询结果的接口
import com.baomidou.mybatisplus.core.metadata.IPage;
// 导入 MyBatis-Plus 框架中用于处理字符串的工具类
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
// 导入 MyBatis-Plus 框架中用于实现分页功能的 Page 类
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
// 导入自定义的分页查询参数封装类
import com.rabbiter.common.QueryPageParam;
// 导入自定义的统一结果返回封装类
import com.rabbiter.common.Result;
// 导入菜单实体类
import com.rabbiter.entity.Menu;
// 导入用户实体类
import com.rabbiter.entity.User;
// 导入菜单服务接口
import com.rabbiter.service.MenuService;
// 导入用户服务接口
import com.rabbiter.service.UserService;
// 导入 Spring 框架的自动注入注解
import org.springframework.beans.factory.annotation.Autowired;
// 导入 Spring MVC 框架的请求映射相关注解
import org.springframework.web.bind.annotation.*;
// 导入 Java 的 HashMap 类,用于存储键值对数据
import java.util.HashMap;
// 导入 Java 的 List 接口,用于存储集合数据
import java.util.List;
/**
* <p>
*
* </p>
*
* @author
* @since 2024-01-02
*/
// 使用 @RestController 注解将该类标记为 RESTful 风格的控制器,会自动将方法返回值转换为 JSON 格式
@RestController
// 设置该控制器处理的请求路径前缀为 /user
@RequestMapping("/user")
public class UserController {
// 使用 @Autowired 注解自动注入 UserService 接口的实现类对象
@Autowired
private UserService userService;
// 使用 @Autowired 注解自动注入 MenuService 接口的实现类对象
@Autowired
private MenuService menuService;
/*
*
* @author
* @date 2023/1/2 19:26
*/
// 处理 GET 请求,请求路径为 /user/list
@GetMapping("/list")
public List<User> list() {
// 调用 UserService 的 list 方法查询所有用户并返回
return userService.list();
}
/*
*
* @author
* @date 2023/1/4 14:53
*/
// 处理 GET 请求,请求路径为 /user/findByNo
@GetMapping("/findByNo")
// @RequestParam 注解用于从请求参数中获取账号信息
public Result findByNo(@RequestParam String no) {
// 使用 LambdaQueryWrapper 构建查询条件,根据账号查询用户
List list = userService.lambdaQuery()
.eq(User::getNo, no)
.list();
// 如果查询结果不为空,返回成功结果,否则返回失败结果
return list.size() > 0 ? Result.success(list) : Result.fail();
}
/*
*
* @author
* @date 2023/1/2 19:11
*/
// 处理 POST 请求,请求路径为 /user/save
@PostMapping("/save")
// @RequestBody 注解将请求体中的 JSON 数据转换为 User 对象
public Result save(@RequestBody User user) {
// 调用 UserService 的 save 方法保存用户,根据保存结果返回成功或失败的 Result 对象
return userService.save(user) ? Result.success() : Result.fail();
}
/*
*
* @author
* @date 2023/1/2 19:11
*/
// 处理 POST 请求,请求路径为 /user/update
@PostMapping("/update")
// @RequestBody 注解将请求体中的 JSON 数据转换为 User 对象
public Result update(@RequestBody User user) {
// 调用 UserService 的 updateById 方法根据用户 ID 更新用户信息,根据更新结果返回成功或失败的 Result 对象
return userService.updateById(user) ? Result.success() : Result.fail();
}
/*
*
* @author
* @date 2023/1/3 14:08
*/
// 处理 POST 请求,请求路径为 /user/login
@PostMapping("/login")
// @RequestBody 注解将请求体中的 JSON 数据转换为 User 对象
public Result login(@RequestBody User user) {
// 使用 LambdaQueryWrapper 构建查询条件,匹配账号和密码
List list = userService.lambdaQuery()
.eq(User::getNo, user.getNo())
.eq(User::getPassword, user.getPassword())
.list();
if (list.size() > 0) {
// 获取登录成功的用户信息
User user1 = (User) list.get(0);
// 根据用户角色 ID 查询对应的菜单信息
List<Menu> menuList = menuService.lambdaQuery()
.like(Menu::getMenuright, user1.getRoleId())
.list();
// 创建一个 HashMap 用于存储用户信息和菜单信息
HashMap res = new HashMap();
res.put("user", user1);
res.put("menu", menuList);
// 返回包含用户信息和菜单信息的成功结果
return Result.success(res);
}
// 登录失败,返回失败结果
return Result.fail();
}
/*
*
* @author
* @date 2023/1/4 15:02
*/
// 处理 POST 请求,请求路径为 /user/mod
@PostMapping("/mod")
// @RequestBody 注解将请求体中的 JSON 数据转换为 User 对象
public boolean mod(@RequestBody User user) {
// 调用 UserService 的 updateById 方法根据用户 ID 更新用户信息,返回更新结果
return userService.updateById(user);
}
/*
*
* @author
* @date 2023/1/2 19:12
*/
// 处理 POST 请求,请求路径为 /user/saveOrUpdate
@PostMapping("/saveOrUpdate")
// @RequestBody 注解将请求体中的 JSON 数据转换为 User 对象
public Result saveOrUpdate(@RequestBody User user) {
// 调用 UserService 的 saveOrUpdate 方法新增或更新用户信息,根据操作结果返回成功或失败的 Result 对象
return userService.saveOrUpdate(user) ? Result.success() : Result.fail();
}
/*
*
* @author
* @date 2023/1/2 19:15
*/
// 处理 GET 请求,请求路径为 /user/del
@GetMapping("/del")
// @RequestParam 注解用于从请求参数中获取用户 ID
public Result delete(Integer id) {
// 调用 UserService 的 removeById 方法根据用户 ID 删除用户信息,根据删除结果返回成功或失败的 Result 对象
return userService.removeById(id) ? Result.success() : Result.fail();
}
/*
*
* @author
* @date 2023/1/2 19:36
*/
// 处理 POST 请求,请求路径为 /user/listP
@PostMapping("/listP")
// @RequestBody 注解将请求体中的 JSON 数据转换为 User 对象
public Result query(@RequestBody User user) {
// 创建 LambdaQueryWrapper 对象用于构建查询条件
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
// 如果用户名称不为空,添加模糊查询条件
if (StringUtils.isNotBlank(user.getName())) {
wrapper.like(User::getName, user.getName());
}
// 调用 UserService 的 list 方法根据查询条件查询用户列表,并返回成功结果
return Result.success(userService.list(wrapper));
}
/*
*
* @author
* @date 2023/1/2 19:48
*/
// 处理 POST 请求,请求路径为 /user/listPage
@PostMapping("/listPage")
// @RequestBody 注解将请求体中的 JSON 数据转换为 QueryPageParam 对象
public List<User> listPage(@RequestBody QueryPageParam query) {
// 从 QueryPageParam 对象中获取查询参数
HashMap param = query.getParam();
// 从查询参数中获取用户名称
String name = (String) param.get("name");
System.out.println("name=>" + (String) param.get("name"));
// 创建 Page 对象用于存储分页信息
Page<User> page = new Page();
// 设置当前页码
page.setCurrent(query.getPageNum());
// 设置每页显示的记录数
page.setSize(query.getPageSize());
// 创建 LambdaQueryWrapper 对象用于构建查询条件
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper();
// 如果用户名称不为空,添加模糊查询条件
lambdaQueryWrapper.like(User::getName, name);
// 调用 UserService 的 page 方法进行分页查询
IPage result = userService.page(page, lambdaQueryWrapper);
System.out.println("total=>" + result.getTotal());
// 返回分页查询结果中的记录列表
return result.getRecords();
}
/*
*
* @author
* @date 2023/1/4 20:28
*/
// 处理 POST 请求,请求路径为 /user/listPageC1
@PostMapping("/listPageC1")
// @RequestBody 注解将请求体中的 JSON 数据转换为 QueryPageParam 对象
public Result listPageC1(@RequestBody QueryPageParam query) {
// 从 QueryPageParam 对象中获取查询参数
HashMap param = query.getParam();
// 从查询参数中获取用户名称
String name = (String) param.get("name");
// 从查询参数中获取用户性别
String sex = (String) param.get("sex");
// 从查询参数中获取用户角色 ID
String roleId = (String) param.get("roleId");
// 创建 Page 对象用于存储分页信息
Page<User> page = new Page();
// 设置当前页码
page.setCurrent(query.getPageNum());
// 设置每页显示的记录数
page.setSize(query.getPageSize());
// 创建 LambdaQueryWrapper 对象用于构建查询条件
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper();
// 如果用户名称不为空且不为 "null",添加模糊查询条件
if (StringUtils.isNotBlank(name) && !"null".equals(name)) {
lambdaQueryWrapper.like(User::getName, name);
}
// 如果用户性别不为空,添加精确查询条件
if (StringUtils.isNotBlank(sex)) {
lambdaQueryWrapper.eq(User::getSex, sex);
}
// 如果用户角色 ID 不为空,添加精确查询条件
if (StringUtils.isNotBlank(roleId)) {
lambdaQueryWrapper.eq(User::getRoleId, roleId);
}
// 调用 UserService 的 pageCC 方法进行分页查询
IPage result = userService.pageCC(page, lambdaQueryWrapper);
System.out.println("total=>" + result.getTotal());
// 返回包含分页查询结果记录列表和总记录数的成功结果
return Result.success(result.getRecords(), result.getTotal());
}
}

@ -0,0 +1,146 @@
package com.rabbiter.entity;
// 导入 MyBatis-Plus 框架的主键类型注解
import com.baomidou.mybatisplus.annotation.IdType;
// 导入 MyBatis-Plus 框架的主键注解
import com.baomidou.mybatisplus.annotation.TableId;
// 导入 MyBatis-Plus 框架的表字段注解
import com.baomidou.mybatisplus.annotation.TableField;
// 导入 Java 的序列化接口
import java.io.Serializable;
// 导入 Java 的对象比较工具类
import java.util.Objects;
// 导入 Swagger 的 API 模型注解
import io.swagger.annotations.ApiModel;
// 导入 Swagger 的 API 模型属性注解
import io.swagger.annotations.ApiModelProperty;
/**
* <p>
*
* </p>
*
* @author
* @since 2024-01-06
*/
// 使用 Swagger 的 @ApiModel 注解为该类添加 API 模型信息
@ApiModel(value="Goods对象", description="")
public class Goods implements Serializable {
// 定义序列化版本号,用于保证序列化和反序列化的兼容性
private static final long serialVersionUID = 1L;
// 使用 Swagger 的 @ApiModelProperty 注解为字段添加 API 模型属性信息
@ApiModelProperty(value = "主键")
// 使用 MyBatis-Plus 的 @TableId 注解指定该字段为主键,并设置主键生成策略为自动增长
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
@ApiModelProperty(value = "货名")
private String name;
@ApiModelProperty(value = "仓库")
private Integer storage;
@ApiModelProperty(value = "分类")
// 使用 MyBatis-Plus 的 @TableField 注解指定该字段在数据库表中的名称
@TableField("goodsType")
private Integer goodstype;
@ApiModelProperty(value = "数量")
private Integer count;
@ApiModelProperty(value = "备注")
private String remark;
// 提供 id 字段的 getter 方法
public Integer getId() {
return id;
}
// 提供 id 字段的 setter 方法
public void setId(Integer id) {
this.id = id;
}
// 提供 name 字段的 getter 方法
public String getName() {
return name;
}
// 提供 name 字段的 setter 方法
public void setName(String name) {
this.name = name;
}
// 提供 storage 字段的 getter 方法
public Integer getStorage() {
return storage;
}
// 提供 storage 字段的 setter 方法
public void setStorage(Integer storage) {
this.storage = storage;
}
// 提供 goodstype 字段的 getter 方法
public Integer getGoodstype() {
return goodstype;
}
// 提供 goodstype 字段的 setter 方法
public void setGoodstype(Integer goodstype) {
this.goodstype = goodstype;
}
// 提供 count 字段的 getter 方法
public Integer getCount() {
return count;
}
// 提供 count 字段的 setter 方法
public void setCount(Integer count) {
this.count = count;
}
// 提供 remark 字段的 getter 方法
public String getRemark() {
return remark;
}
// 提供 remark 字段的 setter 方法
public void setRemark(String remark) {
this.remark = remark;
}
// 重写 toString 方法,方便打印对象信息
@Override
public String toString() {
return "Goods{" +
"id=" + id +
", name='" + name + '\'' +
", storage=" + storage +
", goodstype=" + goodstype +
", count=" + count +
", remark='" + remark + '\'' +
'}';
}
// 重写 equals 方法,用于比较两个 Goods 对象是否相等
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Goods goods = (Goods) o;
// 使用 Objects.equals 方法比较对象的各个字段是否相等
return Objects.equals(id, goods.id) && Objects.equals(name, goods.name) && Objects.equals(storage, goods.storage) && Objects.equals(goodstype, goods.goodstype) && Objects.equals(count, goods.count) && Objects.equals(remark, goods.remark);
}
// 重写 hashCode 方法,用于生成对象的哈希码
@Override
public int hashCode() {
// 使用 Objects.hash 方法根据对象的各个字段生成哈希码
return Objects.hash(id, name, storage, goodstype, count, remark);
}
}

@ -0,0 +1,105 @@
package com.rabbiter.entity;
// 导入 MyBatis-Plus 框架中用于指定主键生成策略的枚举类
import com.baomidou.mybatisplus.annotation.IdType;
// 导入 MyBatis-Plus 框架中用于标记表主键的注解
import com.baomidou.mybatisplus.annotation.TableId;
// 导入 Java 中用于实现序列化的接口,使得该类的对象可以在网络传输或存储时进行序列化和反序列化
import java.io.Serializable;
// 导入 Java 中用于处理对象相等性和哈希码计算的工具类
import java.util.Objects;
// 导入 Swagger 框架中用于标记 API 模型的注解
import io.swagger.annotations.ApiModel;
// 导入 Swagger 框架中用于标记 API 模型属性的注解
import io.swagger.annotations.ApiModelProperty;
/**
* <p>
*
* </p>
*
* @author
* @since 2024-01-05
*/
// 使用 @ApiModel 注解将该类标记为 API 模型value 属性指定模型名称description 属性可对模型进行描述(这里为空)
@ApiModel(value="Goodstype对象", description="")
public class Goodstype implements Serializable {
// 定义一个序列化版本号,用于在反序列化时确保类的版本一致性
private static final long serialVersionUID = 1L;
// 使用 @ApiModelProperty 注解标记该属性在 API 文档中的描述信息,这里表示主键
@ApiModelProperty(value = "主键")
// 使用 @TableId 注解标记该属性为主键并指定主键生成策略为自动增长IdType.AUTO
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
// 使用 @ApiModelProperty 注解标记该属性在 API 文档中的描述信息,这里表示分类名
@ApiModelProperty(value = "分类名")
private String name;
// 使用 @ApiModelProperty 注解标记该属性在 API 文档中的描述信息,这里表示备注
@ApiModelProperty(value = "备注")
private String remark;
// id 属性的 getter 方法,用于获取主键值
public Integer getId() {
return id;
}
// id 属性的 setter 方法,用于设置主键值
public void setId(Integer id) {
this.id = id;
}
// name 属性的 getter 方法,用于获取分类名
public String getName() {
return name;
}
// name 属性的 setter 方法,用于设置分类名
public void setName(String name) {
this.name = name;
}
// remark 属性的 getter 方法,用于获取备注信息
public String getRemark() {
return remark;
}
// remark 属性的 setter 方法,用于设置备注信息
public void setRemark(String remark) {
this.remark = remark;
}
// 重写 toString 方法,返回该对象的字符串表示形式,方便调试和日志记录等场景
@Override
public String toString() {
return "Goodstype{" +
"id=" + id +
", name='" + name + '\'' +
", remark='" + remark + '\'' +
'}';
}
// 重写 equals 方法,用于比较两个 Goodstype 对象是否相等
@Override
public boolean equals(Object o) {
// 如果两个对象是同一个引用,则返回 true
if (this == o) return true;
// 如果 o 为 null 或者 o 的类与当前类不同,则返回 false
if (o == null || getClass() != o.getClass()) return false;
// 将 o 强制转换为 Goodstype 类型
Goodstype goodstype = (Goodstype) o;
// 使用 Objects.equals 方法比较两个对象的 id、name 和 remark 属性是否相等
return Objects.equals(id, goodstype.id) && Objects.equals(name, goodstype.name) && Objects.equals(remark, goodstype.remark);
}
// 重写 hashCode 方法,用于生成该对象的哈希码,以便在哈希表等数据结构中使用
@Override
public int hashCode() {
// 使用 Objects.hash 方法根据 id、name 和 remark 属性生成哈希码
return Objects.hash(id, name, remark);
}
}

@ -0,0 +1,197 @@
package com.rabbiter.entity;
// 导入 MyBatis-Plus 框架中用于标记表字段的注解类
import com.baomidou.mybatisplus.annotation.TableField;
// 导入 Java 中用于实现序列化的接口,使该类的对象可进行序列化和反序列化操作
import java.io.Serializable;
// 导入 Java 中用于处理对象相等性和哈希码计算的工具类
import java.util.Objects;
// 导入 Swagger 框架中用于标记 API 模型的注解
import io.swagger.annotations.ApiModel;
// 导入 Swagger 框架中用于标记 API 模型属性的注解
import io.swagger.annotations.ApiModelProperty;
/**
* <p>
*
* </p>
*
* @author
* @since 2024-01-03
*/
// 使用 @ApiModel 注解将该类标记为 API 模型value 属性指定模型名称description 属性可对模型进行描述(这里为空)
@ApiModel(value = "Menu对象", description = "")
public class Menu implements Serializable {
// 定义一个序列化版本号,用于在反序列化时确保类的版本一致性
private static final long serialVersionUID = 1L;
// 菜单的唯一标识字段
private Integer id;
// 使用 @ApiModelProperty 注解标记该属性在 API 文档中的描述信息,这里表示菜单编码
@ApiModelProperty(value = "菜单编码")
// 使用 @TableField 注解指定该属性在数据库表中的字段名
@TableField("menuCode")
private String menucode;
// 使用 @ApiModelProperty 注解标记该属性在 API 文档中的描述信息,这里表示菜单名字
@ApiModelProperty(value = "菜单名字")
@TableField("menuName")
private String menuname;
// 使用 @ApiModelProperty 注解标记该属性在 API 文档中的描述信息,这里表示菜单级别
@ApiModelProperty(value = "菜单级别")
@TableField("menuLevel")
private String menulevel;
// 使用 @ApiModelProperty 注解标记该属性在 API 文档中的描述信息,这里表示菜单的父 code
@ApiModelProperty(value = "菜单的父code")
@TableField("menuParentCode")
private String menuparentcode;
// 使用 @ApiModelProperty 注解标记该属性在 API 文档中的描述信息,这里表示点击触发的函数
@ApiModelProperty(value = "点击触发的函数")
@TableField("menuClick")
private String menuclick;
// 使用 @ApiModelProperty 注解标记该属性在 API 文档中的描述信息,这里表示权限
@ApiModelProperty(value = "权限 0超级管理员1表示管理员2表示普通用户可以用逗号组合使用")
@TableField("menuRight")
private String menuright;
// 使用 @TableField 注解指定该属性在数据库表中的字段名
@TableField("menuComponent")
private String menucomponent;
// 使用 @TableField 注解指定该属性在数据库表中的字段名
@TableField("menuIcon")
private String menuicon;
// id 属性的 getter 方法,用于获取菜单的唯一标识
public Integer getId() {
return id;
}
// id 属性的 setter 方法,用于设置菜单的唯一标识
public void setId(Integer id) {
this.id = id;
}
// menucode 属性的 getter 方法,用于获取菜单编码
public String getMenucode() {
return menucode;
}
// menucode 属性的 setter 方法,用于设置菜单编码
public void setMenucode(String menucode) {
this.menucode = menucode;
}
// menuname 属性的 getter 方法,用于获取菜单名字
public String getMenuname() {
return menuname;
}
// menuname 属性的 setter 方法,用于设置菜单名字
public void setMenuname(String menuname) {
this.menuname = menuname;
}
// menulevel 属性的 getter 方法,用于获取菜单级别
public String getMenulevel() {
return menulevel;
}
// menulevel 属性的 setter 方法,用于设置菜单级别
public void setMenulevel(String menulevel) {
this.menulevel = menulevel;
}
// menuparentcode 属性的 getter 方法,用于获取菜单的父 code
public String getMenuparentcode() {
return menuparentcode;
}
// menuparentcode 属性的 setter 方法,用于设置菜单的父 code
public void setMenuparentcode(String menuparentcode) {
this.menuparentcode = menuparentcode;
}
// menuclick 属性的 getter 方法,用于获取点击触发的函数
public String getMenuclick() {
return menuclick;
}
// menuclick 属性的 setter 方法,用于设置点击触发的函数
public void setMenuclick(String menuclick) {
this.menuclick = menuclick;
}
// menuright 属性的 getter 方法,用于获取权限信息
public String getMenuright() {
return menuright;
}
// menuright 属性的 setter 方法,用于设置权限信息
public void setMenuright(String menuright) {
this.menuright = menuright;
}
// menucomponent 属性的 getter 方法,用于获取菜单组件信息
public String getMenucomponent() {
return menucomponent;
}
// menucomponent 属性的 setter 方法,用于设置菜单组件信息
public void setMenucomponent(String menucomponent) {
this.menucomponent = menucomponent;
}
// menuicon 属性的 getter 方法,用于获取菜单图标信息
public String getMenuicon() {
return menuicon;
}
// menuicon 属性的 setter 方法,用于设置菜单图标信息
public void setMenuicon(String menuicon) {
this.menuicon = menuicon;
}
// 重写 toString 方法,返回 Menu 对象的字符串表示形式,方便调试和日志记录等
@Override
public String toString() {
return "Menu{" +
"id=" + id +
", menucode='" + menucode + '\'' +
", menuname='" + menuname + '\'' +
", menulevel='" + menulevel + '\'' +
", menuparentcode='" + menuparentcode + '\'' +
", menuclick='" + menuclick + '\'' +
", menuright='" + menuright + '\'' +
", menucomponent='" + menucomponent + '\'' +
", menuicon='" + menuicon + '\'' +
'}';
}
// 重写 equals 方法,用于比较两个 Menu 对象是否相等
@Override
public boolean equals(Object o) {
// 如果两个对象是同一个引用,则返回 true
if (this == o) return true;
// 如果 o 为 null 或者 o 的类与当前类不同,则返回 false
if (o == null || getClass() != o.getClass()) return false;
// 将 o 强制转换为 Menu 类型
Menu menu = (Menu) o;
// 使用 Objects.equals 方法比较两个对象的各个属性是否相等
return Objects.equals(id, menu.id) && Objects.equals(menucode, menu.menucode) && Objects.equals(menuname, menu.menuname) && Objects.equals(menulevel, menu.menulevel) && Objects.equals(menuparentcode, menu.menuparentcode) && Objects.equals(menuclick, menu.menuclick) && Objects.equals(menuright, menu.menuright) && Objects.equals(menucomponent, menu.menucomponent) && Objects.equals(menuicon, menu.menuicon);
}
// 重写 hashCode 方法,用于生成 Menu 对象的哈希码,以便在哈希表等数据结构中使用
@Override
public int hashCode() {
// 使用 Objects.hash 方法根据对象的各个属性生成哈希码
return Objects.hash(id, menucode, menuname, menulevel, menuparentcode, menuclick, menuright, menucomponent, menuicon);
}
}

@ -0,0 +1,186 @@
package com.rabbiter.entity;
// 导入 MyBatis-Plus 框架中用于指定主键生成策略的枚举类
import com.baomidou.mybatisplus.annotation.IdType;
// 导入 MyBatis-Plus 框架中用于标记表主键的注解
import com.baomidou.mybatisplus.annotation.TableId;
// 导入 Java 8 中用于处理日期和时间的类,这里表示操作时间
import java.time.LocalDateTime;
// 导入 MyBatis-Plus 框架中用于标记表字段的注解
import com.baomidou.mybatisplus.annotation.TableField;
// 导入 Java 中用于实现序列化的接口,使得该类的对象可以进行序列化和反序列化操作
import java.io.Serializable;
// 导入 Java 中用于处理对象相等性和哈希码计算的工具类
import java.util.Objects;
// 导入 Swagger 框架中用于标记 API 模型的注解
import io.swagger.annotations.ApiModel;
// 导入 Swagger 框架中用于标记 API 模型属性的注解
import io.swagger.annotations.ApiModelProperty;
/**
* <p>
*
* </p>
*
* @author
* @since 2024-01-06
*/
// 使用 @ApiModel 注解将该类标记为 API 模型value 属性指定模型名称description 属性可对模型进行描述(这里为空)
@ApiModel(value = "Record对象", description = "")
public class Record implements Serializable {
// 定义一个序列化版本号,用于在反序列化时确保类的版本一致性
private static final long serialVersionUID = 1L;
// 使用 @ApiModelProperty 注解标记该属性在 API 文档中的描述信息,这里表示主键
@ApiModelProperty(value = "主键")
// 使用 @TableId 注解标记该属性为主键并指定主键生成策略为自动增长IdType.AUTO
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
// 使用 @ApiModelProperty 注解标记该属性在 API 文档中的描述信息,这里表示货品 id
@ApiModelProperty(value = "货品id")
private Integer goods;
// 使用 @ApiModelProperty 注解标记该属性在 API 文档中的描述信息,这里表示取货人/补货人
@ApiModelProperty(value = "取货人/补货人")
// 使用 @TableField 注解指定该属性在数据库表中的字段名
@TableField("userId")
private Integer userid;
// 使用 @ApiModelProperty 注解标记该属性在 API 文档中的描述信息,这里表示操作人 id
@ApiModelProperty(value = "操作人id")
private Integer adminId;
// 使用 @ApiModelProperty 注解标记该属性在 API 文档中的描述信息,这里表示数量
@ApiModelProperty(value = "数量")
private Integer count;
// 使用 @ApiModelProperty 注解标记该属性在 API 文档中的描述信息,这里表示操作时间
@ApiModelProperty(value = "操作时间")
private LocalDateTime createtime;
// 使用 @ApiModelProperty 注解标记该属性在 API 文档中的描述信息,这里表示备注
@ApiModelProperty(value = "备注")
private String remark;
// 使用 @TableField 注解标记该属性exist = false 表示该属性在数据库表中不存在
@TableField(exist = false)
private String action;
// id 属性的 getter 方法,用于获取主键值
public Integer getId() {
return id;
}
// id 属性的 setter 方法,用于设置主键值
public void setId(Integer id) {
this.id = id;
}
// goods 属性的 getter 方法,用于获取货品 id
public Integer getGoods() {
return goods;
}
// goods 属性的 setter 方法,用于设置货品 id
public void setGoods(Integer goods) {
this.goods = goods;
}
// userid 属性的 getter 方法,用于获取取货人/补货人 id
public Integer getUserid() {
return userid;
}
// userid 属性的 setter 方法,用于设置取货人/补货人 id
public void setUserid(Integer userid) {
this.userid = userid;
}
// adminId 属性的 getter 方法,用于获取操作人 id
public Integer getAdminId() {
return adminId;
}
// adminId 属性的 setter 方法,用于设置操作人 id
public void setAdminId(Integer adminId) {
this.adminId = adminId;
}
// count 属性的 getter 方法,用于获取数量
public Integer getCount() {
return count;
}
// count 属性的 setter 方法,用于设置数量
public void setCount(Integer count) {
this.count = count;
}
// createtime 属性的 getter 方法,用于获取操作时间
public LocalDateTime getCreatetime() {
return createtime;
}
// createtime 属性的 setter 方法,用于设置操作时间
public void setCreatetime(LocalDateTime createtime) {
this.createtime = createtime;
}
// remark 属性的 getter 方法,用于获取备注信息
public String getRemark() {
return remark;
}
// remark 属性的 setter 方法,用于设置备注信息
public void setRemark(String remark) {
this.remark = remark;
}
// action 属性的 getter 方法,用于获取操作类型(在数据库表中不存在)
public String getAction() {
return action;
}
// action 属性的 setter 方法,用于设置操作类型(在数据库表中不存在)
public void setAction(String action) {
this.action = action;
}
// 重写 toString 方法,返回 Record 对象的字符串表示形式,方便调试和日志记录等
@Override
public String toString() {
return "Record{" +
"id=" + id +
", goods=" + goods +
", userid=" + userid +
", adminId=" + adminId +
", count=" + count +
", createtime=" + createtime +
", remark='" + remark + '\'' +
", action='" + action + '\'' +
'}';
}
// 重写 equals 方法,用于比较两个 Record 对象是否相等
@Override
public boolean equals(Object o) {
// 如果两个对象是同一个引用,则返回 true
if (this == o) return true;
// 如果 o 为 null 或者 o 的类与当前类不同,则返回 false
if (o == null || getClass() != o.getClass()) return false;
// 将 o 强制转换为 Record 类型
Record record = (Record) o;
// 使用 Objects.equals 方法比较两个对象的各个属性是否相等
return Objects.equals(id, record.id) && Objects.equals(goods, record.goods) && Objects.equals(userid, record.userid) && Objects.equals(adminId, record.adminId) && Objects.equals(count, record.count) && Objects.equals(createtime, record.createtime) && Objects.equals(remark, record.remark) && Objects.equals(action, record.action);
}
// 重写 hashCode 方法,用于生成 Record 对象的哈希码,以便在哈希表等数据结构中使用
@Override
public int hashCode() {
// 使用 Objects.hash 方法根据对象的各个属性生成哈希码
return Objects.hash(id, goods, userid, adminId, count, createtime, remark, action);
}
}

@ -0,0 +1,78 @@
package com.rabbiter.entity;
// 定义一个名为 RecordRes 的类,继承自 Record 类
public class RecordRes extends Record {
// 定义一个字符串类型的属性,用于存储用户名
private String username;
// 定义一个字符串类型的属性,用于存储管理员名
private String adminname;
// 定义一个字符串类型的属性,用于存储货品名
private String goodsname;
// 定义一个字符串类型的属性,用于存储仓库名
private String storagename;
// 定义一个字符串类型的属性,用于存储货品类型名
private String goodstypename;
// username 属性的 getter 方法,用于获取用户名
public String getUsername() {
return username;
}
// username 属性的 setter 方法,用于设置用户名
public void setUsername(String username) {
this.username = username;
}
// adminname 属性的 getter 方法,用于获取管理员名
public String getAdminname() {
return adminname;
}
// adminname 属性的 setter 方法,用于设置管理员名
public void setAdminname(String adminname) {
this.adminname = adminname;
}
// goodsname 属性的 getter 方法,用于获取货品名
public String getGoodsname() {
return goodsname;
}
// goodsname 属性的 setter 方法,用于设置货品名
public void setGoodsname(String goodsname) {
this.goodsname = goodsname;
}
// storagename 属性的 getter 方法,用于获取仓库名
public String getStoragename() {
return storagename;
}
// storagename 属性的 setter 方法,用于设置仓库名
public void setStoragename(String storagename) {
this.storagename = storagename;
}
// goodstypename 属性的 getter 方法,用于获取货品类型名
public String getGoodstypename() {
return goodstypename;
}
// goodstypename 属性的 setter 方法,用于设置货品类型名
public void setGoodstypename(String goodstypename) {
this.goodstypename = goodstypename;
}
// 重写 toString 方法,返回 RecordRes 对象的字符串表示形式
@Override
public String toString() {
return "RecordRes{" +
"username='" + username + '\'' +
", adminname='" + adminname + '\'' +
", goodsname='" + goodsname + '\'' +
", storagename='" + storagename + '\'' +
", goodstypename='" + goodstypename + '\'' +
'}';
}
}

@ -0,0 +1,105 @@
package com.rabbiter.entity;
// 导入 MyBatis-Plus 框架中用于指定主键生成策略的枚举类
import com.baomidou.mybatisplus.annotation.IdType;
// 导入 MyBatis-Plus 框架中用于标记表主键的注解
import com.baomidou.mybatisplus.annotation.TableId;
// 导入 Java 中用于实现序列化的接口,使该类的对象可进行序列化和反序列化操作
import java.io.Serializable;
// 导入 Java 中用于处理对象相等性和哈希码计算的工具类
import java.util.Objects;
// 导入 Swagger 框架中用于标记 API 模型的注解
import io.swagger.annotations.ApiModel;
// 导入 Swagger 框架中用于标记 API 模型属性的注解
import io.swagger.annotations.ApiModelProperty;
/**
* <p>
*
* </p>
*
* @author
* @since 2024-01-05
*/
// 使用 @ApiModel 注解将该类标记为 API 模型value 属性指定模型名称description 属性可对模型进行描述(这里为空)
@ApiModel(value = "Storage对象", description = "")
public class Storage implements Serializable {
// 定义一个序列化版本号,用于在反序列化时确保类的版本一致性
private static final long serialVersionUID = 1L;
// 使用 @ApiModelProperty 注解标记该属性在 API 文档中的描述信息,这里表示主键
@ApiModelProperty(value = "主键")
// 使用 @TableId 注解标记该属性为主键并指定主键生成策略为自动增长IdType.AUTO
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
// 使用 @ApiModelProperty 注解标记该属性在 API 文档中的描述信息,这里表示仓库名
@ApiModelProperty(value = "仓库名")
private String name;
// 使用 @ApiModelProperty 注解标记该属性在 API 文档中的描述信息,这里表示备注
@ApiModelProperty(value = "备注")
private String remark;
// id 属性的 getter 方法,用于获取主键值
public Integer getId() {
return id;
}
// id 属性的 setter 方法,用于设置主键值
public void setId(Integer id) {
this.id = id;
}
// name 属性的 getter 方法,用于获取仓库名
public String getName() {
return name;
}
// name 属性的 setter 方法,用于设置仓库名
public void setName(String name) {
this.name = name;
}
// remark 属性的 getter 方法,用于获取备注信息
public String getRemark() {
return remark;
}
// remark 属性的 setter 方法,用于设置备注信息
public void setRemark(String remark) {
this.remark = remark;
}
// 重写 toString 方法,返回该对象的字符串表示形式,方便调试和日志记录等场景
@Override
public String toString() {
return "Storage{" +
"id=" + id +
", name='" + name + '\'' +
", remark='" + remark + '\'' +
'}';
}
// 重写 equals 方法,用于比较两个 Storage 对象是否相等
@Override
public boolean equals(Object o) {
// 如果两个对象是同一个引用,则返回 true
if (this == o) return true;
// 如果 o 为 null 或者 o 的类与当前类不同,则返回 false
if (o == null || getClass() != o.getClass()) return false;
// 将 o 强制转换为 Storage 类型
Storage storage = (Storage) o;
// 使用 Objects.equals 方法比较两个对象的 id、name 和 remark 属性是否相等
return Objects.equals(id, storage.id) && Objects.equals(name, storage.name) && Objects.equals(remark, storage.remark);
}
// 重写 hashCode 方法,用于生成该对象的哈希码,以便在哈希表等数据结构中使用
@Override
public int hashCode() {
// 使用 Objects.hash 方法根据 id、name 和 remark 属性生成哈希码
return Objects.hash(id, name, remark);
}
}

@ -0,0 +1,198 @@
package com.rabbiter.entity;
// 导入 MyBatis-Plus 框架中用于指定主键生成策略的枚举类
import com.baomidou.mybatisplus.annotation.IdType;
// 导入 MyBatis-Plus 框架中用于标记表主键的注解
import com.baomidou.mybatisplus.annotation.TableId;
// 导入 MyBatis-Plus 框架中用于标记表字段的注解
import com.baomidou.mybatisplus.annotation.TableField;
// 导入 Java 中用于实现序列化的接口,使得该类的对象可以在网络传输或存储时进行序列化和反序列化
import java.io.Serializable;
// 导入 Java 中用于处理对象相等性和哈希码计算的工具类
import java.util.Objects;
// 导入 Swagger 框架中用于标记 API 模型的注解
import io.swagger.annotations.ApiModel;
// 导入 Swagger 框架中用于标记 API 模型属性的注解
import io.swagger.annotations.ApiModelProperty;
/**
* <p>
*
* </p>
*
* @author
* @since 2024-01-02
*/
// 使用 @ApiModel 注解将该类标记为 API 模型value 属性指定模型名称description 属性可对模型进行描述(这里为空)
@ApiModel(value = "User对象", description = "")
public class User implements Serializable {
// 定义一个序列化版本号,用于在反序列化时确保类的版本一致性
private static final long serialVersionUID = 1L;
// 使用 @ApiModelProperty 注解标记该属性在 API 文档中的描述信息,这里表示主键
@ApiModelProperty(value = "主键")
// 使用 @TableId 注解标记该属性为主键并指定主键生成策略为自动增长IdType.AUTO
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
// 使用 @ApiModelProperty 注解标记该属性在 API 文档中的描述信息,这里表示账号
@ApiModelProperty(value = "账号")
private String no;
// 使用 @ApiModelProperty 注解标记该属性在 API 文档中的描述信息,这里表示名字
@ApiModelProperty(value = "名字")
private String name;
// 使用 @ApiModelProperty 注解标记该属性在 API 文档中的描述信息,这里表示密码
@ApiModelProperty(value = "密码")
private String password;
// 定义一个整数类型的属性,表示年龄,未使用 @ApiModelProperty 注解,可能在某些情况下不需要在 API 文档中特别说明
private Integer age;
// 使用 @ApiModelProperty 注解标记该属性在 API 文档中的描述信息,这里表示性别
@ApiModelProperty(value = "性别")
private Integer sex;
// 使用 @ApiModelProperty 注解标记该属性在 API 文档中的描述信息,这里表示电话
@ApiModelProperty(value = "电话")
private String phone;
// 使用 @ApiModelProperty 注解标记该属性在 API 文档中的描述信息,这里表示角色
@ApiModelProperty(value = "角色 0超级管理员1管理员2普通账号")
private Integer roleId;
// 使用 @ApiModelProperty 注解标记该属性在 API 文档中的描述信息,这里表示是否有效
@ApiModelProperty(value = "是否有效Y有效其他无效")
// 使用 @TableField 注解指定该属性在数据库表中的字段名isValid
@TableField("isValid")
private String isvalid;
// id 属性的 getter 方法,用于获取主键值
public Integer getId() {
return id;
}
// id 属性的 setter 方法,用于设置主键值
public void setId(Integer id) {
this.id = id;
}
// no 属性的 getter 方法,用于获取账号
public String getNo() {
return no;
}
// no 属性的 setter 方法,用于设置账号
public void setNo(String no) {
this.no = no;
}
// name 属性的 getter 方法,用于获取名字
public String getName() {
return name;
}
// name 属性的 setter 方法,用于设置名字
public void setName(String name) {
this.name = name;
}
// password 属性的 getter 方法,用于获取密码
public String getPassword() {
return password;
}
// password 属性的 setter 方法,用于设置密码
public void setPassword(String password) {
this.password = password;
}
// age 属性的 getter 方法,用于获取年龄
public Integer getAge() {
return age;
}
// age 属性的 setter 方法,用于设置年龄
public void setAge(Integer age) {
this.age = age;
}
// sex 属性的 getter 方法,用于获取性别
public Integer getSex() {
return sex;
}
// sex 属性的 setter 方法,用于设置性别
public void setSex(Integer sex) {
this.sex = sex;
}
// phone 属性的 getter 方法,用于获取电话
public String getPhone() {
return phone;
}
// phone 属性的 setter 方法,用于设置电话
public void setPhone(String phone) {
this.phone = phone;
}
// roleId 属性的 getter 方法,用于获取角色 ID
public Integer getRoleId() {
return roleId;
}
// roleId 属性的 setter 方法,用于设置角色 ID
public void setRoleId(Integer roleId) {
this.roleId = roleId;
}
// isvalid 属性的 getter 方法,用于获取是否有效信息
public String getIsvalid() {
return isvalid;
}
// isvalid 属性的 setter 方法,用于设置是否有效信息
public void setIsvalid(String isvalid) {
this.isvalid = isvalid;
}
// 重写 toString 方法,返回 User 对象的字符串表示形式,方便调试和日志记录等场景
@Override
public String toString() {
return "User{" +
"id=" + id +
", no='" + no + '\'' +
", name='" + name + '\'' +
", password='" + password + '\'' +
", age=" + age +
", sex=" + sex +
", phone='" + phone + '\'' +
", roleId=" + roleId +
", isvalid='" + isvalid + '\'' +
'}';
}
// 重写 equals 方法,用于比较两个 User 对象是否相等
@Override
public boolean equals(Object o) {
// 如果两个对象是同一个引用,则返回 true
if (this == o) return true;
// 如果 o 为 null 或者 o 的类与当前类不同,则返回 false
if (o == null || getClass() != o.getClass()) return false;
// 将 o 强制转换为 User 类型
User user = (User) o;
// 使用 Objects.equals 方法比较两个对象的各个属性是否相等
return Objects.equals(id, user.id) && Objects.equals(no, user.no) && Objects.equals(name, user.name) && Objects.equals(password, user.password) && Objects.equals(age, user.age) && Objects.equals(sex, user.sex) && Objects.equals(phone, user.phone) && Objects.equals(roleId, user.roleId) && Objects.equals(isvalid, user.isvalid);
}
// 重写 hashCode 方法,用于生成 User 对象的哈希码,以便在哈希表等数据结构中使用
@Override
public int hashCode() {
// 使用 Objects.hash 方法根据对象的各个属性生成哈希码
return Objects.hash(id, no, name, password, age, sex, phone, roleId, isvalid);
}
}

@ -0,0 +1,22 @@
package com.rabbiter.mapper;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.rabbiter.entity.Goods;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
/**
* <p>
* Mapper
* </p>
*
* @author
* @since 2024-01-06
*/
@Mapper
public interface GoodsMapper extends BaseMapper<Goods> {
IPage pageCC(IPage<Goods> page, @Param(Constants.WRAPPER) Wrapper wrapper);
}

@ -0,0 +1,22 @@
package com.rabbiter.mapper;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.rabbiter.entity.Goodstype;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
/**
* <p>
* Mapper
* </p>
*
* @author
* @since 2024-01-05
*/
@Mapper
public interface GoodstypeMapper extends BaseMapper<Goodstype> {
IPage pageCC(IPage<Goodstype> page, @Param(Constants.WRAPPER) Wrapper wrapper);
}

@ -0,0 +1,18 @@
package com.rabbiter.mapper;
import com.rabbiter.entity.Menu;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
/**
* <p>
* Mapper
* </p>
*
* @author
* @since 2024-01-03
*/
@Mapper
public interface MenuMapper extends BaseMapper<Menu> {
}

@ -0,0 +1,22 @@
package com.rabbiter.mapper;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.rabbiter.entity.Record;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
/**
* <p>
* Mapper
* </p>
*
* @author
* @since 2024-01-06
*/
@Mapper
public interface RecordMapper extends BaseMapper<Record> {
IPage pageCC(IPage<Record> page, @Param(Constants.WRAPPER) Wrapper wrapper);
}

@ -0,0 +1,22 @@
package com.rabbiter.mapper;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.rabbiter.entity.Storage;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
/**
* <p>
* Mapper
* </p>
*
* @author
* @since 2024-01-05
*/
@Mapper
public interface StorageMapper extends BaseMapper<Storage> {
IPage pageCC(IPage<Storage> page, @Param(Constants.WRAPPER) Wrapper wrapper);
}

@ -0,0 +1,24 @@
package com.rabbiter.mapper;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.rabbiter.entity.User;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
/**
* <p>
* Mapper
* </p>
*
* @author
* @since 2024-01-02
*/
@Mapper
public interface UserMapper extends BaseMapper<User> {
IPage pageC(IPage<User> page);
IPage pageCC(IPage<User> page, @Param(Constants.WRAPPER) Wrapper wrapper);
}

@ -0,0 +1,18 @@
package com.rabbiter.service;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.rabbiter.entity.Goods;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
*
* </p>
*
* @author
* @since 2024-01-06
*/
public interface GoodsService extends IService<Goods> {
IPage pageCC(IPage<Goods> page, Wrapper wrapper);
}

@ -0,0 +1,18 @@
package com.rabbiter.service;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.rabbiter.entity.Goodstype;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
*
* </p>
*
* @author
* @since 2024-01-05
*/
public interface GoodstypeService extends IService<Goodstype> {
IPage pageCC(IPage<Goodstype> page, Wrapper wrapper);
}

@ -0,0 +1,28 @@
package com.rabbiter.service.Impl;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.rabbiter.entity.Goods;
import com.rabbiter.mapper.GoodsMapper;
import com.rabbiter.service.GoodsService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
* <p>
*
* </p>
*
* @author
* @since 2024-01-06
*/
@Service
public class GoodsServiceImpl extends ServiceImpl<GoodsMapper, Goods> implements GoodsService {
@Autowired
private GoodsMapper goodsMapper;
@Override
public IPage pageCC(IPage<Goods> page, Wrapper wrapper) {
return goodsMapper.pageCC(page,wrapper);
}
}

@ -0,0 +1,30 @@
package com.rabbiter.service.Impl;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.rabbiter.entity.Goodstype;
import com.rabbiter.mapper.GoodstypeMapper;
import com.rabbiter.service.GoodstypeService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
* <p>
*
* </p>
*
* @author
* @since 2024-01-05
*/
@Service
public class GoodstypeServiceImpl extends ServiceImpl<GoodstypeMapper, Goodstype> implements GoodstypeService {
@Autowired
private GoodstypeMapper goodstypeMapper;
@Override
public IPage pageCC(IPage<Goodstype> page, Wrapper wrapper) {
return goodstypeMapper.pageCC(page,wrapper);
}
}

@ -0,0 +1,20 @@
package com.rabbiter.service.Impl;
import com.rabbiter.entity.Menu;
import com.rabbiter.mapper.MenuMapper;
import com.rabbiter.service.MenuService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
*
* </p>
*
* @author
* @since 2024-01-03
*/
@Service
public class MenuServiceImpl extends ServiceImpl<MenuMapper, Menu> implements MenuService {
}

@ -0,0 +1,29 @@
package com.rabbiter.service.Impl;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.rabbiter.entity.Record;
import com.rabbiter.mapper.RecordMapper;
import com.rabbiter.service.RecordService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
* <p>
*
* </p>
*
* @author
* @since 2024-01-06
*/
@Service
public class RecordServiceImpl extends ServiceImpl<RecordMapper, Record> implements RecordService {
@Autowired
private RecordMapper recordMapper;
@Override
public IPage pageCC(IPage<Record> page, Wrapper wrapper) {
return recordMapper.pageCC(page,wrapper);
}
}

@ -0,0 +1,29 @@
package com.rabbiter.service.Impl;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.rabbiter.entity.Storage;
import com.rabbiter.mapper.StorageMapper;
import com.rabbiter.service.StorageService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
* <p>
*
* </p>
*
* @author
* @since 2024-01-05
*/
@Service
public class StorageServiceImpl extends ServiceImpl<StorageMapper, Storage> implements StorageService {
@Autowired
private StorageMapper storageMapper;
@Override
public IPage pageCC(IPage<Storage> page, Wrapper wrapper) {
return storageMapper.pageCC(page,wrapper);
}
}

@ -0,0 +1,33 @@
package com.rabbiter.service.Impl;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.rabbiter.entity.User;
import com.rabbiter.mapper.UserMapper;
import com.rabbiter.service.UserService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
* <p>
*
* </p>
*
* @author
* @since 2024-01-02
*/
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
@Autowired
private UserMapper userMapper;
@Override
public IPage pageC(IPage<User> page) {
return userMapper.pageC(page);
}
@Override
public IPage pageCC(IPage<User> page, Wrapper wrapper) {
return userMapper.pageCC(page,wrapper);
}
}

@ -0,0 +1,16 @@
package com.rabbiter.service;
import com.rabbiter.entity.Menu;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
*
* </p>
*
* @author
* @since 2024-01-03
*/
public interface MenuService extends IService<Menu> {
}

@ -0,0 +1,18 @@
package com.rabbiter.service;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.rabbiter.entity.Record;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
*
* </p>
*
* @author
* @since 2024-01-06
*/
public interface RecordService extends IService<Record> {
IPage pageCC(IPage<Record> page, Wrapper wrapper);
}

@ -0,0 +1,18 @@
package com.rabbiter.service;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.rabbiter.entity.Storage;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
*
* </p>
*
* @author
* @since 2024-01-05
*/
public interface StorageService extends IService<Storage> {
IPage pageCC(IPage<Storage> page, Wrapper wrapper);
}

@ -0,0 +1,20 @@
package com.rabbiter.service;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.rabbiter.entity.User;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
*
* </p>
*
* @author
* @since 2024-01-02
*/
public interface UserService extends IService<User> {
IPage pageC(IPage<User> page);
IPage pageCC(IPage<User> page, Wrapper wrapper);
}

@ -0,0 +1,13 @@
server:
port: 9131
spring:
datasource:
url: jdbc:mysql://localhost:3306/warehouse_manager?useUnicode=true&characterEncoding=utf-8&serveTimezone=UTC&useSSL=false&allowPublicKeyRetrieval=true
driver-class-name: com.mysql.cj.jdbc.Driver
username: root
password: LYH666666
Logging:
level:
com.rabbiter: debug

@ -0,0 +1,24 @@
<?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.rabbiter.mapper.GoodsMapper">
<select id="pageCC" resultType="com.rabbiter.entity.Goods">
select * from goods ${ew.customSqlSegment}
</select>
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.rabbiter.entity.Goods">
<id column="id" property="id" />
<result column="name" property="name" />
<result column="storage" property="storage" />
<result column="goodsType" property="goodstype" />
<result column="count" property="count" />
<result column="remark" property="remark" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
id, name, storage, goodsType, count, remark
</sql>
</mapper>

@ -0,0 +1,21 @@
<?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.rabbiter.mapper.GoodstypeMapper">
<select id="pageCC" resultType="com.rabbiter.entity.Goodstype">
select * from goodstype ${ew.customSqlSegment}
</select>
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.rabbiter.entity.Goodstype">
<id column="id" property="id" />
<result column="name" property="name" />
<result column="remark" property="remark" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
id, name, remark
</sql>
</mapper>

@ -0,0 +1,23 @@
<?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.rabbiter.mapper.MenuMapper">
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.rabbiter.entity.Menu">
<id column="id" property="id" />
<result column="menuCode" property="menucode" />
<result column="menuName" property="menuname" />
<result column="menuLevel" property="menulevel" />
<result column="menuParentCode" property="menuparentcode" />
<result column="menuClick" property="menuclick" />
<result column="menuRight" property="menuright" />
<result column="menuComponent" property="menucomponent" />
<result column="menuIcon" property="menuicon" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
id, menuCode, menuName, menuLevel, menuParentCode, menuClick, menuRight, menuComponent, menuIcon
</sql>
</mapper>

@ -0,0 +1,29 @@
<?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.rabbiter.mapper.RecordMapper">
<select id="pageCC" resultType="com.rabbiter.entity.RecordRes">
select a.*,b.name goodsname,c.name storagename,d.name goodstypename,
(select u.name from user u where u.id=a.userid)username,
(select u.name from user u where u.id=a.admin_id)adminname
from record a ,goods b,storage c,goodstype d
${ew.customSqlSegment}
</select>
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.rabbiter.entity.Record">
<id column="id" property="id" />
<result column="goods" property="goods" />
<result column="userId" property="userid" />
<result column="admin_id" property="adminId" />
<result column="count" property="count" />
<result column="createtime" property="createtime" />
<result column="remark" property="remark" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
id, goods, userId, admin_id, count, createtime, remark
</sql>
</mapper>

@ -0,0 +1,20 @@
<?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.rabbiter.mapper.StorageMapper">
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.rabbiter.entity.Storage">
<id column="id" property="id" />
<result column="name" property="name" />
<result column="remark" property="remark" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
id, name, remark
</sql>
<select id="pageCC" resultType="com.rabbiter.entity.Storage">
select * from storage ${ew.customSqlSegment}
</select>
</mapper>

@ -0,0 +1,31 @@
<?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.rabbiter.mapper.UserMapper">
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.rabbiter.entity.User">
<id column="id" property="id" />
<result column="no" property="no" />
<result column="name" property="name" />
<result column="password" property="password" />
<result column="age" property="age" />
<result column="sex" property="sex" />
<result column="phone" property="phone" />
<result column="role_id" property="roleId" />
<result column="isValid" property="isvalid" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
id, no, name, password, age, sex, phone, role_id, isValid
</sql>
<select id="pageC" resultType="com.rabbiter.entity.User">
select * from user
</select>
<select id="pageCC" resultType="com.rabbiter.entity.User">
select * from user ${ew.customSqlSegment}
</select>
</mapper>

@ -0,0 +1,13 @@
server:
port: 9131
spring:
datasource:
url: jdbc:mysql://localhost:3306/warehouse_manager?useUnicode=true&characterEncoding=utf-8&serveTimezone=UTC&useSSL=false&allowPublicKeyRetrieval=true
driver-class-name: com.mysql.cj.jdbc.Driver
username: root
password: LYH666666
Logging:
level:
com.rabbiter: debug

@ -0,0 +1,24 @@
<?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.rabbiter.mapper.GoodsMapper">
<select id="pageCC" resultType="com.rabbiter.entity.Goods">
select * from goods ${ew.customSqlSegment}
</select>
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.rabbiter.entity.Goods">
<id column="id" property="id" />
<result column="name" property="name" />
<result column="storage" property="storage" />
<result column="goodsType" property="goodstype" />
<result column="count" property="count" />
<result column="remark" property="remark" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
id, name, storage, goodsType, count, remark
</sql>
</mapper>

@ -0,0 +1,21 @@
<?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.rabbiter.mapper.GoodstypeMapper">
<select id="pageCC" resultType="com.rabbiter.entity.Goodstype">
select * from goodstype ${ew.customSqlSegment}
</select>
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.rabbiter.entity.Goodstype">
<id column="id" property="id" />
<result column="name" property="name" />
<result column="remark" property="remark" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
id, name, remark
</sql>
</mapper>

@ -0,0 +1,23 @@
<?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.rabbiter.mapper.MenuMapper">
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.rabbiter.entity.Menu">
<id column="id" property="id" />
<result column="menuCode" property="menucode" />
<result column="menuName" property="menuname" />
<result column="menuLevel" property="menulevel" />
<result column="menuParentCode" property="menuparentcode" />
<result column="menuClick" property="menuclick" />
<result column="menuRight" property="menuright" />
<result column="menuComponent" property="menucomponent" />
<result column="menuIcon" property="menuicon" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
id, menuCode, menuName, menuLevel, menuParentCode, menuClick, menuRight, menuComponent, menuIcon
</sql>
</mapper>

@ -0,0 +1,29 @@
<?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.rabbiter.mapper.RecordMapper">
<select id="pageCC" resultType="com.rabbiter.entity.RecordRes">
select a.*,b.name goodsname,c.name storagename,d.name goodstypename,
(select u.name from user u where u.id=a.userid)username,
(select u.name from user u where u.id=a.admin_id)adminname
from record a ,goods b,storage c,goodstype d
${ew.customSqlSegment}
</select>
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.rabbiter.entity.Record">
<id column="id" property="id" />
<result column="goods" property="goods" />
<result column="userId" property="userid" />
<result column="admin_id" property="adminId" />
<result column="count" property="count" />
<result column="createtime" property="createtime" />
<result column="remark" property="remark" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
id, goods, userId, admin_id, count, createtime, remark
</sql>
</mapper>

@ -0,0 +1,20 @@
<?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.rabbiter.mapper.StorageMapper">
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.rabbiter.entity.Storage">
<id column="id" property="id" />
<result column="name" property="name" />
<result column="remark" property="remark" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
id, name, remark
</sql>
<select id="pageCC" resultType="com.rabbiter.entity.Storage">
select * from storage ${ew.customSqlSegment}
</select>
</mapper>

@ -0,0 +1,31 @@
<?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.rabbiter.mapper.UserMapper">
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.rabbiter.entity.User">
<id column="id" property="id" />
<result column="no" property="no" />
<result column="name" property="name" />
<result column="password" property="password" />
<result column="age" property="age" />
<result column="sex" property="sex" />
<result column="phone" property="phone" />
<result column="role_id" property="roleId" />
<result column="isValid" property="isvalid" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
id, no, name, password, age, sex, phone, role_id, isValid
</sql>
<select id="pageC" resultType="com.rabbiter.entity.User">
select * from user
</select>
<select id="pageCC" resultType="com.rabbiter.entity.User">
select * from user ${ew.customSqlSegment}
</select>
</mapper>

@ -0,0 +1,166 @@
/*
Navicat Premium Data Transfer
Source Server : localhost
Source Server Type : MySQL
Source Server Version : 80019
Source Host : localhost:3306
Source Schema : warehouse_manager
Target Server Type : MySQL
Target Server Version : 80019
File Encoding : 65001
Date: 06/07/2024 19:24:10
*/
SET NAMES utf8;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for goods
-- ----------------------------
DROP TABLE IF EXISTS `goods`;
CREATE TABLE `goods` (
`id` int(0) NOT NULL AUTO_INCREMENT COMMENT '主键',
`name` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '货名',
`storage` int(0) NOT NULL COMMENT '仓库',
`goodsType` int(0) NOT NULL COMMENT '分类',
`count` int(0) NULL DEFAULT NULL COMMENT '数量',
`remark` varchar(1000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '备注',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 13 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of goods
-- ----------------------------
INSERT INTO `goods` VALUES (1, 'iPhone14', 2, 2, 95, '货物不可以挤压');
INSERT INTO `goods` VALUES (4, '洁面乳', 1, 1, 1047, '货物不可以挤压');
INSERT INTO `goods` VALUES (5, '葡萄', 5, 5, 500, '货物不可以挤压');
INSERT INTO `goods` VALUES (6, '西红柿', 5, 6, 800, '货物不可以挤压');
INSERT INTO `goods` VALUES (7, '皮皮虾', 4, 4, 500, '货物不可以挤压');
INSERT INTO `goods` VALUES (8, 'AD钙', 3, 3, 400, '货物不可以挤压');
INSERT INTO `goods` VALUES (11, 'iPad Air5', 2, 2, 800, '货物不可以挤压');
INSERT INTO `goods` VALUES (12, '旺仔牛奶', 3, 3, 1550, '');
-- ----------------------------
-- Table structure for goodstype
-- ----------------------------
DROP TABLE IF EXISTS `goodstype`;
CREATE TABLE `goodstype` (
`id` int(0) NOT NULL AUTO_INCREMENT COMMENT '主键',
`name` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '分类名',
`remark` varchar(1000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '备注',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 7 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of goodstype
-- ----------------------------
INSERT INTO `goodstype` VALUES (1, '日用品', '日常生活用品');
INSERT INTO `goodstype` VALUES (2, '数码产品', '数码产品');
INSERT INTO `goodstype` VALUES (3, '食品', '食品');
INSERT INTO `goodstype` VALUES (4, '冷冻品', '冷冻食品');
INSERT INTO `goodstype` VALUES (5, '水果', '水果产品');
INSERT INTO `goodstype` VALUES (6, '蔬菜', '蔬菜产品');
-- ----------------------------
-- Table structure for menu
-- ----------------------------
DROP TABLE IF EXISTS `menu`;
CREATE TABLE `menu` (
`id` int(0) NOT NULL COMMENT '主键',
`menuCode` varchar(8) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '菜单编码',
`menuName` varchar(16) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '菜单名字',
`menuLevel` varchar(2) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '菜单级别',
`menuParentCode` varchar(8) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '菜单的父code',
`menuClick` varchar(16) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '点击触发的函数',
`menuRight` varchar(8) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '权限 0超级管理员1表示管理员2表示普通用户可以用逗号组合使用',
`menuComponent` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '对应Vue菜单组件',
`menuIcon` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '菜单图标',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of menu
-- ----------------------------
INSERT INTO `menu` VALUES (1, '001', '管理员信息管理', '1', NULL, 'Admin', '0', 'admin/AdminManage.vue', 'iconfont icon-r-setting');
INSERT INTO `menu` VALUES (2, '002', '用户信息管理', '1', NULL, 'User', '0,1', 'user/UserManage.vue', 'iconfont icon-r-user1');
INSERT INTO `menu` VALUES (3, '003', '仓库信息管理', '1', NULL, 'Storage', '0,1', 'storage/StorageManage', 'iconfont icon-r-shield');
INSERT INTO `menu` VALUES (4, '004', '物品分类管理', '1', NULL, 'Goodstype', '0,1', 'goodstype/GoodstypeManage', 'iconfont icon-r-list');
INSERT INTO `menu` VALUES (5, '005', '物品信息管理 ', '1', NULL, 'Goods', '0,1,2', 'goods/GoodsManage', 'iconfont icon-r-mark1');
INSERT INTO `menu` VALUES (6, '006', '操作日志', '1', NULL, 'Record', '0,1,2', 'record/RecordManage', 'iconfont icon-r-paper');
-- ----------------------------
-- Table structure for record
-- ----------------------------
DROP TABLE IF EXISTS `record`;
CREATE TABLE `record` (
`id` int(0) NOT NULL AUTO_INCREMENT COMMENT '主键',
`goods` int(0) NOT NULL COMMENT '货品id',
`userId` int(0) NULL DEFAULT NULL COMMENT '取货人/补货人',
`admin_id` int(0) NULL DEFAULT NULL COMMENT '操作人id',
`count` int(0) NULL DEFAULT NULL COMMENT '数量',
`createtime` datetime NULL DEFAULT NULL COMMENT '操作时间',
`remark` varchar(1000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '备注',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 20 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of record
-- ----------------------------
INSERT INTO `record` VALUES (1, 1, 3, 2, 100, '2023-01-06 20:46:48', '取货');
INSERT INTO `record` VALUES (12, 1, 3, 1, -5, '2023-01-19 15:32:27', '');
INSERT INTO `record` VALUES (15, 4, 3, 1, 100, '2023-06-11 21:08:13', '');
INSERT INTO `record` VALUES (16, 4, 3, 1, -50, '2023-06-11 21:08:25', '');
INSERT INTO `record` VALUES (17, 4, 3, 1, 100, '2023-06-11 21:17:24', '');
INSERT INTO `record` VALUES (18, 4, 3, 1, -200, '2023-06-11 21:17:33', '');
INSERT INTO `record` VALUES (19, 4, 3, 1, 100, '2023-08-06 11:15:11', '');
-- ----------------------------
-- Table structure for storage
-- ----------------------------
DROP TABLE IF EXISTS `storage`;
CREATE TABLE `storage` (
`id` int(0) NOT NULL AUTO_INCREMENT COMMENT '主键',
`name` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '仓库名',
`remark` varchar(1000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '备注',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 8 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of storage
-- ----------------------------
INSERT INTO `storage` VALUES (1, '日用品仓库', '用于存放日用品');
INSERT INTO `storage` VALUES (2, '数码仓库', '用于存放数码产品');
INSERT INTO `storage` VALUES (3, '食品仓库', '用于存放食品');
INSERT INTO `storage` VALUES (4, '冷冻仓库', '用于存放冷冻食品');
INSERT INTO `storage` VALUES (5, '果蔬仓库', '用于存放水果和蔬菜');
INSERT INTO `storage` VALUES (6, '服装仓库', '用于存放服装');
INSERT INTO `storage` VALUES (7, '水产仓库', '用于存放水产品');
-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`id` int(0) NOT NULL AUTO_INCREMENT COMMENT '主键',
`no` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '账号',
`name` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '名字',
`password` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '密码',
`age` int(0) NULL DEFAULT NULL COMMENT '年龄',
`sex` int(0) NULL DEFAULT NULL COMMENT '性别',
`phone` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '电话',
`role_id` int(0) NULL DEFAULT NULL COMMENT '角色 0超级管理员1管理员2普通账号',
`isValid` varchar(4) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT 'Y' COMMENT '是否有效Y有效其他无效',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 18 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES (1, 'superadmin', '张三', '123456', 18, 1, '18855079621', 0, 'Y');
INSERT INTO `user` VALUES (2, 'admin', '李四', '123456', 19, 0, '18855079621', 1, 'Y');
INSERT INTO `user` VALUES (3, 'user', '王五', '123456', 23, 0, '13333333333', 2, 'Y');
SET FOREIGN_KEY_CHECKS = 1;

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

Loading…
Cancel
Save