Compare commits

...

89 Commits
main ... master

Author SHA1 Message Date
Eterlaze 7a97c1331c 修改文本错误
8 months ago
Eterlaze 338231f3d9 修改文本错误
8 months ago
wjy 0291699dbe 主页面增加轮播图
8 months ago
gxy 896f2df03c 报错提示修正
8 months ago
Eterlaze 664cdcffa0 仓库管理服务实现类/仓库管理服务接口
8 months ago
Eterlaze b517333358 车辆资料服务实现类/车辆资料服务接口
8 months ago
Eterlaze 0a6b4eb8d6 用户实现类/用户服务接口(测试)
8 months ago
Eterlaze ac1486a643 系统日志服务实现类/系统日志服务接口
8 months ago
Eterlaze 74ab37d253 仓库服务实现类
8 months ago
Eterlaze 7d546715ba 登录日志实现类
8 months ago
Eterlaze a30ed12583 仓库记录实现类/仓库记录接口
8 months ago
Eterlaze ea9cf45352 员工服务实现类/员工服务接口
8 months ago
Eterlaze 1213876381 邮件服务实现类
8 months ago
Eterlaze 90ef2d9d95 驾驶员服务实现类/驾驶员接口
8 months ago
zxh 48716748e2 系统配置文件补充
8 months ago
gxy a05fc08a02 浏览器和ip获取功能(参考)
8 months ago
gxy 0315abc925 JWT的生成与验证
8 months ago
xxy 2e01afd604 车辆信息实体
8 months ago
wjq 748310cd3f 员工管理实体
8 months ago
xzy 9635fe0029 登录服务接口
8 months ago
wjy 58262872c6 仓库管理接口
8 months ago
wjy a00fd602d3 仓库管理及仓库记录实体
8 months ago
Eterlaze a697e2ce63 驾驶员资料实体
8 months ago
Eterlaze c52a2d0f08 HTTTP响应中获取JSON数据
8 months ago
zxh 5c1cbf2c7e Springboot启动测试类
8 months ago
Eterlaze 4d7dc992dc Springboot启动项
8 months ago
Eterlaze 875b8db4ad 商品类服务接口/实现类
8 months ago
Eterlaze 8a0e88df26 Springboot数据库连接
8 months ago
Eterlaze 79b0f1eaf8 货品界面合作公司和主界面更新
8 months ago
xxy fda3f14340 驾驶员资料UI更新
8 months ago
cjy 1750c64aef 配送管理界面更新
8 months ago
wjq 697e052991 员工管理界面优化
8 months ago
xzy c3122c027b 系统登录记录实体
8 months ago
Eterlaze e4e8ca1e4a 用户实体类
8 months ago
Eterlaze ab733a2ab9 合作公司实体类
8 months ago
Eterlaze 8015876210 个人接口/用户接口(测试)
8 months ago
xxy f6b8f1cd93 运单服务组件与接口
8 months ago
xxy 97e72136c8 Maven文件初始化配置镜像
8 months ago
Eterlaze 9a5d1343c6 时间日期生成类
8 months ago
Eterlaze 6a9cc6504d 随机生成数字字符串类
8 months ago
wjy b818822162 测试枚举(暂定)
8 months ago
wjy 716d498acd 仓库管理控制器,仓库管理实体类
8 months ago
gxy 92ab3432bc 系统视图
8 months ago
gxy 47dcb14d2e 安全验证
8 months ago
Eterlaze d6bfc34538 响应结果类
8 months ago
Eterlaze 69fc05f838 业务枚举/角色枚举
8 months ago
cjy 5313a6a0a5 配送实现类
8 months ago
cjy e71f539f9a 配送管理枚举更新
8 months ago
Eterlaze 62b0db2147 DisableBaseResponse注解
8 months ago
xxy 12ea837508 驾驶员及车辆信息控制类
8 months ago
wjq 0d0f660aaa 员工原理和仓库管理的控制器
8 months ago
wjq 55281a4c3e 管理系统页面更新
8 months ago
wjq 31bb16eeea 仓储管理界面更新
8 months ago
gxy abcefd2453 数据库
8 months ago
Eterlaze ec45e4c6f5 数据库接口(总)
8 months ago
xzy 6ff925443d 登录实体
8 months ago
xzy af65bfedf6 登录控制器及其登录数据传输
8 months ago
xzy 1977e2f614 添加按钮美化注册栏
8 months ago
cjy 2343ae0207 配送服务接口
8 months ago
wjy 61cc373a33 邮件服务控制器/邮件服务接口
8 months ago
wjy 5ede697ed0 Log和DisableBaseResponse自定义注解撰写
8 months ago
Eterlaze 65cc72961f 商品视图
8 months ago
Eterlaze 517f678c07 派送状态审核判断
8 months ago
Eterlaze 6bebe728c9 商品管理实体/验证码发送实体
8 months ago
Eterlaze a243cd7e6a 商品管理传数据的接口
8 months ago
xzy 1df66044dd 登录界面美化
8 months ago
xzy aec930528f Merge remote-tracking branch 'origin/master'
8 months ago
xzy 7641898e62 登录界面美化
8 months ago
Eterlaze bf7f432278 登录日志记录
8 months ago
Eterlaze 1316ccaa6a Merge remote-tracking branch 'origin/master'
8 months ago
Eterlaze e860b81652 登录传数据
8 months ago
Eterlaze 0400b2e49a 删除误传文件
8 months ago
Eterlaze 8be3b7bdfb 派送状态审核判断
8 months ago
Eterlaze e0deda9e57 商品管理实体/验证码发送实体
8 months ago
Eterlaze c6c1b01145 商品管理传数据接口
8 months ago
Eterlaze 37aef88d1e 商品管理传数据的接口/商品管理实体/验证码发送实体/派送状态审核判断/商品试图/数据库仓库接口,商品服业务操作以及商品业务服务逻辑实现类
8 months ago
cjy b4feb5201c 配送管理接口与配送管理实体
8 months ago
cjy 969760e76a 配送管理页面优化
8 months ago
zxh 3603c4b1e3 运单管理启动接口/运单管理实体
8 months ago
zxh 42e226625e 运单界面修正
8 months ago
Eterlaze 78376dec90 用户抛异常函数
8 months ago
Eterlaze f9ac9c2dc9 管理员库接口
8 months ago
Eterlaze 04d7eb6aed 管理员登录/管理
8 months ago
Eterlaze 31130dd171 后端基础框架
8 months ago
xzy 93a6f4f350 登录注册功能完善+添加管理员登录按钮
8 months ago
Eterlaze 717f001ad8 登录注册功能完善+添加管理员登录按钮
8 months ago
Eterlaze 1ef4d76a64 登录注册界面修复与优化-增加管理员登录按钮
8 months ago
Eterlaze ab6ed90053 Merge branch 'main' of https://bdgit.educoder.net/fdzcxy212211113/YZWL
8 months ago
Eterlaze c107824a29 登录注册界面修复与优化
8 months ago

8
.idea/.gitignore vendored

@ -0,0 +1,8 @@
# 默认忽略的文件
/shelf/
/workspace.xml
# 基于编辑器的 HTTP 客户端请求
/httpRequests/
# Datasource local storage ignored files
/dataSources/
/dataSources.local.xml

@ -0,0 +1,9 @@
<?xml version="1.0" encoding="UTF-8"?>
<module type="JAVA_MODULE" version="4">
<component name="NewModuleRootManager" inherit-compiler-output="true">
<exclude-output />
<content url="file://$MODULE_DIR$" />
<orderEntry type="inheritedJdk" />
<orderEntry type="sourceFolder" forTests="false" />
</component>
</module>

@ -0,0 +1,22 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="CompilerConfiguration">
<annotationProcessing>
<profile default="true" name="Default" enabled="true" />
<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="api" />
</profile>
</annotationProcessing>
<bytecodeTargetLevel>
<module name="WarehouseManagerApi" target="1.8" />
</bytecodeTargetLevel>
</component>
<component name="JavacSettings">
<option name="ADDITIONAL_OPTIONS_OVERRIDE">
<module name="api" options="-parameters" />
</option>
</component>
</project>

@ -0,0 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="DataSourceManagerImpl" format="xml" multifile-model="true">
<data-source source="LOCAL" name="@localhost" uuid="5e70ad7c-68d1-40df-b32c-d79b12d35703">
<driver-ref>mysql.8</driver-ref>
<synchronize>true</synchronize>
<jdbc-driver>com.mysql.cj.jdbc.Driver</jdbc-driver>
<jdbc-url>jdbc:mysql://localhost:3306</jdbc-url>
<working-dir>$ProjectFileDir$</working-dir>
</data-source>
</component>
</project>

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

@ -0,0 +1,20 @@
<?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="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="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,13 @@
<project version="4">
<component name="ExternalStorageConfigurationManager" enabled="true" />
<component name="MavenProjectsManager">
<option name="originalFiles">
<list>
<option value="$PROJECT_DIR$/IDEA/pom.xml" />
</list>
</option>
</component>
<component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" project-jdk-name="17" project-jdk-type="JavaSDK">
<output url="file://$PROJECT_DIR$/out" />
</component>
</project>

@ -0,0 +1,8 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectModuleManager">
<modules>
<module fileurl="file://$PROJECT_DIR$/.idea/RoundtableLogistics.iml" filepath="$PROJECT_DIR$/.idea/RoundtableLogistics.iml" />
</modules>
</component>
</project>

@ -0,0 +1,124 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="Palette2">
<group name="Swing">
<item class="com.intellij.uiDesigner.HSpacer" tooltip-text="Horizontal Spacer" icon="/com/intellij/uiDesigner/icons/hspacer.svg" removable="false" auto-create-binding="false" can-attach-label="false">
<default-constraints vsize-policy="1" hsize-policy="6" anchor="0" fill="1" />
</item>
<item class="com.intellij.uiDesigner.VSpacer" tooltip-text="Vertical Spacer" icon="/com/intellij/uiDesigner/icons/vspacer.svg" removable="false" auto-create-binding="false" can-attach-label="false">
<default-constraints vsize-policy="6" hsize-policy="1" anchor="0" fill="2" />
</item>
<item class="javax.swing.JPanel" icon="/com/intellij/uiDesigner/icons/panel.svg" removable="false" auto-create-binding="false" can-attach-label="false">
<default-constraints vsize-policy="3" hsize-policy="3" anchor="0" fill="3" />
</item>
<item class="javax.swing.JScrollPane" icon="/com/intellij/uiDesigner/icons/scrollPane.svg" removable="false" auto-create-binding="false" can-attach-label="true">
<default-constraints vsize-policy="7" hsize-policy="7" anchor="0" fill="3" />
</item>
<item class="javax.swing.JButton" icon="/com/intellij/uiDesigner/icons/button.svg" removable="false" auto-create-binding="true" can-attach-label="false">
<default-constraints vsize-policy="0" hsize-policy="3" anchor="0" fill="1" />
<initial-values>
<property name="text" value="Button" />
</initial-values>
</item>
<item class="javax.swing.JRadioButton" icon="/com/intellij/uiDesigner/icons/radioButton.svg" removable="false" auto-create-binding="true" can-attach-label="false">
<default-constraints vsize-policy="0" hsize-policy="3" anchor="8" fill="0" />
<initial-values>
<property name="text" value="RadioButton" />
</initial-values>
</item>
<item class="javax.swing.JCheckBox" icon="/com/intellij/uiDesigner/icons/checkBox.svg" removable="false" auto-create-binding="true" can-attach-label="false">
<default-constraints vsize-policy="0" hsize-policy="3" anchor="8" fill="0" />
<initial-values>
<property name="text" value="CheckBox" />
</initial-values>
</item>
<item class="javax.swing.JLabel" icon="/com/intellij/uiDesigner/icons/label.svg" removable="false" auto-create-binding="false" can-attach-label="false">
<default-constraints vsize-policy="0" hsize-policy="0" anchor="8" fill="0" />
<initial-values>
<property name="text" value="Label" />
</initial-values>
</item>
<item class="javax.swing.JTextField" icon="/com/intellij/uiDesigner/icons/textField.svg" removable="false" auto-create-binding="true" can-attach-label="true">
<default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1">
<preferred-size width="150" height="-1" />
</default-constraints>
</item>
<item class="javax.swing.JPasswordField" icon="/com/intellij/uiDesigner/icons/passwordField.svg" removable="false" auto-create-binding="true" can-attach-label="true">
<default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1">
<preferred-size width="150" height="-1" />
</default-constraints>
</item>
<item class="javax.swing.JFormattedTextField" icon="/com/intellij/uiDesigner/icons/formattedTextField.svg" removable="false" auto-create-binding="true" can-attach-label="true">
<default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1">
<preferred-size width="150" height="-1" />
</default-constraints>
</item>
<item class="javax.swing.JTextArea" icon="/com/intellij/uiDesigner/icons/textArea.svg" removable="false" auto-create-binding="true" can-attach-label="true">
<default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
<preferred-size width="150" height="50" />
</default-constraints>
</item>
<item class="javax.swing.JTextPane" icon="/com/intellij/uiDesigner/icons/textPane.svg" removable="false" auto-create-binding="true" can-attach-label="true">
<default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
<preferred-size width="150" height="50" />
</default-constraints>
</item>
<item class="javax.swing.JEditorPane" icon="/com/intellij/uiDesigner/icons/editorPane.svg" removable="false" auto-create-binding="true" can-attach-label="true">
<default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
<preferred-size width="150" height="50" />
</default-constraints>
</item>
<item class="javax.swing.JComboBox" icon="/com/intellij/uiDesigner/icons/comboBox.svg" removable="false" auto-create-binding="true" can-attach-label="true">
<default-constraints vsize-policy="0" hsize-policy="2" anchor="8" fill="1" />
</item>
<item class="javax.swing.JTable" icon="/com/intellij/uiDesigner/icons/table.svg" removable="false" auto-create-binding="true" can-attach-label="false">
<default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
<preferred-size width="150" height="50" />
</default-constraints>
</item>
<item class="javax.swing.JList" icon="/com/intellij/uiDesigner/icons/list.svg" removable="false" auto-create-binding="true" can-attach-label="false">
<default-constraints vsize-policy="6" hsize-policy="2" anchor="0" fill="3">
<preferred-size width="150" height="50" />
</default-constraints>
</item>
<item class="javax.swing.JTree" icon="/com/intellij/uiDesigner/icons/tree.svg" removable="false" auto-create-binding="true" can-attach-label="false">
<default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
<preferred-size width="150" height="50" />
</default-constraints>
</item>
<item class="javax.swing.JTabbedPane" icon="/com/intellij/uiDesigner/icons/tabbedPane.svg" removable="false" auto-create-binding="true" can-attach-label="false">
<default-constraints vsize-policy="3" hsize-policy="3" anchor="0" fill="3">
<preferred-size width="200" height="200" />
</default-constraints>
</item>
<item class="javax.swing.JSplitPane" icon="/com/intellij/uiDesigner/icons/splitPane.svg" removable="false" auto-create-binding="false" can-attach-label="false">
<default-constraints vsize-policy="3" hsize-policy="3" anchor="0" fill="3">
<preferred-size width="200" height="200" />
</default-constraints>
</item>
<item class="javax.swing.JSpinner" icon="/com/intellij/uiDesigner/icons/spinner.svg" removable="false" auto-create-binding="true" can-attach-label="true">
<default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1" />
</item>
<item class="javax.swing.JSlider" icon="/com/intellij/uiDesigner/icons/slider.svg" removable="false" auto-create-binding="true" can-attach-label="false">
<default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1" />
</item>
<item class="javax.swing.JSeparator" icon="/com/intellij/uiDesigner/icons/separator.svg" removable="false" auto-create-binding="false" can-attach-label="false">
<default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3" />
</item>
<item class="javax.swing.JProgressBar" icon="/com/intellij/uiDesigner/icons/progressbar.svg" removable="false" auto-create-binding="true" can-attach-label="false">
<default-constraints vsize-policy="0" hsize-policy="6" anchor="0" fill="1" />
</item>
<item class="javax.swing.JToolBar" icon="/com/intellij/uiDesigner/icons/toolbar.svg" removable="false" auto-create-binding="false" can-attach-label="false">
<default-constraints vsize-policy="0" hsize-policy="6" anchor="0" fill="1">
<preferred-size width="-1" height="20" />
</default-constraints>
</item>
<item class="javax.swing.JToolBar$Separator" icon="/com/intellij/uiDesigner/icons/toolbarSeparator.svg" removable="false" auto-create-binding="false" can-attach-label="false">
<default-constraints vsize-policy="0" hsize-policy="0" anchor="0" fill="1" />
</item>
<item class="javax.swing.JScrollBar" icon="/com/intellij/uiDesigner/icons/scrollbar.svg" removable="false" auto-create-binding="true" can-attach-label="false">
<default-constraints vsize-policy="6" hsize-policy="0" anchor="0" fill="2" />
</item>
</group>
</component>
</project>

@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="VcsDirectoryMappings">
<mapping directory="$PROJECT_DIR$" vcs="Git" />
</component>
</project>

35
IDEA/.gitignore vendored

@ -0,0 +1,35 @@
HELP.md
target/
!.mvn/wrapper/maven-wrapper.jar
!**/src/main/**/target/
!**/src/test/**/target/
### STS ###
.apt_generated
.classpath
.factorypath
.project
.settings
.springBeans
.sts4-cache
### IntelliJ IDEA ###
.idea
.DS_Store
*.DS_Store
*.iws
*.iml
*.ipr
### NetBeans ###
/nbproject/private/
/nbbuild/
/dist/
/nbdist/
/.nb-gradle/
build/
!**/src/main/**/build/
!**/src/test/**/build/
### VS Code ###
.vscode/

@ -0,0 +1,140 @@
<?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>
<groupId>com.example</groupId>
<artifactId>api</artifactId>
<version>0.0.1-SNAPSHOT</version>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.7.2</version>
</parent>
<properties>
<java.version>11</java.version>
<jwt.version>0.9.1</jwt.version>
<mybatis-plus.version>3.4.2</mybatis-plus.version>
<fastjson.version>1.2.73</fastjson.version>
<mybatis-enhance-actable.version>1.4.7.RELEASE</mybatis-enhance-actable.version>
</properties>
<dependencies>
<!--SpringBoot依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<!--SpringData依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<!--SpringSecurity依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<!--Email邮箱发送依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-mail</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>5.3.3</version>
</dependency>
<!--jwt依赖-->
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>${jwt.version}</version>
</dependency>
<!--mysql驱动-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<!--lombok-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.24</version>
<optional>true</optional>
</dependency>
<!--json工具-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>${fastjson.version}</version>
</dependency>
<!--jdk9以上缺失的jar包-->
<dependency>
<groupId>javax.xml.bind</groupId>
<artifactId>jaxb-api</artifactId>
<version>2.3.0</version>
</dependency>
<dependency>
<groupId>com.sun.xml.bind</groupId>
<artifactId>jaxb-impl</artifactId>
<version>2.3.0</version>
</dependency>
<dependency>
<groupId>com.sun.xml.bind</groupId>
<artifactId>jaxb-core</artifactId>
<version>2.3.0</version>
</dependency>
<dependency>
<groupId>javax.activation</groupId>
<artifactId>activation</artifactId>
<version>1.1.1</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<excludes>
<exclude>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</exclude>
</excludes>
</configuration>
</plugin>
</plugins>
</build>
<!--更换阿里云maven镜像-->
<repositories>
</repositories>
</project>

@ -0,0 +1,18 @@
package com.example.api;
import com.example.api.repository.AdminRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import java.util.HashMap;
import java.util.Hashtable;
@SpringBootApplication
public class ApiApplication {
public static void main(String[] args) {
SpringApplication.run(ApiApplication.class, args);
}
}

@ -0,0 +1,16 @@
package com.example.api.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* DisableBaseResponse 使
*
*/
@Target(ElementType.METHOD) // 指定该注解只能用于方法
@Retention(RetentionPolicy.RUNTIME) // 指定该注解在运行时有效
public @interface DisableBaseResponse {
// 该注解定义为空,不包含任何成员变量
}

@ -0,0 +1,20 @@
package com.example.api.annotation;
import com.example.api.model.enums.BusinessType;
import java.lang.annotation.*;
@Target(ElementType.METHOD) //目标类型
@Retention(RetentionPolicy.RUNTIME) //作用范围
@Documented
public @interface Log {
/*
*/
String module() default "";
/*
*/
BusinessType type();
}

@ -0,0 +1,86 @@
package com.example.api.aspect;
import com.example.api.annotation.Log;
import com.example.api.model.entity.SystemLog;
import com.example.api.service.SystemLogService;
import com.example.api.utils.IpUtil;
import com.example.api.utils.JwtTokenUtil;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.time.LocalDateTime;
/**
* LogAspect Aspect
*/
@Aspect // 表明这是一个切面
@Component // 表明这是一个 Spring 组件
public class LogAspect {
@Autowired // 自动注入 SystemLogService
private SystemLogService logService;
/**
* @Log
*/
@Pointcut("@annotation(com.example.api.annotation.Log)")
public void pt(){}
/**
*
* @param point
* @return
* @throws Throwable
*/
@Around("pt()")
public Object Around(ProceedingJoinPoint point) throws Throwable {
// 记录开始时间
long beginTime = System.currentTimeMillis();
Object res = null;
try {
// 执行方法
res = point.proceed();
} finally {
// 计算执行时长
long time = System.currentTimeMillis() - beginTime;
recordLog(point);
}
return res;
}
/**
*
* @param point
*/
private void recordLog(ProceedingJoinPoint point){
// 获取当前请求对象
ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = requestAttributes.getRequest();
// 获取目标方法签名
MethodSignature signature = (MethodSignature) point.getSignature();
Method method = signature.getMethod();
Log annotation = method.getAnnotation(Log.class);
// 封装日志对象
SystemLog systemLog = new SystemLog();
systemLog.setModule(annotation.module());
systemLog.setBusinessType(annotation.type().getName());
systemLog.setIp(IpUtil.getIpAddr(request));
systemLog.setTime(LocalDateTime.now());
// 获取方法的全路径
systemLog.setMethod(signature.getDeclaringTypeName()+"."+signature.getName());
// 获取token,并解析token来获取当前账号
String token = request.getHeader(JwtTokenUtil.TOKEN_HEADER);
systemLog.setAccount(JwtTokenUtil.getUsername(token));
// 持久化到数据库
logService.record(systemLog);
}
}

@ -0,0 +1,121 @@
package com.example.api.controller;
import com.example.api.exception.AccountAndPasswordError;
import com.example.api.model.dto.LoginDto;
import com.example.api.model.entity.Admin;
import com.example.api.model.entity.LoginLog;
import com.example.api.model.enums.Role;
import com.example.api.model.support.ResponseResult;
import com.example.api.repository.AdminRepository;
import com.example.api.service.AdminService;
import com.example.api.service.LoginLogService;
import com.example.api.utils.JwtTokenUtil;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
// 定义RestController注解表示该类是一个控制器用于处理HTTP请求
@RestController
// 定义RequestMapping注解设置该控制器的基础URL路径
@RequestMapping("/api/admin")
// 使用@Slf4j注解来自动生成日志对象
@Slf4j
public class AdminController {
// 使用LoggerFactory获取当前类的日志对象
Logger logger = LoggerFactory.getLogger(AdminController.class);
// 通过@Resource注解自动注入AdminService
@Resource
private AdminService adminService;
// 通过@Resource注解自动注入AdminRepository
@Resource
private AdminRepository adminRepository;
// 通过@Resource注解自动注入LoginLogService
@Resource
private LoginLogService loginLogService;
// 检查是否有初始化管理员账号
@GetMapping("hasInit")
public boolean hasInit() {
return adminRepository.existsAdminByRoles(Role.ROLE_SUPER_ADMIN.getValue());
}
// 初始化管理员账号
@PostMapping("/init")
public Admin init(@RequestBody Admin admin) throws Exception {
admin.setRoles(Role.ROLE_SUPER_ADMIN.getValue());
return adminService.save(admin);
}
// 获取所有管理员账号信息
@GetMapping("")
@PreAuthorize("hasAnyRole('ROLE_SUPER_ADMIN' ,'ROLE_ADMIN')")
public List<Admin> findAll() {
return adminService.findAll();
}
// 删除管理员账号
@DeleteMapping("")
@PreAuthorize("hasAnyRole('ROLE_SUPER_ADMIN' ,'ROLE_ADMIN')")
public void delete(String id) {
adminService.delete(id);
}
// 保存管理员账号信息
@PostMapping("")
@PreAuthorize("hasAnyRole('ROLE_SUPER_ADMIN' ,'ROLE_ADMIN')")
public Admin save(@RequestBody Admin admin) throws Exception {
return adminService.save(admin);
}
// 管理员登录
@PostMapping("/login")
public Map<String, Object> loginByEmail(String type, @RequestBody LoginDto dto, HttpServletRequest request) throws Exception {
Map<String, Object> map = new HashMap<>();
Admin admin = null;
String token = null;
try {
// 根据登录类型(邮箱或密码)进行登录
admin = type.equals("email") ? adminService.loginByEmail(dto) : adminService.loginByPassword(dto);
// 创建JWT令牌
token = adminService.createToken(admin,
dto.isRemember() ? JwtTokenUtil.REMEMBER_EXPIRATION_TIME : JwtTokenUtil.EXPIRATION_TIME);
} catch (Exception e) {
// 抛出异常,表示邮箱或密码错误
throw new Exception("邮箱或密码错误");
} finally {
// 记录登录日志
loginLogService.recordLog(dto, admin, request);
}
// 将管理员信息和令牌放入返回结果
map.put("admin", admin);
map.put("token", token);
return map;
}
// 发送邮箱验证码
@GetMapping("/sendEmail")
public ResponseResult sendEmail(String email) throws Exception {
Boolean flag = adminService.sendEmail(email);
ResponseResult res = new ResponseResult();
if (flag) {
res.setMsg("发送成功,请登录邮箱查看");
} else {
res.setMsg("发送验证码失败,请检查邮箱服务");
}
res.setStatus(flag);
return res;
}
}

@ -0,0 +1,86 @@
package com.example.api.controller;
import com.example.api.annotation.Log;
import com.example.api.model.entity.Commodity;
import com.example.api.model.enums.BusinessType;
import com.example.api.service.CommodityService;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.List;
/**
* CommodityController RESTful API
*/
@RestController // 表明这是一个 REST 控制器,其方法的返回值会自动作为 HTTP 响应体
@RequestMapping("/api/commodity") // 定义类级别的路由:/api/commodity
@PreAuthorize("hasAnyRole('ROLE_SUPER_ADMIN','ROLE_COMMODITY','ROLE_SALE')") // 权限注解,只有具有指定角色的用户才能访问
public class CommodityController {
@Resource // 自动注入 CommodityService
private CommodityService commodityService;
/**
*
* @param commodity
* @return
*/
@Log(module = "商品管理", type = BusinessType.INSERT) // 记录日志,标记为插入操作
@PostMapping("") // 定义 POST 请求的路由
public Commodity save(@RequestBody Commodity commodity) {
return commodityService.save(commodity);
}
/**
*
* @param id ID
*/
@Log(module = "商品管理", type = BusinessType.DELETE) // 记录日志,标记为删除操作
@DeleteMapping("") // 定义 DELETE 请求的路由
public void delete(String id) {
commodityService.delete(id);
}
/**
*
* @param commodity
*/
@Log(module = "商品管理", type = BusinessType.UPDATE) // 记录日志,标记为更新操作
@PutMapping("") // 定义 PUT 请求的路由
public void update(@RequestBody Commodity commodity) {
commodityService.update(commodity);
}
/**
*
* @return
*/
@Log(module = "商品管理", type = BusinessType.QUERY) // 记录日志,标记为查询操作
@GetMapping("") // 定义 GET 请求的路由
public List<Commodity> findAll() {
return commodityService.findAll();
}
/**
*
* @param name
* @return
*/
@Log(module = "商品管理", type = BusinessType.QUERY) // 记录日志,标记为查询操作
@GetMapping("/search/{name}") // 定义 GET 请求的路由,包含路径变量
public List<Commodity> findByLikeName(@PathVariable String name) {
return commodityService.findAllByLikeName(name);
}
/**
* ID
* @param id ID
* @return
*/
@Log(module = "商品管理", type = BusinessType.QUERY) // 记录日志,标记为查询操作
@GetMapping("/{id}") // 定义 GET 请求的路由,包含路径变量
public Commodity findById(@PathVariable String id) {
return commodityService.findById(id);
}
}

@ -0,0 +1,61 @@
package com.example.api.controller;
import com.example.api.annotation.Log; // 导入自定义的日志注解
import com.example.api.model.entity.Distribution; // 导入配送实体类
import com.example.api.model.enums.BusinessType; // 导入业务类型枚举
import com.example.api.repository.DriverRepository; // 导入司机数据访问层接口
import com.example.api.repository.VehicleRepository; // 导入车辆数据访问层接口
import com.example.api.service.DistributionService; // 导入配送服务类
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource; // 导入资源注入注解
import java.util.HashMap; // 导入HashMap类
import java.util.List; // 导入List接口
import java.util.Map; // 导入Map接口
// 定义RestController注解表示该类是一个控制器用于处理HTTP请求
@RestController
// 定义RequestMapping注解设置该控制器的基础URL路径
@RequestMapping("/api/distribution")
public class DistributionController {
// 通过@Resource注解自动注入DistributionService
@Resource
private DistributionService distributionService;
// 通过@Resource注解自动注入DriverRepository
@Resource
private DriverRepository driverRepository;
// 通过@Resource注解自动注入VehicleRepository
@Resource
private VehicleRepository vehicleRepository;
// 使用@Log注解记录操作日志模块为“配送管理”操作类型为插入BusinessType.INSERT
@Log(module = "配送管理", type = BusinessType.INSERT)
// 处理POST请求用于保存配送信息
@PostMapping("")
public Distribution save(@RequestBody Distribution distribution) throws Exception {
return distributionService.save(distribution);
}
// 使用@Log注解记录操作日志模块为“配送管理”操作类型为查询BusinessType.QUERY
@Log(module = "配送管理", type = BusinessType.QUERY)
// 处理GET请求用于查询所有配送信息
@GetMapping("")
public List<Distribution> findAll() {
return distributionService.findAll();
}
// 处理GET请求用于获取可用于配送的司机和车辆信息
@GetMapping("can")
public Map<String, Object> can() {
Map<String, Object> map = new HashMap<>();
// 将所有司机信息放入map中
map.put("drivers", driverRepository.findAll());
// 将所有车辆信息放入map中
map.put("vehicles", vehicleRepository.findAll());
return map;
}
}

@ -0,0 +1,54 @@
package com.example.api.controller;
import com.example.api.annotation.Log; // 导入自定义的日志注解,用于记录操作日志
import com.example.api.model.entity.Driver; // 导入Driver实体类代表驾驶员信息
import com.example.api.model.enums.BusinessType; // 导入BusinessType枚举定义不同的业务操作类型
import com.example.api.service.DriverService; // 导入DriverService服务类包含对Driver数据的操作
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource; // 导入Resource注解用于依赖注入
import java.util.List; // 导入List接口用于处理列表数据
// 定义RestController注解标识该类为一个RESTful控制器
@RestController
// 定义RequestMapping注解设置基础URL路径为"/api/driver"所有方法的URL都将在此基础上构建
@RequestMapping("/api/driver")
public class DriverController {
// 使用@Resource注解自动注入DriverService服务用于处理驾驶员相关的业务逻辑
@Resource
private DriverService driverService;
// 使用@Log注解记录插入操作的日志模块为"驾驶员管理"操作类型为BusinessType.INSERT
@Log(module = "驾驶员管理", type = BusinessType.INSERT)
// 处理POST请求用于保存驾驶员信息
@PostMapping("")
public Driver save(@RequestBody Driver driver) {
return driverService.save(driver);
}
// 使用@Log注解记录查询操作的日志模块为"驾驶员管理"操作类型为BusinessType.QUERY
@Log(module = "驾驶员管理", type = BusinessType.QUERY)
// 处理GET请求用于查询所有驾驶员信息
@GetMapping("")
public List<Driver> findAll() {
return driverService.findAll();
}
// 使用@Log注解记录查询操作的日志模块为"驾驶员管理"操作类型为BusinessType.QUERY
@Log(module = "驾驶员管理", type = BusinessType.QUERY)
// 处理GET请求通过URL中的{id}路径变量查询特定驾驶员信息
@GetMapping("/{id}")
public Driver findById(@PathVariable String id) {
return driverService.findById(id);
}
// 使用@Log注解记录删除操作的日志模块为"驾驶员管理"操作类型为BusinessType.DELETE
@Log(module = "驾驶员管理", type = BusinessType.DELETE)
// 处理DELETE请求通过URL参数{id}删除特定驾驶员信息
@DeleteMapping("")
public void delete(String id) {
driverService.delete(id);
}
}

@ -0,0 +1,52 @@
package com.example.api.controller;
import com.example.api.utils.RandomUtil; // 导入自定义工具类,用于生成随机数或随机字符串
import org.springframework.beans.factory.annotation.Value; // 导入@Value注解用于注入配置文件中的值
import org.springframework.mail.MailException; // 导入MailException用于捕获邮件发送过程中的异常
import org.springframework.mail.SimpleMailMessage; // 导入SimpleMailMessage用于构建简单的邮件消息
import org.springframework.mail.javamail.JavaMailSender; // 导入JavaMailSender用于发送邮件
import org.springframework.web.bind.annotation.GetMapping; // 导入@GetMapping注解用于处理GET请求
import org.springframework.web.bind.annotation.RequestMapping; // 导入@RequestMapping注解用于定义请求的映射路径
import org.springframework.web.bind.annotation.RestController; // 导入@RestController注解标识该类为RESTful控制器
import javax.annotation.Resource; // 导入@Resource注解用于依赖注入
// 定义RestController注解标识该类为一个RESTful控制器
@RestController
// 定义RequestMapping注解设置基础URL路径为"/api/email"所有方法的URL都将在此基础上构建
@RequestMapping("/api/email")
public class EmailController {
// 使用@Resource注解自动注入JavaMailSender用于发送邮件
@Resource
private JavaMailSender mailSender;
// 使用@Value注解注入配置文件中的邮件用户名作为发件人地址
@Value("${spring.mail.username}")
private String from;
// 处理GET请求用于发送邮件
@GetMapping("/send")
public String send() {
SimpleMailMessage message = new SimpleMailMessage();
// 设置发件人地址
message.setFrom(from);
// 设置收件人地址
message.setTo("1402014577@qq.com");
// 设置邮件主题
message.setSubject("验证码");
// 设置邮件内容,包括一个随机生成的验证码
message.setText("你的验证码为: " + RandomUtil.next() + " 十五分钟内有效");
try {
// 发送邮件
mailSender.send(message);
// 如果发送成功,返回成功消息
return "发送普通邮件成功";
} catch (MailException e) {
// 如果发送失败,打印堆栈跟踪并返回失败消息
e.printStackTrace();
return "邮件发送失败";
}
}
}

@ -0,0 +1,65 @@
package com.example.api.controller;
import com.example.api.annotation.Log; // 导入自定义的日志注解,用于记录操作日志
import com.example.api.model.entity.Employee; // 导入Employee实体类代表员工信息
import com.example.api.model.enums.BusinessType; // 导入BusinessType枚举定义不同的业务操作类型
import com.example.api.service.EmployeeService; // 导入EmployeeService服务类包含对Employee数据的操作
import org.springframework.security.access.prepost.PreAuthorize; // 导入Spring Security的PreAuthorize注解用于权限控制
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource; // 导入Resource注解用于依赖注入
import java.util.List; // 导入List接口用于处理列表数据
// 定义RestController注解标识该类为一个RESTful控制器
@RestController
// 定义RequestMapping注解设置基础URL路径为"/api/employee"所有方法的URL都将在此基础上构建
@RequestMapping("/api/employee")
// 使用PreAuthorize注解限制访问权限只允许拥有'ROLE_SUPER_ADMIN'或'ROLE_EMPLOYEE'角色的用户访问
@PreAuthorize("hasAnyRole('ROLE_SUPER_ADMIN' ,'ROLE_EMPLOYEE')")
public class EmployeeController {
// 使用@Resource注解自动注入EmployeeService服务用于处理员工相关的业务逻辑
@Resource
private EmployeeService employeeService;
// 使用@Log注解记录查询操作的日志模块为"员工管理"操作类型为BusinessType.QUERY
@Log(module = "员工管理", type = BusinessType.QUERY)
// 处理GET请求用于查询所有员工信息
@GetMapping("")
public List<Employee> findAll() {
return employeeService.findAll();
}
// 使用@Log注解记录查询操作的日志模块为"员工管理"操作类型为BusinessType.QUERY
@Log(module = "员工管理", type = BusinessType.QUERY)
// 处理GET请求通过URL中的{id}路径变量查询特定员工信息
@GetMapping("/{id}")
public Employee findById(@PathVariable String id) {
return employeeService.findById(id);
}
// 使用@Log注解记录插入操作的日志模块为"员工管理"操作类型为BusinessType.INSERT
@Log(module = "员工管理", type = BusinessType.INSERT)
// 处理POST请求用于保存员工信息
@PostMapping("")
public Employee save(@RequestBody Employee employee) {
return employeeService.save(employee);
}
// 使用@Log注解记录更新操作的日志模块为"员工管理"操作类型为BusinessType.UPDATE
@Log(module = "员工管理", type = BusinessType.UPDATE)
// 处理PUT请求用于更新员工信息
@PutMapping("")
public void update(@RequestBody Employee employee) {
employeeService.update(employee);
}
// 使用@Log注解记录删除操作的日志模块为"员工管理"操作类型为BusinessType.DELETE
@Log(module = "员工管理", type = BusinessType.DELETE)
// 处理DELETE请求通过URL参数{id}删除特定员工信息
@DeleteMapping("")
public void delete(String id) {
employeeService.delete(id);
}
}

@ -0,0 +1,81 @@
package com.example.api.controller;
// 导入相关的实体类
import com.example.api.model.entity.Inventory;
import com.example.api.model.entity.InventoryRecord;
// 导入用于展示商品图表的数据传输对象
import com.example.api.model.vo.CommodityChartVo;
// 导入库存服务接口
import com.example.api.service.InventoryService;
// 导入库存记录服务接口
import com.example.api.service.InventoryRecordService;
// 导入Spring框架的注解支持
import org.springframework.web.bind.annotation.*;
// 使用javax.annotation.Resource注解来实现依赖注入
import javax.annotation.Resource;
// 导入Java的util包用于操作集合
import java.util.List;
// 使用RestController注解声明这是一个REST控制器
@RestController
// 使用RequestMapping注解指定这个控制器的基础URL路径
@RequestMapping("/api/inventory")
public class InventoryController {
// 使用@Resource注解注入InventoryService
@Resource
private InventoryService inventoryService;
// 使用@Resource注解注入InventoryRecordService
@Resource
private InventoryRecordService recordService;
// 使用GetMapping注解定义一个GET请求的处理器用于获取所有库存信息
@GetMapping("")
public List<Inventory> findAll() {
return inventoryService.findAll();
}
// 使用GetMapping注解定义一个GET请求的处理器用于分析商品数据
public List<CommodityChartVo> analyze(Integer type) {
return recordService.analyzeCommodity(type);
}
// 使用GetMapping注解定义一个GET请求的处理器通过路径变量{id}获取指定仓库的库存情况
@GetMapping("/warehouse/{id}")
public List<Inventory> findByWarehouse(@PathVariable String id) {
return inventoryService.findByWarehouseId(id);
}
// 使用GetMapping注解定义一个GET请求的处理器通过路径变量{id}查询某个商品在所有仓库的库存
@GetMapping("/commodity/{id}")
public List<Inventory> findByCommodity(@PathVariable String id) {
return inventoryService.findByCommodityId(id);
}
// 使用GetMapping注解定义一个GET请求的处理器通过路径变量{id}查询某个仓库库内商品的出库入库记录
@GetMapping("/record/warehouse/{id}")
public List<InventoryRecord> findRecordByWarehouse(@PathVariable String id) {
return recordService.findAllByWarehouseId(id);
}
// 使用GetMapping注解定义一个GET请求的处理器通过路径变量{id}查询某个商品在所有仓库出库入库记录
@GetMapping("/record/commodity/{id}")
public List<InventoryRecord> findRecordByCommodity(@PathVariable String id) {
return recordService.findAllByCommodityId(id);
}
// 使用PostMapping注解定义一个POST请求的处理器用于处理商品入库记录
@PostMapping("/in")
public InventoryRecord in(@RequestBody InventoryRecord record) throws Exception {
return recordService.in(record);
}
// 使用PostMapping注解定义一个POST请求的处理器用于处理商品出库记录
@PostMapping("/out")
public InventoryRecord out(@RequestBody InventoryRecord record) throws Exception {
return recordService.out(record);
}
}

@ -0,0 +1,77 @@
package com.example.api.controller;
// 导入登录日志实体类
import com.example.api.model.entity.LoginLog;
// 导入系统日志实体类
import com.example.api.model.entity.SystemLog;
// 导入响应结果类,用于统一返回格式
import com.example.api.model.support.ResponseResult;
// 导入系统日志视图对象,用于查询系统日志
import com.example.api.model.vo.SystemLogVo;
// 导入登录日志服务接口
import com.example.api.service.LoginLogService;
// 导入系统日志服务接口
import com.example.api.service.SystemLogService;
// 导入Spring框架的注解支持
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
// 导入Java的util包用于操作集合
import java.util.List;
// 导入Java的Map接口用于操作键值对集合
import java.util.Map;
// 使用RestController注解声明这是一个REST控制器
@RestController
// 使用RequestMapping注解指定这个控制器的基础URL路径
@RequestMapping("/api")
public class LogController {
// 使用@Autowired注解注入LoginLogService
@Autowired
private LoginLogService loginLogService;
// 使用@Autowired注解注入SystemLogService
@Autowired
private SystemLogService systemLogService;
// 使用GetMapping注解定义一个GET请求的处理器用于获取所有登录日志
@GetMapping("/loginlog")
public List<LoginLog> getLoginLog(){
// 调用loginLogService的getAll方法获取所有登录日志
List<LoginLog> all = loginLogService.getAll();
return all;
}
// 使用DeleteMapping注解定义一个DELETE请求的处理器用于删除指定ID的登录日志
@DeleteMapping("/loginlog")
public void delLoginLog(String id){
// 调用loginLogService的delLoginLog方法删除指定ID的登录日志
loginLogService.delLoginLog(id);
}
// 使用GetMapping注解定义一个GET请求的处理器用于获取所有系统日志
@GetMapping("/systemlog")
public List<SystemLog> getSystemLog(){
// 直接返回systemLogService的getAll方法获取的所有系统日志
return systemLogService.getAll();
}
// 使用DeleteMapping注解定义一个DELETE请求的处理器用于删除指定ID的系统日志
@DeleteMapping("/systemlog")
public void deleteSystemLogById(String id){
// 调用systemLogService的delete方法删除指定ID的系统日志
systemLogService.delete(id);
}
// 使用GetMapping注解定义一个GET请求的处理器用于根据条件查询系统日志
@GetMapping("/querySystemlog")
public List<SystemLog> querySystemlog(SystemLogVo systemLogVo){
// 打印传入的系统日志视图对象
System.out.println(systemLogVo);
// 调用systemLogService的query方法根据条件查询系统日志
return systemLogService.query(systemLogVo);
}
}

@ -0,0 +1,22 @@
package com.example.api.controller;
// 导入项目中定义的角色枚举类
import com.example.api.model.enums.Role;
// 导入Spring框架的注解支持
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
// 使用RestController注解声明这是一个REST控制器它会自动处理HTTP请求并返回数据
@RestController
// 使用RequestMapping注解指定这个控制器的基础URL路径为"/api/role"
@RequestMapping("/api/role")
public class RoleController {
// 使用GetMapping注解定义一个GET请求的处理器当访问"/api/role"路径时会被调用
@GetMapping("")
public Role[] list() {
// 返回Role枚举类中定义的所有角色数组
return Role.ROLES;
}
}

@ -0,0 +1,33 @@
package com.example.api.controller;
import com.example.api.model.entity.Sale;
import com.example.api.service.SaleService;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.List;
@RestController
@RequestMapping("/api/sale")
@PreAuthorize("hasAnyRole('ROLE_SUPER_ADMIN' ,'ROLE_SALE')")
public class SaleController {
@Resource
private SaleService saleService;
@PostMapping("")
public Sale save(@RequestBody Sale sale) {
return saleService.save(sale);
}
@GetMapping("")
public List<Sale> findAll() {
return saleService.findAll();
}
@GetMapping("/search/{name}")
public List<Sale> search(@PathVariable String name) {
return saleService.searchByCompany(name);
}
}

@ -0,0 +1,18 @@
package com.example.api.controller;
import com.example.api.model.entity.User;
import com.example.api.repository.UserRepository;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
@RestController
@RequestMapping("/api/user")
public class UserController {
@Resource
private UserRepository userRepository;
}

@ -0,0 +1,65 @@
package com.example.api.controller;
// 导入自定义的日志注解类
import com.example.api.annotation.Log;
// 导入车辆实体类
import com.example.api.model.entity.Vehicle;
// 导入业务类型枚举类
import com.example.api.model.enums.BusinessType;
// 导入车辆服务接口
import com.example.api.service.VehicleService;
// 导入Spring框架的注解支持
import org.springframework.web.bind.annotation.*;
// 使用javax.annotation.Resource注解来实现依赖注入
import javax.annotation.Resource;
// 导入Java的util包用于操作集合
import java.util.List;
// 使用RestController注解声明这是一个REST控制器
@RestController
// 使用RequestMapping注解指定这个控制器的基础URL路径为"/api/vehicle"
@RequestMapping("/api/vehicle")
public class VehicleController {
// 使用@Resource注解注入VehicleService
@Resource
private VehicleService vehicleService;
// 使用Log注解记录操作日志模块为"车辆管理"业务类型为BusinessType.INSERT插入
@Log(module = "车辆管理", type = BusinessType.INSERT)
// 使用PostMapping注解定义一个POST请求的处理器用于保存车辆信息
@PostMapping("")
public Vehicle save(@RequestBody Vehicle vehicle) {
// 调用vehicleService的save方法保存车辆信息
return vehicleService.save(vehicle);
}
// 使用Log注解记录操作日志模块为"车辆管理"业务类型为BusinessType.QUERY查询
@Log(module = "车辆管理", type = BusinessType.QUERY)
// 使用GetMapping注解定义一个GET请求的处理器用于获取所有车辆信息
@GetMapping("")
public List<Vehicle> findAll() {
// 调用vehicleService的findAll方法获取所有车辆信息
return vehicleService.findAll();
}
// 使用Log注解记录操作日志模块为"车辆管理"业务类型为BusinessType.QUERY查询
@Log(module = "车辆管理", type = BusinessType.QUERY)
// 使用GetMapping注解定义一个GET请求的处理器用于根据ID查询单个车辆信息
@GetMapping("/{id}")
public Vehicle findById(@PathVariable String id) {
// 调用vehicleService的findById方法根据ID查询单个车辆信息
return vehicleService.findById(id);
}
// 使用Log注解记录操作日志模块为"车辆管理"业务类型为BusinessType.DELETE删除
@Log(module = "车辆管理", type = BusinessType.DELETE)
// 使用DeleteMapping注解定义一个DELETE请求的处理器用于删除车辆信息
@DeleteMapping("")
public void delete(String id) {
// 调用vehicleService的delete方法删除车辆信息
vehicleService.delete(id);
}
}

@ -0,0 +1,52 @@
package com.example.api.controller;
import com.example.api.annotation.Log;
import com.example.api.model.entity.Warehouse;
import com.example.api.model.enums.BusinessType;
import com.example.api.service.WarehouseService;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.List;
// 使用RestController注解声明这是一个REST控制器
@RestController
// 使用RequestMapping注解指定这个控制器的基础URL路径为"/api/warehouse"
@RequestMapping("/api/warehouse")
// 使用PreAuthorize注解设置权限只有拥有'ROLE_SUPER_ADMIN'或'ROLE_WAREHOUSE'角色的用户可以访问
@PreAuthorize("hasAnyRole('ROLE_SUPER_ADMIN' ,'ROLE_WAREHOUSE')")
public class WarehouseController {
// 使用@Resource注解注入WarehouseService
@Resource
private WarehouseService warehouseService;
// 使用Log注解记录操作日志模块为"仓库管理"业务类型为BusinessType.INSERT插入
@Log(module = "仓库管理", type = BusinessType.INSERT)
// 使用PostMapping注解定义一个POST请求的处理器用于保存仓库信息
@PostMapping("")
public Warehouse save(@RequestBody Warehouse warehouse) {
// 调用warehouseService的save方法保存仓库信息
return warehouseService.save(warehouse);
}
// 使用Log注解记录操作日志模块为"仓库管理"业务类型为BusinessType.QUERY查询
@Log(module = "仓库管理", type = BusinessType.QUERY)
// 使用GetMapping注解定义一个GET请求的处理器用于获取所有仓库信息
@GetMapping("")
public List<Warehouse> findAll() {
// 调用warehouseService的findAll方法获取所有仓库信息
return warehouseService.findAll();
}
// 使用Log注解记录操作日志模块为"仓库管理"业务类型为BusinessType.DELETE删除
@Log(module = "仓库管理", type = BusinessType.DELETE)
// 使用DeleteMapping注解定义一个DELETE请求的处理器用于删除仓库信息
@DeleteMapping("")
public void delete(String id) {
// 调用warehouseService的delete方法删除仓库信息
warehouseService.delete(id);
}
}

@ -0,0 +1,5 @@
package com.example.api.exception;
public class AccountAndPasswordError extends Exception{
}

@ -0,0 +1,48 @@
package com.example.api.handler;
// 导入自定义的账户和密码错误异常类
import com.example.api.exception.AccountAndPasswordError;
// 导入用于封装API响应结果的类
import com.example.api.model.support.ResponseResult;
// 导入登录日志服务接口
import com.example.api.service.LoginLogService;
// 导入SLF4J的Logger工厂用于日志记录
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
// 导入Spring的Autowired注解用于依赖注入
import org.springframework.beans.factory.annotation.Autowired;
// 导入Spring Security的访问拒绝异常类
import org.springframework.security.access.AccessDeniedException;
// 导入Spring MVC的注解用于定义异常处理方法和全局异常处理
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestControllerAdvice;
/**
* controller
* controller
* ResponseApiResult
*/
@ResponseBody
@RestControllerAdvice
public class GlobalExceptionHandler {
// 使用@Autowired注解注入LoginLogService
@Autowired
private LoginLogService loginLogService;
// 创建一个Logger实例用于记录日志
private final Logger logger = LoggerFactory.getLogger(getClass());
// 使用@ExceptionHandler注解定义一个方法来处理所有类型的异常
@ExceptionHandler(value = Exception.class)
public Object handleException(Exception e) {
// 如果异常是AccessDeniedException类型返回403状态码和相应消息
if (e instanceof AccessDeniedException) {
return new ResponseResult<>(403, "你没有访问权限");
}
// 记录异常信息
logger.warn(e.getMessage());
// 对于其他类型的异常返回400状态码和异常信息
return new ResponseResult<>(400, e.getMessage());
}
}

@ -0,0 +1,42 @@
package com.example.api.handler;
// 导入自定义的禁止基础响应注解
import com.example.api.annotation.DisableBaseResponse;
// 导入用于封装API响应结果的类
import com.example.api.model.support.ResponseResult;
// 导入Spring的MethodParameter类用于获取方法参数信息
import org.springframework.core.MethodParameter;
// 导入Spring的MediaType类用于表示媒体类型
import org.springframework.http.MediaType;
// 导入Spring的ServerHttpRequest和ServerHttpResponse类用于处理HTTP请求和响应
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
// 导入Spring MVC的@ControllerAdvice注解用于定义全局的控制器增强
import org.springframework.web.bind.annotation.ControllerAdvice;
// 导入Spring MVC的ResponseBodyAdvice接口用于在响应写入前进行处理
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
/**
* Controller
* ResponseResult<T>
*/
@ControllerAdvice(value = "com.example.api.controller")
public class GlobalResponseHandler implements ResponseBodyAdvice<Object> {
// 实现supports方法判断当前方法是否需要被增强
@Override
public boolean supports(MethodParameter methodParameter, Class c) {
// 如果方法参数上有DisableBaseResponse注解则不进行增强
return !methodParameter.hasParameterAnnotation(DisableBaseResponse.class);
}
// 实现beforeBodyWrite方法在响应写入前进行处理
@Override
public Object beforeBodyWrite(Object o, MethodParameter methodParameter, MediaType mediaType, Class aClass,
ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
// 如果返回值为null则返回一个空的ResponseResult对象
// 否则将返回值封装在ResponseResult对象中
return o == null ? new ResponseResult<>() : new ResponseResult<>(o);
}
}

@ -0,0 +1,19 @@
package com.example.api.model.dto;
import lombok.Data;
/**
*
*/
@Data
public class LoginDto {
private String email;
private String password;
private String code;
private boolean remember;
}

@ -0,0 +1,52 @@
package com.example.api.model.entity;
// 导入Lombok提供的注解用于简化Java类的编写
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
// 导入Hibernate提供的注解用于定义生成ID的策略
import org.hibernate.annotations.GenericGenerator;
// 导入JPA注解用于定义实体和字段的映射
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
/**
*
*/
// 使用@Data注解自动生成getter和setter方法以及toString(), equals()和hashCode()方法
@Data
// 使用@Entity注解标记这个类是一个JPA实体可以被持久化到数据库
@Entity
// 使用@NoArgsConstructor生成一个无参数的构造函数
@NoArgsConstructor
// 使用@AllArgsConstructor生成一个全参数的构造函数
@AllArgsConstructor
public class Admin {
// 使用@Id标记这个字段为主键
@Id
// 使用@GeneratedValue指定主键值的生成策略这里使用"uuid2"生成器
@GeneratedValue(generator = "uuid2")
// 使用@GenericGenerator定义一个名为"uuid2"的生成器使用Hibernate的UUID生成策略
@GenericGenerator(name = "uuid2", strategy = "org.hibernate.id.UUIDGenerator")
private String id;
// 使用@Column注解定义email字段的数据库列属性设置数据类型为varchar(30),默认值为'LTD',且字段不能为空
@Column(columnDefinition = "varchar(30) default 'LTD' not null")
private String email;
// 使用@Column注解定义password字段的数据库列属性设置数据类型为varchar(30),默认值为'LTD',且字段不能为空
@Column(columnDefinition = "varchar(30) default 'LTD' not null")
private String password;
// roles字段用于存储管理员的角色信息
private String roles;
// createAt字段用于存储管理员的创建时间
private String createAt;
}

@ -0,0 +1,50 @@
package com.example.api.model.entity;
// 导入Lombok提供的@Data注解用于自动生成类的getter、setter、toString、equals和hashCode方法
import lombok.Data;
// 导入Lombok提供的@NoArgsConstructor注解用于生成无参构造函数
import lombok.NoArgsConstructor;
// 导入Hibernate提供的GenericGenerator注解用于自定义主键生成策略
import org.hibernate.annotations.GenericGenerator;
// 导入JPA提供的@Entity注解用于标记类为JPA实体
import javax.persistence.Entity;
// 导入JPA提供的@Id注解用于标记类的字段为主键
import javax.persistence.Id;
// 导入JPA提供的@GeneratedValue注解用于指定主键的生成策略
import javax.persistence.GeneratedValue;
/**
*
*/
// @Data注解自动生成getter和setter方法以及toString(), equals()和hashCode()方法
@Data
// @Entity注解标记这个类是一个JPA实体可以被持久化到数据库
@Entity
// @NoArgsConstructor注解生成一个无参数的构造函数
@NoArgsConstructor
public class Code {
// 使用@Id标记email字段为主键
@Id
private String email;
// value字段用于存储验证码的值
private String value;
// exp字段用于存储验证码的过期时间毫秒值
private long exp;
/**
* Code
* @param email
* @param value
*/
public Code(String email, String value) {
this.email = email;
this.value = value;
// 设置验证码的过期时间为当前时间加上15分钟15分钟 = 15 * 60秒 = 15 * 60 * 1000毫秒
this.exp = System.currentTimeMillis() + 1000 * 60 * 15;
}
}

@ -0,0 +1,54 @@
package com.example.api.model.entity;
// 导入Lombok提供的@Data注解用于自动生成类的getter、setter、toString、equals和hashCode方法
import lombok.Data;
// 导入Lombok提供的@NoArgsConstructor注解用于生成无参构造函数
import lombok.NoArgsConstructor;
// 导入Hibernate提供的GenericGenerator注解用于自定义主键生成策略
import org.hibernate.annotations.GenericGenerator;
// 导入JPA提供的@Entity注解用于标记类为JPA实体
import javax.persistence.Entity;
// 导入JPA提供的@Id注解用于标记类的字段为主键
import javax.persistence.Id;
// 导入JPA提供的@GeneratedValue注解用于指定主键的生成策略
import javax.persistence.GeneratedValue;
/**
*
*/
// @Data注解自动生成getter和setter方法以及toString(), equals()和hashCode()方法
@Data
// @Entity注解标记这个类是一个JPA实体可以被持久化到数据库
@Entity
// @NoArgsConstructor注解生成一个无参数的构造函数
@NoArgsConstructor
public class Commodity {
// 使用@Id标记id字段为主键
@Id
// 使用@GeneratedValue指定主键值的生成策略这里使用"uuid2"生成器
@GeneratedValue(generator = "uuid2")
// 使用@GenericGenerator定义一个名为"uuid2"的生成器使用Hibernate的UUID生成策略
@GenericGenerator(name = "uuid2", strategy = "org.hibernate.id.UUIDGenerator")
private String id;
// name字段用于存储商品的名称
private String name;
// price字段用于存储商品的价格
private double price;
// description字段用于存储商品的描述信息
private String description;
// count字段用于存储商品的数量
private int count;
// createAt字段用于存储商品的创建时间
private String createAt;
// updateAt字段用于存储商品的更新时间
private String updateAt;
}

@ -0,0 +1,40 @@
package com.example.api.model.entity;
// 导入Lombok提供的@Data注解用于自动生成类的getter、setter、toString、equals和hashCode方法
import lombok.Data;
// 导入Lombok提供的@NoArgsConstructor注解用于生成无参构造函数
import lombok.NoArgsConstructor;
// 导入Hibernate提供的GenericGenerator注解用于自定义主键生成策略
import org.hibernate.annotations.GenericGenerator;
// 导入JPA提供的@Entity注解用于标记类为JPA实体
import javax.persistence.Entity;
// 导入JPA提供的@Id注解用于标记类的字段为主键
import javax.persistence.Id;
// 导入JPA提供的@GeneratedValue注解用于指定主键的生成策略
import javax.persistence.GeneratedValue;
/**
*
*/
// @Data注解自动生成getter和setter方法以及toString(), equals()和hashCode()方法
@Data
// @Entity注解标记这个类是一个JPA实体可以被持久化到数据库
@Entity
// @NoArgsConstructor注解生成一个无参数的构造函数
@NoArgsConstructor
public class Company {
/**
* id
* 使@Id
* 使@GeneratedValue@GenericGenerator使
* 使"uuid2"使UUID
*/
@Id
@GeneratedValue(generator = "uuid2")
@GenericGenerator(name = "uuid2", strategy = "org.hibernate.id.UUIDGenerator")
private String id;
// 这里可以添加其他的字段和方法,例如公司名称、地址、联系方式等
}

@ -0,0 +1,81 @@
package com.example.api.model.entity;
// 导入Jackson库提供的@JsonFormat注解用于定义JSON序列化和反序列化时的格式
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Lombok提供的@Data注解用于自动生成类的getter、setter、toString、equals和hashCode方法
import lombok.Data;
// 导入Lombok提供的@NoArgsConstructor注解用于生成无参构造函数
import lombok.NoArgsConstructor;
// 导入Hibernate提供的GenericGenerator注解用于自定义主键生成策略
import org.hibernate.annotations.GenericGenerator;
// 导入JPA提供的@Entity注解用于标记类为JPA实体
import javax.persistence.Entity;
// 导入JPA提供的@Id注解用于标记类的字段为主键
import javax.persistence.Id;
// 导入JPA提供的@GeneratedValue注解用于指定主键的生成策略
import javax.persistence.GeneratedValue;
// 导入java.time.LocalDateTime用于存储日期和时间
import java.time.LocalDateTime;
// 导入java.util.Date用于存储日期
import java.util.Date;
/**
*
*/
// @Data注解自动生成getter和setter方法以及toString(), equals()和hashCode()方法
@Data
// @Entity注解标记这个类是一个JPA实体可以被持久化到数据库
@Entity
// @NoArgsConstructor注解生成一个无参数的构造函数
@NoArgsConstructor
public class Distribution {
/**
* id
* 使@Id
* 使@GeneratedValue@GenericGenerator使
* 使"uuid2"使UUID
*/
@Id
@GeneratedValue(generator = "uuid2")
@GenericGenerator(name = "uuid2", strategy = "org.hibernate.id.UUIDGenerator")
private String id;
// 司机id
private String did;
// 车辆id
private String vid;
// 司机姓名
private String driver;
// 车牌号
private String number;
// 客户电话
private String phone;
// 客户地址
private String address;
// 是否加急处理
private boolean urgent;
// 关注事项
private String care;
/**
*
* 使@JsonFormatJSON
* "yyyy-MM-dd HH:mm:ss""GMT+8"
*/
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private LocalDateTime time;
// 配送状态
private Integer status;
}

@ -0,0 +1,49 @@
package com.example.api.model.entity;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
/**
*
*/
@Data
@Entity
@NoArgsConstructor
public class Driver {
@Id
@GeneratedValue(generator = "uuid2")
@GenericGenerator(name = "uuid2", strategy = "org.hibernate.id.UUIDGenerator")
private String id;
private String name;
private String gender;
private String phone;
//家庭住址
private String address;
//身份证号码
private String idCard;
//驾驶证
private String license;
//驾驶证分数 12分
private String score;
//正在驾驶
private boolean driving;
private String createAt;
private String updateAt;
}

@ -0,0 +1,57 @@
package com.example.api.model.entity;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
/**
*
*/
// @Data注解自动生成getter和setter方法以及toString(), equals()和hashCode()方法
@Data
// @Entity注解标记这个类是一个JPA实体可以被持久化到数据库
@Entity
// @NoArgsConstructor注解生成一个无参数的构造函数
@NoArgsConstructor
public class Employee {
/**
* id
* 使@Id
* 使@GeneratedValue@GenericGenerator使
* 使"uuid2"使UUID
*/
@Id
@GeneratedValue(generator = "uuid2")
@GenericGenerator(name = "uuid2", strategy = "org.hibernate.id.UUIDGenerator")
private String id;
// 员工的名字
private String name;
// 员工的性别
private String gender;
// 员工的手机号
private String phone;
// 员工的家庭住址
private String address;
// 员工的身份证号码
private String idCard;
// 员工所属的部门
private String department;
// 员工记录的创建时间
private String createAt;
// 员工记录的更新时间
private String updateAt;
}

@ -0,0 +1,48 @@
package com.example.api.model.entity;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
/**
*
*/
// @Data注解自动生成getter和setter方法以及toString(), equals()和hashCode()方法
@Data
// @Entity注解标记这个类是一个JPA实体可以被持久化到数据库
@Entity
// @NoArgsConstructor注解生成一个无参数的构造函数
@NoArgsConstructor
public class Inventory {
/**
* id
* 使@Id
* 使@GeneratedValue@GenericGenerator使
* 使"uuid2"使UUID
*/
@Id
@GeneratedValue(generator = "uuid2")
@GenericGenerator(name = "uuid2", strategy = "org.hibernate.id.UUIDGenerator")
private String id;
// 仓库id用于标识库存所属的仓库
private String wid;
// 商品信息id用于标识库存中商品的具体信息
private String cid;
// 商品名,用于存储库存中商品的名称
private String name;
// 所在位置区域,用于标识商品在仓库中的具体位置
private String location;
// 数量,用于存储库存中商品的数量
private Integer count;
}

@ -0,0 +1,57 @@
package com.example.api.model.entity;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
/**
*
*/
// @Data注解自动生成getter和setter方法以及toString(), equals()和hashCode()方法
@Data
// @Entity注解标记这个类是一个JPA实体可以被持久化到数据库
@Entity
// @NoArgsConstructor注解生成一个无参数的构造函数
@NoArgsConstructor
public class InventoryRecord {
/**
* id
* 使@Id
* 使@GeneratedValue@GenericGenerator使
* 使"uuid2"使UUID
*/
@Id
@GeneratedValue(generator = "uuid2")
@GenericGenerator(name = "uuid2", strategy = "org.hibernate.id.UUIDGenerator")
private String id;
// 商品名,用于存储记录中商品的名称
private String name;
// 仓库id用于标识商品所在的仓库
private String wid;
// 商品信息id用于标识记录中商品的具体信息
private String cid;
// 变动数量,用于记录商品数量的增减
private Integer count;
/**
*
* -1+1
*/
private Integer type;
// 描述信息,用于存储库存记录的详细描述
private String description;
// 创建时间,用于存储记录的创建时间
private String createAt;
}

@ -0,0 +1,59 @@
package com.example.api.model.entity;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.hibernate.annotations.GenericGenerator;
import org.hibernate.annotations.Table;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import java.time.LocalDateTime;
import java.util.Date;
/**
*
*/
// @Entity注解标记这个类是一个JPA实体可以被持久化到数据库
@Entity
// @Data注解自动生成getter和setter方法以及toString(), equals()和hashCode()方法
@Data
// @AllArgsConstructor注解生成一个全参数的构造函数
@AllArgsConstructor
// @NoArgsConstructor注解生成一个无参数的构造函数
@NoArgsConstructor
public class LoginLog {
/**
* id
* 使@Id
* 使@GeneratedValue@GenericGenerator使
* 使"uuid2"使UUID
*/
@Id
@GeneratedValue(generator = "uuid2")
@GenericGenerator(name = "uuid2", strategy = "org.hibernate.id.UUIDGenerator")
private String id;
// 登录邮箱,用于存储登录用户的邮箱地址
private String email;
// 登录状态,用于存储登录操作的结果状态
private Integer status;
// 用户的IP地址用于存储登录用户的IP地址
private String ip;
/**
*
* 使@JsonFormatJSON
* "yyyy-MM-dd HH:mm:ss""GMT+8"
*/
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private Date date;
// 浏览器,用于存储登录用户使用的浏览器信息
private String browser;
}

@ -0,0 +1,43 @@
package com.example.api.model.entity;
import lombok.Data; // 导入Lombok的@Data注解自动为类生成getter和setter方法以及toString、equals和hashCode方法
import lombok.NoArgsConstructor; // 导入Lombok的@NoArgsConstructor注解自动生成无参构造函数
import org.hibernate.annotations.GenericGenerator; // 导入Hibernate的GenericGenerator注解用于自定义主键生成策略
import javax.persistence.Entity; // 导入JPA的@Entity注解声明这个类是一个实体类
import javax.persistence.GeneratedValue; // 导入JPA的@GeneratedValue注解用于指定主键生成策略
import javax.persistence.Id; // 导入JPA的@Id注解用于标记类的主键属性
/**
*
*/
@Data
@Entity
@NoArgsConstructor
public class Sale {
// 使用@Id注解标记为主键
@Id
// 使用@GeneratedValue注解指定主键生成策略
@GeneratedValue(generator = "uuid2")
// 使用GenericGenerator注解自定义主键生成器这里使用的是UUID生成器
@GenericGenerator(name = "uuid2", strategy = "org.hibernate.id.UUIDGenerator")
private String id; // 销售记录的唯一标识符
private String company; // 销售公司名称
private String number; // 销售编号
private String commodity; // 销售商品名称
private String count; // 销售数量
private double price; // 销售价格
private String phone; // 联系电话
private String description; // 销售描述
private boolean pay; // 是否已支付
private String createAt; // 创建时间
}

@ -0,0 +1,64 @@
package com.example.api.model.entity;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import java.time.LocalDateTime;
/**
*
*/
// @Entity注解标记这个类是一个JPA实体可以被持久化到数据库
@Entity
// @Data注解自动生成getter和setter方法以及toString(), equals()和hashCode()方法
@Data
// @NoArgsConstructor注解生成一个无参数的构造函数
@NoArgsConstructor
public class SystemLog {
/**
* id
* 使@Id
* 使@GeneratedValue@GenericGenerator使
* 使"uuid2"使UUID
*/
@Id
@GeneratedValue(generator = "uuid2")
@GenericGenerator(name = "uuid2", strategy = "org.hibernate.id.UUIDGenerator")
private String id;
// 账号,用于存储执行操作的用户账号
private String account;
// 功能模块,用于存储用户操作的功能模块名称
private String module;
/**
*
* 使@Columnvarchar(30)'LTD'
*/
@Column(columnDefinition = "varchar(30) default 'LTD' not null")
private String businessType;
// 用户IP用于存储用户操作的IP地址
@Column(columnDefinition = "varchar(40) default 'LTD' not null")
private String ip;
// 请求方法,用于存储用户操作的请求方法
@Column(columnDefinition = "varchar(100) default 'LTD' not null")
private String method;
/**
*
* 使@JsonFormatJSON
* "yyyy-MM-dd HH:mm:ss""GMT+8"
*/
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private LocalDateTime time;
}

@ -0,0 +1,45 @@
package com.example.api.model.entity;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
/**
*
*/
// @Data注解自动生成getter和setter方法以及toString(), equals()和hashCode()方法
@Data
// @Entity注解标记这个类是一个JPA实体可以被持久化到数据库
@Entity
// @NoArgsConstructor注解生成一个无参数的构造函数
@NoArgsConstructor
public class User {
/**
* id
* 使@Id
* 使@GeneratedValue@GenericGenerator使
* 使"uuid2"使UUID
*/
@Id
@GeneratedValue(generator = "uuid2")
@GenericGenerator(name = "uuid2", strategy = "org.hibernate.id.UUIDGenerator")
private String id;
// 用户名,用于存储用户的登录名称
private String username;
// 密码,用于存储用户的登录密码
private String password;
// 创建时间,用于存储用户记录的创建时间
private String createAt;
// 更新时间,用于存储用户记录的更新时间
private String updateAt;
}

@ -0,0 +1,48 @@
package com.example.api.model.entity;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
/**
*
*/
// @Data注解自动生成getter和setter方法以及toString(), equals()和hashCode()方法
@Data
// @Entity注解标记这个类是一个JPA实体可以被持久化到数据库
@Entity
// @NoArgsConstructor注解生成一个无参数的构造函数
@NoArgsConstructor
public class Vehicle {
/**
* id
* 使@Id
* 使@GeneratedValue@GenericGenerator使
* 使"uuid2"使UUID
*/
@Id
@GeneratedValue(generator = "uuid2")
@GenericGenerator(name = "uuid2", strategy = "org.hibernate.id.UUIDGenerator")
private String id;
// 车牌号,用于存储车辆的车牌号码
private String number;
// 车辆类型,用于存储车辆的类型(例如:轿车、卡车等)
private String type;
/**
*
* truefalse
*/
private boolean driving;
// 创建时间,用于存储车辆记录的创建时间
private String createAt;
}

@ -0,0 +1,42 @@
package com.example.api.model.entity;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
/**
*
*/
// @Data注解自动生成getter和setter方法以及toString(), equals()和hashCode()方法
@Data
// @Entity注解标记这个类是一个JPA实体可以被持久化到数据库
@Entity
// @NoArgsConstructor注解生成一个无参数的构造函数
@NoArgsConstructor
public class Warehouse {
/**
* id
* 使@Id
* 使@GeneratedValue@GenericGenerator使
* 使"uuid2"使UUID
*/
@Id
@GeneratedValue(generator = "uuid2")
@GenericGenerator(name = "uuid2", strategy = "org.hibernate.id.UUIDGenerator")
private String id;
// 仓库名称,用于存储仓库的名称
private String name;
// 仓库负责人,用于存储负责管理仓库的人员的名称或职位
private String principle;
// 创建时间,用于存储仓库记录的创建时间
private String createAt;
}

@ -0,0 +1,38 @@
package com.example.api.model.enums;
/*
*/
public enum BusinessType {
// 枚举实例
OTHER("其他"), // 其他类型的业务操作
QUERY("查询"), // 查询数据的业务操作
INSERT("新增"), // 新增数据的业务操作
UPDATE("更新"), // 更新数据的业务操作
DELETE("删除"), // 删除数据的业务操作
EXPORT("导出"), // 导出数据的业务操作
FORCE("退出"); // 强制退出系统的业务操作
// 构造函数,用于为枚举实例命名
private BusinessType(String name){
this.name = name;
}
// 用于存储每个枚举实例的名称
private String name;
// 获取枚举实例的名称
public String getName() {
return name;
}
// 设置枚举实例的名称
public void setName(String name) {
this.name = name;
}
// 重写toString方法返回枚举实例的名称
@Override
public String toString() {
return name;
}
}

@ -0,0 +1,41 @@
package com.example.api.model.enums;
import lombok.Getter;
import lombok.Setter;
/**
*
*/
public enum DistributionStatus {
/**
* 0
*/
REVIEWING(0),
/**
* 1
*/
REVIEW_SUCCESS(1),
/**
* 2
*/
END(2);
/**
*
* @param code
*/
DistributionStatus(Integer code) {
this.code = code;
}
/**
* lombok@Getter@Settercodegettersetter
*/
@Getter
@Setter
private Integer code;
}

@ -0,0 +1,76 @@
package com.example.api.model.enums;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Getter;
/**
*
*/
@Getter
@JsonFormat(shape = JsonFormat.Shape.OBJECT)
public enum Role {
/**
*
*
*/
ROLE_SUPER_ADMIN("ROLE_SUPER_ADMIN", "超级管理员"),
/**
*
*/
ROLE_ADMIN("ROLE_ADMIN", "操作员相关权限"),
/**
*
*/
ROLE_COMMODITY("ROLE_COMMODITY", "商品相关权限"),
/**
*
*/
ROLE_EMPLOYEE("ROLE_EMPLOYEE", "员工相关权限"),
/**
*
*/
ROLE_SALE("ROLE_SALE", "销售相关权限"),
/**
*
*/
ROLE_WAREHOUSE("ROLE_WAREHOUSE", "仓库相关权限");
/**
*
*/
private final String value;
/**
*
*/
private final String description;
/**
*
*
*/
public static final Role[] ROLES = {
ROLE_ADMIN,
ROLE_COMMODITY,
ROLE_EMPLOYEE,
ROLE_SALE,
ROLE_WAREHOUSE
};
/**
*
* @param value
* @param description
*/
Role(String value, String description) {
this.value = value;
this.description = description;
}
}

@ -0,0 +1,6 @@
package com.example.api.model.enums;
public class Test {
public static void main(String[] args) {
}
}

@ -0,0 +1,70 @@
package com.example.api.model.support;
import lombok.Data;
/**
* API
* @param <T>
*/
@Data
public class ResponseResult<T> {
// 响应代码200表示成功其他代码表示错误或特定状态
private Integer code;
// 状态标志true表示成功false表示失败
private boolean status;
// 响应消息,用于给调用者提供额外的信息
private String msg;
// 响应数据,泛型支持,可以是任何类型的对象
private T data;
/**
*
*
*/
public ResponseResult() {
this.code = 200;
this.status = true;
this.msg = null;
this.data = null;
}
/**
*
* @param data
*/
public ResponseResult(T data) {
this.code = 200;
this.status = true;
this.msg = null;
this.data = data;
}
/**
*
* @param msg
* @param data
*/
public ResponseResult(String msg, T data) {
this.code = 200;
this.status = true;
this.msg = msg;
this.data = data;
}
/**
*
* @param code
* @param msg
*/
public ResponseResult(Integer code, String msg) {
this.code = code;
this.status = false;
this.msg = msg;
this.data = null;
}
}

@ -0,0 +1,16 @@
package com.example.api.model.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
@Data
@AllArgsConstructor
public class CommodityChartVo {
//商品名
private Integer value;
//数量
private String name;
}

@ -0,0 +1,13 @@
package com.example.api.model.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class SystemLogVo {
private String account;
private String module;
}

@ -0,0 +1,36 @@
package com.example.api.repository;
import com.example.api.model.entity.Admin; // 导入Admin实体类
import org.springframework.data.jpa.repository.JpaRepository; // 继承JPA仓库接口
import org.springframework.stereotype.Repository; // 标识这是一个Repository组件
/**
*
*/
// 使用@Repository注解标识这是一个Spring组件通常用于数据访问层
@Repository
public interface AdminRepository extends JpaRepository<Admin, String> {
/**
*
* @param email
* @param password
* @return null
*/
Admin findAdminByEmailAndPassword(String email, String password);
/**
*
* @param email
* @return null
*/
Admin findAdminByEmail(String email);
/**
*
* @param roles
* @return truefalse
*/
boolean existsAdminByRoles(String roles);
}

@ -0,0 +1,22 @@
package com.example.api.repository;
import com.example.api.model.entity.Code; // 导入Code实体类
import org.springframework.data.jpa.repository.JpaRepository; // 继承JPA仓库接口
import org.springframework.stereotype.Repository; // 标识这是一个Repository组件
/**
*
*/
// 使用@Repository注解标识这是一个Spring组件通常用于数据访问层
@Repository
public interface CodeRepository extends JpaRepository<Code, String> {
/**
*
* @param email
* @param value
* @return null
*/
Code findByEmailAndValue(String email, String value);
}

@ -0,0 +1,30 @@
package com.example.api.repository;
import com.example.api.model.entity.Commodity; // 导入Commodity实体类
import org.springframework.data.jpa.repository.JpaRepository; // 继承JPA仓库接口
import org.springframework.stereotype.Repository; // 标识这是一个Repository组件
import java.util.List; // 导入List类用于返回多个结果
/**
*
*/
// 使用@Repository注解标识这是一个Spring组件通常用于数据访问层
@Repository
public interface CommodityRepository extends JpaRepository<Commodity, String> {
/**
*
* @param name
* @return null
*/
Commodity findByName(String name);
/**
*
* @param name
* @return
*/
List<Commodity> findByNameLike(String name);
}

@ -0,0 +1,9 @@
package com.example.api.repository;
import com.example.api.model.entity.Distribution;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface DistributionRepository extends JpaRepository<Distribution, String> {
}

@ -0,0 +1,36 @@
package com.example.api.repository;
import com.example.api.model.entity.Driver; // 导入Driver实体类
import org.springframework.data.jpa.repository.JpaRepository; // 继承JPA仓库接口
import org.springframework.data.jpa.repository.Modifying; // 注解,用于标识修改数据库的操作
import org.springframework.data.jpa.repository.Query; // 注解用于执行自定义的JPQL或SQL查询
import org.springframework.stereotype.Repository; // 标识这是一个Repository组件
import org.springframework.transaction.annotation.Transactional; // 注解,用于声明事务性方法
import java.util.List; // 导入List类用于返回多个结果
/**
*
*/
// 使用@Repository注解标识这是一个Spring组件通常用于数据访问层
@Repository
public interface DriverRepository extends JpaRepository<Driver, String> {
/**
*
* @param driving
* @param id ID
*/
@Modifying // 标识这是一个修改操作
@Transactional // 标识这是一个事务性方法
@Query("update Driver d set d.driving = ?1 where d.id = ?2") // JPQL查询用于更新操作
void updateDriving(boolean driving, String id);
/**
*
* @param driving
* @return
*/
List<Driver> findAllByDriving(boolean driving);
}

@ -0,0 +1,9 @@
package com.example.api.repository;
import com.example.api.model.entity.Employee;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface EmployeeRepository extends JpaRepository<Employee, String> {
}

@ -0,0 +1,37 @@
package com.example.api.repository;
import com.example.api.model.entity.InventoryRecord; // 导入InventoryRecord实体类
import org.springframework.data.jpa.repository.JpaRepository; // 继承JPA仓库接口
import org.springframework.stereotype.Repository; // 标识这是一个Repository组件
import java.util.List; // 导入List类用于返回多个结果
/**
*
*/
// 使用@Repository注解标识这是一个Spring组件通常用于数据访问层
@Repository
public interface InventoryRecordRepository extends JpaRepository<InventoryRecord, String> {
/**
* ID
* @param wid ID
* @return ID
*/
List<InventoryRecord> findAllByWid(String wid);
/**
*
* @param type -1+1
* @return
*/
List<InventoryRecord> findAllByType(Integer type);
/**
* ID
* @param cid ID
* @return ID
*/
List<InventoryRecord> findAllByCid(String cid);
}

@ -0,0 +1,38 @@
package com.example.api.repository;
import com.example.api.model.entity.Inventory; // 导入Inventory实体类
import org.springframework.data.jpa.repository.JpaRepository; // 继承JPA仓库接口
import org.springframework.stereotype.Repository; // 标识这是一个Repository组件
import java.util.List; // 导入List类用于返回多个结果
/**
*
*/
// 使用@Repository注解标识这是一个Spring组件通常用于数据访问层
@Repository
public interface InventoryRepository extends JpaRepository<Inventory, String> {
/**
* IDID
* @param wid ID
* @param cid ID
* @return null
*/
Inventory findByWidAndCid(String wid, String cid);
/**
* ID
* @param cid ID
* @return ID
*/
List<Inventory> findAllByCid(String cid);
/**
* ID
* @param wid ID
* @return ID
*/
List<Inventory> findAllByWid(String wid);
}

@ -0,0 +1,9 @@
package com.example.api.repository;
import com.example.api.model.entity.LoginLog;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface LoginLogRepository extends JpaRepository<LoginLog,String> {
}

@ -0,0 +1,18 @@
package com.example.api.repository;
import com.example.api.model.entity.Sale; // 导入Sale实体类
import org.springframework.data.jpa.repository.JpaRepository; // 导入Spring Data JPA的JpaRepository接口
import org.springframework.stereotype.Repository; // 导入Spring的@Repository注解用于声明这是一个Repository
import java.util.List; // 导入List接口用于返回列表类型的数据
// 使用@Repository注解声明这是一个Repository通常用于数据库操作
@Repository
// 声明这是一个SaleRepository接口它继承了JpaRepository接口
public interface SaleRepository extends JpaRepository<Sale, String> {
// 定义一个方法findAllByCompanyLike用于根据公司名称模糊查询销售记录
// 这个方法会根据传入的参数name查询company字段中包含name字符串的所有Sale记录
List<Sale> findAllByCompanyLike(String name);
}

@ -0,0 +1,14 @@
package com.example.api.repository;
import com.example.api.model.entity.SystemLog;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public interface SystemLogRepository extends JpaRepository<SystemLog,String>, JpaSpecificationExecutor<SystemLog> {
}

@ -0,0 +1,9 @@
package com.example.api.repository;
import com.example.api.model.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface UserRepository extends JpaRepository<User, String> {
}

@ -0,0 +1,36 @@
package com.example.api.repository;
import com.example.api.model.entity.Vehicle; // 导入Vehicle实体类
import org.springframework.data.jpa.repository.JpaRepository; // 继承JPA仓库接口
import org.springframework.data.jpa.repository.Modifying; // 注解,用于标识修改数据库的操作
import org.springframework.data.jpa.repository.Query; // 注解用于执行自定义的JPQL或SQL查询
import org.springframework.stereotype.Repository; // 标识这是一个Repository组件
import org.springframework.transaction.annotation.Transactional; // 注解,用于声明事务性方法
import java.util.List; // 导入List类用于返回多个结果
/**
*
*/
// 使用@Repository注解标识这是一个Spring组件通常用于数据访问层
@Repository
public interface VehicleRepository extends JpaRepository<Vehicle, String> {
/**
*
* @param driving truefalse
* @param id ID
*/
@Modifying // 标识这是一个修改操作
@Transactional // 标识这是一个事务性方法
@Query("update Vehicle v set v.driving = ?1 where v.id = ?2") // JPQL查询用于更新操作
void updateDriving(boolean driving, String id);
/**
*
* @param driving truefalse
* @return vehicles
*/
List<Vehicle> findAllByDriving(boolean driving);
}

@ -0,0 +1,9 @@
package com.example.api.repository;
import com.example.api.model.entity.Warehouse;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface WareHouseRepository extends JpaRepository<Warehouse, String> {
}

@ -0,0 +1,63 @@
package com.example.api.security;
import com.example.api.model.support.ResponseResult; // 导入自定义响应结果类
import com.example.api.utils.JwtTokenUtil; // 导入JWT工具类
import com.example.api.utils.ResponseUtil; // 导入响应工具类
import org.springframework.security.authentication.AuthenticationManager; // 导入认证管理器
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; // 导入用户名密码认证令牌
import org.springframework.security.core.authority.SimpleGrantedAuthority; // 导入简单授权对象
import org.springframework.security.core.context.SecurityContextHolder; // 导入安全上下文持有者
import org.springframework.security.web.authentication.www.BasicAuthenticationFilter; // 导入基本认证过滤器
import javax.servlet.FilterChain; // 导入过滤器链
import javax.servlet.ServletException; // 导入Servlet异常
import javax.servlet.http.HttpServletRequest; // 导入HTTP请求
import javax.servlet.http.HttpServletResponse; // 导入HTTP响应
import java.io.IOException; // 导入IO异常
import java.util.ArrayList; // 导入ArrayList
import java.util.List; // 导入List
/**
* JWTRequestAuthorization HeaderJWT
* JWTtoken
*/
public class JwtAuthorizationFilter extends BasicAuthenticationFilter {
public JwtAuthorizationFilter(AuthenticationManager authenticationManager) {
super(authenticationManager);
}
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
throws IOException, ServletException {
// 从Request Header取出Token
String token = request.getHeader(JwtTokenUtil.TOKEN_HEADER);
// Token为空放行
// 如果接下来进入的URL不是公共的地址SpringSecurity会返回403的错误
if (token == null || !JwtTokenUtil.checkToken(token)) {
chain.doFilter(request, response);
return;
}
// 判断JWT Token是否过期
if (JwtTokenUtil.isExpiration(token)) {
ResponseUtil.writeJson(response, new ResponseResult<>(403, "令牌已过期, 请重新登录"));
return;
}
// 解析token
String username = JwtTokenUtil.getUsername(token);
List<String> tokenRoles = JwtTokenUtil.getTokenRoles(token);
ArrayList<SimpleGrantedAuthority> roles = new ArrayList<>();
for (String role : tokenRoles) {
roles.add(new SimpleGrantedAuthority(role));
}
// 向SpringSecurity的Context中加入认证信息
SecurityContextHolder.getContext().setAuthentication(
new UsernamePasswordAuthenticationToken(username, null, roles));
super.doFilterInternal(request, response, chain);
}
}

@ -0,0 +1,61 @@
package com.example.api.security;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.CorsConfigurationSource;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
@Bean
public BCryptPasswordEncoder bCryptPasswordEncoder() {
return new BCryptPasswordEncoder();
}
/**
* HTTP
*
* @param http h
* @throws Exception e
*/
@Override
protected void configure(HttpSecurity http) throws Exception {
//开启跨域
http.csrf().disable().cors();
//禁用session
http.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
//添加自定义的jwt过滤器
http.addFilter(new JwtAuthorizationFilter(authenticationManagerBean()));
}
/**
* SpringSecurity RequestHeader"Authorization"
* apicors error
*
* @return *
*/
@Bean
CorsConfigurationSource corsConfigurationSource() {
final UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
final CorsConfiguration corsConfiguration = new CorsConfiguration();
corsConfiguration.addAllowedHeader("*");
corsConfiguration.addAllowedHeader("DELETE");
corsConfiguration.addAllowedMethod("*");
corsConfiguration.addAllowedOrigin("*");
source.registerCorsConfiguration("/**", corsConfiguration);
return source;
}
}

@ -0,0 +1,72 @@
package com.example.api.service;
import com.example.api.model.dto.LoginDto; // 导入LoginDto数据传输对象封装登录信息
import com.example.api.model.entity.Admin; // 导入Admin实体类代表管理员信息
import java.util.List; // 导入List类用于处理列表数据
/**
*
*/
public interface AdminService {
/**
*
* @param admin
* @return ID
* @throws Exception
*/
Admin save(Admin admin) throws Exception;
/**
* ID
* @param id ID
* @return null
*/
Admin findById(String id);
/**
*
* @param email
* @return truefalse
* @throws Exception
*/
boolean sendEmail(String email) throws Exception;
/**
*
* @param dto
* @return
* @throws Exception
*/
Admin loginByPassword(LoginDto dto) throws Exception;
/**
*
* @param dto
* @return
* @throws Exception
*/
Admin loginByEmail(LoginDto dto) throws Exception;
/**
*
* @return
*/
List<Admin> findAll();
/**
* JWT
* @param admin
* @param exp
* @return JWT
*/
String createToken(Admin admin, long exp);
/**
* ID
* @param id ID
*/
void delete(String id);
}

@ -0,0 +1,51 @@
package com.example.api.service;
import com.example.api.model.entity.Commodity; // 导入Commodity实体类代表商品信息
import java.util.List; // 导入List类用于处理列表数据
/**
*
*/
public interface CommodityService {
/**
*
* @param commodity
* @return ID
*/
Commodity save(Commodity commodity);
/**
*
* @param commodity
*/
void update(Commodity commodity);
/**
* ID
* @param id ID
*/
void delete(String id);
/**
* ID
* @param id ID
* @return null
*/
Commodity findById(String id);
/**
*
* @return
*/
List<Commodity> findAll();
/**
*
* @param name
* @return
*/
List<Commodity> findAllByLikeName(String name);
}

@ -0,0 +1,26 @@
package com.example.api.service;
import com.example.api.model.entity.Distribution; // 导入Distribution实体类代表配送信息
import java.util.List; // 导入List类用于处理列表数据
/**
*
*/
public interface DistributionService {
/**
*
* @param distribution
* @return ID
* @throws Exception
*/
Distribution save(Distribution distribution) throws Exception;
/**
*
* @return
*/
List<Distribution> findAll();
}

@ -0,0 +1,44 @@
package com.example.api.service;
import com.example.api.model.entity.Driver; // 导入Driver实体类代表司机信息
import java.util.List; // 导入List类用于处理列表数据
/**
*
*/
public interface DriverService {
/**
*
* @param driver
* @return ID
*/
Driver save(Driver driver);
/**
*
* @param driver
*/
void update(Driver driver);
/**
* ID
* @param id ID
*/
void delete(String id);
/**
* ID
* @param id ID
* @return null
*/
Driver findById(String id);
/**
*
* @return
*/
List<Driver> findAll();
}

@ -0,0 +1,26 @@
package com.example.api.service;
import org.springframework.mail.MailException; // 导入Spring邮件异常类用于处理邮件发送过程中的异常
/**
*
*/
public interface EmailService {
/**
*
* @param email
* @return truefalse
* @throws MailException MailException
*/
boolean sendVerificationCode(String email) throws MailException;
/**
*
* @param email
* @param code
* @return truefalse
*/
boolean checkVerificationCode(String email, String code);
}

@ -0,0 +1,43 @@
package com.example.api.service;
import com.example.api.model.entity.Employee; // 导入Employee实体类代表员工信息
import java.util.List; // 导入List类用于处理列表数据
/**
*
*/
public interface EmployeeService {
/**
*
* @param employee
* @return ID
*/
Employee save(Employee employee);
/**
*
* @param employee
*/
void update(Employee employee);
/**
* ID
* @param id ID
*/
void delete(String id);
/**
* ID
* @param id ID
* @return null
*/
Employee findById(String id);
/**
*
* @return
*/
List<Employee> findAll();
}

@ -0,0 +1,50 @@
package com.example.api.service;
import com.example.api.model.entity.InventoryRecord; // 导入InventoryRecord实体类代表库存记录信息
import com.example.api.model.vo.CommodityChartVo; // 导入CommodityChartVo视图对象用于展示商品排行统计信息
import java.util.List; // 导入List类用于处理列表数据
/**
*
*/
public interface InventoryRecordService {
/**
*
* @param type 1-1
* @return
*/
List<CommodityChartVo> analyzeCommodity(Integer type);
/**
* ID
* @param wid ID
* @return ID
*/
List<InventoryRecord> findAllByWarehouseId(String wid);
/**
* ID
* @param cid ID
* @return ID
*/
List<InventoryRecord> findAllByCommodityId(String cid);
/**
*
* @param record
* @return
* @throws Exception
*/
InventoryRecord out(InventoryRecord record) throws Exception;
/**
*
* @param record
* @return
* @throws Exception
*/
InventoryRecord in(InventoryRecord record) throws Exception;
}

@ -0,0 +1,38 @@
package com.example.api.service;
import com.example.api.model.entity.Inventory; // 导入Inventory实体类代表库存信息
import java.util.List; // 导入List类用于处理列表数据
/**
*
*/
public interface InventoryService {
/**
*
* @param inventory
* @return ID
*/
Inventory save(Inventory inventory);
/**
*
* @return
*/
List<Inventory> findAll();
/**
* ID
* @param cid ID
* @return ID
*/
List<Inventory> findByCommodityId(String cid);
/**
* ID
* @param wid ID
* @return ID
*/
List<Inventory> findByWarehouseId(String wid);
}

@ -0,0 +1,35 @@
package com.example.api.service;
import com.example.api.model.dto.LoginDto; // 导入LoginDto数据传输对象封装登录信息
import com.example.api.model.entity.Admin; // 导入Admin实体类代表管理员信息
import com.example.api.model.entity.LoginLog; // 导入LoginLog实体类代表登录日志信息
import javax.servlet.http.HttpServletRequest; // 导入HttpServletRequest接口用于获取HTTP请求信息
import java.util.List; // 导入List类用于处理列表数据
/**
*
*/
public interface LoginLogService {
/**
*
* @return
*/
List<LoginLog> getAll();
/**
*
* @param loginDto
* @param admin null
* @param request HTTPIP
*/
void recordLog(LoginDto loginDto, Admin admin, HttpServletRequest request);
/**
*
* @param id ID
*/
void delLoginLog(String id);
}

@ -0,0 +1,32 @@
package com.example.api.service;
import com.example.api.model.entity.Sale; // 导入Sale实体类这个类包含了销售记录的属性
import java.util.List; // 导入List接口用于定义返回销售记录列表的方法
/**
*
*/
public interface SaleService {
/**
*
* @param sale
* @return
*/
Sale save(Sale sale);
/**
*
* @return
*/
List<Sale> findAll();
/**
*
* @param name
* @return
*/
List<Sale> searchByCompany(String name);
}

@ -0,0 +1,39 @@
package com.example.api.service;
import com.example.api.model.entity.SystemLog; // 导入SystemLog实体类代表系统日志信息
import com.example.api.model.vo.SystemLogVo; // 导入SystemLogVo视图对象用于封装查询条件
import org.springframework.data.jpa.repository.Query; // 导入Query注解用于定义自定义查询
import java.util.List; // 导入List类用于处理列表数据
/**
*
*/
public interface SystemLogService {
/**
*
* @param log
*/
public void record(SystemLog log);
/**
*
* @return
*/
public List<SystemLog> getAll();
/**
*
* @param id ID
*/
public void delete(String id);
/**
*
* @param systemLogVo
* @return
*/
public List<SystemLog> query(SystemLogVo systemLogVo);
}

@ -0,0 +1,4 @@
package com.example.api.service;
public interface UserService {
}

@ -0,0 +1,43 @@
package com.example.api.service;
import com.example.api.model.entity.Vehicle; // 导入Vehicle实体类代表车辆信息
import java.util.List; // 导入List类用于处理列表数据
/**
*
*/
public interface VehicleService {
/**
*
* @param vehicle
* @return ID
*/
Vehicle save(Vehicle vehicle);
/**
*
* @param vehicle
*/
void update(Vehicle vehicle);
/**
* ID
* @param id ID
*/
void delete(String id);
/**
* ID
* @param id ID
* @return null
*/
Vehicle findById(String id);
/**
*
* @return
*/
List<Vehicle> findAll();
}

@ -0,0 +1,30 @@
package com.example.api.service;
import com.example.api.model.entity.Warehouse; // 导入Warehouse实体类代表仓库信息
import java.util.List; // 导入List类用于处理列表数据
/**
*
*/
public interface WarehouseService {
/**
*
* @param warehouse
* @return ID
*/
Warehouse save(Warehouse warehouse);
/**
*
* @return
*/
List<Warehouse> findAll();
/**
* ID
* @param id ID
*/
void delete(String id);
}

@ -0,0 +1,144 @@
package com.example.api.service.impl;
import com.example.api.exception.AccountAndPasswordError; // 导入自定义异常类,用于处理账号和密码错误的情况
import com.example.api.model.dto.LoginDto; // 导入登录数据传输对象,用于封装登录请求的数据
import com.example.api.model.entity.Admin; // 导入Admin实体类代表系统中的管理员账户
import com.example.api.model.entity.LoginLog; // 导入登录日志实体类,用于记录管理员登录日志
import com.example.api.repository.AdminRepository; // 导入AdminRepository接口用于访问管理员数据
import com.example.api.repository.LoginLogRepository; // 导入LoginLogRepository接口用于访问登录日志数据
import com.example.api.service.AdminService; // 导入AdminService接口定义管理员服务
import com.example.api.service.EmailService; // 导入EmailService接口用于发送邮件服务
import com.example.api.utils.DataTimeUtil; // 导入日期时间工具类,用于处理日期时间
import com.example.api.utils.JwtTokenUtil; // 导入JWT工具类用于生成和解析JWT令牌
import org.springframework.stereotype.Service; // 标识这是一个Service组件Spring容器会进行管理
import javax.annotation.Resource; // 注解用于注入Spring管理的Bean
import java.util.Date; // 导入Date类用于处理日期
import java.util.List; // 导入List类用于处理列表数据
/**
* Admin
*/
@Service
public class AdminServiceImpl implements AdminService {
@Resource
private AdminRepository adminRepository; // 注入Admin仓库用于访问管理员数据
@Resource
private EmailService emailService; // 注入邮件服务,用于发送邮件
/**
*
* @param admin
* @return
* @throws Exception
*/
@Override
public Admin save(Admin admin) throws Exception {
// 校验邮箱长度和密码长度,如果不符合要求则抛出异常
if (admin.getEmail().length() < 8 || admin.getPassword().length() < 5) throw new Exception("请求参数异常");
// 设置创建时间
admin.setCreateAt(DataTimeUtil.getNowTimeString());
// 保存管理员信息
return adminRepository.save(admin);
}
/**
* ID
* @param id ID
* @return null
*/
@Override
public Admin findById(String id) {
// 根据ID查询管理员信息如果不存在则返回null
return adminRepository.findById(id).orElse(null);
}
/**
*
* @param email
* @return
* @throws Exception
*/
@Override
public boolean sendEmail(String email) throws Exception {
// 根据邮箱查询管理员信息
Admin admin = adminRepository.findAdminByEmail(email);
// 如果管理员信息不存在,则抛出异常
if (admin == null) throw new Exception("不存在的邮箱账户");
// 发送验证邮件
return emailService.sendVerificationCode(email);
}
/**
*
* @param dto
* @return
* @throws Exception
*/
@Override
public Admin loginByPassword(LoginDto dto) throws Exception {
// 根据邮箱和密码查询管理员信息
Admin one = adminRepository.findAdminByEmailAndPassword(dto.getEmail(), dto.getPassword());
// 如果管理员信息不存在,则抛出异常
if (one == null) {
throw new Exception("邮箱或密码错误");
}
// 返回管理员信息
return one;
}
/**
*
* @param dto
* @return
* @throws Exception
*/
@Override
public Admin loginByEmail(LoginDto dto) throws Exception {
// 校验邮箱验证码
boolean status = emailService.checkVerificationCode(dto.getEmail(), dto.getCode());
// 如果验证码错误,则抛出异常
if (!status) throw new Exception("验证码错误");
// 根据邮箱查询管理员信息
return adminRepository.findAdminByEmail(dto.getEmail());
}
/**
*
* @return
*/
@Override
public List<Admin> findAll() {
// 查询所有管理员信息
return adminRepository.findAll();
}
/**
* JWT Token
* @param admin
* @param exp Token
* @return JWT Token
*/
@Override
public String createToken(Admin admin, long exp) {
// 从管理员信息中获取角色字符串
String rolesString = admin.getRoles();
// 将角色字符串分割成数组
String[] roles = rolesString != null ? rolesString.split(";") : null;
// 创建JWT Token
return JwtTokenUtil.createToken(admin.getEmail(), roles, exp);
}
/**
*
* @param id ID
*/
@Override
public void delete(String id) {
// 根据ID删除管理员信息
adminRepository.deleteById(id);
}
}

@ -0,0 +1,80 @@
package com.example.api.service.impl;
import com.example.api.model.entity.Commodity; // 导入Commodity实体类
import com.example.api.repository.CommodityRepository; // 导入CommodityRepository接口
import com.example.api.service.CommodityService; // 导入CommodityService接口
import com.example.api.utils.DataTimeUtil; // 导入日期时间工具类
import org.springframework.stereotype.Service; // 导入Service注解
import javax.annotation.Resource; // 导入Resource注解用于注入Spring管理的Bean
import java.util.List; // 导入List类用于处理列表数据
/**
*
*/
@Service
public class CommodityServiceImpl implements CommodityService {
@Resource
private CommodityRepository commodityRepository; // 注入Commodity仓库
/**
*
* @param commodity
* @return
*/
@Override
public Commodity save(Commodity commodity) {
commodity.setCreateAt(DataTimeUtil.getNowTimeString()); // 设置创建时间
return commodityRepository.save(commodity); // 保存商品信息
}
/**
*
* @param commodity
*/
@Override
public void update(Commodity commodity) {
commodity.setUpdateAt(DataTimeUtil.getNowTimeString()); // 设置更新时间
commodityRepository.save(commodity); // 更新商品信息
}
/**
* ID
* @param id ID
*/
@Override
public void delete(String id) {
commodityRepository.deleteById(id); // 根据ID删除商品信息
}
/**
* ID
* @param id ID
* @return null
*/
@Override
public Commodity findById(String id) {
return commodityRepository.findById(id).orElse(null); // 根据ID查询商品信息
}
/**
*
* @return
*/
@Override
public List<Commodity> findAll() {
return commodityRepository.findAll(); // 查询所有商品信息
}
/**
*
* @param name
* @return
*/
@Override
public List<Commodity> findAllByLikeName(String name) {
return commodityRepository.findByNameLike("%" + name + "%"); // 模糊查询商品信息
}
}

@ -0,0 +1,65 @@
package com.example.api.service.impl;
import com.example.api.model.entity.Distribution; // 导入Distribution实体类代表配送信息
import com.example.api.model.entity.Driver; // 导入Driver实体类代表司机信息
import com.example.api.model.entity.Vehicle; // 导入Vehicle实体类代表车辆信息
import com.example.api.repository.DistributionRepository; // 导入DistributionRepository接口用于访问配送数据
import com.example.api.repository.DriverRepository; // 导入DriverRepository接口用于访问司机数据
import com.example.api.repository.VehicleRepository; // 导入VehicleRepository接口用于访问车辆数据
import com.example.api.service.DistributionService; // 导入DistributionService接口定义配送服务
import org.springframework.stereotype.Service; // 导入Service注解标识服务组件
import javax.annotation.Resource; // 注解用于注入Spring管理的Bean
import java.util.List; // 导入List类用于处理列表数据
import java.util.Optional; // 导入Optional类用于处理可能为空的数据
/**
*
*/
@Service
public class DistributionServiceImpl implements DistributionService {
@Resource
private DistributionRepository distributionRepository; // 注入配送仓库,用于数据库操作
@Resource
private DriverRepository driverRepository; // 注入司机仓库,用于数据库操作
@Resource
private VehicleRepository vehicleRepository; // 注入车辆仓库,用于数据库操作
/**
*
* @param distribution
* @return
* @throws Exception
*/
@Override
public Distribution save(Distribution distribution) throws Exception {
// 检查配送信息是否已存在,如果不存在则进行保存
if (distributionRepository.findById(distribution.getId()) == null) {
// 根据配送信息中的司机ID查询司机信息
Optional<Driver> driver = driverRepository.findById(distribution.getDid());
// 根据配送信息中车辆ID查询车辆信息
Optional<Vehicle> vehicle = vehicleRepository.findById(distribution.getVid());
// 检查司机或车辆是否已经被分配任务,如果已经被分配则抛出异常
if (driver.get().isDriving() || vehicle.get().isDriving()) throw new Exception("司机或货车状态不可用");
// 更新司机和车辆的状态为正在配送
driverRepository.updateDriving(true, distribution.getDid());
vehicleRepository.updateDriving(true, distribution.getVid());
}
// 保存配送信息到数据库
return distributionRepository.save(distribution);
}
/**
*
* @return
*/
@Override
public List<Distribution> findAll() {
// 调用配送仓库的方法查询所有配送信息
return distributionRepository.findAll();
}
}

@ -0,0 +1,70 @@
package com.example.api.service.impl;
import com.example.api.model.entity.Driver; // 导入Driver实体类代表司机信息
import com.example.api.repository.DriverRepository; // 导入DriverRepository接口用于访问司机数据
import com.example.api.service.DriverService; // 导入DriverService接口定义司机服务
import com.example.api.utils.DataTimeUtil; // 导入DataTimeUtil工具类用于处理日期和时间
import org.springframework.stereotype.Service; // 导入Service注解标识服务组件
import javax.annotation.Resource; // 注解用于注入Spring管理的Bean
import java.util.List; // 导入List类用于处理列表数据
/**
*
*/
@Service
public class DriverServiceImpl implements DriverService {
@Resource
private DriverRepository driverRepository; // 使用@Resource注解注入DriverRepository
/**
*
* @param driver
* @return ID
*/
@Override
public Driver save(Driver driver) {
driver.setCreateAt(DataTimeUtil.getNowTimeString()); // 设置司机的创建时间为当前时间
return driverRepository.save(driver); // 调用仓库层方法保存司机信息
}
/**
*
* @param driver
*/
@Override
public void update(Driver driver) {
driver.setUpdateAt(DataTimeUtil.getNowTimeString()); // 设置司机的更新时间为当前时间
driverRepository.save(driver); // 调用仓库层方法更新司机信息
}
/**
* ID
* @param id ID
*/
@Override
public void delete(String id) {
driverRepository.deleteById(id); // 调用仓库层方法根据ID删除司机信息
}
/**
* ID
* @param id ID
* @return null
*/
@Override
public Driver findById(String id) {
return driverRepository.findById(id).orElse(null); // 调用仓库层方法根据ID查询司机信息
}
/**
*
* @return
*/
@Override
public List<Driver> findAll() {
return driverRepository.findAll(); // 调用仓库层方法查询所有司机信息
}
}

@ -0,0 +1,79 @@
package com.example.api.service.impl;
import com.example.api.model.entity.Code; // 导入Code实体类代表验证码信息
import com.example.api.repository.CodeRepository; // 导入CodeRepository接口用于访问验证码数据
import com.example.api.service.EmailService; // 导入EmailService接口定义邮件服务
import com.example.api.utils.RandomUtil; // 导入RandomUtil工具类用于生成随机数虽然在代码中未使用
import org.springframework.beans.factory.annotation.Autowired; // 导入Autowired注解用于自动注入Bean
import org.springframework.beans.factory.annotation.Value; // 导入Value注解用于注入配置文件中的值
import org.springframework.mail.MailException; // 导入MailException异常类处理邮件发送异常
import org.springframework.mail.SimpleMailMessage; // 导入SimpleMailMessage类构建简单的邮件消息
import org.springframework.mail.javamail.JavaMailSender; // 导入JavaMailSender接口用于发送邮件
import org.springframework.stereotype.Service; // 导入Service注解标识服务组件
import javax.annotation.Resource; // 注解用于注入Spring管理的Bean
/**
*
*/
@Service
public class EmailServiceImpl implements EmailService {
@Resource
private CodeRepository codeRepository; // 注入Code仓库用于数据库操作
@Autowired
private JavaMailSender mailSender; // 自动注入JavaMailSender用于发送邮件
@Value("${spring.mail.username}") // 注入配置文件中定义的邮件发送者地址
private String from; // 邮件发送者地址
/**
*
* @param email
* @return truefalse
* @throws MailException
*/
@Override
public boolean sendVerificationCode(String email) throws MailException {
SimpleMailMessage message = new SimpleMailMessage(); // 创建SimpleMailMessage对象
message.setFrom(from); // 设置邮件发送者
message.setTo(email); // 设置邮件收件人
// 设置邮件标题
message.setSubject("验证码");
// 设置邮件内容,这里硬编码了验证码值,实际应用中应该使用随机生成的验证码
String value = "123456";
message.setText("你的验证码为: " + value + " 十五分钟内有效");
try {
// 发送邮件
// mailSender.send(message);
} catch (Exception e) {
e.printStackTrace();
return false; // 发送失败返回false
}
// 保存验证码到数据库
// 同一主键的email为update操作
codeRepository.save(new Code(email, value));
System.out.println("执行save code");
return true; // 发送成功返回true
}
/**
*
* @param email
* @param value
* @return truefalse
*/
@Override
public boolean checkVerificationCode(String email, String value) {
Code code = codeRepository.findByEmailAndValue(email, value);
// 如果验证码存在且未过期
if (code != null && code.getExp() > System.currentTimeMillis()) {
// 登录成功删除验证码
codeRepository.delete(code);
return true; // 校验成功返回true
}
return false; // 校验失败返回false
}
}

@ -0,0 +1,70 @@
package com.example.api.service.impl;
import com.example.api.model.entity.Employee; // 导入Employee实体类代表员工信息
import com.example.api.repository.EmployeeRepository; // 导入EmployeeRepository接口用于访问员工数据
import com.example.api.service.EmployeeService; // 导入EmployeeService接口定义员工服务
import com.example.api.utils.DataTimeUtil; // 导入DataTimeUtil工具类用于处理日期和时间
import org.springframework.stereotype.Service; // 导入Service注解标识服务组件
import javax.annotation.Resource; // 注解用于注入Spring管理的Bean
import java.util.List; // 导入List类用于处理列表数据
/**
*
*/
@Service
public class EmployeeServiceImpl implements EmployeeService {
@Resource
private EmployeeRepository employeeRepository; // 使用@Resource注解注入EmployeeRepository
/**
*
* @param employee
* @return ID
*/
@Override
public Employee save(Employee employee) {
employee.setCreateAt(DataTimeUtil.getNowTimeString()); // 设置员工的创建时间为当前时间
return employeeRepository.save(employee); // 调用仓库层方法保存员工信息
}
/**
*
* @param employee
*/
@Override
public void update(Employee employee) {
employee.setUpdateAt(DataTimeUtil.getNowTimeString()); // 设置员工的更新时间为当前时间
employeeRepository.save(employee); // 调用仓库层方法更新员工信息
}
/**
* ID
* @param id ID
*/
@Override
public void delete(String id) {
employeeRepository.deleteById(id); // 调用仓库层方法根据ID删除员工信息
}
/**
* ID
* @param id ID
* @return null
*/
@Override
public Employee findById(String id) {
return employeeRepository.findById(id).orElse(null); // 调用仓库层方法根据ID查询员工信息
}
/**
*
* @return
*/
@Override
public List<Employee> findAll() {
return employeeRepository.findAll(); // 调用仓库层方法查询所有员工信息
}
}

@ -0,0 +1,140 @@
package com.example.api.service.impl;
import com.example.api.model.entity.Commodity; // 导入Commodity实体类代表商品信息
import com.example.api.model.entity.Inventory; // 导入Inventory实体类代表库存信息
import com.example.api.model.entity.InventoryRecord; // 导入InventoryRecord实体类代表库存记录信息
import com.example.api.model.vo.CommodityChartVo; // 导入CommodityChartVo类代表商品图表视图对象
import com.example.api.repository.CommodityRepository; // 导入CommodityRepository接口用于访问商品数据
import com.example.api.repository.InventoryRecordRepository; // 导入InventoryRecordRepository接口用于访问库存记录数据
import com.example.api.repository.InventoryRepository; // 导入InventoryRepository接口用于访问库存数据
import com.example.api.service.InventoryRecordService; // 导入InventoryRecordService接口定义库存记录服务
import com.example.api.utils.DataTimeUtil; // 导入DataTimeUtil工具类用于处理日期和时间
import org.springframework.stereotype.Service; // 导入Service注解标识服务组件
import javax.annotation.Resource; // 注解用于注入Spring管理的Bean
import java.util.*;
/**
*
*/
@Service
public class InventoryRecordServiceImpl implements InventoryRecordService {
@Resource
private InventoryRepository inventoryRepository; // 注入库存仓库,用于数据库操作
@Resource
private CommodityRepository commodityRepository; // 注入商品仓库,用于数据库操作
@Resource
private InventoryRecordRepository recordRepository; // 注入库存记录仓库,用于数据库操作
/**
*
* @param type
* @return
*/
@Override
public List<CommodityChartVo> analyzeCommodity(Integer type) {
List<CommodityChartVo> result = new ArrayList<>();
List<InventoryRecord> all = recordRepository.findAllByType(type); // 根据类型查询所有库存记录
Map<String, Integer> map = new HashMap<>();
for (InventoryRecord r : all) {
// 统计每种商品的数量
if (map.containsKey(r.getName())) {
map.put(r.getName(), map.get(r.getName()) + r.getCount());
} else {
map.put(r.getName(), r.getCount());
}
}
for (String key : map.keySet()) {
// 将统计结果转换为图表视图对象
result.add(new CommodityChartVo(map.get(key), key));
}
return result;
}
/**
* ID
* @param wid ID
* @return
*/
@Override
public List<InventoryRecord> findAllByWarehouseId(String wid) {
return recordRepository.findAllByWid(wid); // 根据仓库ID查询所有库存记录
}
/**
* ID
* @param cid ID
* @return
*/
@Override
public List<InventoryRecord> findAllByCommodityId(String cid) {
return recordRepository.findAllByCid(cid); // 根据商品ID查询所有库存记录
}
/**
*
* @param record
* @return
* @throws Exception
*/
@Override
public InventoryRecord out(InventoryRecord record) throws Exception {
// 查找当前商品在该仓库的库存
Inventory inventory = inventoryRepository.findByWidAndCid(record.getWid(), record.getCid());
// 查询结果为空或库存不足
if (inventory == null || inventory.getCount() < record.getCount()) {
throw new Exception("仓库内不存在该商品或库存数量不足");
}
// 更新商品和库存信息
Optional<Commodity> optional = commodityRepository.findById(record.getCid());
if (optional == null) {
throw new Exception("不存在的商品id");
}
Commodity commodity = optional.get();
commodity.setCount(commodity.getCount() - record.getCount());
commodityRepository.save(commodity);
inventory.setCount(inventory.getCount() - record.getCount());
inventoryRepository.save(inventory);
// 保存出库记录
record.setCreateAt(DataTimeUtil.getNowTimeString());
record.setType(-1);
return recordRepository.save(record);
}
/**
*
* @param record
* @return
* @throws Exception
*/
@Override
public InventoryRecord in(InventoryRecord record) throws Exception {
Optional<Commodity> optional = commodityRepository.findById(record.getCid());
if (optional == null) {
throw new Exception("不存在的商品id");
}
Commodity commodity = optional.get();
commodity.setCount(commodity.getCount() + record.getCount());
commodityRepository.save(commodity);
// 查找当前商品在该仓库的库存
Inventory inventory = inventoryRepository.findByWidAndCid(record.getWid(), record.getCid());
// 查询结果为空则新建库存信息
if (inventory == null) {
inventory = new Inventory();
inventory.setCid(record.getCid());
inventory.setWid(record.getWid());
inventory.setCount(0);
inventory.setName(record.getName());
}
inventory.setCount(inventory.getCount() + record.getCount());
inventoryRepository.save(inventory);
// 保存入库记录
record.setCreateAt(DataTimeUtil.getNowTimeString());
record.setType(+1);
return recordRepository.save(record);
}
}

@ -0,0 +1,59 @@
package com.example.api.service.impl;
import com.example.api.model.entity.Inventory; // 导入Inventory实体类代表库存信息
import com.example.api.repository.InventoryRepository; // 导入InventoryRepository接口用于访问库存数据
import com.example.api.service.InventoryService; // 导入InventoryService接口定义库存服务
import org.springframework.stereotype.Service; // 导入Service注解标识服务组件
import javax.annotation.Resource; // 注解用于注入Spring管理的Bean
import java.util.List; // 导入List类用于处理列表数据
/**
*
*/
@Service
public class InventoryServiceImpl implements InventoryService {
@Resource
private InventoryRepository inventoryRepository; // 使用@Resource注解注入InventoryRepository
/**
*
* @param inventory
* @return
*/
@Override
public Inventory save(Inventory inventory) {
return inventoryRepository.save(inventory); // 调用仓库层方法保存库存信息
}
/**
*
* @return
*/
@Override
public List<Inventory> findAll() {
return inventoryRepository.findAll(); // 调用仓库层方法查询所有库存信息
}
/**
* ID
* @param cid ID
* @return ID
*/
@Override
public List<Inventory> findByCommodityId(String cid) {
return inventoryRepository.findAllByCid(cid); // 调用仓库层方法根据商品ID查询库存信息
}
/**
* ID
* @param wid ID
* @return ID
*/
@Override
public List<Inventory> findByWarehouseId(String wid) {
return inventoryRepository.findAllByWid(wid); // 调用仓库层方法根据仓库ID查询库存信息
}
}

@ -0,0 +1,68 @@
package com.example.api.service.impl;
import com.example.api.model.dto.LoginDto; // 导入LoginDto数据传输对象封装登录信息
import com.example.api.model.entity.Admin; // 导入Admin实体类代表管理员信息
import com.example.api.model.entity.LoginLog; // 导入LoginLog实体类代表登录日志信息
import com.example.api.repository.LoginLogRepository; // 导入LoginLogRepository接口用于访问登录日志数据
import com.example.api.service.LoginLogService; // 导入LoginLogService接口定义登录日志服务
import com.example.api.utils.BrowserUtil; // 导入BrowserUtil工具类用于获取浏览器信息
import com.example.api.utils.IpUtil; // 导入IpUtil工具类用于获取IP地址
import org.springframework.stereotype.Service; // 导入Service注解标识服务组件
import javax.annotation.Resource; // 注解用于注入Spring管理的Bean
import javax.servlet.http.HttpServletRequest; // 导入HttpServletRequest接口用于获取HTTP请求信息
import java.time.LocalDateTime; // 导入LocalDateTime类用于处理日期和时间
import java.util.Date; // 导入Date类用于处理日期
import java.util.List; // 导入List类用于处理列表数据
/**
*
*/
@Service
public class LoginLogServiceImpl implements LoginLogService {
@Resource
private LoginLogRepository loginLogRepository; // 使用@Resource注解注入LoginLogRepository
/**
*
* @return
*/
@Override
public List<LoginLog> getAll() {
return loginLogRepository.findAll(); // 调用仓库层方法查询所有登录日志
}
/**
*
* @param loginDto
* @param admin
* @param request HTTP
*/
@Override
public void recordLog(LoginDto loginDto, Admin admin, HttpServletRequest request) {
// 创建日志对象
LoginLog loginLog = new LoginLog();
loginLog.setDate(new Date()); // 设置登录时间为当前时间
loginLog.setEmail(loginDto.getEmail()); // 设置登录邮箱
// 获取浏览器版本
loginLog.setBrowser(BrowserUtil.getBrower(request));
loginLog.setIp(IpUtil.getIpAddr(request)); // 获取登录IP地址
// 设置登录状态null为0表示登录失败非null为1表示登录成功
if (admin == null){
loginLog.setStatus(0);
} else {
loginLog.setStatus(1);
}
// 将日志记录写入数据库
loginLogRepository.save(loginLog);
}
/**
*
* @param id ID
*/
@Override
public void delLoginLog(String id) {
loginLogRepository.deleteById(id); // 调用仓库层方法根据ID删除登录日志
}
}

@ -0,0 +1,43 @@
package com.example.api.service.impl;
import com.example.api.model.entity.Sale; // 导入Sale实体类
import com.example.api.repository.SaleRepository; // 导入SaleRepository接口
import com.example.api.service.SaleService; // 导入SaleService接口
import com.example.api.utils.DataTimeUtil; // 导入用于处理日期时间的工具类
import org.springframework.stereotype.Service; // 导入Spring的@Service注解用于声明这是一个服务组件
import javax.annotation.Resource; // 导入@Resource注解用于注入Spring管理的Bean
import java.util.List; // 导入List接口用于返回列表类型的数据
// 使用@Service注解声明这是一个服务组件
@Service
public class SaleServiceImpl implements SaleService {
// 使用@Resource注解注入SaleRepository
@Resource
private SaleRepository saleRepository;
// 实现SaleService接口的save方法用于保存Sale对象
@Override
public Sale save(Sale sale) {
// 使用DataTimeUtil工具类获取当前时间字符串并设置到Sale对象的createAt字段
sale.setCreateAt(DataTimeUtil.getNowTimeString());
// 调用saleRepository的save方法保存Sale对象并返回保存后的对象
return saleRepository.save(sale);
}
// 实现SaleService接口的findAll方法用于查询所有Sale对象
@Override
public List<Sale> findAll() {
// 直接调用saleRepository的findAll方法查询所有Sale对象并返回查询结果
return saleRepository.findAll();
}
// 实现SaleService接口的searchByCompany方法用于根据公司名称搜索Sale对象
@Override
public List<Sale> searchByCompany(String name) {
// 调用saleRepository的findAllByCompanyLike方法根据公司名称模糊搜索Sale对象并返回搜索结果
return saleRepository.findAllByCompanyLike(name);
}
}

@ -0,0 +1,88 @@
package com.example.api.service.impl;
import com.example.api.model.entity.SystemLog; // 导入SystemLog实体类代表系统日志信息
import com.example.api.model.vo.SystemLogVo; // 导入SystemLogVo视图对象用于封装查询条件
import com.example.api.repository.SystemLogRepository; // 导入SystemLogRepository接口用于访问系统日志数据
import com.example.api.service.SystemLogService; // 导入SystemLogService接口定义系统日志服务
import org.springframework.beans.factory.annotation.Autowired; // 导入Autowired注解用于自动注入Bean
import org.springframework.data.jpa.domain.Specification; // 导入Specification接口用于构建JPA查询条件
import org.springframework.security.core.parameters.P; // 导入P注解用于方法参数注解此处未使用
import org.springframework.stereotype.Service; // 导入Service注解标识服务组件
import org.springframework.util.StringUtils; // 导入StringUtils工具类用于字符串操作
import javax.persistence.criteria.*;
import java.util.ArrayList; // 导入ArrayList类用于创建列表此处未使用
import java.util.List; // 导入List类用于处理列表数据
/**
*
*/
@Service
public class SystemLogServiceImpl implements SystemLogService {
@Autowired
private SystemLogRepository systemLogRepository; // 自动注入SystemLogRepository
/**
*
* @param log
*/
@Override
public void record(SystemLog log) {
systemLogRepository.save(log); // 调用仓库层方法保存系统日志
}
/**
*
* @return
*/
@Override
public List<SystemLog> getAll() {
return systemLogRepository.findAll(); // 调用仓库层方法查询所有系统日志
}
/**
*
* @param id ID
*/
@Override
public void delete(String id) {
systemLogRepository.deleteById(id); // 调用仓库层方法根据ID删除系统日志
}
/**
*
* @param systemLogVo
* @return
*/
@Override
public List<SystemLog> query(SystemLogVo systemLogVo) {
// 构造查询条件
Specification<SystemLog> specification = new Specification<SystemLog>() {
@Override
public Predicate toPredicate(Root<SystemLog> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder) {
Path<String> account = root.get("account"); // 获取account字段
Path<String> module = root.get("module"); // 获取module字段
Predicate res = null; // 初始化查询结果
// 如果账号不为空,构建账号的模糊查询条件
if (!StringUtils.isEmpty(systemLogVo.getAccount())) {
Predicate like1 = criteriaBuilder.like(account.as(String.class), "%" + systemLogVo.getAccount() + "%");
// 如果模块不为空,构建模块的模糊查询条件
if (!StringUtils.isEmpty(systemLogVo.getModule())) {
Predicate like2 = criteriaBuilder.like(module.as(String.class), "%" + systemLogVo.getModule() + "%");
// 组合账号和模块的查询条件
res = criteriaBuilder.and(like1, like2);
} else {
// 仅组合账号的查询条件
res = criteriaBuilder.and(like1);
}
} else if (!StringUtils.isEmpty(systemLogVo.getModule())) {
// 如果账号为空但模块不为空,仅构建模块的模糊查询条件
Predicate like2 = criteriaBuilder.like(module.as(String.class), "%" + systemLogVo.getModule() + "%");
res = criteriaBuilder.and(like2);
}
return res; // 返回查询条件
}
};
return systemLogRepository.findAll(specification); // 调用仓库层方法执行查询
}
}

@ -0,0 +1,9 @@
package com.example.api.service.impl;
import com.example.api.service.UserService;
import org.springframework.stereotype.Service;
@Service
public class UserServiceImpl implements UserService {
}

@ -0,0 +1,69 @@
package com.example.api.service.impl;
import com.example.api.model.entity.Vehicle; // 导入Vehicle实体类代表车辆信息
import com.example.api.repository.VehicleRepository; // 导入VehicleRepository接口用于访问车辆数据
import com.example.api.service.VehicleService; // 导入VehicleService接口定义车辆服务
import com.example.api.utils.DataTimeUtil; // 导入DataTimeUtil工具类用于处理日期和时间
import org.springframework.stereotype.Service; // 导入Service注解标识服务组件
import javax.annotation.Resource; // 注解用于注入Spring管理的Bean
import java.util.List; // 导入List类用于处理列表数据
/**
*
*/
@Service
public class VehicleServiceImpl implements VehicleService {
@Resource
private VehicleRepository vehicleRepository; // 使用@Resource注解注入VehicleRepository
/**
*
* @param vehicle
* @return ID
*/
@Override
public Vehicle save(Vehicle vehicle) {
vehicle.setCreateAt(DataTimeUtil.getNowTimeString()); // 设置车辆的创建时间为当前时间
return vehicleRepository.save(vehicle); // 调用仓库层方法保存车辆信息
}
/**
*
* @param vehicle
*/
@Override
public void update(Vehicle vehicle) {
vehicleRepository.save(vehicle); // 调用仓库层方法更新车辆信息
}
/**
* ID
* @param id ID
*/
@Override
public void delete(String id) {
vehicleRepository.deleteById(id); // 调用仓库层方法根据ID删除车辆信息
}
/**
* ID
* @param id ID
* @return null
*/
@Override
public Vehicle findById(String id) {
return vehicleRepository.findById(id).orElse(null); // 调用仓库层方法根据ID查询车辆信息
}
/**
*
* @return
*/
@Override
public List<Vehicle> findAll() {
return vehicleRepository.findAll(); // 调用仓库层方法查询所有车辆信息
}
}

@ -0,0 +1,50 @@
package com.example.api.service.impl;
import com.example.api.model.entity.Warehouse; // 导入Warehouse实体类代表仓库信息
import com.example.api.repository.WareHouseRepository; // 导入WareHouseRepository接口用于访问仓库数据
import com.example.api.service.WarehouseService; // 导入WarehouseService接口定义仓库服务
import com.example.api.utils.DataTimeUtil; // 导入DataTimeUtil工具类用于处理日期和时间
import org.springframework.stereotype.Service; // 导入Service注解标识服务组件
import javax.annotation.Resource; // 注解用于注入Spring管理的Bean
import java.util.List; // 导入List类用于处理列表数据
/**
*
*/
@Service
public class WarehouseServiceImpl implements WarehouseService {
@Resource
private WareHouseRepository wareHouseRepository; // 使用@Resource注解注入WareHouseRepository
/**
*
* @param warehouse
* @return ID
*/
@Override
public Warehouse save(Warehouse warehouse) {
warehouse.setCreateAt(DataTimeUtil.getNowTimeString()); // 设置仓库的创建时间为当前时间
return wareHouseRepository.save(warehouse); // 调用仓库层方法保存仓库信息
}
/**
*
* @return
*/
@Override
public List<Warehouse> findAll() {
return wareHouseRepository.findAll(); // 调用仓库层方法查询所有仓库信息
}
/**
* ID
* @param id ID
*/
@Override
public void delete(String id) {
wareHouseRepository.deleteById(id); // 调用仓库层方法根据ID删除仓库信息
}
}

@ -0,0 +1,56 @@
package com.example.api.task;
import com.example.api.model.entity.Admin; // 导入Admin实体类代表管理员信息
import com.example.api.repository.AdminRepository; // 导入AdminRepository接口用于访问管理员数据
import org.slf4j.Logger; // 导入Logger接口用于日志记录
import org.slf4j.LoggerFactory; // 导入LoggerFactory类用于创建Logger实例
import org.springframework.beans.factory.annotation.Autowired; // 导入Autowired注解用于自动注入Bean
import org.springframework.boot.ApplicationArguments; // 导入ApplicationArguments类用于获取启动参数
import org.springframework.boot.ApplicationRunner; // 导入ApplicationRunner接口用于在Spring Boot启动时执行代码
import org.springframework.core.annotation.Order; // 导入Order注解用于指定组件的执行顺序
import org.springframework.stereotype.Component; // 导入Component注解标识组件
import java.text.SimpleDateFormat; // 导入SimpleDateFormat类用于日期格式化
import java.util.Date; // 导入Date类用于处理日期
import java.util.concurrent.Executors; // 导入Executors工具类用于创建线程池
import java.util.concurrent.ScheduledExecutorService; // 导入ScheduledExecutorService接口用于延迟或定时执行任务
import java.util.concurrent.TimeUnit; // 导入TimeUnit枚举用于时间单位转换
/**
*
* ApplicationRunnerSpring Bootrun
*/
@Component
@Order(1)
public class ConsumeMqTask implements ApplicationRunner {
@Autowired
private AdminRepository adminRepository; // 自动注入AdminRepository
/**
*
*/
private static final Logger LOGGER = LoggerFactory.getLogger(ConsumeMqTask.class);
@Override
public void run(ApplicationArguments args) throws Exception {
// 记录启动时的日志信息
LOGGER.info("start to run ConsumeMqTask.");
// 以下是示例代码,用于在启动时创建一个超级管理员账号
/*
Admin admin = new Admin();
admin.setRoles("ROLE_SUPER_ADMIN");
admin.setEmail("admin@qq.com");
admin.setPassword("123456");
Date date = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String time = sdf.format(date);
admin.setCreateAt(time);
adminRepository.save(admin);
*/
// 记录结束时的日志信息
LOGGER.info("end to run ConsumeMqTask.");
}
}

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

Loading…
Cancel
Save