Compare commits

..

No commits in common. 'master' and 'hst' have entirely different histories.
master ... hst

@ -1,33 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" output="target/classes" path="src/main/java">
<attributes>
<attribute name="optional" value="true"/>
<attribute name="maven.pomderived" value="true"/>
</attributes>
</classpathentry>
<classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources">
<attributes>
<attribute name="maven.pomderived" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="src" output="target/test-classes" path="src/test/java">
<attributes>
<attribute name="test" value="true"/>
<attribute name="optional" value="true"/>
<attribute name="maven.pomderived" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7">
<attributes>
<attribute name="maven.pomderived" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
<attributes>
<attribute name="maven.pomderived" value="true"/>
<attribute name="org.eclipse.jst.component.dependency" value="/WEB-INF/lib"/>
</attributes>
</classpathentry>
<classpathentry kind="output" path="target/classes"/>
</classpath>

9
.gitattributes vendored

@ -1,9 +0,0 @@
*.md linguist-language=Java
*.yml linguist-language=Java
*.html linguist-language=Java
*.js linguist-language=Java
*.xml linguist-language=Java
*.css linguist-language=Java
*.sql linguist-language=Java
*.uml linguist-language=Java
*.cmd linguist-language=Java

1
.gitignore vendored

@ -1 +0,0 @@
/target/

8
.idea/.gitignore vendored

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

@ -1,15 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<module version="4">
<component name="FacetManager">
<facet type="web" name="Web">
<configuration>
<descriptors>
<deploymentDescriptor name="web.xml" url="file://$MODULE_DIR$/src/main/webapp/WEB-INF/web.xml" />
</descriptors>
<webroots>
<root url="file://$MODULE_DIR$/src/main/webapp" relative="/" />
</webroots>
</configuration>
</facet>
</component>
</module>

@ -1,14 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="CompilerConfiguration">
<annotationProcessing>
<profile name="Maven default annotation processors profile" enabled="true">
<sourceOutputDir name="target/generated-sources/annotations" />
<sourceTestOutputDir name="target/generated-test-sources/test-annotations" />
<outputRelativeToContentRoot value="true" />
<module name="company-financial-management-main" />
<module name="ssm3d8m9" />
</profile>
</annotationProcessing>
</component>
</project>

@ -1,9 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="Encoding" defaultCharsetForPropertiesFiles="UTF-8">
<file url="file://$PROJECT_DIR$/src/main/java" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/main/resources" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/main/webapp/admin/dist/fonts/element-icons.535877f5.woff" charset="GBK" />
<file url="PROJECT" charset="UTF-8" />
</component>
</project>

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

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

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

@ -1,46 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>spring</name>
<comment></comment>
<projects>
</projects>
<buildSpec>
<buildCommand>
<name>org.eclipse.jdt.core.javabuilder</name>
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>org.eclipse.wst.common.project.facet.core.builder</name>
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>org.eclipse.wst.validation.validationbuilder</name>
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>org.springframework.ide.eclipse.core.springbuilder</name>
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>org.springframework.ide.eclipse.boot.validation.springbootbuilder</name>
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>org.eclipse.m2e.core.maven2Builder</name>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures>
<nature>org.springframework.ide.eclipse.core.springnature</nature>
<nature>org.eclipse.jdt.core.javanature</nature>
<nature>org.eclipse.m2e.core.maven2Nature</nature>
<nature>org.eclipse.wst.common.project.facet.core.nature</nature>
<nature>org.eclipse.wst.common.modulecore.ModuleCoreNature</nature>
</natures>
</projectDescription>

@ -1,13 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" path="src/main/webapp"/>
<classpathentry excluding="**/bower_components/*|**/node_modules/*|**/*.min.js" kind="src" path="target/m2e-wtp/web-resources"/>
<classpathentry kind="con" path="org.eclipse.wst.jsdt.launching.JRE_CONTAINER"/>
<classpathentry kind="con" path="org.eclipse.wst.jsdt.launching.WebProject">
<attributes>
<attribute name="hide" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="con" path="org.eclipse.wst.jsdt.launching.baseBrowserLibrary"/>
<classpathentry kind="output" path=""/>
</classpath>

@ -1,5 +0,0 @@
eclipse.preferences.version=1
encoding//src/main/java=UTF-8
encoding//src/main/resources=UTF-8
encoding//src/test/java=UTF-8
encoding/<project>=UTF-8

@ -1,9 +0,0 @@
eclipse.preferences.version=1
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
org.eclipse.jdt.core.compiler.compliance=1.7
org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
org.eclipse.jdt.core.compiler.release=disabled
org.eclipse.jdt.core.compiler.source=1.7

@ -1,4 +0,0 @@
activeProfiles=
eclipse.preferences.version=1
resolveWorkspaceProjects=true
version=1

@ -1,10 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?><project-modules id="moduleCoreId" project-version="1.5.0">
<wb-module deploy-name="spring-schema">
<wb-resource deploy-path="/" source-path="/target/m2e-wtp/web-resources"/>
<wb-resource deploy-path="/" source-path="/src/main/webapp" tag="defaultRootSource"/>
<wb-resource deploy-path="/WEB-INF/classes" source-path="/src/main/java"/>
<wb-resource deploy-path="/WEB-INF/classes" source-path="/src/main/resources"/>
<property name="java-output-path" value="/mybatisplus-spring-mvc/target/classes"/>
<property name="context-root" value="spring-schema"/>
</wb-module>
</project-modules>

@ -1,7 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<faceted-project>
<fixed facet="wst.jsdt.web"/>
<installed facet="java" version="1.7"/>
<installed facet="jst.web" version="3.0"/>
<installed facet="wst.jsdt.web" version="1.0"/>
</faceted-project>

@ -1 +0,0 @@
org.eclipse.wst.jsdt.launching.baseBrowserLibrary

@ -1,2 +0,0 @@
disabled=06target
eclipse.preferences.version=1

@ -1,54 +0,0 @@
# 公司财务管理系统(数据库加VX获取☟)
> VX13033494971
#### 介绍
公司财务管理系统
有BUG可留言加微
#### 软件架构
Java + SSMSpring+SpringMVC+Mybatis + Vue + Mysql
#### 项目说明
> + 多用户登录
> + 注册
> + 个人中心
> + 员工管理
> + 部门分类管理
> + 供应商信息管理
> + 客户信息管理
> + 记账凭证管理
> + 日记账管理
> + 发票信息管理
> + 员工缴费管理
> + 支票信息管理
> + 员工报销管理
> + 员工薪酬管理
> + 商品库存(入库,出库)管理
> + 成本结余管理
> + 商品类型管理
### 部分功能演示
![输入图片说明](photo/1.png)
![输入图片说明](photo/2.png)
![输入图片说明](photo/3.png)
![输入图片说明](photo/4.png)
![输入图片说明](photo/5.png)
![输入图片说明](photo/6.png)
![输入图片说明](photo/7.png)
![输入图片说明](photo/8.png)
![输入图片说明](photo/9.png)
![输入图片说明](photo/10.png)
![输入图片说明](photo/11.png)
![输入图片说明](photo/12.png)
![输入图片说明](photo/13.png)
### 环境需求(可免费提供)
- idea/eclipse、jdk-1.8、maven-3.8.6、mysql、nodejs
## 有项目修改、安装调试需求 请联系微信
![输入图片说明](photo/0-WeChat.png)
## 其他项目定制加微☝☝☝

Binary file not shown.

Before

Width:  |  Height:  |  Size: 1.6 MiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 489 KiB

@ -1,272 +0,0 @@
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.jlwl</groupId>
<artifactId>ssm3d8m9</artifactId>
<packaging>war</packaging>
<version>1.0-SNAPSHOT</version>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<spring.version>5.0.0.RELEASE</spring.version>
<junit.version>4.12</junit.version>
<druid.version>1.1.0</druid.version>
<fastjson.version>1.2.8</fastjson.version>
<mybaitsplus.version>2.3</mybaitsplus.version>
<mysql.version>5.1.38</mysql.version>
<log4j.version>1.2.17</log4j.version>
<slf4j.version>1.7.19</slf4j.version>
<aspectjweaver.version>1.8.8</aspectjweaver.version>
<fileupload.version>1.3.1</fileupload.version>
<jstl.version>1.2</jstl.version>
</properties>
<dependencies>
<!-- JUnit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
<!-- Spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${spring.version}</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>${spring.version}</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${spring.version}</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
<!-- Spring MVC -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${spring.version}</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
<!-- AOP -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>${aspectjweaver.version}</version>
</dependency>
<!-- FileUpload -->
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>${fileupload.version}</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>${jstl.version}</version>
</dependency>
<!-- Mybatis-Plus -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus</artifactId>
<version>${mybaitsplus.version}</version>
</dependency>
<!-- Mysql -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
<dependency>
<groupId>com.microsoft.sqlserver</groupId>
<artifactId>sqljdbc4</artifactId>
<scope>4.0</scope>
<version>4.0</version>
</dependency>
<dependency>
<groupId>com.microsoft.sqlserver</groupId>
<artifactId>mssql-jdbc</artifactId>
<version>6.2.0.jre8</version>
<scope>runtime</scope>
</dependency>
<!-- Druid -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>${druid.version}</version>
</dependency>
<!-- FastJson -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>${fastjson.version}</version>
</dependency>
<!-- Log -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>${log4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${slf4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${slf4j.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.0</version>
</dependency>
<dependency>
<groupId>javax.validation</groupId>
<artifactId>validation-api</artifactId>
<version>2.0.1.Final</version>
</dependency>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.5</version>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>4.0.12</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.tomcat.embed/tomcat-embed-core -->
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-core</artifactId>
<version>9.0.29</version>
</dependency>
<!-- https://mvnrepository.com/artifact/commons-beanutils/commons-beanutils -->
<dependency>
<groupId>commons-beanutils</groupId>
<artifactId>commons-beanutils</artifactId>
<version>1.8.0</version>
</dependency>
<!-- 百度人工智能 -->
<dependency>
<groupId>com.baidu.aip</groupId>
<artifactId>java-sdk</artifactId>
<version>4.4.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-annotations -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.10.1</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.10.1</version>
</dependency>
<dependency>
<groupId>org.codehaus.jackson</groupId>
<artifactId>jackson-mapper-asl</artifactId>
<version>1.9.13</version>
</dependency>
</dependencies>
<build>
<!-- 项目访问名称 -->
<finalName>ssm3d8m9</finalName>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin-3.1</artifactId>
<configuration>
<source>1.7</source>
<target>1.7</target>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>7</source>
<target>7</target>
</configuration>
</plugin>
</plugins>
</build>
</project>

@ -1,333 +0,0 @@
package com.controller;
// 导入用于格式化日期的类
import java.text.SimpleDateFormat;
// 导入动态数组类
import java.util.ArrayList;
// 导入用于操作数组的工具类
import java.util.Arrays;
// 导入用于处理日期和时间的类
import java.util.Calendar;
// 导入 Map 接口,用于存储键值对
import java.util.Map;
// 导入 HashMap 类,是 Map 接口的实现类
import java.util.HashMap;
// 导入迭代器接口
import java.util.Iterator;
// 导入日期类
import java.util.Date;
// 导入列表接口
import java.util.List;
// 导入 HTTP 请求类
import javax.servlet.http.HttpServletRequest;
// 导入自定义的验证工具类
import com.utils.ValidatorUtils;
// 导入 Apache Commons Lang 工具类,用于字符串操作
import org.apache.commons.lang3.StringUtils;
// 导入 Spring 的依赖注入注解
import org.springframework.beans.factory.annotation.Autowired;
// 导入 Spring 的日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
// 导入 Spring 的路径变量注解
import org.springframework.web.bind.annotation.PathVariable;
// 导入 Spring 的请求体注解
import org.springframework.web.bind.annotation.RequestBody;
// 导入 Spring 的请求映射注解
import org.springframework.web.bind.annotation.RequestMapping;
// 导入 Spring 的请求参数注解
import org.springframework.web.bind.annotation.RequestParam;
// 导入 Spring 的 REST 控制器注解
import org.springframework.web.bind.annotation.RestController;
// 导入 MyBatis-Plus 的实体包装器类
import com.baomidou.mybatisplus.mapper.EntityWrapper;
// 导入 MyBatis-Plus 的包装器接口
import com.baomidou.mybatisplus.mapper.Wrapper;
// 导入自定义的忽略认证注解
import com.annotation.IgnoreAuth;
// 导入成本结余实体类
import com.entity.ChengbenjieyuEntity;
// 导入成本结余视图类
import com.entity.view.ChengbenjieyuView;
// 导入成本结余服务类
import com.service.ChengbenjieyuService;
// 导入令牌服务类
import com.service.TokenService;
// 导入自定义的分页工具类
import com.utils.PageUtils;
// 导入自定义的响应结果类
import com.utils.R;
// 导入自定义的 MD5 工具类
import com.utils.MD5Util;
// 导入自定义的 MyBatis-Plus 工具类
import com.utils.MPUtil;
// 导入自定义的通用工具类
import com.utils.CommonUtil;
//成本结余
// 后端接口
// @author
// @email
//@date 2021-04-24 15:19:31
// 标记为 REST 控制器,用于处理 HTTP 请求并返回 JSON 数据
@RestController
// 定义请求映射的基础路径
@RequestMapping("/chengbenjieyu")
public class ChengbenjieyuController {
// 自动注入成本结余服务类的实例
@Autowired
private ChengbenjieyuService chengbenjieyuService;
// 后端列表
// 该方法用于处理后端获取成本结余列表的请求,支持分页查询,同时可根据日期范围进行筛选。
// @param params 请求参数,包含分页、排序等信息
// @param chengbenjieyu 成本结余实体,用于构建查询条件
// @param riqistart 开始日期,可为空,用于筛选数据
// @param riqiend 结束日期,可为空,用于筛选数据
// @param request HTTP 请求对象
// @return 包含分页数据的响应结果
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, ChengbenjieyuEntity chengbenjieyu,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date riqistart,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date riqiend,
HttpServletRequest request) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<ChengbenjieyuEntity> ew = new EntityWrapper<ChengbenjieyuEntity>();
// 如果开始日期不为空,则添加大于等于该日期的查询条件
if (riqistart != null) ew.ge("riqi", riqistart);
// 如果结束日期不为空,则添加小于等于该日期的查询条件
if (riqiend != null) ew.le("riqi", riqiend);
// 调用服务类的查询分页方法,传入请求参数和处理后的查询条件
PageUtils page = chengbenjieyuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chengbenjieyu), params), params));
// 返回成功响应,并将分页数据放入响应结果中
return R.ok().put("data", page);
}
// 前端列表
// 该方法用于处理前端获取成本结余列表的请求,支持分页查询,同时可根据日期范围进行筛选。
// @param params 请求参数,包含分页、排序等信息
// @param chengbenjieyu 成本结余实体,用于构建查询条件
// @param riqistart 开始日期,可为空,用于筛选数据
// @param riqiend 结束日期,可为空,用于筛选数据
// @param request HTTP 请求对象
// @return 包含分页数据的响应结果
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, ChengbenjieyuEntity chengbenjieyu,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date riqistart,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date riqiend,
HttpServletRequest request) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<ChengbenjieyuEntity> ew = new EntityWrapper<ChengbenjieyuEntity>();
// 如果开始日期不为空,则添加大于等于该日期的查询条件
if (riqistart != null) ew.ge("riqi", riqistart);
// 如果结束日期不为空,则添加小于等于该日期的查询条件
if (riqiend != null) ew.le("riqi", riqiend);
// 调用服务类的查询分页方法,传入请求参数和处理后的查询条件
PageUtils page = chengbenjieyuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chengbenjieyu), params), params));
// 返回成功响应,并将分页数据放入响应结果中
return R.ok().put("data", page);
}
// 列表
// 该方法用于获取满足特定条件的成本结余列表。
// @param chengbenjieyu 成本结余实体,用于构建查询条件
// @return 包含成本结余列表的响应结果
@RequestMapping("/lists")
public R list(ChengbenjieyuEntity chengbenjieyu) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<ChengbenjieyuEntity> ew = new EntityWrapper<ChengbenjieyuEntity>();
// 设置查询条件,使所有字段相等
ew.allEq(MPUtil.allEQMapPre(chengbenjieyu, "chengbenjieyu"));
// 调用服务类的查询列表视图方法,传入查询条件
return R.ok().put("data", chengbenjieyuService.selectListView(ew));
}
// 查询
// 该方法用于根据条件查询单个成本结余信息。
// @param chengbenjieyu 成本结余实体,用于构建查询条件
// @return 包含查询结果的响应结果
@RequestMapping("/query")
public R query(ChengbenjieyuEntity chengbenjieyu) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<ChengbenjieyuEntity> ew = new EntityWrapper<ChengbenjieyuEntity>();
// 设置查询条件,使所有字段相等
ew.allEq(MPUtil.allEQMapPre(chengbenjieyu, "chengbenjieyu"));
// 调用服务类的查询视图方法,传入查询条件
ChengbenjieyuView chengbenjieyuView = chengbenjieyuService.selectView(ew);
// 返回成功响应,并将查询结果放入响应结果中
return R.ok("查询成本结余成功").put("data", chengbenjieyuView);
}
// 后端详情
// 该方法用于获取指定 ID 的成本结余详细信息。
//@param id 成本结余的 ID
// @return 包含成本结余详细信息的响应结果
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id) {
// 根据 ID 查询成本结余实体
ChengbenjieyuEntity chengbenjieyu = chengbenjieyuService.selectById(id);
// 返回成功响应,并将成本结余详细信息放入响应结果中
return R.ok().put("data", chengbenjieyu);
}
//前端详情
// 该方法用于获取指定 ID 的成本结余详细信息。
//@param id 成本结余的 ID
// @return 包含成本结余详细信息的响应结果
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id) {
// 根据 ID 查询成本结余实体
ChengbenjieyuEntity chengbenjieyu = chengbenjieyuService.selectById(id);
// 返回成功响应,并将成本结余详细信息放入响应结果中
return R.ok().put("data", chengbenjieyu);
}
// 后端保存
// 该方法用于在后端保存新的成本结余信息。
//@param chengbenjieyu 成本结余实体,包含要保存的信息
// @param request HTTP 请求对象
// @return 保存成功的响应结果
@RequestMapping("/save")
public R save(@RequestBody ChengbenjieyuEntity chengbenjieyu, HttpServletRequest request) {
// 为成本结余实体设置一个唯一的 ID由当前时间戳和随机数组成
chengbenjieyu.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(chengbenjieyu);
// 调用服务类的插入方法,保存成本结余信息
chengbenjieyuService.insert(chengbenjieyu);
// 返回成功响应
return R.ok();
}
//前端保存
// 该方法用于在前端保存新的成本结余信息。
// @param chengbenjieyu 成本结余实体,包含要保存的信息
//@param request HTTP 请求对象
// @return 保存成功的响应结果
@RequestMapping("/add")
public R add(@RequestBody ChengbenjieyuEntity chengbenjieyu, HttpServletRequest request) {
// 为成本结余实体设置一个唯一的 ID由当前时间戳和随机数组成
chengbenjieyu.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(chengbenjieyu);
// 调用服务类的插入方法,保存成本结余信息
chengbenjieyuService.insert(chengbenjieyu);
// 返回成功响应
return R.ok();
}
// 修改
//该方法用于修改已有的成本结余信息。
//@param chengbenjieyu 成本结余实体,包含要修改的信息
// @param request HTTP 请求对象
// @return 修改成功的响应结果
@RequestMapping("/update")
public R update(@RequestBody ChengbenjieyuEntity chengbenjieyu, HttpServletRequest request) {
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(chengbenjieyu);
// 调用服务类的更新方法,根据 ID 更新成本结余信息
chengbenjieyuService.updateById(chengbenjieyu); // 全部更新
// 返回成功响应
return R.ok();
}
// 删除
// 该方法用于批量删除指定 ID 的成本结余信息。
// @param ids 要删除的成本结余的 ID 数组
// @return 删除成功的响应结果
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) {
// 调用服务类的批量删除方法,根据 ID 列表删除成本结余信息
chengbenjieyuService.deleteBatchIds(Arrays.asList(ids));
// 返回成功响应
return R.ok();
}
// 提醒接口
// 该方法用于根据指定列和时间范围统计满足条件的成本结余数量。
// @param columnName 要统计的列名
// @param request HTTP 请求对象
// @param type 提醒类型
// @param map 请求参数,包含提醒开始时间和结束时间等信息
// @return 包含统计数量的响应结果
@RequestMapping("/remind/{columnName}/{type}")
public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
@PathVariable("type") String type, @RequestParam Map<String, Object> map) {
// 将列名和提醒类型放入请求参数中
map.put("column", columnName);
map.put("type", type);
if (type.equals("2")) {
// 创建日期格式化对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
// 获取日历实例
Calendar c = Calendar.getInstance();
Date remindStartDate = null;
Date remindEndDate = null;
if (map.get("remindstart") != null) {
// 获取提醒开始时间的偏移量
Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
// 设置日历时间为当前时间
c.setTime(new Date());
// 计算提醒开始日期
c.add(Calendar.DAY_OF_MONTH, remindStart);
remindStartDate = c.getTime();
// 将格式化后的提醒开始日期放入请求参数中
map.put("remindstart", sdf.format(remindStartDate));
}
if (map.get("remindend") != null) {
// 获取提醒结束时间的偏移量
Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
// 设置日历时间为当前时间
c.setTime(new Date());
// 计算提醒结束日期
c.add(Calendar.DAY_OF_MONTH, remindEnd);
remindEndDate = c.getTime();
// 将格式化后的提醒结束日期放入请求参数中
map.put("remindend", sdf.format(remindEndDate));
}
}
// 创建一个包装器,用于构建 SQL 查询条件
Wrapper<ChengbenjieyuEntity> wrapper = new EntityWrapper<ChengbenjieyuEntity>();
if (map.get("remindstart") != null) {
// 设置查询条件,列值大于等于提醒开始日期
wrapper.ge(columnName, map.get("remindstart"));
}
if (map.get("remindend") != null) {
// 设置查询条件,列值小于等于提醒结束日期
wrapper.le(columnName, map.get("remindend"));
}
// 调用服务类的统计数量方法,根据查询条件统计满足条件的成本结余数量
int count = chengbenjieyuService.selectCount(wrapper);
// 返回成功响应,并将统计数量放入响应结果中
return R.ok().put("count", count);
}
}

@ -1,334 +0,0 @@
package com.controller;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.lang3.StringUtils;
import org.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.ResourceUtils;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.annotation.IgnoreAuth;
import com.baidu.aip.face.AipFace;
import com.baidu.aip.face.MatchRequest;
import com.baidu.aip.util.Base64Util;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.entity.ConfigEntity;
import com.service.CommonService;
import com.service.ConfigService;
import com.utils.BaiduUtil;
import com.utils.FileUtil;
import com.utils.R;
// 通用接口
// 该控制器类提供了一系列通用的业务接口,用于处理各种不同的功能需求,
// 如地理位置信息获取、人脸比对、数据查询、状态修改、统计计算等。
@RestController
public class CommonController {
// 自动注入通用服务类的实例,用于调用通用业务逻辑方法
@Autowired
private CommonService commonService;
// 自动注入配置服务类的实例,用于获取和管理系统配置信息
@Autowired
private ConfigService configService;
// 静态变量,用于存储百度人脸识别客户端实例,保证全局唯一
private static AipFace client = null;
// 静态变量,用于存储百度地图 API 的访问密钥
private static String BAIDU_DITU_AK = null;
// 根据经纬度获取所在城市信息
// @param lng 经度
// @param lat 纬度
// @return R 响应对象,包含操作结果和城市信息数据
@RequestMapping("/location")
public R location(String lng, String lat) {
// 如果百度地图 API 密钥为空,则从配置中获取
if (BAIDU_DITU_AK == null) {
BAIDU_DITU_AK = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "baidu_ditu_ak")).getValue();
// 如果获取到的密钥仍为空,则返回错误响应
if (BAIDU_DITU_AK == null) {
return R.error("请在配置管理中正确配置baidu_ditu_ak");
}
}
// 调用工具类方法,根据经纬度和 API 密钥获取城市信息
Map<String, String> map = BaiduUtil.getCityByLonLat(BAIDU_DITU_AK, lng, lat);
// 返回成功响应,并将城市信息数据放入响应结果中
return R.ok().put("data", map);
}
//人脸比对接口
// @param face1 第一张人脸的文件名
// @param face2 第二张人脸的文件名
// @param request HTTP 请求对象,用于获取文件路径等信息
//@return R 响应对象,包含操作结果和人脸比对结果数据
@RequestMapping("/matchFace")
public R matchFace(String face1, String face2, HttpServletRequest request) {
// 如果百度人脸识别客户端实例为空,则进行初始化
if (client == null) {
/*String AppID = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "AppID")).getValue();*/
// 从配置中获取 API 密钥和 Secret 密钥
String APIKey = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "APIKey")).getValue();
String SecretKey = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "SecretKey")).getValue();
// 使用密钥获取访问令牌
String token = BaiduUtil.getAuth(APIKey, SecretKey);
// 如果令牌获取失败,则返回错误响应
if (token == null) {
return R.error("请在配置管理中正确配置APIKey和SecretKey");
}
// 初始化百度人脸识别客户端
client = new AipFace(null, APIKey, SecretKey);
// 设置连接超时时间为 2000 毫秒
client.setConnectionTimeoutInMillis(2000);
// 设置套接字超时时间为 60000 毫秒
client.setSocketTimeoutInMillis(60000);
}
JSONObject res = null;
try {
// 根据文件名和文件路径构建人脸文件对象
File file1 = new File(request.getSession().getServletContext().getRealPath("/upload") + "/" + face1);
File file2 = new File(request.getSession().getServletContext().getRealPath("/upload") + "/" + face2);
// 将文件转换为字节数组,并进行 Base64 编码
String img1 = Base64Util.encode(FileUtil.FileToByte(file1));
String img2 = Base64Util.encode(FileUtil.FileToByte(file2));
// 创建人脸比对请求对象
MatchRequest req1 = new MatchRequest(img1, "BASE64");
MatchRequest req2 = new MatchRequest(img2, "BASE64");
// 将两个请求对象添加到列表中
ArrayList<MatchRequest> requests = new ArrayList<MatchRequest>();
requests.add(req1);
requests.add(req2);
// 调用百度人脸识别客户端进行人脸比对
res = client.match(requests);
// 打印比对结果
System.out.println(res.get("result"));
} catch (FileNotFoundException e) {
// 如果文件不存在,打印异常堆栈信息并返回错误响应
e.printStackTrace();
return R.error("文件不存在");
} catch (IOException e) {
// 如果发生 I/O 异常,打印异常堆栈信息
e.printStackTrace();
}
// 返回成功响应,并将人脸比对结果数据放入响应结果中
return R.ok().put("data", com.alibaba.fastjson.JSONObject.parse(res.get("result").toString()));
}
// 获取 table 表中的 column 列表(联动接口)
// @param tableName 表名
// @param columnName 列名
//@param level 层级信息,可选参数
// @param parent 父级信息,可选参数
// @return R 响应对象,包含操作结果和查询到的列值列表数据
@IgnoreAuth
@RequestMapping("/option/{tableName}/{columnName}")
public R getOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName, String level, String parent) {
// 创建参数 Map用于存储表名和列名等信息
Map<String, Object> params = new HashMap<String, Object>();
params.put("table", tableName);
params.put("column", columnName);
// 如果层级信息不为空,则添加到参数中
if (StringUtils.isNotBlank(level)) {
params.put("level", level);
}
// 如果父级信息不为空,则添加到参数中
if (StringUtils.isNotBlank(parent)) {
params.put("parent", parent);
}
// 调用通用服务类的方法,获取列值列表
List<String> data = commonService.getOption(params);
// 返回成功响应,并将列值列表数据放入响应结果中
return R.ok().put("data", data);
}
// 根据 table 中的 column 获取单条记录
// @param tableName 表名
// @param columnName 列名
// @param columnValue 列值
// @return R 响应对象,包含操作结果和查询到的单条记录数据
@IgnoreAuth
@RequestMapping("/follow/{tableName}/{columnName}")
public R getFollowByOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName, @RequestParam String columnValue) {
// 创建参数 Map用于存储表名、列名和列值等信息
Map<String, Object> params = new HashMap<String, Object>();
params.put("table", tableName);
params.put("column", columnName);
params.put("columnValue", columnValue);
// 调用通用服务类的方法,获取单条记录
Map<String, Object> result = commonService.getFollowByOption(params);
// 返回成功响应,并将单条记录数据放入响应结果中
return R.ok().put("data", result);
}
//修改 table 表的 sfsh 状态
// @param tableName 表名
//@param map 包含修改信息的 Map 对象
// @return R 响应对象,包含操作结果
@RequestMapping("/sh/{tableName}")
public R sh(@PathVariable("tableName") String tableName, @RequestBody Map<String, Object> map) {
// 将表名添加到参数 Map 中
map.put("table", tableName);
// 调用通用服务类的方法,进行状态修改操作
commonService.sh(map);
// 返回成功响应
return R.ok();
}
// 获取需要提醒的记录数
// @param tableName 表名
// @param columnName 列名
// @param type 类型1 表示数字2 表示日期
// @param map 请求参数 Map包含提醒相关信息
//@return R 响应对象,包含操作结果和需要提醒的记录数
@IgnoreAuth
@RequestMapping("/remind/{tableName}/{columnName}/{type}")
public R remindCount(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName,
@PathVariable("type") String type, @RequestParam Map<String, Object> map) {
// 将表名、列名和类型添加到参数 Map 中
map.put("table", tableName);
map.put("column", columnName);
map.put("type", type);
// 如果类型为日期2则进行日期相关的处理
if (type.equals("2")) {
// 创建日期格式化对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
// 获取日历实例
Calendar c = Calendar.getInstance();
Date remindStartDate = null;
Date remindEndDate = null;
// 如果存在提醒开始时间参数,则进行计算和格式化
if (map.get("remindstart") != null) {
Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH, remindStart);
remindStartDate = c.getTime();
map.put("remindstart", sdf.format(remindStartDate));
}
// 如果存在提醒结束时间参数,则进行计算和格式化
if (map.get("remindend") != null) {
Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH, remindEnd);
remindEndDate = c.getTime();
map.put("remindend", sdf.format(remindEndDate));
}
}
// 调用通用服务类的方法,获取需要提醒的记录数
int count = commonService.remindCount(map);
// 返回成功响应,并将记录数放入响应结果中
return R.ok().put("count", count);
}
// 单列求和
//@param tableName 表名
// @param columnName 列名
// @return R 响应对象,包含操作结果和求和结果数据
@IgnoreAuth
@RequestMapping("/cal/{tableName}/{columnName}")
public R cal(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName) {
// 创建参数 Map用于存储表名和列名等信息
Map<String, Object> params = new HashMap<String, Object>();
params.put("table", tableName);
params.put("column", columnName);
// 调用通用服务类的方法,进行单列求和操作
Map<String, Object> result = commonService.selectCal(params);
// 返回成功响应,并将求和结果数据放入响应结果中
return R.ok().put("data", result);
}
// 分组统计
// @param tableName 表名
// @param columnName 列名
// @return R 响应对象,包含操作结果和分组统计结果数据
@IgnoreAuth
@RequestMapping("/group/{tableName}/{columnName}")
public R group(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName) {
// 创建参数 Map用于存储表名和列名等信息
Map<String, Object> params = new HashMap<String, Object>();
params.put("table", tableName);
params.put("column", columnName);
// 调用通用服务类的方法,进行分组统计操作
List<Map<String, Object>> result = commonService.selectGroup(params);
// 创建日期格式化对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
// 遍历统计结果,将日期类型的数据进行格式化
for (Map<String, Object> m : result) {
for (String k : m.keySet()) {
if (m.get(k) instanceof Date) {
m.put(k, sdf.format((Date) m.get(k)));
}
}
}
// 返回成功响应,并将分组统计结果数据放入响应结果中
return R.ok().put("data", result);
}
// (按值统计)
// @param tableName 表名
// @param yColumnName y 列名
// @param xColumnName x 列名
//@return R 响应对象,包含操作结果和按值统计结果数据
@IgnoreAuth
@RequestMapping("/value/{tableName}/{xColumnName}/{yColumnName}")
public R value(@PathVariable("tableName") String tableName, @PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName) {
// 创建参数 Map用于存储表名、x 列名和 y 列名等信息
Map<String, Object> params = new HashMap<String, Object>();
params.put("table", tableName);
params.put("xColumn", xColumnName);
params.put("yColumn", yColumnName);
// 调用通用服务类的方法,进行按值统计操作
List<Map<String, Object>> result = commonService.selectValue(params);
// 创建日期格式化对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
// 遍历统计结果,将日期类型的数据进行格式化
for (Map<String, Object> m : result) {
for (String k : m.keySet()) {
if (m.get(k) instanceof Date) {
m.put(k, sdf.format((Date) m.get(k)));
}
}
}
// 返回成功响应,并将按值统计结果数据放入响应结果中
return R.ok().put("data", result);
}
}

@ -1,151 +0,0 @@
package com.controller;
import java.util.Arrays;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.annotation.IgnoreAuth;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.entity.ConfigEntity;
import com.service.ConfigService;
import com.utils.PageUtils;
import com.utils.R;
import com.utils.ValidatorUtils;
// 登录相关
// 该控制器类主要处理与系统配置相关的业务逻辑,包括配置信息的查询、保存、修改和删除等操作。
@RequestMapping("config")
@RestController
public class ConfigController {
// 自动注入配置服务类的实例,用于调用配置相关的业务逻辑方法
@Autowired
private ConfigService configService;
// 获取配置信息列表(支持分页)
// @param params 请求参数,包含分页、排序等信息
// @param config 配置实体,可用于构建查询条件(当前未实际使用)
// @return R 响应对象,包含操作结果和分页后的配置信息数据
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, ConfigEntity config) {
// 创建一个实体包装器,用于构建 SQL 查询条件(当前未添加具体条件)
EntityWrapper<ConfigEntity> ew = new EntityWrapper<ConfigEntity>();
// 调用配置服务类的查询分页方法,传入请求参数
PageUtils page = configService.queryPage(params);
// 返回成功响应,并将分页后的配置信息数据放入响应结果中
return R.ok().put("data", page);
}
//获取配置信息列表(支持分页,无需身份验证)
//@param params 请求参数,包含分页、排序等信息
// @param config 配置实体,可用于构建查询条件(当前未实际使用)
// @return R 响应对象,包含操作结果和分页后的配置信息数据
@IgnoreAuth
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, ConfigEntity config) {
// 创建一个实体包装器,用于构建 SQL 查询条件(当前未添加具体条件)
EntityWrapper<ConfigEntity> ew = new EntityWrapper<ConfigEntity>();
// 调用配置服务类的查询分页方法,传入请求参数
PageUtils page = configService.queryPage(params);
// 返回成功响应,并将分页后的配置信息数据放入响应结果中
return R.ok().put("data", page);
}
//根据 ID 获取配置信息详情
//@param id 配置信息的 ID
// @return R 响应对象,包含操作结果和指定 ID 的配置信息数据
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") String id) {
// 根据 ID 查询配置实体
ConfigEntity config = configService.selectById(id);
// 返回成功响应,并将配置信息数据放入响应结果中
return R.ok().put("data", config);
}
// 根据 ID 获取配置信息详情(无需身份验证)
// @param id 配置信息的 ID
//@return R 响应对象,包含操作结果和指定 ID 的配置信息数据
@IgnoreAuth
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") String id) {
// 根据 ID 查询配置实体
ConfigEntity config = configService.selectById(id);
// 返回成功响应,并将配置信息数据放入响应结果中
return R.ok().put("data", config);
}
//根据配置名称获取配置信息
// @param name 配置名称
// @return R 响应对象,包含操作结果和指定名称的配置信息数据
@RequestMapping("/info")
public R infoByName(@RequestParam String name) {
// 创建实体包装器,设置查询条件为配置名称等于指定名称
// 注意:此处代码写死了查询名称为 "faceFile",与传入的 name 参数无关,可能存在逻辑错误
ConfigEntity config = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "faceFile"));
// 返回成功响应,并将配置信息数据放入响应结果中
return R.ok().put("data", config);
}
// 保存配置信息
// @param config 要保存的配置实体
// @return R 响应对象,包含操作结果
@PostMapping("/save")
public R save(@RequestBody ConfigEntity config) {
// 注释掉的验证实体方法,可用于验证配置实体数据的合法性
// ValidatorUtils.validateEntity(config);
// 调用配置服务类的插入方法,保存配置信息
configService.insert(config);
// 返回成功响应
return R.ok();
}
// 修改配置信息
// @param config 要修改的配置实体
// @return R 响应对象,包含操作结果
@RequestMapping("/update")
public R update(@RequestBody ConfigEntity config) {
// 注释掉的验证实体方法,可用于验证配置实体数据的合法性
// ValidatorUtils.validateEntity(config);
// 调用配置服务类的更新方法,根据 ID 更新配置信息(全部更新)
configService.updateById(config);
// 返回成功响应
return R.ok();
}
// 删除配置信息(批量删除)
// @param ids 要删除的配置信息的 ID 数组
//@return R 响应对象,包含操作结果
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) {
// 调用配置服务类的批量删除方法,根据 ID 列表删除配置信息
configService.deleteBatchIds(Arrays.asList(ids));
// 返回成功响应
return R.ok();
}
}

@ -1,313 +0,0 @@
package com.controller;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Date;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import com.utils.ValidatorUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.annotation.IgnoreAuth;
import com.entity.ShangpinchukuEntity;
import com.entity.view.ShangpinchukuView;
import com.service.ShangpinchukuService;
import com.service.TokenService;
import com.utils.PageUtils;
import com.utils.R;
import com.utils.MD5Util;
import com.utils.MPUtil;
import com.utils.CommonUtil;
// 商品出库
//后端接口
// @author
// @email
// @date 2021-04-24 15:19:31
@RestController
@RequestMapping("/shangpinchuku")
public class ShangpinchukuController {
// 自动注入商品出库服务类的实例,用于处理商品出库相关业务逻辑
@Autowired
private ShangpinchukuService shangpinchukuService;
//后端列表
// 该方法用于获取商品出库信息的分页列表(后端使用),支持根据商品出库实体和出库时间范围构建查询条件,
// 并且根据会话中的 tableName 和 username 信息添加额外的查询条件
// @param params 请求参数,包含分页、排序等信息
// @param shangpinchuku 商品出库实体,用于构建查询条件
// @param chukushijianstart 出库时间开始时间,可选参数,格式为 yyyy-MM-dd HH:mm:ss
// @param chukushijianend 出库时间结束时间,可选参数,格式为 yyyy-MM-dd HH:mm:ss
// @param request HTTP 请求对象
// @return R 响应对象,包含操作结果和分页后的商品出库数据
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, ShangpinchukuEntity shangpinchuku,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date chukushijianstart,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date chukushijianend,
HttpServletRequest request) {
// 从会话中获取 tableName
String tableName = request.getSession().getAttribute("tableName").toString();
// 如果 tableName 是 "yuangong",则设置商品出库实体的员工工号为会话中的 username
if (tableName.equals("yuangong")) {
shangpinchuku.setYuangonggonghao((String) request.getSession().getAttribute("username"));
}
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<ShangpinchukuEntity> ew = new EntityWrapper<ShangpinchukuEntity>();
// 如果出库时间开始时间不为空,添加大于等于该时间的查询条件
if (chukushijianstart != null)
ew.ge("chukushijian", chukushijianstart);
// 如果出库时间结束时间不为空,添加小于等于该时间的查询条件
if (chukushijianend != null)
ew.le("chukushijian", chukushijianend);
// 调用商品出库服务类的 queryPage 方法进行分页查询MPUtil 用于处理排序和条件查询
PageUtils page = shangpinchukuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, shangpinchuku), params), params));
// 返回成功响应,并将分页数据放入响应结果中
return R.ok().put("data", page);
}
// 前端列表
// 该方法用于获取商品出库信息的分页列表(前端使用),支持根据商品出库实体和出库时间范围构建查询条件
// @param params 请求参数,包含分页、排序等信息
// @param shangpinchuku 商品出库实体,用于构建查询条件
// @param chukushijianstart 出库时间开始时间,可选参数,格式为 yyyy-MM-dd HH:mm:ss
// @param chukushijianend 出库时间结束时间,可选参数,格式为 yyyy-MM-dd HH:mm:ss
//@param request HTTP 请求对象
// @return R 响应对象,包含操作结果和分页后的商品出库数据
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, ShangpinchukuEntity shangpinchuku,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date chukushijianstart,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date chukushijianend,
HttpServletRequest request) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<ShangpinchukuEntity> ew = new EntityWrapper<ShangpinchukuEntity>();
// 如果出库时间开始时间不为空,添加大于等于该时间的查询条件
if (chukushijianstart != null)
ew.ge("chukushijian", chukushijianstart);
// 如果出库时间结束时间不为空,添加小于等于该时间的查询条件
if (chukushijianend != null)
ew.le("chukushijian", chukushijianend);
// 调用商品出库服务类的 queryPage 方法进行分页查询MPUtil 用于处理排序和条件查询
PageUtils page = shangpinchukuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, shangpinchuku), params), params));
// 返回成功响应,并将分页数据放入响应结果中
return R.ok().put("data", page);
}
// 列表
// 该方法用于获取满足特定条件的商品出库信息列表
// @param shangpinchuku 商品出库实体,用于构建查询条件
// @return R 响应对象,包含操作结果和查询到的商品出库信息列表数据
@RequestMapping("/lists")
public R list(ShangpinchukuEntity shangpinchuku) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<ShangpinchukuEntity> ew = new EntityWrapper<ShangpinchukuEntity>();
// 设置查询条件,使所有字段相等
ew.allEq(MPUtil.allEQMapPre(shangpinchuku, "shangpinchuku"));
// 调用商品出库服务类的 selectListView 方法获取列表数据
return R.ok().put("data", shangpinchukuService.selectListView(ew));
}
//查询
// 该方法用于根据商品出库实体的条件查询单个商品出库视图
// @param shangpinchuku 商品出库实体,用于构建查询条件
// @return R 响应对象,包含操作结果和查询到的商品出库视图数据
@RequestMapping("/query")
public R query(ShangpinchukuEntity shangpinchuku) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<ShangpinchukuEntity> ew = new EntityWrapper<ShangpinchukuEntity>();
// 设置查询条件,使所有字段相等
ew.allEq(MPUtil.allEQMapPre(shangpinchuku, "shangpinchuku"));
// 调用商品出库服务类的 selectView 方法获取商品出库视图
ShangpinchukuView shangpinchukuView = shangpinchukuService.selectView(ew);
// 返回成功响应,并将查询结果放入响应结果中
return R.ok("查询商品出库成功").put("data", shangpinchukuView);
}
// 后端详情
// 该方法用于获取指定 ID 的商品出库详情(后端使用)
// @param id 商品出库记录的 ID
// @return R 响应对象,包含操作结果和指定 ID 的商品出库数据
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id) {
// 根据 ID 调用商品出库服务类的 selectById 方法获取商品出库实体
ShangpinchukuEntity shangpinchuku = shangpinchukuService.selectById(id);
// 返回成功响应,并将商品出库实体放入响应结果中
return R.ok().put("data", shangpinchuku);
}
// 前端详情
//该方法用于获取指定 ID 的商品出库详情(前端使用)
// @param id 商品出库记录的 ID
//@return R 响应对象,包含操作结果和指定 ID 的商品出库数据
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id) {
// 根据 ID 调用商品出库服务类的 selectById 方法获取商品出库实体
ShangpinchukuEntity shangpinchuku = shangpinchukuService.selectById(id);
// 返回成功响应,并将商品出库实体放入响应结果中
return R.ok().put("data", shangpinchuku);
}
//后端保存
// 该方法用于在后端保存新的商品出库记录
// @param shangpinchuku 要保存的商品出库实体
// @param request HTTP 请求对象
//@return R 响应对象,包含操作结果
@RequestMapping("/save")
public R save(@RequestBody ShangpinchukuEntity shangpinchuku, HttpServletRequest request) {
// 为商品出库实体设置一个唯一的 ID由当前时间戳和随机数组成
shangpinchuku.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(shangpinchuku);
// 调用商品出库服务类的 insert 方法保存商品出库记录
shangpinchukuService.insert(shangpinchuku);
// 返回成功响应
return R.ok();
}
// 前端保存
// 该方法用于在前端保存新的商品出库记录
// @param shangpinchuku 要保存的商品出库实体
// @param request HTTP 请求对象
//@return R 响应对象,包含操作结果
@RequestMapping("/add")
public R add(@RequestBody ShangpinchukuEntity shangpinchuku, HttpServletRequest request) {
// 为商品出库实体设置一个唯一的 ID由当前时间戳和随机数组成
shangpinchuku.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(shangpinchuku);
// 调用商品出库服务类的 insert 方法保存商品出库记录
shangpinchukuService.insert(shangpinchuku);
// 返回成功响应
return R.ok();
}
// 修改
//该方法用于修改已有的商品出库记录
// @param shangpinchuku 要修改的商品出库实体
// @param request HTTP 请求对象
// @return R 响应对象,包含操作结果
@RequestMapping("/update")
public R update(@RequestBody ShangpinchukuEntity shangpinchuku, HttpServletRequest request) {
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(shangpinchuku);
// 调用商品出库服务类的 updateById 方法根据 ID 更新商品出库记录
shangpinchukuService.updateById(shangpinchuku); // 全部更新
// 返回成功响应
return R.ok();
}
// 删除
//该方法用于批量删除指定 ID 的商品出库记录
// @param ids 要删除的商品出库记录的 ID 数组
// @return R 响应对象,包含操作结果
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) {
// 调用商品出库服务类的 deleteBatchIds 方法批量删除商品出库记录
shangpinchukuService.deleteBatchIds(Arrays.asList(ids));
// 返回成功响应
return R.ok();
}
//提醒接口
//该方法用于根据指定列和时间范围统计满足条件的商品出库记录数量,
// 并且根据会话中的 tableName 和 username 信息添加额外的查询条件
// @param columnName 要统计的列名
//@param request HTTP 请求对象
//@param type 类型1 表示数字2 表示日期
//@param map 请求参数,包含提醒开始时间和结束时间等信息
// @return R 响应对象,包含操作结果和统计的数量
@RequestMapping("/remind/{columnName}/{type}")
public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
@PathVariable("type") String type, @RequestParam Map<String, Object> map) {
// 将列名、类型等信息放入请求参数中
map.put("column", columnName);
map.put("type", type);
// 如果类型为日期2则进行日期相关的处理
if (type.equals("2")) {
// 创建日期格式化对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
// 获取日历实例
Calendar c = Calendar.getInstance();
Date remindStartDate = null;
Date remindEndDate = null;
// 如果存在提醒开始时间参数,则进行计算和格式化
if (map.get("remindstart") != null) {
Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH, remindStart);
remindStartDate = c.getTime();
map.put("remindstart", sdf.format(remindStartDate));
}
// 如果存在提醒结束时间参数,则进行计算和格式化
if (map.get("remindend") != null) {
Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH, remindEnd);
remindEndDate = c.getTime();
map.put("remindend", sdf.format(remindEndDate));
}
}
// 创建一个包装器,用于构建 SQL 查询条件
Wrapper<ShangpinchukuEntity> wrapper = new EntityWrapper<ShangpinchukuEntity>();
// 根据提醒开始时间和结束时间设置查询条件
if (map.get("remindstart") != null) {
wrapper.ge(columnName, map.get("remindstart"));
}
if (map.get("remindend") != null) {
wrapper.le(columnName, map.get("remindend"));
}
// 从会话中获取 tableName
String tableName = request.getSession().getAttribute("tableName").toString();
// 如果 tableName 是 "yuangong",则添加员工工号等于会话中 username 的查询条件
if (tableName.equals("yuangong")) {
wrapper.eq("yuangonggonghao", (String) request.getSession().getAttribute("username"));
}
// 调用商品出库服务类的 selectCount 方法统计满足条件的数量
int count = shangpinchukuService.selectCount(wrapper);
// 返回成功响应,并将统计数量放入响应结果中
return R.ok().put("count", count);
}
}

@ -1,298 +0,0 @@
package com.controller;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Date;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import com.utils.ValidatorUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.annotation.IgnoreAuth;
import com.entity.ShangpinkucunEntity;
import com.entity.view.ShangpinkucunView;
import com.service.ShangpinkucunService;
import com.service.TokenService;
import com.utils.PageUtils;
import com.utils.R;
import com.utils.MD5Util;
import com.utils.MPUtil;
import com.utils.CommonUtil;
//商品库存
// 后端接口
// @author
// @email
// @date 2021-04-24 15:19:31
@RestController
@RequestMapping("/shangpinkucun")
public class ShangpinkucunController {
// 自动注入商品库存服务类的实例,用于处理商品库存相关业务逻辑
@Autowired
private ShangpinkucunService shangpinkucunService;
//后端列表
// 该方法用于获取商品库存信息的分页列表(后端使用),支持根据商品库存实体和登记日期范围构建查询条件
//@param params 请求参数,包含分页、排序等信息
//@param shangpinkucun 商品库存实体,用于构建查询条件
// @param dengjiriqistart 登记日期开始时间,可选参数,格式为 yyyy-MM-dd HH:mm:ss
// @param dengjiriqiend 登记日期结束时间,可选参数,格式为 yyyy-MM-dd HH:mm:ss
// @param request HTTP 请求对象
// @return R 响应对象,包含操作结果和分页后的商品库存数据
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, ShangpinkucunEntity shangpinkucun,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date dengjiriqistart,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date dengjiriqiend,
HttpServletRequest request) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<ShangpinkucunEntity> ew = new EntityWrapper<ShangpinkucunEntity>();
// 如果登记日期开始时间不为空,添加大于等于该时间的查询条件
if (dengjiriqistart != null)
ew.ge("dengjiriqi", dengjiriqistart);
// 如果登记日期结束时间不为空,添加小于等于该时间的查询条件
if (dengjiriqiend != null)
ew.le("dengjiriqi", dengjiriqiend);
// 调用商品库存服务类的 queryPage 方法进行分页查询MPUtil 用于处理排序和条件查询
PageUtils page = shangpinkucunService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, shangpinkucun), params), params));
// 返回成功响应,并将分页数据放入响应结果中
return R.ok().put("data", page);
}
//前端列表
//该方法用于获取商品库存信息的分页列表(前端使用),支持根据商品库存实体和登记日期范围构建查询条件
// @param params 请求参数,包含分页、排序等信息
// @param shangpinkucun 商品库存实体,用于构建查询条件
// @param dengjiriqistart 登记日期开始时间,可选参数,格式为 yyyy-MM-dd HH:mm:ss
// @param dengjiriqiend 登记日期结束时间,可选参数,格式为 yyyy-MM-dd HH:mm:ss
// @param request HTTP 请求对象
// @return R 响应对象,包含操作结果和分页后的商品库存数据
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, ShangpinkucunEntity shangpinkucun,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date dengjiriqistart,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date dengjiriqiend,
HttpServletRequest request) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<ShangpinkucunEntity> ew = new EntityWrapper<ShangpinkucunEntity>();
// 如果登记日期开始时间不为空,添加大于等于该时间的查询条件
if (dengjiriqistart != null)
ew.ge("dengjiriqi", dengjiriqistart);
// 如果登记日期结束时间不为空,添加小于等于该时间的查询条件
if (dengjiriqiend != null)
ew.le("dengjiriqi", dengjiriqiend);
// 调用商品库存服务类的 queryPage 方法进行分页查询MPUtil 用于处理排序和条件查询
PageUtils page = shangpinkucunService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, shangpinkucun), params), params));
// 返回成功响应,并将分页数据放入响应结果中
return R.ok().put("data", page);
}
//列表
// 该方法用于获取满足特定条件的商品库存信息列表
//@param shangpinkucun 商品库存实体,用于构建查询条件
//@return R 响应对象,包含操作结果和查询到的商品库存信息列表数据
@RequestMapping("/lists")
public R list(ShangpinkucunEntity shangpinkucun) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<ShangpinkucunEntity> ew = new EntityWrapper<ShangpinkucunEntity>();
// 设置查询条件,使所有字段相等
ew.allEq(MPUtil.allEQMapPre(shangpinkucun, "shangpinkucun"));
// 调用商品库存服务类的 selectListView 方法获取列表数据
return R.ok().put("data", shangpinkucunService.selectListView(ew));
}
//查询
// 该方法用于根据商品库存实体的条件查询单个商品库存视图
// @param shangpinkucun 商品库存实体,用于构建查询条件
// @return R 响应对象,包含操作结果和查询到的商品库存视图数据
@RequestMapping("/query")
public R query(ShangpinkucunEntity shangpinkucun) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<ShangpinkucunEntity> ew = new EntityWrapper<ShangpinkucunEntity>();
// 设置查询条件,使所有字段相等
ew.allEq(MPUtil.allEQMapPre(shangpinkucun, "shangpinkucun"));
// 调用商品库存服务类的 selectView 方法获取商品库存视图
ShangpinkucunView shangpinkucunView = shangpinkucunService.selectView(ew);
// 返回成功响应,并将查询结果放入响应结果中
return R.ok("查询商品库存成功").put("data", shangpinkucunView);
}
//后端详情
// 该方法用于获取指定 ID 的商品库存详情(后端使用)
//@param id 商品库存记录的 ID
//@return R 响应对象,包含操作结果和指定 ID 的商品库存数据
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id) {
// 根据 ID 调用商品库存服务类的 selectById 方法获取商品库存实体
ShangpinkucunEntity shangpinkucun = shangpinkucunService.selectById(id);
// 返回成功响应,并将商品库存实体放入响应结果中
return R.ok().put("data", shangpinkucun);
}
// 前端详情
// 该方法用于获取指定 ID 的商品库存详情(前端使用)
//@param id 商品库存记录的 ID
//@return R 响应对象,包含操作结果和指定 ID 的商品库存数据
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id) {
// 根据 ID 调用商品库存服务类的 selectById 方法获取商品库存实体
ShangpinkucunEntity shangpinkucun = shangpinkucunService.selectById(id);
// 返回成功响应,并将商品库存实体放入响应结果中
return R.ok().put("data", shangpinkucun);
}
// 后端保存
// 该方法用于在后端保存新的商品库存记录
// @param shangpinkucun 要保存的商品库存实体
// @param request HTTP 请求对象
// @return R 响应对象,包含操作结果
@RequestMapping("/save")
public R save(@RequestBody ShangpinkucunEntity shangpinkucun, HttpServletRequest request) {
// 为商品库存实体设置一个唯一的 ID由当前时间戳和随机数组成
shangpinkucun.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(shangpinkucun);
// 调用商品库存服务类的 insert 方法保存商品库存记录
shangpinkucunService.insert(shangpinkucun);
// 返回成功响应
return R.ok();
}
// 前端保存
//该方法用于在前端保存新的商品库存记录
// @param shangpinkucun 要保存的商品库存实体
// @param request HTTP 请求对象
// @return R 响应对象,包含操作结果
@RequestMapping("/add")
public R add(@RequestBody ShangpinkucunEntity shangpinkucun, HttpServletRequest request) {
// 为商品库存实体设置一个唯一的 ID由当前时间戳和随机数组成
shangpinkucun.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(shangpinkucun);
// 调用商品库存服务类的 insert 方法保存商品库存记录
shangpinkucunService.insert(shangpinkucun);
// 返回成功响应
return R.ok();
}
// 修改
// 该方法用于修改已有的商品库存记录
// @param shangpinkucun 要修改的商品库存实体
//@param request HTTP 请求对象
// @return R 响应对象,包含操作结果
@RequestMapping("/update")
public R update(@RequestBody ShangpinkucunEntity shangpinkucun, HttpServletRequest request) {
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(shangpinkucun);
// 调用商品库存服务类的 updateById 方法根据 ID 更新商品库存记录
shangpinkucunService.updateById(shangpinkucun); // 全部更新
// 返回成功响应
return R.ok();
}
// 删除
//该方法用于批量删除指定 ID 的商品库存记录
//@param ids 要删除的商品库存记录的 ID 数组
// @return R 响应对象,包含操作结果
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) {
// 调用商品库存服务类的 deleteBatchIds 方法批量删除商品库存记录
shangpinkucunService.deleteBatchIds(Arrays.asList(ids));
// 返回成功响应
return R.ok();
}
// 提醒接口
// 该方法用于根据指定列和时间范围统计满足条件的商品库存记录数量
//@param columnName 要统计的列名
//@param request HTTP 请求对象
// @param type 类型1 表示数字2 表示日期
// @param map 请求参数,包含提醒开始时间和结束时间等信息
// @return R 响应对象,包含操作结果和统计的数量
@RequestMapping("/remind/{columnName}/{type}")
public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
@PathVariable("type") String type, @RequestParam Map<String, Object> map) {
// 将列名、类型等信息放入请求参数中
map.put("column", columnName);
map.put("type", type);
// 如果类型为日期2则进行日期相关的处理
if (type.equals("2")) {
// 创建日期格式化对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
// 获取日历实例
Calendar c = Calendar.getInstance();
Date remindStartDate = null;
Date remindEndDate = null;
// 如果存在提醒开始时间参数,则进行计算和格式化
if (map.get("remindstart") != null) {
Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH, remindStart);
remindStartDate = c.getTime();
map.put("remindstart", sdf.format(remindStartDate));
}
// 如果存在提醒结束时间参数,则进行计算和格式化
if (map.get("remindend") != null) {
Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH, remindEnd);
remindEndDate = c.getTime();
map.put("remindend", sdf.format(remindEndDate));
}
}
// 创建一个包装器,用于构建 SQL 查询条件
Wrapper<ShangpinkucunEntity> wrapper = new EntityWrapper<ShangpinkucunEntity>();
// 根据提醒开始时间和结束时间设置查询条件
if (map.get("remindstart") != null) {
wrapper.ge(columnName, map.get("remindstart"));
}
if (map.get("remindend") != null) {
wrapper.le(columnName, map.get("remindend"));
}
// 调用商品库存服务类的 selectCount 方法统计满足条件的数量
int count = shangpinkucunService.selectCount(wrapper);
// 返回成功响应,并将统计数量放入响应结果中
return R.ok().put("count", count);
}
}

@ -1,282 +0,0 @@
package com.controller;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Date;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import com.utils.ValidatorUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.annotation.IgnoreAuth;
import com.entity.ShangpinleixingEntity;
import com.entity.view.ShangpinleixingView;
import com.service.ShangpinleixingService;
import com.service.TokenService;
import com.utils.PageUtils;
import com.utils.R;
import com.utils.MD5Util;
import com.utils.MPUtil;
import com.utils.CommonUtil;
// 商品类型
//后端接口
// @author
// @email
// @date 2021-04-24 15:19:31
@RestController
@RequestMapping("/shangpinleixing")
public class ShangpinleixingController {
// 自动注入商品类型服务类,用于处理商品类型相关的业务逻辑
@Autowired
private ShangpinleixingService shangpinleixingService;
//后端列表
//用于获取商品类型信息的分页列表,供后端使用
//@param params 请求参数,包含分页、排序等信息
//@param shangpinleixing 商品类型实体,用于构建查询条件
//@param request HTTP 请求对象
//@return R 通用响应对象,包含操作结果和分页数据
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, ShangpinleixingEntity shangpinleixing,
HttpServletRequest request) {
// 创建实体包装器,用于构建 SQL 查询条件
EntityWrapper<ShangpinleixingEntity> ew = new EntityWrapper<ShangpinleixingEntity>();
// 调用服务类的 queryPage 方法进行分页查询MPUtil 用于处理排序和条件查询
PageUtils page = shangpinleixingService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, shangpinleixing), params), params));
// 返回成功响应,并将分页数据放入响应结果中
return R.ok().put("data", page);
}
// 前端列表
// 用于获取商品类型信息的分页列表,供前端使用
//@param params 请求参数,包含分页、排序等信息
//@param shangpinleixing 商品类型实体,用于构建查询条件
// @param request HTTP 请求对象
//@return R 通用响应对象,包含操作结果和分页数据
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, ShangpinleixingEntity shangpinleixing,
HttpServletRequest request) {
// 创建实体包装器,用于构建 SQL 查询条件
EntityWrapper<ShangpinleixingEntity> ew = new EntityWrapper<ShangpinleixingEntity>();
// 调用服务类的 queryPage 方法进行分页查询MPUtil 用于处理排序和条件查询
PageUtils page = shangpinleixingService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, shangpinleixing), params), params));
// 返回成功响应,并将分页数据放入响应结果中
return R.ok().put("data", page);
}
// 列表
// 用于获取满足特定条件的商品类型信息列表
// @param shangpinleixing 商品类型实体,用于构建查询条件
// @return R 通用响应对象,包含操作结果和查询到的商品类型信息列表
@RequestMapping("/lists")
public R list(ShangpinleixingEntity shangpinleixing) {
// 创建实体包装器,用于构建 SQL 查询条件
EntityWrapper<ShangpinleixingEntity> ew = new EntityWrapper<ShangpinleixingEntity>();
// 设置查询条件,使所有字段相等
ew.allEq(MPUtil.allEQMapPre(shangpinleixing, "shangpinleixing"));
// 调用服务类的 selectListView 方法获取列表数据
return R.ok().put("data", shangpinleixingService.selectListView(ew));
}
//查询
//用于根据商品类型实体的条件查询单个商品类型视图
//@param shangpinleixing 商品类型实体,用于构建查询条件
// @return R 通用响应对象,包含操作结果和查询到的商品类型视图
@RequestMapping("/query")
public R query(ShangpinleixingEntity shangpinleixing) {
// 创建实体包装器,用于构建 SQL 查询条件
EntityWrapper<ShangpinleixingEntity> ew = new EntityWrapper<ShangpinleixingEntity>();
// 设置查询条件,使所有字段相等
ew.allEq(MPUtil.allEQMapPre(shangpinleixing, "shangpinleixing"));
// 调用服务类的 selectView 方法获取商品类型视图
ShangpinleixingView shangpinleixingView = shangpinleixingService.selectView(ew);
// 返回成功响应,并将查询结果放入响应结果中
return R.ok("查询商品类型成功").put("data", shangpinleixingView);
}
//后端详情
//用于获取指定 ID 的商品类型详情,供后端使用
//@param id 商品类型记录的 ID
//@return R 通用响应对象,包含操作结果和指定 ID 的商品类型信息
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id) {
// 根据 ID 调用服务类的 selectById 方法获取商品类型实体
ShangpinleixingEntity shangpinleixing = shangpinleixingService.selectById(id);
// 返回成功响应,并将商品类型实体放入响应结果中
return R.ok().put("data", shangpinleixing);
}
// 前端详情
// 用于获取指定 ID 的商品类型详情,供前端使用
//@param id 商品类型记录的 ID
//@return R 通用响应对象,包含操作结果和指定 ID 的商品类型信息
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id) {
// 根据 ID 调用服务类的 selectById 方法获取商品类型实体
ShangpinleixingEntity shangpinleixing = shangpinleixingService.selectById(id);
// 返回成功响应,并将商品类型实体放入响应结果中
return R.ok().put("data", shangpinleixing);
}
//后端保存
// 用于在后端保存新的商品类型记录
// @param shangpinleixing 要保存的商品类型实体
// @param request HTTP 请求对象
// @return R 通用响应对象,包含操作结果
@RequestMapping("/save")
public R save(@RequestBody ShangpinleixingEntity shangpinleixing, HttpServletRequest request) {
// 为商品类型实体设置一个唯一的 ID由当前时间戳和随机数组成
shangpinleixing.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(shangpinleixing);
// 调用服务类的 insert 方法保存商品类型记录
shangpinleixingService.insert(shangpinleixing);
// 返回成功响应
return R.ok();
}
// 前端保存
// 用于在前端保存新的商品类型记录
// @param shangpinleixing 要保存的商品类型实体
// @param request HTTP 请求对象
//@return R 通用响应对象,包含操作结果
@RequestMapping("/add")
public R add(@RequestBody ShangpinleixingEntity shangpinleixing, HttpServletRequest request) {
// 为商品类型实体设置一个唯一的 ID由当前时间戳和随机数组成
shangpinleixing.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(shangpinleixing);
// 调用服务类的 insert 方法保存商品类型记录
shangpinleixingService.insert(shangpinleixing);
// 返回成功响应
return R.ok();
}
// 修改
// 用于修改已有的商品类型记录
// @param shangpinleixing 要修改的商品类型实体
// @param request HTTP 请求对象
// @return R 通用响应对象,包含操作结果
@RequestMapping("/update")
public R update(@RequestBody ShangpinleixingEntity shangpinleixing, HttpServletRequest request) {
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(shangpinleixing);
// 调用服务类的 updateById 方法根据 ID 更新商品类型记录
shangpinleixingService.updateById(shangpinleixing); // 全部更新
// 返回成功响应
return R.ok();
}
//删除
//用于批量删除指定 ID 的商品类型记录
//@param ids 要删除的商品类型记录的 ID 数组
// @return R 通用响应对象,包含操作结果
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) {
// 调用服务类的 deleteBatchIds 方法批量删除商品类型记录
shangpinleixingService.deleteBatchIds(Arrays.asList(ids));
// 返回成功响应
return R.ok();
}
// 提醒接口
// 用于根据指定列和时间范围统计满足条件的商品类型记录数量
// @param columnName 要统计的列名
// @param request HTTP 请求对象
// @param type 类型1 表示数字2 表示日期
// @param map 请求参数,包含提醒开始时间和结束时间等信息
// @return R 通用响应对象,包含操作结果和统计的数量
@RequestMapping("/remind/{columnName}/{type}")
public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
@PathVariable("type") String type, @RequestParam Map<String, Object> map) {
// 将列名和类型放入请求参数中
map.put("column", columnName);
map.put("type", type);
if (type.equals("2")) {
// 创建日期格式化对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
// 获取日历实例
Calendar c = Calendar.getInstance();
Date remindStartDate = null;
Date remindEndDate = null;
if (map.get("remindstart") != null) {
// 解析提醒开始时间的偏移量
Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
c.setTime(new Date());
// 计算提醒开始日期
c.add(Calendar.DAY_OF_MONTH, remindStart);
remindStartDate = c.getTime();
// 将格式化后的提醒开始日期放入请求参数中
map.put("remindstart", sdf.format(remindStartDate));
}
if (map.get("remindend") != null) {
// 解析提醒结束时间的偏移量
Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
c.setTime(new Date());
// 计算提醒结束日期
c.add(Calendar.DAY_OF_MONTH, remindEnd);
remindEndDate = c.getTime();
// 将格式化后的提醒结束日期放入请求参数中
map.put("remindend", sdf.format(remindEndDate));
}
}
// 创建实体包装器,用于构建 SQL 查询条件
Wrapper<ShangpinleixingEntity> wrapper = new EntityWrapper<ShangpinleixingEntity>();
if (map.get("remindstart") != null) {
// 设置大于等于提醒开始日期的查询条件
wrapper.ge(columnName, map.get("remindstart"));
}
if (map.get("remindend") != null) {
// 设置小于等于提醒结束日期的查询条件
wrapper.le(columnName, map.get("remindend"));
}
// 调用服务类的 selectCount 方法统计满足条件的记录数量
int count = shangpinleixingService.selectCount(wrapper);
// 返回成功响应,并将统计数量放入响应结果中
return R.ok().put("count", count);
}
}

@ -1,312 +0,0 @@
package com.controller;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Date;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import com.utils.ValidatorUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.annotation.IgnoreAuth;
import com.entity.ShangpinrukuEntity;
import com.entity.view.ShangpinrukuView;
import com.service.ShangpinrukuService;
import com.service.TokenService;
import com.utils.PageUtils;
import com.utils.R;
import com.utils.MD5Util;
import com.utils.MPUtil;
import com.utils.CommonUtil;
//商品入库
//后端接口
//@author
// @email
// @date 2021-04-24 15:19:31
@RestController
@RequestMapping("/shangpinruku")
public class ShangpinrukuController {
// 自动注入商品入库服务类的实例,用于处理商品入库相关业务逻辑
@Autowired
private ShangpinrukuService shangpinrukuService;
// 后端列表
// 该方法用于获取商品入库信息的分页列表(后端使用),支持根据商品入库实体和入库时间范围构建查询条件,
// 并且根据会话中的 tableName 和 username 信息添加额外的查询条件
// @param params 请求参数,包含分页、排序等信息
// @param shangpinruku 商品入库实体,用于构建查询条件
// @param rukushijianstart 入库时间开始时间,可选参数,格式为 yyyy-MM-dd HH:mm:ss
// @param rukushijianend 入库时间结束时间,可选参数,格式为 yyyy-MM-dd HH:mm:ss
// @param request HTTP 请求对象
// @return R 响应对象,包含操作结果和分页后的商品入库数据
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, ShangpinrukuEntity shangpinruku,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date rukushijianstart,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date rukushijianend,
HttpServletRequest request) {
// 从会话中获取 tableName
String tableName = request.getSession().getAttribute("tableName").toString();
// 如果 tableName 是 "yuangong",则设置商品入库实体的员工工号为会话中的 username
if (tableName.equals("yuangong")) {
shangpinruku.setYuangonggonghao((String) request.getSession().getAttribute("username"));
}
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<ShangpinrukuEntity> ew = new EntityWrapper<ShangpinrukuEntity>();
// 如果入库时间开始时间不为空,添加大于等于该时间的查询条件
if (rukushijianstart != null)
ew.ge("rukushijian", rukushijianstart);
// 如果入库时间结束时间不为空,添加小于等于该时间的查询条件
if (rukushijianend != null)
ew.le("rukushijian", rukushijianend);
// 调用商品入库服务类的 queryPage 方法进行分页查询MPUtil 用于处理排序和条件查询
PageUtils page = shangpinrukuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, shangpinruku), params), params));
// 返回成功响应,并将分页数据放入响应结果中
return R.ok().put("data", page);
}
//前端列表
//该方法用于获取商品入库信息的分页列表(前端使用),支持根据商品入库实体和入库时间范围构建查询条件
// @param params 请求参数,包含分页、排序等信息
//@param shangpinruku 商品入库实体,用于构建查询条件
// @param rukushijianstart 入库时间开始时间,可选参数,格式为 yyyy-MM-dd HH:mm:ss
// @param rukushijianend 入库时间结束时间,可选参数,格式为 yyyy-MM-dd HH:mm:ss
// @param request HTTP 请求对象
// @return R 响应对象,包含操作结果和分页后的商品入库数据
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, ShangpinrukuEntity shangpinruku,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date rukushijianstart,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date rukushijianend,
HttpServletRequest request) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<ShangpinrukuEntity> ew = new EntityWrapper<ShangpinrukuEntity>();
// 如果入库时间开始时间不为空,添加大于等于该时间的查询条件
if (rukushijianstart != null)
ew.ge("rukushijian", rukushijianstart);
// 如果入库时间结束时间不为空,添加小于等于该时间的查询条件
if (rukushijianend != null)
ew.le("rukushijian", rukushijianend);
// 调用商品入库服务类的 queryPage 方法进行分页查询MPUtil 用于处理排序和条件查询
PageUtils page = shangpinrukuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, shangpinruku), params), params));
// 返回成功响应,并将分页数据放入响应结果中
return R.ok().put("data", page);
}
// 列表
// 该方法用于获取满足特定条件的商品入库信息列表
//@param shangpinruku 商品入库实体,用于构建查询条件
// @return R 响应对象,包含操作结果和查询到的商品入库信息列表数据
@RequestMapping("/lists")
public R list(ShangpinrukuEntity shangpinruku) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<ShangpinrukuEntity> ew = new EntityWrapper<ShangpinrukuEntity>();
// 设置查询条件,使所有字段相等
ew.allEq(MPUtil.allEQMapPre(shangpinruku, "shangpinruku"));
// 调用商品入库服务类的 selectListView 方法获取列表数据
return R.ok().put("data", shangpinrukuService.selectListView(ew));
}
//查询
// 该方法用于根据商品入库实体的条件查询单个商品入库视图
//@param shangpinruku 商品入库实体,用于构建查询条件
//@return R 响应对象,包含操作结果和查询到的商品入库视图数据
@RequestMapping("/query")
public R query(ShangpinrukuEntity shangpinruku) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<ShangpinrukuEntity> ew = new EntityWrapper<ShangpinrukuEntity>();
// 设置查询条件,使所有字段相等
ew.allEq(MPUtil.allEQMapPre(shangpinruku, "shangpinruku"));
// 调用商品入库服务类的 selectView 方法获取商品入库视图
ShangpinrukuView shangpinrukuView = shangpinrukuService.selectView(ew);
// 返回成功响应,并将查询结果放入响应结果中
return R.ok("查询商品入库成功").put("data", shangpinrukuView);
}
//后端详情
// 该方法用于获取指定 ID 的商品入库详情(后端使用)
//@param id 商品入库记录的 ID
// @return R 响应对象,包含操作结果和指定 ID 的商品入库数据
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id) {
// 根据 ID 调用商品入库服务类的 selectById 方法获取商品入库实体
ShangpinrukuEntity shangpinruku = shangpinrukuService.selectById(id);
// 返回成功响应,并将商品入库实体放入响应结果中
return R.ok().put("data", shangpinruku);
}
//前端详情
// 该方法用于获取指定 ID 的商品入库详情(前端使用)
// @param id 商品入库记录的 ID
//@return R 响应对象,包含操作结果和指定 ID 的商品入库数据
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id) {
// 根据 ID 调用商品入库服务类的 selectById 方法获取商品入库实体
ShangpinrukuEntity shangpinruku = shangpinrukuService.selectById(id);
// 返回成功响应,并将商品入库实体放入响应结果中
return R.ok().put("data", shangpinruku);
}
// 后端保存
// 该方法用于在后端保存新的商品入库记录
// @param shangpinruku 要保存的商品入库实体
// @param request HTTP 请求对象
//@return R 响应对象,包含操作结果
@RequestMapping("/save")
public R save(@RequestBody ShangpinrukuEntity shangpinruku, HttpServletRequest request) {
// 为商品入库实体设置一个唯一的 ID由当前时间戳和随机数组成
shangpinruku.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(shangpinruku);
// 调用商品入库服务类的 insert 方法保存商品入库记录
shangpinrukuService.insert(shangpinruku);
// 返回成功响应
return R.ok();
}
// 前端保存
// 该方法用于在前端保存新的商品入库记录
// @param shangpinruku 要保存的商品入库实体
// @param request HTTP 请求对象
// @return R 响应对象,包含操作结果
@RequestMapping("/add")
public R add(@RequestBody ShangpinrukuEntity shangpinruku, HttpServletRequest request) {
// 为商品入库实体设置一个唯一的 ID由当前时间戳和随机数组成
shangpinruku.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(shangpinruku);
// 调用商品入库服务类的 insert 方法保存商品入库记录
shangpinrukuService.insert(shangpinruku);
// 返回成功响应
return R.ok();
}
// 修改
// 该方法用于修改已有的商品入库记录
// @param shangpinruku 要修改的商品入库实体
// @param request HTTP 请求对象
// @return R 响应对象,包含操作结果
@RequestMapping("/update")
public R update(@RequestBody ShangpinrukuEntity shangpinruku, HttpServletRequest request) {
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(shangpinruku);
// 调用商品入库服务类的 updateById 方法根据 ID 更新商品入库记录
shangpinrukuService.updateById(shangpinruku); // 全部更新
// 返回成功响应
return R.ok();
}
// 删除
//该方法用于批量删除指定 ID 的商品入库记录
// @param ids 要删除的商品入库记录的 ID 数组
// @return R 响应对象,包含操作结果
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) {
// 调用商品入库服务类的 deleteBatchIds 方法批量删除商品入库记录
shangpinrukuService.deleteBatchIds(Arrays.asList(ids));
// 返回成功响应
return R.ok();
}
//提醒接口
// 该方法用于根据指定列和时间范围统计满足条件的商品入库记录数量,
// 并且根据会话中的 tableName 和 username 信息添加额外的查询条件
// @param columnName 要统计的列名
//@param request HTTP 请求对象
// @param type 类型1 表示数字2 表示日期
// @param map 请求参数,包含提醒开始时间和结束时间等信息
// @return R 响应对象,包含操作结果和统计的数量
@RequestMapping("/remind/{columnName}/{type}")
public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
@PathVariable("type") String type, @RequestParam Map<String, Object> map) {
// 将列名、类型等信息放入请求参数中
map.put("column", columnName);
map.put("type", type);
// 如果类型为日期2则进行日期相关的处理
if (type.equals("2")) {
// 创建日期格式化对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
// 获取日历实例
Calendar c = Calendar.getInstance();
Date remindStartDate = null;
Date remindEndDate = null;
// 如果存在提醒开始时间参数,则进行计算和格式化
if (map.get("remindstart") != null) {
Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH, remindStart);
remindStartDate = c.getTime();
map.put("remindstart", sdf.format(remindStartDate));
}
// 如果存在提醒结束时间参数,则进行计算和格式化
if (map.get("remindend") != null) {
Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH, remindEnd);
remindEndDate = c.getTime();
map.put("remindend", sdf.format(remindEndDate));
}
}
// 创建一个包装器,用于构建 SQL 查询条件
Wrapper<ShangpinrukuEntity> wrapper = new EntityWrapper<ShangpinrukuEntity>();
// 根据提醒开始时间和结束时间设置查询条件
if (map.get("remindstart") != null) {
wrapper.ge(columnName, map.get("remindstart"));
}
if (map.get("remindend") != null) {
wrapper.le(columnName, map.get("remindend"));
}
// 从会话中获取 tableName
String tableName = request.getSession().getAttribute("tableName").toString();
// 如果 tableName 是 "yuangong",则添加员工工号等于会话中 username 的查询条件
if (tableName.equals("yuangong")) {
wrapper.eq("yuangonggonghao", (String) request.getSession().getAttribute("username"));
}
// 调用商品入库服务类的 selectCount 方法统计满足条件的数量
int count = shangpinrukuService.selectCount(wrapper);
// 返回成功响应,并将统计数量放入响应结果中
return R.ok().put("count", count);
}
}

@ -1,250 +0,0 @@
package com.controller;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import com.annotation.IgnoreAuth;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.entity.TokenEntity;
import com.entity.UserEntity;
import com.service.TokenService;
import com.service.UserService;
import com.utils.CommonUtil;
import com.utils.MD5Util;
import com.utils.MPUtil;
import com.utils.PageUtils;
import com.utils.R;
import com.utils.ValidatorUtils;
// 登录相关
@RequestMapping("users")
@RestController
public class UserController {
// 自动注入用户服务类,用于处理用户相关业务逻辑
@Autowired
private UserService userService;
// 自动注入令牌服务类,用于处理令牌相关业务逻辑
@Autowired
private TokenService tokenService;
// 登录
// 处理用户登录请求,验证用户名和密码,生成并返回令牌
// @param username 用户名
// @param password 密码
// @param captcha 验证码(当前代码未使用)
// @param request HTTP请求对象
// @return R 响应对象,包含操作结果和令牌(如果登录成功)
@IgnoreAuth
@PostMapping(value = "/login")
public R login(String username, String password, String captcha, HttpServletRequest request) {
// 根据用户名查询用户实体
UserEntity user = userService.selectOne(new EntityWrapper<UserEntity>().eq("username", username));
// 如果用户不存在或密码不正确,返回错误响应
if (user == null || !user.getPassword().equals(password)) {
return R.error("账号或密码不正确");
}
// 生成令牌参数包括用户ID、用户名、用户表名和用户角色
String token = tokenService.generateToken(user.getId(), username, "users", user.getRole());
// 返回成功响应,并将令牌放入响应结果中
return R.ok().put("token", token);
}
//注册
//处理用户注册请求,验证用户信息并插入数据库
//@param user 用户实体,包含注册信息
//@return R 响应对象,包含操作结果
@IgnoreAuth
@PostMapping(value = "/register")
public R register(@RequestBody UserEntity user) {
// 注释掉的验证实体方法,可用于验证实体数据的合法性
// ValidatorUtils.validateEntity(user);
// 检查用户名是否已存在
if (userService.selectOne(new EntityWrapper<UserEntity>().eq("username", user.getUsername())) != null) {
return R.error("用户已存在");
}
// 插入用户信息到数据库
userService.insert(user);
// 返回成功响应
return R.ok();
}
// 退出
//处理用户退出请求,使当前会话失效
//@param request HTTP请求对象
//@return R 响应对象,包含操作结果
@GetMapping(value = "logout")
public R logout(HttpServletRequest request) {
// 使会话失效
request.getSession().invalidate();
// 返回成功响应
return R.ok("退出成功");
}
// 处理用户密码重置请求,将用户密码重置为默认值
//@param username 用户名
// @param request HTTP请求对象
// @return R 响应对象,包含操作结果
@IgnoreAuth
@RequestMapping(value = "/resetPass")
public R resetPass(String username, HttpServletRequest request) {
// 根据用户名查询用户实体
UserEntity user = userService.selectOne(new EntityWrapper<UserEntity>().eq("username", username));
// 如果用户不存在,返回错误响应
if (user == null) {
return R.error("账号不存在");
}
// 将用户密码设置为默认值 "123456"
user.setPassword("123456");
// 更新用户信息到数据库
userService.update(user, null);
// 返回成功响应,并提示密码已重置
return R.ok("密码已重置为123456");
}
//列表(分页)
// 获取用户信息的分页列表
// @param params 请求参数,包含分页、排序等信息
// @param user 用户实体,用于构建查询条件
// @return R 响应对象,包含操作结果和分页数据
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, UserEntity user) {
// 创建实体包装器用于构建SQL查询条件
EntityWrapper<UserEntity> ew = new EntityWrapper<UserEntity>();
// 调用用户服务类的 queryPage 方法进行分页查询MPUtil 用于处理排序和条件查询
PageUtils page = userService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params));
// 返回成功响应,并将分页数据放入响应结果中
return R.ok().put("data", page);
}
// 列表
//获取满足特定条件的用户信息列表
//@param user 用户实体,用于构建查询条件
//@return R 响应对象,包含操作结果和查询到的用户信息列表
@RequestMapping("/list")
public R list(UserEntity user) {
// 创建实体包装器,用于构建 SQL 查询条件
EntityWrapper<UserEntity> ew = new EntityWrapper<UserEntity>();
// 设置查询条件,使所有字段相等
ew.allEq(MPUtil.allEQMapPre(user, "user"));
// 调用用户服务类的 selectListView 方法获取列表数据
return R.ok().put("data", userService.selectListView(ew));
}
//信息
// 获取指定ID的用户信息
// @param id 用户ID
//@return R 响应对象,包含操作结果和用户信息
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") String id) {
// 根据ID查询用户实体
UserEntity user = userService.selectById(id);
// 返回成功响应,并将用户信息放入响应结果中
return R.ok().put("data", user);
}
//获取用户的session用户信息
//从会话中获取用户ID并查询对应的用户信息
//@param request HTTP请求对象
// @return R 响应对象,包含操作结果和用户信息
@RequestMapping("/session")
public R getCurrUser(HttpServletRequest request) {
// 从会话中获取用户ID
Long id = (Long) request.getSession().getAttribute("userId");
// 根据ID查询用户实体
UserEntity user = userService.selectById(id);
// 返回成功响应,并将用户信息放入响应结果中
return R.ok().put("data", user);
}
//保存
// 保存新用户信息,检查用户名是否已存在
//@param user 用户实体,包含要保存的信息
// @return R 响应对象,包含操作结果
@PostMapping("/save")
public R save(@RequestBody UserEntity user) {
// 注释掉的验证实体方法,可用于验证实体数据的合法性
// ValidatorUtils.validateEntity(user);
// 检查用户名是否已存在
if (userService.selectOne(new EntityWrapper<UserEntity>().eq("username", user.getUsername())) != null) {
return R.error("用户已存在");
}
// 插入用户信息到数据库
userService.insert(user);
// 返回成功响应
return R.ok();
}
// 修改
// 修改用户信息,检查用户名是否已被其他用户使用
//@param user 用户实体,包含要修改的信息
//@return R 响应对象,包含操作结果
@RequestMapping("/update")
public R update(@RequestBody UserEntity user) {
// 注释掉的验证实体方法,可用于验证实体数据的合法性
// ValidatorUtils.validateEntity(user);
// 根据用户名查询用户实体
UserEntity u = userService.selectOne(new EntityWrapper<UserEntity>().eq("username", user.getUsername()));
// 如果用户名已存在且不是当前用户,返回错误响应
if (u != null && u.getId() != user.getId() && u.getUsername().equals(user.getUsername())) {
return R.error("用户名已存在。");
}
// 根据用户ID更新用户信息到数据库
userService.updateById(user); // 全部更新
// 返回成功响应
return R.ok();
}
// 删除
// 批量删除用户信息
// @param ids 要删除的用户ID数组
//@return R 响应对象,包含操作结果
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) {
// 调用用户服务类的 deleteBatchIds 方法批量删除用户信息
userService.deleteBatchIds(Arrays.asList(ids));
// 返回成功响应
return R.ok();
}
}

@ -1,61 +0,0 @@
package com.dao;
import com.entity.ChengbenjieyuEntity;
import com.baomidou.mybatisplus.mapper.BaseMapper;
import java.util.List;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
import org.apache.ibatis.annotations.Param;
import com.entity.vo.ChengbenjieyuVO;
import com.entity.view.ChengbenjieyuView;
// 成本结余数据访问接口继承自MyBatis-Plus的BaseMapper接口用于对成本结余实体进行数据库操作。
// 除了BaseMapper提供的基本CRUD操作外该接口还定义了一些自定义的查询方法。
// @author
// @email
// @date 2021-04-24 15:19:31
public interface ChengbenjieyuDao extends BaseMapper<ChengbenjieyuEntity> {
//根据查询条件包装器查询成本结余值对象VO列表。
// 值对象VO通常是为了特定业务场景而封装的可能包含实体类的部分属性或经过处理后的属性。
//@param wrapper 查询条件包装器,用于筛选符合条件的成本结余数据。
// @param ("ew ")使用@Param注解指定参数名称为"ew"方便在SQL映射文件中引用该参数。
// @return 符合条件的成本结余值对象VO列表。
List<ChengbenjieyuVO> selectListVO(@Param("ew") Wrapper<ChengbenjieyuEntity> wrapper);
// 根据查询条件包装器查询单个成本结余值对象VO
//@param wrapper 查询条件包装器,用于精确筛选出一个成本结余数据。
// @param ("ew") 使用@Param注解指定参数名称为"ew"方便在SQL映射文件中引用该参数。
// @return 符合条件的单个成本结余值对象VO若未找到则返回 null。
ChengbenjieyuVO selectVO(@Param("ew") Wrapper<ChengbenjieyuEntity> wrapper);
// 根据查询条件包装器查询成本结余视图列表。
// 视图View通常是对实体数据进行特定组装或处理后得到的以满足特定的展示需求。
// @param wrapper 查询条件包装器,用于筛选符合条件的成本结余视图数据。
// @param ("ew") 使用@Param注解指定参数名称为"ew"方便在SQL映射文件中引用该参数。
// @return 符合条件的成本结余视图列表。
List<ChengbenjieyuView> selectListView(@Param("ew") Wrapper<ChengbenjieyuEntity> wrapper);
// 根据分页信息和查询条件包装器查询成本结余视图列表,支持分页查询。
// @param page 分页信息对象,包含当前页码、每页记录数等信息。
//@param wrapper 查询条件包装器,用于筛选符合条件的成本结余视图数据。
//@param ("ew") 使用@Param注解指定参数名称为"ew"方便在SQL映射文件中引用该参数。
//@return 符合条件的成本结余视图列表,按分页信息进行分页。
List<ChengbenjieyuView> selectListView(Pagination page, @Param("ew") Wrapper<ChengbenjieyuEntity> wrapper);
// 根据查询条件包装器查询单个成本结余视图。
// @param wrapper 查询条件包装器,用于精确筛选出一个成本结余视图数据。
//@param ("ew") 使用@Param注解指定参数名称为"ew"方便在SQL映射文件中引用该参数。
// @return 符合条件的单个成本结余视图,若未找到则返回 null。
ChengbenjieyuView selectView(@Param("ew") Wrapper<ChengbenjieyuEntity> wrapper);
}

@ -1,65 +0,0 @@
package com.dao;
import java.util.List;
import java.util.Map;
//通用接口,定义了一系列通用的数据访问方法,
//这些方法可用于执行多种不同类型的数据库操作,
//适用于各种业务场景中通用的数据查询、处理和统计等需求。
public interface CommonDao {
// 根据传入的参数获取选项列表。
// @param params 包含查询条件的参数Map用于筛选符合条件的选项。
// @return 包含符合条件选项的字符串列表。
List<String> getOption(Map<String, Object> params);
// 根据传入的参数获取与选项相关的详细信息。
// @param params 包含查询条件的参数Map用于定位特定的选项及其相关信息。
// @return 包含选项相关详细信息的Map键为信息的名称值为对应的信息内容。
Map<String, Object> getFollowByOption(Map<String, Object> params);
// 根据传入的参数获取另一种与选项相关的信息列表。
// @param params 包含查询条件的参数Map用于筛选出符合条件的信息。
// @return 包含符合条件信息的字符串列表。
List<String> getFollowByOption2(Map<String, Object> params);
// 执行某种数据处理操作,可能是更新、删除或其他自定义操作。
// @param params 包含操作所需参数的Map具体操作由实现类根据参数内容决定。
void sh(Map<String, Object> params);
//统计提醒的数量。
//@param params 包含统计条件的参数Map用于筛选出符合条件的提醒记录。
//@return 符合条件的提醒记录数量。
int remindCount(Map<String, Object> params);
// 根据传入的参数进行数据计算并返回计算结果。
//@param params 包含计算所需数据和条件的参数Map具体计算逻辑由实现类实现。
//@return 包含计算结果的Map键为计算结果的名称值为对应的计算结果。
Map<String, Object> selectCal(Map<String, Object> params);
// 根据传入的参数进行分组查询,并返回分组结果。
// @param params 包含分组查询条件的参数Map用于指定分组依据和筛选条件。
// @return 包含分组结果的Map列表每个Map表示一组数据及其相关统计信息。
List<Map<String, Object>> selectGroup(Map<String, Object> params);
// 根据传入的参数查询特定的值,并返回查询结果。
// @param params 包含查询条件的参数Map用于筛选出符合条件的数据记录。
// @return 包含查询结果的Map列表每个Map表示一条符合条件的数据记录。
List<Map<String, Object>> selectValue(Map<String, Object> params);
}

@ -1,19 +0,0 @@
package com.dao;
import com.baomidou.mybatisplus.mapper.BaseMapper;
import com.entity.ConfigEntity;
//配置数据访问接口继承自MyBatis-Plus的BaseMapper接口
// 用于对配置实体ConfigEntity进行数据库操作。
// 借助BaseMapper该接口自动具备了对ConfigEntity实体的基本CRUD创建、读取、更新、删除操作能力
// 例如插入、查询、更新和删除ConfigEntity对象对应的数据库记录。
// 如果后续需要对配置数据进行更复杂的数据库操作,可以在此接口中添加自定义的方法。
//@author
// @email
// @date
public interface ConfigDao extends BaseMapper<ConfigEntity> {
// 目前该接口仅继承BaseMapper的功能未添加额外的自定义方法。
// 如果有特殊的数据库操作需求,可在此处添加对应的方法声明。
}

@ -1,61 +0,0 @@
package com.dao;
import com.entity.ShangpinchukuEntity;
import com.baomidou.mybatisplus.mapper.BaseMapper;
import java.util.List;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
import org.apache.ibatis.annotations.Param;
import com.entity.vo.ShangpinchukuVO;
import com.entity.view.ShangpinchukuView;
// 商品出库
// 该接口用于处理与商品出库相关的数据访问操作,继承自 MyBatis-Plus 的 BaseMapper 接口,
// 具备对商品出库实体类ShangpinchukuEntity的基本增删改查功能。
// @author
// @email
// @date 2021-04-24 15:19:31
public interface ShangpinchukuDao extends BaseMapper<ShangpinchukuEntity> {
// 根据传入的查询条件包装器Wrapper查询符合条件的商品出库值对象VO列表。
// 值对象VO通常用于封装特定业务场景下需要展示或处理的数据可能包含实体类的部分属性。
//@param wrapper 用于构建查询条件的包装器,可设置各种条件(如等于、大于、小于等)来筛选数据。
// @return 符合查询条件的商品出库值对象ShangpinchukuVO列表如果没有符合条件的数据则返回空列表。
List<ShangpinchukuVO> selectListVO(@Param("ew") Wrapper<ShangpinchukuEntity> wrapper);
// 根据传入的查询条件包装器Wrapper查询符合条件的单个商品出库值对象VO
// @param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的单个商品出库值对象ShangpinchukuVO如果没有符合条件的数据则返回 null。
ShangpinchukuVO selectVO(@Param("ew") Wrapper<ShangpinchukuEntity> wrapper);
// 根据传入的查询条件包装器Wrapper查询符合条件的商品出库视图对象View列表。
// 视图对象View通常是对实体类数据进行了一定的处理或关联查询后得到的用于满足特定的展示需求。
//@param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的商品出库视图对象ShangpinchukuView列表如果没有符合条件的数据则返回空列表。
List<ShangpinchukuView> selectListView(@Param("ew") Wrapper<ShangpinchukuEntity> wrapper);
//根据传入的分页信息Pagination和查询条件包装器Wrapper查询符合条件的商品出库视图对象View列表。
//此方法支持分页查询,适用于数据量较大的情况,可按页获取符合条件的数据。
// @param page 分页信息对象,包含了当前页码、每页显示的记录数等信息。
// @param wrapper 用于构建查询条件的包装器。
// @return 当前页符合查询条件的商品出库视图对象ShangpinchukuView列表如果没有符合条件的数据则返回空列表。
List<ShangpinchukuView> selectListView(Pagination page, @Param("ew") Wrapper<ShangpinchukuEntity> wrapper);
// 根据传入的查询条件包装器Wrapper查询符合条件的单个商品出库视图对象View
// @param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的单个商品出库视图对象ShangpinchukuView如果没有符合条件的数据则返回 null。
ShangpinchukuView selectView(@Param("ew") Wrapper<ShangpinchukuEntity> wrapper);
}

@ -1,61 +0,0 @@
package com.dao;
import com.entity.ShangpinkucunEntity;
import com.baomidou.mybatisplus.mapper.BaseMapper;
import java.util.List;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
import org.apache.ibatis.annotations.Param;
import com.entity.vo.ShangpinkucunVO;
import com.entity.view.ShangpinkucunView;
// 商品库存
// 该接口用于处理与商品库存相关的数据访问操作,继承自 MyBatis-Plus 的 BaseMapper 接口,
// 拥有对商品库存实体类ShangpinkucunEntity的基本增删改查能力。
// @author
// @email
// @date 2021-04-24 15:19:31
public interface ShangpinkucunDao extends BaseMapper<ShangpinkucunEntity> {
// 根据传入的查询条件包装器Wrapper查询符合条件的商品库存值对象VO列表。
// 值对象VO一般用于封装特定业务场景下所需的数据可能包含实体类的部分属性。
//@param wrapper 用于构建查询条件的包装器,可以设置各种条件(如等于、大于、小于等)来筛选数据。
// @return 符合查询条件的商品库存值对象ShangpinkucunVO列表若没有符合条件的数据则返回空列表。
List<ShangpinkucunVO> selectListVO(@Param("ew") Wrapper<ShangpinkucunEntity> wrapper);
// 根据传入的查询条件包装器Wrapper查询符合条件的单个商品库存值对象VO
//@param wrapper 用于构建查询条件的包装器。
//@return 符合查询条件的单个商品库存值对象ShangpinkucunVO若没有符合条件的数据则返回 null。
ShangpinkucunVO selectVO(@Param("ew") Wrapper<ShangpinkucunEntity> wrapper);
//根据传入的查询条件包装器Wrapper查询符合条件的商品库存视图对象View列表。
//视图对象View通常是对实体类数据进行了一定处理或关联查询后得到的以满足特定的展示需求。
//@param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的商品库存视图对象ShangpinkucunView列表若没有符合条件的数据则返回空列表。
List<ShangpinkucunView> selectListView(@Param("ew") Wrapper<ShangpinkucunEntity> wrapper);
//根据传入的分页信息Pagination和查询条件包装器Wrapper查询符合条件的商品库存视图对象View列表。
//此方法支持分页查询,适用于数据量较大的情况,可按页获取符合条件的数据。
// @param page 分页信息对象,包含当前页码、每页显示的记录数等信息。
// @param wrapper 用于构建查询条件的包装器。
// @return 当前页符合查询条件的商品库存视图对象ShangpinkucunView列表若没有符合条件的数据则返回空列表。
List<ShangpinkucunView> selectListView(Pagination page, @Param("ew") Wrapper<ShangpinkucunEntity> wrapper);
// 根据传入的查询条件包装器Wrapper查询符合条件的单个商品库存视图对象View
// @param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的单个商品库存视图对象ShangpinkucunView若没有符合条件的数据则返回 null。
ShangpinkucunView selectView(@Param("ew") Wrapper<ShangpinkucunEntity> wrapper);
}

@ -1,60 +0,0 @@
package com.dao;
import com.entity.ShangpinleixingEntity;
import com.baomidou.mybatisplus.mapper.BaseMapper;
import java.util.List;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
import org.apache.ibatis.annotations.Param;
import com.entity.vo.ShangpinleixingVO;
import com.entity.view.ShangpinleixingView;
// 商品类型
// 此接口用于与数据库中商品类型相关的数据进行交互,继承自 MyBatis-Plus 的 BaseMapper 接口,具备基本的增删改查功能。
//@author
// @email
// @date 2021-04-24 15:19:31
public interface ShangpinleixingDao extends BaseMapper<ShangpinleixingEntity> {
//根据指定的查询条件查询商品类型值对象VO列表。
//值对象VO通常用于封装特定业务场景下需要的数据可能是实体类部分字段的组合或经过处理后的数据。
// @param wrapper 用于构建查询条件的包装器,可设置如等于、大于、小于等条件。
// @return 符合查询条件的商品类型值对象列表,如果没有符合条件的数据则返回空列表。
List<ShangpinleixingVO> selectListVO(@Param("ew") Wrapper<ShangpinleixingEntity> wrapper);
// 根据指定的查询条件查询单个商品类型值对象VO
// @param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的单个商品类型值对象,如果没有符合条件的数据则返回 null。
ShangpinleixingVO selectVO(@Param("ew") Wrapper<ShangpinleixingEntity> wrapper);
// 根据指定的查询条件,查询商品类型视图对象列表。
// 视图对象通常用于展示数据,可能包含关联查询或格式化后的数据。
// @param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的商品类型视图对象列表,如果没有符合条件的数据则返回空列表。
List<ShangpinleixingView> selectListView(@Param("ew") Wrapper<ShangpinleixingEntity> wrapper);
//根据分页信息和查询条件,查询商品类型视图对象列表。
// 该方法支持分页查询,适用于处理大量数据。
// @param page 分页对象,包含当前页码、每页显示记录数等信息。
// @param wrapper 用于构建查询条件的包装器。
// @return 当前页符合查询条件的商品类型视图对象列表,如果没有符合条件的数据则返回空列表。
List<ShangpinleixingView> selectListView(Pagination page, @Param("ew") Wrapper<ShangpinleixingEntity> wrapper);
// 根据指定的查询条件,查询单个商品类型视图对象。
// @param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的单个商品类型视图对象,如果没有符合条件的数据则返回 null。
ShangpinleixingView selectView(@Param("ew") Wrapper<ShangpinleixingEntity> wrapper);
}

@ -1,61 +0,0 @@
package com.dao;
import com.entity.ShangpinrukuEntity;
import com.baomidou.mybatisplus.mapper.BaseMapper;
import java.util.List;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
import org.apache.ibatis.annotations.Param;
import com.entity.vo.ShangpinrukuVO;
import com.entity.view.ShangpinrukuView;
//商品入库
//该接口主要负责与数据库中商品入库相关数据进行交互,继承自 MyBatis-Plus 的 BaseMapper 接口,
//可使用其提供的基本增删改查操作方法来处理商品入库实体ShangpinrukuEntity
// @author
// @email
// @date 2021-04-24 15:19:31
public interface ShangpinrukuDao extends BaseMapper<ShangpinrukuEntity> {
//根据传入的查询条件包装器Wrapper查询符合条件的商品入库值对象VO列表。
//值对象VO通常用于封装特定业务场景下需要的数据可能只包含实体类的部分字段或经过计算处理后的数据。
//@param wrapper 用于构建查询条件的包装器,可设置各种条件(如等于、大于、小于等)来筛选数据。
//@return 符合查询条件的商品入库值对象ShangpinrukuVO列表如果没有符合条件的数据则返回空列表。
List<ShangpinrukuVO> selectListVO(@Param("ew") Wrapper<ShangpinrukuEntity> wrapper);
// 根据传入的查询条件包装器Wrapper查询符合条件的单个商品入库值对象VO
// @param wrapper 用于构建查询条件的包装器。
//@return 符合查询条件的单个商品入库值对象ShangpinrukuVO如果没有符合条件的数据则返回 null。
ShangpinrukuVO selectVO(@Param("ew") Wrapper<ShangpinrukuEntity> wrapper);
//根据传入的查询条件包装器Wrapper查询符合条件的商品入库视图对象View列表。
//视图对象View通常用于展示数据可能会包含一些关联查询或格式化后的数据以满足前端展示的需求。
//@param wrapper 用于构建查询条件的包装器。
//@return 符合查询条件的商品入库视图对象ShangpinrukuView列表如果没有符合条件的数据则返回空列表。
List<ShangpinrukuView> selectListView(@Param("ew") Wrapper<ShangpinrukuEntity> wrapper);
// 根据传入的分页信息Pagination和查询条件包装器Wrapper查询符合条件的商品入库视图对象View列表。
// 此方法支持分页查询,适用于处理大量数据,可按页获取符合条件的数据。
//@param page 分页对象,包含当前页码、每页显示记录数等信息。
// @param wrapper 用于构建查询条件的包装器。
//@return 当前页符合查询条件的商品入库视图对象ShangpinrukuView列表如果没有符合条件的数据则返回空列表。
List<ShangpinrukuView> selectListView(Pagination page, @Param("ew") Wrapper<ShangpinrukuEntity> wrapper);
// 根据传入的查询条件包装器Wrapper查询符合条件的单个商品入库视图对象View
// @param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的单个商品入库视图对象ShangpinrukuView如果没有符合条件的数据则返回 null。
ShangpinrukuView selectView(@Param("ew") Wrapper<ShangpinrukuEntity> wrapper);
}

@ -1,37 +0,0 @@
package com.dao;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import com.baomidou.mybatisplus.mapper.BaseMapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
import com.entity.TokenEntity;
// token
// 该接口用于与数据库中的 token 数据进行交互,继承自 MyBatis-Plus 的 BaseMapper 接口,
// 可以使用 BaseMapper 提供的基本增删改查操作方法对 TokenEntity 进行操作。
public interface TokenDao extends BaseMapper<TokenEntity> {
//根据传入的查询条件包装器Wrapper查询符合条件的 Token 实体列表。
// 此方法用于获取满足特定条件的所有 Token 数据。
// @param wrapper 用于构建查询条件的包装器,可通过该包装器设置各种查询条件,如等于、大于、小于等。
// @return 符合查询条件的 Token 实体列表,如果没有符合条件的数据则返回空列表。
List<TokenEntity> selectListView(@Param("ew") Wrapper<TokenEntity> wrapper);
// 根据传入的分页信息Pagination和查询条件包装器Wrapper查询符合条件的 Token 实体列表。
// 此方法支持分页查询,适用于处理大量数据,可按页获取符合条件的 Token 数据。
//@param page 分页对象,包含当前页码、每页显示记录数等信息。
// @param wrapper 用于构建查询条件的包装器。
// @return 当前页符合查询条件的 Token 实体列表,如果没有符合条件的数据则返回空列表。
List<TokenEntity> selectListView(Pagination page, @Param("ew") Wrapper<TokenEntity> wrapper);
}

@ -1,34 +0,0 @@
package com.dao;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import com.baomidou.mybatisplus.mapper.BaseMapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
import com.entity.UserEntity;
// 用户
// 该接口主要用于与数据库中的用户表进行交互,继承自 MyBatis-Plus 的 BaseMapper 接口,
//具备对 UserEntity 实体对象的基本增删改查功能。
public interface UserDao extends BaseMapper<UserEntity> {
//根据传入的查询条件包装器 wrapper 查询用户实体列表。
// @param wrapper 用于构建查询条件的包装器,可设置如等于、大于、小于等各种查询条件。
// @return 符合查询条件的用户实体列表,若没有符合条件的记录则返回空列表。
List<UserEntity> selectListView(@Param("ew") Wrapper<UserEntity> wrapper);
// 根据传入的分页信息 page 和查询条件包装器 wrapper 进行分页查询用户实体列表。
//@param page 分页对象,包含当前页码、每页显示的记录数等分页信息。
// @param wrapper 用于构建查询条件的包装器。
// @return 当前页符合查询条件的用户实体列表,若没有符合条件的记录则返回空列表。
List<UserEntity> selectListView(Pagination page, @Param("ew") Wrapper<UserEntity> wrapper);
}

@ -1,179 +0,0 @@
package com.entity;
import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.annotations.TableName;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import java.lang.reflect.InvocationTargetException;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
import org.springframework.format.annotation.DateTimeFormat;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.apache.commons.beanutils.BeanUtils;
import com.baomidou.mybatisplus.annotations.TableField;
import com.baomidou.mybatisplus.enums.FieldFill;
import com.baomidou.mybatisplus.enums.IdType;
// 成本结余
// 数据库通用操作实体类(普通增删改查)
//@author
// @email
// @date 2021-04-24 15:19:31
@TableName("chengbenjieyu")
public class ChengbenjieyuEntity<T> implements Serializable {
private static final long serialVersionUID = 1L;
public ChengbenjieyuEntity() {
}
public ChengbenjieyuEntity(T t) {
try {
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// 主键id
@TableId
private Long id;
// 成本名称
private String chengbenmingcheng;
//收入项目
private String shouruxiangmu;
// 收入金额
private Integer shourujine;
// 支出项目
private String zhichuxiangmu;
//支出金额
private Integer zhichujine;
//结余金额
private String jieyujine;
// 日期
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd")
@DateTimeFormat
private Date riqi;
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date addtime;
public Date getAddtime() {
return addtime;
}
public void setAddtime(Date addtime) {
this.addtime = addtime;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
// 设置:成本名称
public void setChengbenmingcheng(String chengbenmingcheng) {
this.chengbenmingcheng = chengbenmingcheng;
}
// 获取:成本名称
public String getChengbenmingcheng() {
return chengbenmingcheng;
}
// 设置:收入项目
public void setShouruxiangmu(String shouruxiangmu) {
this.shouruxiangmu = shouruxiangmu;
}
// 获取:收入项目
public String getShouruxiangmu() {
return shouruxiangmu;
}
// 设置:收入金额
public void setShourujine(Integer shourujine) {
this.shourujine = shourujine;
}
// 获取:收入金额
public Integer getShourujine() {
return shourujine;
}
// 设置:支出项目
public void setZhichuxiangmu(String zhichuxiangmu) {
this.zhichuxiangmu = zhichuxiangmu;
}
// 获取:支出项目
public String getZhichuxiangmu() {
return zhichuxiangmu;
}
// 设置:支出金额
public void setZhichujine(Integer zhichujine) {
this.zhichujine = zhichujine;
}
// 获取:支出金额
public Integer getZhichujine() {
return zhichujine;
}
// 设置:结余金额
public void setJieyujine(String jieyujine) {
this.jieyujine = jieyujine;
}
// 获取:结余金额
public String getJieyujine() {
return jieyujine;
}
// 设置:日期
public void setRiqi(Date riqi) {
this.riqi = riqi;
}
// 获取:日期
public Date getRiqi() {
return riqi;
}
}

@ -1,50 +0,0 @@
package com.entity;
import java.io.Serializable;
import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.annotations.TableName;
import com.baomidou.mybatisplus.enums.IdType;
// 类说明 :
@TableName("config")
public class ConfigEntity implements Serializable{
private static final long serialVersionUID = 1L;
@TableId(type = IdType.AUTO)
private Long id;
// key
private String name;
// value
private String value;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
}

@ -1,91 +0,0 @@
package com.entity;
// 自定义异常
// 该类继承自 RuntimeException属于非受检异常在使用时不需要显式捕获或抛出。
// 用于在特定业务场景下抛出带有自定义错误信息和错误码的异常。
public class EIException extends RuntimeException {
// 序列化版本号,用于在反序列化时验证类的版本一致性
private static final long serialVersionUID = 1L;
// 异常信息,用于描述异常的具体情况
private String msg;
// 异常码,默认为 500表示服务器内部错误
private int code = 500;
// 构造函数,接收异常信息作为参数
// @param msg 异常信息
public EIException(String msg) {
// 调用父类 RuntimeException 的构造函数,传入异常信息
super(msg);
// 将传入的异常信息赋值给当前对象的 msg 属性
this.msg = msg;
}
// 构造函数,接收异常信息和 Throwable 对象作为参数
// @param msg 异常信息
// @param e 异常的原因,即导致此异常抛出的另一个异常
public EIException(String msg, Throwable e) {
// 调用父类 RuntimeException 的构造函数,传入异常信息和异常原因
super(msg, e);
// 将传入的异常信息赋值给当前对象的 msg 属性
this.msg = msg;
}
// 构造函数,接收异常信息和异常码作为参数
//@param msg 异常信息
// @param code 异常码
public EIException(String msg, int code) {
// 调用父类 RuntimeException 的构造函数,传入异常信息
super(msg);
// 将传入的异常信息赋值给当前对象的 msg 属性
this.msg = msg;
// 将传入的异常码赋值给当前对象的 code 属性
this.code = code;
}
//构造函数,接收异常信息、异常码和 Throwable 对象作为参数
// @param msg 异常信息
//@param code 异常码
// @param e 异常的原因,即导致此异常抛出的另一个异常
public EIException(String msg, int code, Throwable e) {
// 调用父类 RuntimeException 的构造函数,传入异常信息和异常原因
super(msg, e);
// 将传入的异常信息赋值给当前对象的 msg 属性
this.msg = msg;
// 将传入的异常码赋值给当前对象的 code 属性
this.code = code;
}
// 获取异常信息的方法
// @return 异常信息
public String getMsg() {
return msg;
}
// 设置异常信息的方法
// @param msg 要设置的异常信息
public void setMsg(String msg) {
this.msg = msg;
}
//获取异常码的方法
//@return 异常码
public int getCode() {
return code;
}
// 设置异常码的方法
// @param code 要设置的异常码
public void setCode(int code) {
this.code = code;
}
}

@ -1,224 +0,0 @@
package com.entity;
import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.annotations.TableName;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import java.lang.reflect.InvocationTargetException;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
import org.springframework.format.annotation.DateTimeFormat;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.apache.commons.beanutils.BeanUtils;
import com.baomidou.mybatisplus.annotations.TableField;
import com.baomidou.mybatisplus.enums.FieldFill;
import com.baomidou.mybatisplus.enums.IdType;
//商品出库
//数据库通用操作实体类(普通增删改查)
//@author
//@email
//@date 2021-04-24 15:19:31
@TableName("shangpinchuku")
public class ShangpinchukuEntity<T> implements Serializable {
private static final long serialVersionUID = 1L;
public ShangpinchukuEntity() {
}
public ShangpinchukuEntity(T t) {
try {
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//主键id
@TableId
private Long id;
// 商品名称
private String shangpinmingcheng;
//商品类型
private String shangpinleixing;
//客户姓名
private String kehuxingming;
// 商品数量
private Integer shangpinshuliang;
//出库时间
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date chukushijian;
// 备注
private String beizhu;
// 员工工号
private String yuangonggonghao;
// 员工姓名
private String yuangongxingming;
// 是否审核
private String sfsh;
// 审核回复
private String shhf;
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date addtime;
public Date getAddtime() {
return addtime;
}
public void setAddtime(Date addtime) {
this.addtime = addtime;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
// 设置:商品名称
public void setShangpinmingcheng(String shangpinmingcheng) {
this.shangpinmingcheng = shangpinmingcheng;
}
//获取:商品名称
public String getShangpinmingcheng() {
return shangpinmingcheng;
}
// 设置:商品类型
public void setShangpinleixing(String shangpinleixing) {
this.shangpinleixing = shangpinleixing;
}
//获取:商品类型
public String getShangpinleixing() {
return shangpinleixing;
}
// 设置:客户姓名
public void setKehuxingming(String kehuxingming) {
this.kehuxingming = kehuxingming;
}
// 获取:客户姓名
public String getKehuxingming() {
return kehuxingming;
}
// 设置:商品数量
public void setShangpinshuliang(Integer shangpinshuliang) {
this.shangpinshuliang = shangpinshuliang;
}
//获取:商品数量
public Integer getShangpinshuliang() {
return shangpinshuliang;
}
// 设置:出库时间
public void setChukushijian(Date chukushijian) {
this.chukushijian = chukushijian;
}
// 获取:出库时间
public Date getChukushijian() {
return chukushijian;
}
// 设置:备注
public void setBeizhu(String beizhu) {
this.beizhu = beizhu;
}
// 获取:备注
public String getBeizhu() {
return beizhu;
}
// 设置:员工工号
public void setYuangonggonghao(String yuangonggonghao) {
this.yuangonggonghao = yuangonggonghao;
}
//获取:员工工号
public String getYuangonggonghao() {
return yuangonggonghao;
}
// 设置:员工姓名
public void setYuangongxingming(String yuangongxingming) {
this.yuangongxingming = yuangongxingming;
}
// 获取:员工姓名
public String getYuangongxingming() {
return yuangongxingming;
}
// 设置:是否审核
public void setSfsh(String sfsh) {
this.sfsh = sfsh;
}
// 获取:是否审核
public String getSfsh() {
return sfsh;
}
// 设置:审核回复
public void setShhf(String shhf) {
this.shhf = shhf;
}
//获取:审核回复
public String getShhf() {
return shhf;
}
}

@ -1,179 +0,0 @@
package com.entity;
import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.annotations.TableName;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import java.lang.reflect.InvocationTargetException;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
import org.springframework.format.annotation.DateTimeFormat;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.apache.commons.beanutils.BeanUtils;
import com.baomidou.mybatisplus.annotations.TableField;
import com.baomidou.mybatisplus.enums.FieldFill;
import com.baomidou.mybatisplus.enums.IdType;
// 商品库存
// 数据库通用操作实体类(普通增删改查)
// @author
// @email
// @date 2021-04-24 15:19:31
@TableName("shangpinkucun")
public class ShangpinkucunEntity<T> implements Serializable {
private static final long serialVersionUID = 1L;
public ShangpinkucunEntity() {
}
public ShangpinkucunEntity(T t) {
try {
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// 主键id
@TableId
private Long id;
// 商品名称
private String shangpinmingcheng;
//商品类型
private String shangpinleixing;
// 商品数量
private Integer shangpinshuliang;
// 商品详情
private String shangpinxiangqing;
//存放位置
private String cunfangweizhi;
// 是否完好
private String shifouwanhao;
// 登记日期
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date dengjiriqi;
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date addtime;
public Date getAddtime() {
return addtime;
}
public void setAddtime(Date addtime) {
this.addtime = addtime;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
// 设置:商品名称
public void setShangpinmingcheng(String shangpinmingcheng) {
this.shangpinmingcheng = shangpinmingcheng;
}
//获取:商品名称
public String getShangpinmingcheng() {
return shangpinmingcheng;
}
// 设置:商品类型
public void setShangpinleixing(String shangpinleixing) {
this.shangpinleixing = shangpinleixing;
}
// 获取:商品类型
public String getShangpinleixing() {
return shangpinleixing;
}
//设置:商品数量
public void setShangpinshuliang(Integer shangpinshuliang) {
this.shangpinshuliang = shangpinshuliang;
}
//获取:商品数量
public Integer getShangpinshuliang() {
return shangpinshuliang;
}
// 设置:商品详情
public void setShangpinxiangqing(String shangpinxiangqing) {
this.shangpinxiangqing = shangpinxiangqing;
}
// 获取:商品详情
public String getShangpinxiangqing() {
return shangpinxiangqing;
}
//设置:存放位置
public void setCunfangweizhi(String cunfangweizhi) {
this.cunfangweizhi = cunfangweizhi;
}
// 获取:存放位置
public String getCunfangweizhi() {
return cunfangweizhi;
}
//设置:是否完好
public void setShifouwanhao(String shifouwanhao) {
this.shifouwanhao = shifouwanhao;
}
//获取:是否完好
public String getShifouwanhao() {
return shifouwanhao;
}
// 设置:登记日期
public void setDengjiriqi(Date dengjiriqi) {
this.dengjiriqi = dengjiriqi;
}
// 获取:登记日期
public Date getDengjiriqi() {
return dengjiriqi;
}
}

@ -1,112 +0,0 @@
package com.entity;
// 导入 MyBatis-Plus 的 TableId 注解,用于指定主键
import com.baomidou.mybatisplus.annotations.TableId;
// 导入 MyBatis-Plus 的 TableName 注解,用于指定实体类对应的数据库表名
import com.baomidou.mybatisplus.annotations.TableName;
// 导入验证注解,用于验证字符串不为空字符串
import javax.validation.constraints.NotBlank;
// 导入验证注解,用于验证集合或数组不为空
import javax.validation.constraints.NotEmpty;
// 导入验证注解,用于验证对象不为 null
import javax.validation.constraints.NotNull;
// 导入 Jackson 的 JsonIgnoreProperties 注解,用于在序列化和反序列化时忽略某些属性
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
// 导入反射调用可能抛出的异常类
import java.lang.reflect.InvocationTargetException;
// 导入 Serializable 接口,使该类的对象可以进行序列化和反序列化
import java.io.Serializable;
// 导入 Date 类,用于处理日期和时间
import java.util.Date;
// 导入 List 接口,用于表示一组对象
import java.util.List;
// 导入 Spring 的 DateTimeFormat 注解,用于指定日期的输入格式
import org.springframework.format.annotation.DateTimeFormat;
// 导入 Jackson 的 JsonFormat 注解,用于指定日期在 JSON 中的输出格式
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入 Apache Commons BeanUtils 工具类,用于对象属性的复制
import org.apache.commons.beanutils.BeanUtils;
// 导入 MyBatis-Plus 的 TableField 注解,用于指定字段的填充策略等
import com.baomidou.mybatisplus.annotations.TableField;
// 导入 MyBatis-Plus 的 FieldFill 枚举,用于指定字段的填充时机
import com.baomidou.mybatisplus.enums.FieldFill;
// 导入 MyBatis-Plus 的 IdType 枚举,用于指定主键的生成类型
import com.baomidou.mybatisplus.enums.IdType;
// 商品类型
//数据库通用操作实体类(普通增删改查)
// @author
// @email
// @date 2021-04-24 15:19:31
// 使用 TableName 注解指定该实体类对应的数据库表名为 "shangpinleixing"
@TableName("shangpinleixing")
// 定义一个泛型实体类,实现 Serializable 接口
public class ShangpinleixingEntity<T> implements Serializable {
// 定义序列化版本号,用于在反序列化时验证类的版本一致性
private static final long serialVersionUID = 1L;
// 无参构造函数,用于创建一个空的 ShangpinleixingEntity 对象
public ShangpinleixingEntity() {
}
// 有参构造函数,接受一个泛型对象 t将其属性复制到当前对象
public ShangpinleixingEntity(T t) {
try {
// 使用 BeanUtils 的 copyProperties 方法将传入对象 t 的属性复制到当前对象
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// 如果在属性复制过程中出现非法访问异常或反射调用目标方法异常,打印异常堆栈信息
// 在实际项目中,建议使用日志记录异常信息,而不是简单打印
e.printStackTrace();
}
}
// 主键id
// 使用 TableId 注解指定该字段为主键
@TableId
private Long id;
// 类型
private String leixing;
// 使用 JsonFormat 注解指定日期在 JSON 中的输出格式
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
// 使用 DateTimeFormat 注解指定日期的输入格式
@DateTimeFormat
private Date addtime;
// 获取添加时间的方法
public Date getAddtime() {
return addtime;
}
// 设置添加时间的方法
public void setAddtime(Date addtime) {
this.addtime = addtime;
}
// 获取主键 id 的方法
public Long getId() {
return id;
}
// 设置主键 id 的方法
public void setId(Long id) {
this.id = id;
}
// 设置:类型
public void setLeixing(String leixing) {
this.leixing = leixing;
}
// 获取:类型
public String getLeixing() {
return leixing;
}
}

@ -1,239 +0,0 @@
package com.entity;
import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.annotations.TableName;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import java.lang.reflect.InvocationTargetException;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
import org.springframework.format.annotation.DateTimeFormat;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.apache.commons.beanutils.BeanUtils;
import com.baomidou.mybatisplus.annotations.TableField;
import com.baomidou.mybatisplus.enums.FieldFill;
import com.baomidou.mybatisplus.enums.IdType;
// 商品入库
//数据库通用操作实体类(普通增删改查)
// @author
// @email
// @date 2021-04-24 15:19:31
@TableName("shangpinruku")
public class ShangpinrukuEntity<T> implements Serializable {
private static final long serialVersionUID = 1L;
public ShangpinrukuEntity() {
}
public ShangpinrukuEntity(T t) {
try {
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// 主键id
@TableId
private Long id;
//商品名称
private String shangpinmingcheng;
// 商品类型
private String shangpinleixing;
// 供应商姓名
private String gongyingshangxingming;
// 商品数量
private Integer shangpinshuliang;
// 入库时间
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date rukushijian;
// 是否完好
private String shifouwanhao;
// 备注
private String beizhu;
// 员工工号
private String yuangonggonghao;
// 员工姓名
private String yuangongxingming;
// 是否审核
private String sfsh;
// 审核回复
private String shhf;
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date addtime;
public Date getAddtime() {
return addtime;
}
public void setAddtime(Date addtime) {
this.addtime = addtime;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
//设置:商品名称
public void setShangpinmingcheng(String shangpinmingcheng) {
this.shangpinmingcheng = shangpinmingcheng;
}
// 获取:商品名称
public String getShangpinmingcheng() {
return shangpinmingcheng;
}
//设置:商品类型
public void setShangpinleixing(String shangpinleixing) {
this.shangpinleixing = shangpinleixing;
}
// 获取:商品类型
public String getShangpinleixing() {
return shangpinleixing;
}
// 设置:供应商姓名
public void setGongyingshangxingming(String gongyingshangxingming) {
this.gongyingshangxingming = gongyingshangxingming;
}
// 获取:供应商姓名
public String getGongyingshangxingming() {
return gongyingshangxingming;
}
// 设置:商品数量
public void setShangpinshuliang(Integer shangpinshuliang) {
this.shangpinshuliang = shangpinshuliang;
}
// 获取:商品数量
public Integer getShangpinshuliang() {
return shangpinshuliang;
}
//设置:入库时间
public void setRukushijian(Date rukushijian) {
this.rukushijian = rukushijian;
}
// 获取:入库时间
public Date getRukushijian() {
return rukushijian;
}
// 设置:是否完好
public void setShifouwanhao(String shifouwanhao) {
this.shifouwanhao = shifouwanhao;
}
// 获取:是否完好
public String getShifouwanhao() {
return shifouwanhao;
}
// 设置:备注
public void setBeizhu(String beizhu) {
this.beizhu = beizhu;
}
// 获取:备注
public String getBeizhu() {
return beizhu;
}
// 设置:员工工号
public void setYuangonggonghao(String yuangonggonghao) {
this.yuangonggonghao = yuangonggonghao;
}
//获取:员工工号
public String getYuangonggonghao() {
return yuangonggonghao;
}
//设置:员工姓名
public void setYuangongxingming(String yuangongxingming) {
this.yuangongxingming = yuangongxingming;
}
// 获取:员工姓名
public String getYuangongxingming() {
return yuangongxingming;
}
// 设置:是否审核
public void setSfsh(String sfsh) {
this.sfsh = sfsh;
}
// 获取:是否审核
public String getSfsh() {
return sfsh;
}
// 设置:审核回复
public void setShhf(String shhf) {
this.shhf = shhf;
}
// 获取:审核回复
public String getShhf() {
return shhf;
}
}

@ -1,158 +0,0 @@
package com.entity;
// 导入 Serializable 接口,实现该接口的类的对象可进行序列化和反序列化操作
import java.io.Serializable;
// 导入 Date 类,用于处理日期和时间
import java.util.Date;
// 导入 MyBatis-Plus 的 TableId 注解,用于指定主键
import com.baomidou.mybatisplus.annotations.TableId;
// 导入 MyBatis-Plus 的 TableName 注解,用于指定实体类对应的数据库表名
import com.baomidou.mybatisplus.annotations.TableName;
// 导入 MyBatis-Plus 的 IdType 枚举,用于指定主键的生成类型
import com.baomidou.mybatisplus.enums.IdType;
// token表
// 该类作为 token 表的实体类,用于映射数据库中 token 表的字段和操作
// 使用 TableName 注解指定该实体类对应的数据库表名为 "token"
@TableName("token")
public class TokenEntity implements Serializable {
// 定义序列化版本号,用于在反序列化时验证类的版本一致性
private static final long serialVersionUID = 1L;
// 使用 TableId 注解指定该字段为主键,且主键生成类型为自动递增
@TableId(type = IdType.AUTO)
private Long id;
// 用户id
private Long userid;
// 用户名
private String username;
//表名
private String tablename;
// 角色
private String role;
// token
private String token;
// 过期时间
private Date expiratedtime;
// 新增时间
private Date addtime;
// 获取主键 ID 的方法
public Long getId() {
return id;
}
// 设置主键 ID 的方法
public void setId(Long id) {
this.id = id;
}
// 获取用户 ID 的方法
public Long getUserid() {
return userid;
}
// 设置用户 ID 的方法
public void setUserid(Long userid) {
this.userid = userid;
}
// 获取用户角色的方法
public String getRole() {
return role;
}
// 设置用户角色的方法
public void setRole(String role) {
this.role = role;
}
// 获取 token 的方法
public String getToken() {
return token;
}
// 获取表名的方法
public String getTablename() {
return tablename;
}
// 设置表名的方法
public void setTablename(String tablename) {
this.tablename = tablename;
}
// 设置 token 的方法
public void setToken(String token) {
this.token = token;
}
// 获取 token 过期时间的方法
public Date getExpiratedtime() {
return expiratedtime;
}
// 设置 token 过期时间的方法
public void setExpiratedtime(Date expiratedtime) {
this.expiratedtime = expiratedtime;
}
// 获取新增时间的方法
public Date getAddtime() {
return addtime;
}
// 设置新增时间的方法
public void setAddtime(Date addtime) {
this.addtime = addtime;
}
// 获取用户名的方法
public String getUsername() {
return username;
}
// 设置用户名的方法
public void setUsername(String username) {
this.username = username;
}
//有参构造函数
// @param userid 用户 ID
//@param username 用户名
//@param tablename 表名
// @param role 用户角色
//@param token token 值
// @param expiratedtime token 过期时间
public TokenEntity(Long userid, String username, String tablename, String role, String token, Date expiratedtime) {
super();
this.userid = userid;
this.username = username;
this.tablename = tablename;
this.role = role;
this.token = token;
this.expiratedtime = expiratedtime;
}
// 无参构造函数
public TokenEntity() {
}
}

@ -1,92 +0,0 @@
package com.entity;
// 导入 Serializable 接口,实现该接口的类的对象可以进行序列化和反序列化操作
import java.io.Serializable;
// 导入 Date 类,用于表示日期和时间
import java.util.Date;
// 导入 MyBatis-Plus 的 TableId 注解,用于指定主键
import com.baomidou.mybatisplus.annotations.TableId;
// 导入 MyBatis-Plus 的 TableName 注解,用于指定实体类对应的数据库表名
import com.baomidou.mybatisplus.annotations.TableName;
// 导入 MyBatis-Plus 的 IdType 枚举,用于指定主键的生成类型
import com.baomidou.mybatisplus.enums.IdType;
// 用户
//该类是一个实体类,用于映射数据库中的用户信息表
// 使用 TableName 注解指定该实体类对应的数据库表名为 "users"
@TableName("users")
public class UserEntity implements Serializable {
// 定义序列化版本号,用于在反序列化时验证类的版本一致性
private static final long serialVersionUID = 1L;
// 使用 TableId 注解指定该字段为主键,且主键生成类型为自动递增
@TableId(type = IdType.AUTO)
private Long id;
// 用户账号
private String username;
// 密码
private String password;
//用户类型
private String role;
// 用户信息添加时间
private Date addtime;
// 获取用户账号的方法
public String getUsername() {
return username;
}
// 设置用户账号的方法
public void setUsername(String username) {
this.username = username;
}
// 获取用户密码的方法
public String getPassword() {
return password;
}
// 设置用户密码的方法
public void setPassword(String password) {
this.password = password;
}
// 获取用户类型的方法
public String getRole() {
return role;
}
// 设置用户类型的方法
public void setRole(String role) {
this.role = role;
}
// 获取用户信息添加时间的方法
public Date getAddtime() {
return addtime;
}
// 设置用户信息添加时间的方法
public void setAddtime(Date addtime) {
this.addtime = addtime;
}
// 获取用户主键 ID 的方法
public Long getId() {
return id;
}
// 设置用户主键 ID 的方法
public void setId(Long id) {
this.id = id;
}
}

@ -1,159 +0,0 @@
package com.entity.model;
import com.entity.ChengbenjieyuEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
// 成本结余
// 接收传参的实体类
//(实际开发中配合移动端接口开发手动去掉些没用的字段, 后端一般用entity就够用了
// 取自ModelAndView 的model名称
// @author
// @email
// @date 2021-04-24 15:19:31
public class ChengbenjieyuModel implements Serializable {
private static final long serialVersionUID = 1L;
//收入项目
private String shouruxiangmu;
// 收入金额
private Integer shourujine;
// 支出项目
private String zhichuxiangmu;
//支出金额
private Integer zhichujine;
// 结余金额
private String jieyujine;
// 日期
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date riqi;
// 设置:收入项目
public void setShouruxiangmu(String shouruxiangmu) {
this.shouruxiangmu = shouruxiangmu;
}
// 获取:收入项目
public String getShouruxiangmu() {
return shouruxiangmu;
}
//设置:收入金额
public void setShourujine(Integer shourujine) {
this.shourujine = shourujine;
}
//获取:收入金额
public Integer getShourujine() {
return shourujine;
}
//设置:支出项目
public void setZhichuxiangmu(String zhichuxiangmu) {
this.zhichuxiangmu = zhichuxiangmu;
}
// 获取:支出项目
public String getZhichuxiangmu() {
return zhichuxiangmu;
}
//设置:支出金额
public void setZhichujine(Integer zhichujine) {
this.zhichujine = zhichujine;
}
// 获取:支出金额
public Integer getZhichujine() {
return zhichujine;
}
// 设置:结余金额
public void setJieyujine(String jieyujine) {
this.jieyujine = jieyujine;
}
//获取:结余金额
public String getJieyujine() {
return jieyujine;
}
// 设置:日期
public void setRiqi(Date riqi) {
this.riqi = riqi;
}
// 获取:日期
public Date getRiqi() {
return riqi;
}
}

@ -1,194 +0,0 @@
package com.entity.model;
import com.entity.ShangpinchukuEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
//商品出库
// 接收传参的实体类
//(实际开发中配合移动端接口开发手动去掉些没用的字段, 后端一般用entity就够用了
// 取自ModelAndView 的model名称
// @author
//@email
// @date 2021-04-24 15:19:31
public class ShangpinchukuModel implements Serializable {
private static final long serialVersionUID = 1L;
// 商品类型
private String shangpinleixing;
// 客户姓名
private String kehuxingming;
//商品数量
private Integer shangpinshuliang;
// 出库时间
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date chukushijian;
// 备注
private String beizhu;
//员工工号
private String yuangonggonghao;
//员工姓名
private String yuangongxingming;
// 是否审核
private String sfsh;
// 审核回复
private String shhf;
// 设置:商品类型
public void setShangpinleixing(String shangpinleixing) {
this.shangpinleixing = shangpinleixing;
}
// 获取:商品类型
public String getShangpinleixing() {
return shangpinleixing;
}
// 设置:客户姓名
public void setKehuxingming(String kehuxingming) {
this.kehuxingming = kehuxingming;
}
// 获取:客户姓名
public String getKehuxingming() {
return kehuxingming;
}
// 设置:商品数量
public void setShangpinshuliang(Integer shangpinshuliang) {
this.shangpinshuliang = shangpinshuliang;
}
// 获取:商品数量
public Integer getShangpinshuliang() {
return shangpinshuliang;
}
//设置:出库时间
public void setChukushijian(Date chukushijian) {
this.chukushijian = chukushijian;
}
// 获取:出库时间
public Date getChukushijian() {
return chukushijian;
}
//设置:备注
public void setBeizhu(String beizhu) {
this.beizhu = beizhu;
}
// 获取:备注
public String getBeizhu() {
return beizhu;
}
// 设置:员工工号
public void setYuangonggonghao(String yuangonggonghao) {
this.yuangonggonghao = yuangonggonghao;
}
// 获取:员工工号
public String getYuangonggonghao() {
return yuangonggonghao;
}
//设置:员工姓名
public void setYuangongxingming(String yuangongxingming) {
this.yuangongxingming = yuangongxingming;
}
//获取:员工姓名
public String getYuangongxingming() {
return yuangongxingming;
}
// 设置:是否审核
public void setSfsh(String sfsh) {
this.sfsh = sfsh;
}
//获取:是否审核
public String getSfsh() {
return sfsh;
}
// 设置:审核回复
public void setShhf(String shhf) {
this.shhf = shhf;
}
// 获取:审核回复
public String getShhf() {
return shhf;
}
}

@ -1,140 +0,0 @@
package com.entity.model;
import com.entity.ShangpinkucunEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
//商品库存
// 接收传参的实体类
//(实际开发中配合移动端接口开发手动去掉些没用的字段, 后端一般用entity就够用了
// 取自ModelAndView 的model名称
// @author
// @email
// @date 2021-04-24 15:19:31
public class ShangpinkucunModel implements Serializable {
private static final long serialVersionUID = 1L;
//商品类型
private String shangpinleixing;
// 商品数量
private Integer shangpinshuliang;
//商品详情
private String shangpinxiangqing;
//存放位置
private String cunfangweizhi;
// 是否完好
private String shifouwanhao;
//登记日期
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date dengjiriqi;
// 设置:商品类型
public void setShangpinleixing(String shangpinleixing) {
this.shangpinleixing = shangpinleixing;
}
// 获取:商品类型
public String getShangpinleixing() {
return shangpinleixing;
}
// 设置:商品数量
public void setShangpinshuliang(Integer shangpinshuliang) {
this.shangpinshuliang = shangpinshuliang;
}
// 获取:商品数量
public Integer getShangpinshuliang() {
return shangpinshuliang;
}
// 设置:商品详情
public void setShangpinxiangqing(String shangpinxiangqing) {
this.shangpinxiangqing = shangpinxiangqing;
}
// 获取:商品详情
public String getShangpinxiangqing() {
return shangpinxiangqing;
}
// 设置:存放位置
public void setCunfangweizhi(String cunfangweizhi) {
this.cunfangweizhi = cunfangweizhi;
}
//获取:存放位置
public String getCunfangweizhi() {
return cunfangweizhi;
}
//设置:是否完好
public void setShifouwanhao(String shifouwanhao) {
this.shifouwanhao = shifouwanhao;
}
// 获取:是否完好
public String getShifouwanhao() {
return shifouwanhao;
}
// 设置:登记日期
public void setDengjiriqi(Date dengjiriqi) {
this.dengjiriqi = dengjiriqi;
}
// 获取:登记日期
public Date getDengjiriqi() {
return dengjiriqi;
}
}

@ -1,23 +0,0 @@
package com.entity.model;
import com.entity.ShangpinleixingEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
// 商品类型
//(实际开发中配合移动端接口开发手动去掉些没用的字段, 后端一般用entity就够用了
// 取自ModelAndView 的model名称
// @author
// @email
// @date 2021-04-24 15:19:31
public class ShangpinleixingModel implements Serializable {
private static final long serialVersionUID = 1L;
}

@ -1,214 +0,0 @@
package com.entity.model;
import com.entity.ShangpinrukuEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
// 商品入库
// 接收传参的实体类
//(实际开发中配合移动端接口开发手动去掉些没用的字段, 后端一般用entity就够用了
// @author
// @email
// @date 2021-04-24 15:19:31
public class ShangpinrukuModel implements Serializable {
private static final long serialVersionUID = 1L;
// 商品类型
private String shangpinleixing;
//供应商姓名
private String gongyingshangxingming;
// 商品数量
private Integer shangpinshuliang;
//入库时间
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date rukushijian;
//是否完好
private String shifouwanhao;
// 备注
private String beizhu;
//员工工号
private String yuangonggonghao;
//员工姓名
private String yuangongxingming;
// 是否审核
private String sfsh;
// 审核回复
private String shhf;
//设置:商品类型
public void setShangpinleixing(String shangpinleixing) {
this.shangpinleixing = shangpinleixing;
}
// 获取:商品类型
public String getShangpinleixing() {
return shangpinleixing;
}
//设置:供应商姓名
public void setGongyingshangxingming(String gongyingshangxingming) {
this.gongyingshangxingming = gongyingshangxingming;
}
// 获取:供应商姓名
public String getGongyingshangxingming() {
return gongyingshangxingming;
}
//设置:商品数量
public void setShangpinshuliang(Integer shangpinshuliang) {
this.shangpinshuliang = shangpinshuliang;
}
//获取:商品数量
public Integer getShangpinshuliang() {
return shangpinshuliang;
}
//设置:入库时间
public void setRukushijian(Date rukushijian) {
this.rukushijian = rukushijian;
}
// 获取:入库时间
public Date getRukushijian() {
return rukushijian;
}
// 设置:是否完好
public void setShifouwanhao(String shifouwanhao) {
this.shifouwanhao = shifouwanhao;
}
//获取:是否完好
public String getShifouwanhao() {
return shifouwanhao;
}
//设置:备注
public void setBeizhu(String beizhu) {
this.beizhu = beizhu;
}
//获取:备注
public String getBeizhu() {
return beizhu;
}
//设置:员工工号
public void setYuangonggonghao(String yuangonggonghao) {
this.yuangonggonghao = yuangonggonghao;
}
//获取:员工工号
public String getYuangonggonghao() {
return yuangonggonghao;
}
//设置:员工姓名
public void setYuangongxingming(String yuangongxingming) {
this.yuangongxingming = yuangongxingming;
}
//获取:员工姓名
public String getYuangongxingming() {
return yuangongxingming;
}
//设置:是否审核
public void setSfsh(String sfsh) {
this.sfsh = sfsh;
}
//获取:是否审核
public String getSfsh() {
return sfsh;
}
//设置:审核回复
public void setShhf(String shhf) {
this.shhf = shhf;
}
// 获取:审核回复
public String getShhf() {
return shhf;
}
}

@ -1,48 +0,0 @@
package com.entity.view;
// 引入成本结余实体类
import com.entity.ChengbenjieyuEntity;
// MyBatis-Plus 注解,指定该实体类对应的数据库表名
import com.baomidou.mybatisplus.annotations.TableName;
// Apache Commons BeanUtils 工具类,用于对象属性的复制
import org.apache.commons.beanutils.BeanUtils;
// 反射调用方法时可能抛出的异常类
import java.lang.reflect.InvocationTargetException;
// 实现 Serializable 接口,使该类的对象可以被序列化
import java.io.Serializable;
// 成本结余
// 后端返回视图实体辅助类
// (通常后端关联的表或者自定义的字段需要返回使用)
// @author
// @email
// @date 2021-04-24 15:19:31
// 指定该视图实体类对应数据库中的表名为 "chengbenjieyu"
@TableName("chengbenjieyu")
// 继承自 ChengbenjieyuEntity同时实现 Serializable 接口
public class ChengbenjieyuView extends ChengbenjieyuEntity implements Serializable {
// 序列化版本号,用于在反序列化时验证版本一致性
private static final long serialVersionUID = 1L;
// 无参构造函数,用于创建一个空的 ChengbenjieyuView 对象
public ChengbenjieyuView() {
}
// 有参构造函数,根据传入的 ChengbenjieyuEntity 对象创建 ChengbenjieyuView 对象
// @param chengbenjieyuEntity 成本结余实体对象
public ChengbenjieyuView(ChengbenjieyuEntity chengbenjieyuEntity) {
try {
// 使用 BeanUtils.copyProperties 方法将传入的 chengbenjieyuEntity 对象的属性复制到当前对象
// 这样可以方便地将实体类的属性值传递给视图类
BeanUtils.copyProperties(this, chengbenjieyuEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// 当出现非法访问异常或反射调用目标方法异常时,打印异常堆栈信息
// 这里的异常处理可以进一步完善,例如记录日志或抛出自定义异常
e.printStackTrace();
}
}
}

@ -1,44 +0,0 @@
package com.entity.view;
// 导入商品出库实体类,该类可能包含商品出库相关的属性和业务逻辑
import com.entity.ShangpinchukuEntity;
// 导入 MyBatis-Plus 的注解,用于指定数据库表名
import com.baomidou.mybatisplus.annotations.TableName;
// 导入 Apache Commons BeanUtils 工具类,用于对象属性的复制操作
import org.apache.commons.beanutils.BeanUtils;
// 导入反射调用方法时可能抛出的异常类
import java.lang.reflect.InvocationTargetException;
// 导入可序列化接口,使该类的对象能够进行序列化操作
import java.io.Serializable;
// 商品出库
//后端返回视图实体辅助类
// (通常后端关联的表或者自定义的字段需要返回使用)
// @author
//@email
// @date 2021-04-24 15:19:31
// 使用注解指定该视图实体类对应的数据库表名为 "shangpinchuku"
@TableName("shangpinchuku")
// 该类继承自商品出库实体类,并实现了可序列化接口
public class ShangpinchukuView extends ShangpinchukuEntity implements Serializable {
// 定义序列化版本号,用于在反序列化时验证类的版本一致性
private static final long serialVersionUID = 1L;
// 无参构造函数,用于创建一个空的商品出库视图对象
public ShangpinchukuView() {
}
// 有参构造函数,接受一个商品出库实体对象作为参数
public ShangpinchukuView(ShangpinchukuEntity shangpinchukuEntity) {
try {
// 使用 BeanUtils 的 copyProperties 方法将传入的商品出库实体对象的属性复制到当前视图对象中
BeanUtils.copyProperties(this, shangpinchukuEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// 如果在属性复制过程中发生非法访问异常(例如访问权限不足)或调用目标方法异常(例如反射调用失败)
// 则打印异常堆栈信息,以便开发者排查问题。在实际应用中,可进一步优化异常处理逻辑,如记录日志等
e.printStackTrace();
}
}
}

@ -1,48 +0,0 @@
package com.entity.view;
// 引入商品库存实体类,该类包含了商品库存的相关属性和方法
import com.entity.ShangpinkucunEntity;
// 引入 MyBatis-Plus 框架的 TableName 注解,用于指定实体类对应的数据库表名
import com.baomidou.mybatisplus.annotations.TableName;
// 引入 Apache Commons BeanUtils 工具类,用于实现对象属性的复制
import org.apache.commons.beanutils.BeanUtils;
// 引入反射调用方法时可能抛出的异常类
import java.lang.reflect.InvocationTargetException;
// 引入 Serializable 接口,实现该接口的类的对象可以进行序列化和反序列化操作
import java.io.Serializable;
//商品库存
//后端返回视图实体辅助类
// (通常后端关联的表或者自定义的字段需要返回使用)
// @author
//@email
//@date 2021-04-24 15:19:31
// 使用 TableName 注解指定该视图实体类对应的数据库表名为 "shangpinkucun"
@TableName("shangpinkucun")
// 继承自 ShangpinkucunEntity 类,同时实现 Serializable 接口
public class ShangpinkucunView extends ShangpinkucunEntity implements Serializable {
// 定义序列化版本号,用于在反序列化时验证类的版本一致性
private static final long serialVersionUID = 1L;
// 无参构造函数,用于创建一个空的 ShangpinkucunView 对象
public ShangpinkucunView() {
}
// 有参构造函数,根据传入的 ShangpinkucunEntity 对象创建 ShangpinkucunView 对象
// @param shangpinkucunEntity 商品库存实体对象
public ShangpinkucunView(ShangpinkucunEntity shangpinkucunEntity) {
try {
// 使用 BeanUtils.copyProperties 方法将传入的 shangpinkucunEntity 对象的属性复制到当前对象
// 这样可以方便地将实体类的属性值传递给视图类,避免手动逐个设置属性
BeanUtils.copyProperties(this, shangpinkucunEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// 当出现非法访问异常(如访问私有属性)或反射调用目标方法异常(如方法不存在)时
// 打印异常堆栈信息,方便开发者定位问题。在实际应用中,可考虑将异常信息记录到日志文件中
e.printStackTrace();
}
}
}

@ -1,48 +0,0 @@
package com.entity.view;
// 导入商品类型实体类,这个类包含了商品类型的基本属性和方法
import com.entity.ShangpinleixingEntity;
// 导入 MyBatis-Plus 框架的 TableName 注解,用于指定该实体类对应的数据库表名
import com.baomidou.mybatisplus.annotations.TableName;
// 导入 Apache Commons BeanUtils 工具类,用于将一个 JavaBean 对象的属性复制到另一个 JavaBean 对象
import org.apache.commons.beanutils.BeanUtils;
// 导入反射调用方法时可能抛出的异常类
import java.lang.reflect.InvocationTargetException;
// 导入 Serializable 接口,实现该接口的类的对象可以被序列化,以便在网络传输或持久化存储中使用
import java.io.Serializable;
// 商品类型
// 后端返回视图实体辅助类
//(通常后端关联的表或者自定义的字段需要返回使用)
// @author
// @email
//@date 2021-04-24 15:19:31
// 使用 TableName 注解指定该视图实体类对应数据库中的 "shangpinleixing" 表
@TableName("shangpinleixing")
// 继承自 ShangpinleixingEntity 类,同时实现 Serializable 接口
public class ShangpinleixingView extends ShangpinleixingEntity implements Serializable {
// 定义序列化版本号,用于在反序列化时验证类的版本一致性
private static final long serialVersionUID = 1L;
//无参构造函数,用于创建一个空的 ShangpinleixingView 对象
public ShangpinleixingView() {
}
//有参构造函数,根据传入的 ShangpinleixingEntity 对象创建 ShangpinleixingView 对象
// @param shangpinleixingEntity 商品类型实体对象
public ShangpinleixingView(ShangpinleixingEntity shangpinleixingEntity) {
try {
// 使用 BeanUtils.copyProperties 方法将传入的 shangpinleixingEntity 对象的属性复制到当前对象
// 这样可以避免手动逐个复制属性,提高代码的可维护性
BeanUtils.copyProperties(this, shangpinleixingEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// 当复制属性过程中出现非法访问异常(如访问私有属性)或反射调用目标方法异常(如方法不存在)时
// 打印异常堆栈信息,方便开发者定位问题。在实际项目中,建议将异常信息记录到日志文件中
e.printStackTrace();
}
}
}

@ -1,47 +0,0 @@
package com.entity.view;
// 导入商品入库实体类,该类定义了商品入库信息的相关属性和方法
import com.entity.ShangpinrukuEntity;
// 导入 MyBatis-Plus 的 TableName 注解,用于指定该实体类对应的数据库表名
import com.baomidou.mybatisplus.annotations.TableName;
// 导入 Apache Commons BeanUtils 工具类,用于将一个 JavaBean 对象的属性复制到另一个 JavaBean 对象
import org.apache.commons.beanutils.BeanUtils;
// 导入反射调用方法时可能抛出的异常类
import java.lang.reflect.InvocationTargetException;
// 导入 Serializable 接口,实现该接口的类的对象可以进行序列化和反序列化操作
import java.io.Serializable;
//商品入库
// 后端返回视图实体辅助类
// (通常后端关联的表或者自定义的字段需要返回使用)
// @email
// @date 2021-04-24 15:19:31
// 使用 TableName 注解指定该视图实体类对应的数据库表名为 "shangpinruku"
@TableName("shangpinruku")
// 继承自 ShangpinrukuEntity 类,同时实现 Serializable 接口
public class ShangpinrukuView extends ShangpinrukuEntity implements Serializable {
// 定义序列化版本号,用于在反序列化时验证类的版本一致性
private static final long serialVersionUID = 1L;
// 无参构造函数,用于创建一个空的 ShangpinrukuView 对象
public ShangpinrukuView() {
}
//有参构造函数,根据传入的 ShangpinrukuEntity 对象创建 ShangpinrukuView 对象
// @param shangpinrukuEntity 商品入库实体对象
public ShangpinrukuView(ShangpinrukuEntity shangpinrukuEntity) {
try {
// 使用 BeanUtils.copyProperties 方法将传入的 shangpinrukuEntity 对象的属性复制到当前对象
// 这样可以避免手动逐个复制属性,提高代码的可维护性
BeanUtils.copyProperties(this, shangpinrukuEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// 当复制属性过程中出现非法访问异常(如访问私有属性)或反射调用目标方法异常(如方法不存在)时
// 打印异常堆栈信息,方便开发者定位问题。在实际项目中,建议将异常信息记录到日志文件中
e.printStackTrace();
}
}
}

@ -1,140 +0,0 @@
package com.entity.vo;
import com.entity.ChengbenjieyuEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
//成本结余
// 手机端接口返回实体辅助类
// (主要作用去除一些不必要的字段)
// @author
// @email
//@date 2021-04-24 15:19:31
public class ChengbenjieyuVO implements Serializable {
private static final long serialVersionUID = 1L;
// 收入项目
private String shouruxiangmu;
// 收入金额
private Integer shourujine;
// 支出项目
private String zhichuxiangmu;
//支出金额
private Integer zhichujine;
//结余金额
private String jieyujine;
// 日期
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date riqi;
// 设置:收入项目
public void setShouruxiangmu(String shouruxiangmu) {
this.shouruxiangmu = shouruxiangmu;
}
// 获取:收入项目
public String getShouruxiangmu() {
return shouruxiangmu;
}
//设置:收入金额
public void setShourujine(Integer shourujine) {
this.shourujine = shourujine;
}
// 获取:收入金额
public Integer getShourujine() {
return shourujine;
}
// 设置:支出项目
public void setZhichuxiangmu(String zhichuxiangmu) {
this.zhichuxiangmu = zhichuxiangmu;
}
// 获取:支出项目
public String getZhichuxiangmu() {
return zhichuxiangmu;
}
// 设置:支出金额
public void setZhichujine(Integer zhichujine) {
this.zhichujine = zhichujine;
}
// 获取:支出金额
public Integer getZhichujine() {
return zhichujine;
}
// 设置:结余金额
public void setJieyujine(String jieyujine) {
this.jieyujine = jieyujine;
}
//获取:结余金额
public String getJieyujine() {
return jieyujine;
}
// 设置:日期
public void setRiqi(Date riqi) {
this.riqi = riqi;
}
// 获取:日期
public Date getRiqi() {
return riqi;
}
}

@ -1,140 +0,0 @@
package com.entity.vo;
import com.entity.JizhangpingzhengEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
//记账凭证
//手机端接口返回实体辅助类
// (主要作用去除一些不必要的字段)
// @author
// @email
// @date 2021-04-24 15:19:31
public class JizhangpingzhengVO implements Serializable {
private static final long serialVersionUID = 1L;
// 凭证名称
private String pingzhengmingcheng;
//类型
private String leixing;
//凭证内容
private String pingzhengneirong;
// 登记日期
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date dengjiriqi;
//附件
private String fujian;
//备注
private String beizhu;
//设置:凭证名称
public void setPingzhengmingcheng(String pingzhengmingcheng) {
this.pingzhengmingcheng = pingzhengmingcheng;
}
//获取:凭证名称
public String getPingzhengmingcheng() {
return pingzhengmingcheng;
}
// 设置:类型
public void setLeixing(String leixing) {
this.leixing = leixing;
}
// 获取:类型
public String getLeixing() {
return leixing;
}
//设置:凭证内容
public void setPingzhengneirong(String pingzhengneirong) {
this.pingzhengneirong = pingzhengneirong;
}
// 获取:凭证内容
public String getPingzhengneirong() {
return pingzhengneirong;
}
//设置:登记日期
public void setDengjiriqi(Date dengjiriqi) {
this.dengjiriqi = dengjiriqi;
}
// 获取:登记日期
public Date getDengjiriqi() {
return dengjiriqi;
}
// 设置:附件
public void setFujian(String fujian) {
this.fujian = fujian;
}
//获取:附件
public String getFujian() {
return fujian;
}
// 设置:备注
public void setBeizhu(String beizhu) {
this.beizhu = beizhu;
}
//获取:备注
public String getBeizhu() {
return beizhu;
}
}

@ -1,159 +0,0 @@
package com.entity.vo;
import com.entity.RijizhangEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
// 日记账
//手机端接口返回实体辅助类
// (主要作用去除一些不必要的字段)
// @author
//@email
//@date 2021-04-24 15:19:31
public class RijizhangVO implements Serializable {
private static final long serialVersionUID = 1L;
// 日期
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date riqi;
//摘要
private String zhaiyao;
// 收入
private Integer shouru;
// 支出
private Integer zhichu;
// 金额
private String jine;
// 管理工号
private String guanligonghao;
//管理姓名
private String guanlixingming;
//设置:日期
public void setRiqi(Date riqi) {
this.riqi = riqi;
}
//获取:日期
public Date getRiqi() {
return riqi;
}
//设置:摘要
public void setZhaiyao(String zhaiyao) {
this.zhaiyao = zhaiyao;
}
// 获取:摘要
public String getZhaiyao() {
return zhaiyao;
}
//设置:收入
public void setShouru(Integer shouru) {
this.shouru = shouru;
}
//获取:收入
public Integer getShouru() {
return shouru;
}
// 设置:支出
public void setZhichu(Integer zhichu) {
this.zhichu = zhichu;
}
//获取:支出
public Integer getZhichu() {
return zhichu;
}
// 设置:金额
public void setJine(String jine) {
this.jine = jine;
}
// 获取:金额
public String getJine() {
return jine;
}
//设置:管理工号
public void setGuanligonghao(String guanligonghao) {
this.guanligonghao = guanligonghao;
}
// 获取:管理工号
public String getGuanligonghao() {
return guanligonghao;
}
// 设置:管理姓名
public void setGuanlixingming(String guanlixingming) {
this.guanlixingming = guanlixingming;
}
// 获取:管理姓名
public String getGuanlixingming() {
return guanlixingming;
}
}

@ -1,197 +0,0 @@
package com.entity.vo;
import com.entity.ShangpinchukuEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
//商品出库
// 手机端接口返回实体辅助类
//(主要作用去除一些不必要的字段)
//@author
//@email
//@date 2021-04-24 15:19:31
public class ShangpinchukuVO implements Serializable {
private static final long serialVersionUID = 1L;
// 商品类型
private String shangpinleixing;
//客户姓名
private String kehuxingming;
// 商品数量
private Integer shangpinshuliang;
//出库时间
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date chukushijian;
//备注
private String beizhu;
//员工工号
private String yuangonggonghao;
// 员工姓名
private String yuangongxingming;
// 是否审核
private String sfsh;
//审核回复
private String shhf;
//设置:商品类型
public void setShangpinleixing(String shangpinleixing) {
this.shangpinleixing = shangpinleixing;
}
// 获取:商品类型
public String getShangpinleixing() {
return shangpinleixing;
}
//设置:客户姓名
public void setKehuxingming(String kehuxingming) {
this.kehuxingming = kehuxingming;
}
//获取:客户姓名
public String getKehuxingming() {
return kehuxingming;
}
//设置:商品数量
public void setShangpinshuliang(Integer shangpinshuliang) {
this.shangpinshuliang = shangpinshuliang;
}
// 获取:商品数量
public Integer getShangpinshuliang() {
return shangpinshuliang;
}
//设置:出库时间
public void setChukushijian(Date chukushijian) {
this.chukushijian = chukushijian;
}
// 获取:出库时间
public Date getChukushijian() {
return chukushijian;
}
//设置:备注
public void setBeizhu(String beizhu) {
this.beizhu = beizhu;
}
//获取:备注
public String getBeizhu() {
return beizhu;
}
//设置:员工工号
public void setYuangonggonghao(String yuangonggonghao) {
this.yuangonggonghao = yuangonggonghao;
}
// 获取:员工工号
public String getYuangonggonghao() {
return yuangonggonghao;
}
// 设置:员工姓名
public void setYuangongxingming(String yuangongxingming) {
this.yuangongxingming = yuangongxingming;
}
//获取:员工姓名
public String getYuangongxingming() {
return yuangongxingming;
}
//设置:是否审核
public void setSfsh(String sfsh) {
this.sfsh = sfsh;
}
//获取:是否审核
public String getSfsh() {
return sfsh;
}
// 设置:审核回复
public void setShhf(String shhf) {
this.shhf = shhf;
}
// 获取:审核回复
public String getShhf() {
return shhf;
}
}

@ -1,139 +0,0 @@
package com.entity.vo;
import com.entity.ShangpinkucunEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
// 商品库存
// 手机端接口返回实体辅助类
// (主要作用去除一些不必要的字段)
// @author
// @email
//@date 2021-04-24 15:19:31
public class ShangpinkucunVO implements Serializable {
private static final long serialVersionUID = 1L;
// 商品类型
private String shangpinleixing;
//商品数量
private Integer shangpinshuliang;
// 商品详情
private String shangpinxiangqing;
//存放位置
private String cunfangweizhi;
//是否完好
private String shifouwanhao;
// 登记日期
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date dengjiriqi;
// 设置:商品类型
public void setShangpinleixing(String shangpinleixing) {
this.shangpinleixing = shangpinleixing;
}
// 获取:商品类型
public String getShangpinleixing() {
return shangpinleixing;
}
//设置:商品数量
public void setShangpinshuliang(Integer shangpinshuliang) {
this.shangpinshuliang = shangpinshuliang;
}
//获取:商品数量
public Integer getShangpinshuliang() {
return shangpinshuliang;
}
// 设置:商品详情
public void setShangpinxiangqing(String shangpinxiangqing) {
this.shangpinxiangqing = shangpinxiangqing;
}
// 获取:商品详情
public String getShangpinxiangqing() {
return shangpinxiangqing;
}
// 设置:存放位置
public void setCunfangweizhi(String cunfangweizhi) {
this.cunfangweizhi = cunfangweizhi;
}
// 获取:存放位置
public String getCunfangweizhi() {
return cunfangweizhi;
}
// 设置:是否完好
public void setShifouwanhao(String shifouwanhao) {
this.shifouwanhao = shifouwanhao;
}
// 获取:是否完好
public String getShifouwanhao() {
return shifouwanhao;
}
// 设置:登记日期
public void setDengjiriqi(Date dengjiriqi) {
this.dengjiriqi = dengjiriqi;
}
// 获取:登记日期
public Date getDengjiriqi() {
return dengjiriqi;
}
}

@ -1,24 +0,0 @@
package com.entity.vo;
import com.entity.ShangpinleixingEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
// 商品类型
// 手机端接口返回实体辅助类
//(主要作用去除一些不必要的字段)
// @author
// @email
// @date 2021-04-24 15:19:31
public class ShangpinleixingVO implements Serializable {
private static final long serialVersionUID = 1L;
}

@ -1,214 +0,0 @@
package com.entity.vo;
import com.entity.ShangpinrukuEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
// 商品入库
// (主要作用去除一些不必要的字段)
//@author
// @email
// @date 2021-04-24 15:19:31
public class ShangpinrukuVO implements Serializable {
private static final long serialVersionUID = 1L;
// 商品类型
private String shangpinleixing;
//供应商姓名
private String gongyingshangxingming;
//商品数量
private Integer shangpinshuliang;
//入库时间
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date rukushijian;
// 是否完好
private String shifouwanhao;
//备注
private String beizhu;
//员工工号
private String yuangonggonghao;
//员工姓名
private String yuangongxingming;
//是否审核
private String sfsh;
//审核回复
private String shhf;
//设置:商品类型
public void setShangpinleixing(String shangpinleixing) {
this.shangpinleixing = shangpinleixing;
}
// 获取:商品类型
public String getShangpinleixing() {
return shangpinleixing;
}
//设置:供应商姓名
public void setGongyingshangxingming(String gongyingshangxingming) {
this.gongyingshangxingming = gongyingshangxingming;
}
//获取:供应商姓名
public String getGongyingshangxingming() {
return gongyingshangxingming;
}
// 设置:商品数量
public void setShangpinshuliang(Integer shangpinshuliang) {
this.shangpinshuliang = shangpinshuliang;
}
//获取:商品数量
public Integer getShangpinshuliang() {
return shangpinshuliang;
}
// 设置:入库时间
public void setRukushijian(Date rukushijian) {
this.rukushijian = rukushijian;
}
// 获取:入库时间
public Date getRukushijian() {
return rukushijian;
}
// 设置:是否完好
public void setShifouwanhao(String shifouwanhao) {
this.shifouwanhao = shifouwanhao;
}
//获取:是否完好
public String getShifouwanhao() {
return shifouwanhao;
}
//设置:备注
public void setBeizhu(String beizhu) {
this.beizhu = beizhu;
}
//获取:备注
public String getBeizhu() {
return beizhu;
}
// 设置:员工工号
public void setYuangonggonghao(String yuangonggonghao) {
this.yuangonggonghao = yuangonggonghao;
}
//获取:员工工号
public String getYuangonggonghao() {
return yuangonggonghao;
}
//设置:员工姓名
public void setYuangongxingming(String yuangongxingming) {
this.yuangongxingming = yuangongxingming;
}
//获取:员工姓名
public String getYuangongxingming() {
return yuangongxingming;
}
//设置:是否审核
public void setSfsh(String sfsh) {
this.sfsh = sfsh;
}
// 获取:是否审核
public String getSfsh() {
return sfsh;
}
//设置:审核回复
public void setShhf(String shhf) {
this.shhf = shhf;
}
//获取:审核回复
public String getShhf() {
return shhf;
}
}

@ -1,156 +0,0 @@
package com.entity.vo;
import com.entity.YuangongEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
// 员工
// 手机端接口返回实体辅助类
// (主要作用去除一些不必要的字段)
// @author
//@email
//@date 2021-04-24 15:19:31
public class YuangongVO implements Serializable {
private static final long serialVersionUID = 1L;
// 密码
private String mima;
// 员工姓名
private String yuangongxingming;
// 性别
private String xingbie;
//部门
private String bumen;
//手机
private String shouji;
//邮箱
private String youxiang;
// 身份证
private String shenfenzheng;
// 设置:密码
public void setMima(String mima) {
this.mima = mima;
}
// 获取:密码
public String getMima() {
return mima;
}
// 设置:员工姓名
public void setYuangongxingming(String yuangongxingming) {
this.yuangongxingming = yuangongxingming;
}
//获取:员工姓名
public String getYuangongxingming() {
return yuangongxingming;
}
//设置:性别
public void setXingbie(String xingbie) {
this.xingbie = xingbie;
}
// 获取:性别
public String getXingbie() {
return xingbie;
}
// 设置:部门
public void setBumen(String bumen) {
this.bumen = bumen;
}
// 获取:部门
public String getBumen() {
return bumen;
}
// 设置:手机
public void setShouji(String shouji) {
this.shouji = shouji;
}
// 获取:手机
public String getShouji() {
return shouji;
}
// 设置:邮箱
public void setYouxiang(String youxiang) {
this.youxiang = youxiang;
}
//获取:邮箱
public String getYouxiang() {
return youxiang;
}
// 设置:身份证
public void setShenfenzheng(String shenfenzheng) {
this.shenfenzheng = shenfenzheng;
}
// 获取:身份证
public String getShenfenzheng() {
return shenfenzheng;
}
}

@ -1,177 +0,0 @@
package com.entity.vo;
import com.entity.YuangongbaoxiaoEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
//员工报销
// 手机端接口返回实体辅助类
//@author
// @email
//@date 2021-04-24 15:19:31
public class YuangongbaoxiaoVO implements Serializable {
private static final long serialVersionUID = 1L;
//员工姓名
private String yuangongxingming;
// 报销项目
private String baoxiaoxiangmu;
// 报销金额
private Integer baoxiaojine;
//申请日期
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date shenqingriqi;
// 备注
private String beizhu;
// 管理工号
private String guanligonghao;
//管理姓名
private String guanlixingming;
//是否支付
private String ispay;
// 设置:员工姓名
public void setYuangongxingming(String yuangongxingming) {
this.yuangongxingming = yuangongxingming;
}
// 获取:员工姓名
public String getYuangongxingming() {
return yuangongxingming;
}
// 设置:报销项目
public void setBaoxiaoxiangmu(String baoxiaoxiangmu) {
this.baoxiaoxiangmu = baoxiaoxiangmu;
}
// 获取:报销项目
public String getBaoxiaoxiangmu() {
return baoxiaoxiangmu;
}
// 设置:报销金额
public void setBaoxiaojine(Integer baoxiaojine) {
this.baoxiaojine = baoxiaojine;
}
//获取:报销金额
public Integer getBaoxiaojine() {
return baoxiaojine;
}
//设置:申请日期
public void setShenqingriqi(Date shenqingriqi) {
this.shenqingriqi = shenqingriqi;
}
//获取:申请日期
public Date getShenqingriqi() {
return shenqingriqi;
}
// 设置:备注
public void setBeizhu(String beizhu) {
this.beizhu = beizhu;
}
// 获取:备注
public String getBeizhu() {
return beizhu;
}
// 设置:管理工号
public void setGuanligonghao(String guanligonghao) {
this.guanligonghao = guanligonghao;
}
// 获取:管理工号
public String getGuanligonghao() {
return guanligonghao;
}
// 设置:管理姓名
public void setGuanlixingming(String guanlixingming) {
this.guanlixingming = guanlixingming;
}
// 获取:管理姓名
public String getGuanlixingming() {
return guanlixingming;
}
// 设置:是否支付
public void setIspay(String ispay) {
this.ispay = ispay;
}
//获取:是否支付
public String getIspay() {
return ispay;
}
}

@ -1,216 +0,0 @@
package com.entity.vo;
import com.entity.YuangongjiaokuanEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
// 员工缴款
// 手机端接口返回实体辅助类
// (主要作用去除一些不必要的字段)
// @author
//@email
//@date 2021-04-24 15:19:31
public class YuangongjiaokuanVO implements Serializable {
private static final long serialVersionUID = 1L;
// 员工姓名
private String yuangongxingming;
// 缴费名称
private String jiaofeimingcheng;
//缴款金额
private Integer jiaokuanjine;
// 缴款日期
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date jiaokuanriqi;
//备注
private String beizhu;
// 管理工号
private String guanligonghao;
//管理姓名
private String guanlixingming;
//是否审核
private String sfsh;
// 审核回复
private String shhf;
// 是否支付
private String ispay;
// 设置:员工姓名
public void setYuangongxingming(String yuangongxingming) {
this.yuangongxingming = yuangongxingming;
}
//获取:员工姓名
public String getYuangongxingming() {
return yuangongxingming;
}
// 设置:缴费名称
public void setJiaofeimingcheng(String jiaofeimingcheng) {
this.jiaofeimingcheng = jiaofeimingcheng;
}
//获取:缴费名称
public String getJiaofeimingcheng() {
return jiaofeimingcheng;
}
//设置:缴款金额
public void setJiaokuanjine(Integer jiaokuanjine) {
this.jiaokuanjine = jiaokuanjine;
}
//获取:缴款金额
public Integer getJiaokuanjine() {
return jiaokuanjine;
}
// 设置:缴款日期
public void setJiaokuanriqi(Date jiaokuanriqi) {
this.jiaokuanriqi = jiaokuanriqi;
}
//获取:缴款日期
public Date getJiaokuanriqi() {
return jiaokuanriqi;
}
// 设置:备注
public void setBeizhu(String beizhu) {
this.beizhu = beizhu;
}
//获取:备注
public String getBeizhu() {
return beizhu;
}
// 设置:管理工号
public void setGuanligonghao(String guanligonghao) {
this.guanligonghao = guanligonghao;
}
// 获取:管理工号
public String getGuanligonghao() {
return guanligonghao;
}
// 设置:管理姓名
public void setGuanlixingming(String guanlixingming) {
this.guanlixingming = guanlixingming;
}
// 获取:管理姓名
public String getGuanlixingming() {
return guanlixingming;
}
// 设置:是否审核
public void setSfsh(String sfsh) {
this.sfsh = sfsh;
}
// 获取:是否审核
public String getSfsh() {
return sfsh;
}
// 设置:审核回复
public void setShhf(String shhf) {
this.shhf = shhf;
}
// 获取:审核回复
public String getShhf() {
return shhf;
}
// 设置:是否支付
public void setIspay(String ispay) {
this.ispay = ispay;
}
// 获取:是否支付
public String getIspay() {
return ispay;
}
}

@ -1,232 +0,0 @@
package com.entity.vo;
import com.entity.YuangongxinchouEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
// 员工薪酬
// 手机端接口返回实体辅助类
// (主要作用去除一些不必要的字段)
// @author
// @email
// @date 2021-04-24 15:19:31
public class YuangongxinchouVO implements Serializable {
private static final long serialVersionUID = 1L;
// 员工姓名
private String yuangongxingming;
// 基本工资
private Integer jibengongzi;
// 全勤奖励
private Integer quanqinjiangli;
// 绩效奖励
private Integer jixiaojiangli;
// 社保补助
private Integer shebaobuzhu;
//扣款金额
private Integer koukuanjine;
//扣款事项
private String koukuanshixiang;
// 实发工资
private String shifagongzi;
// 日期
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date riqi;
// 管理工号
private String guanligonghao;
// 管理姓名
private String guanlixingming;
// 设置:员工姓名
public void setYuangongxingming(String yuangongxingming) {
this.yuangongxingming = yuangongxingming;
}
//获取:员工姓名
public String getYuangongxingming() {
return yuangongxingming;
}
//设置:基本工资
public void setJibengongzi(Integer jibengongzi) {
this.jibengongzi = jibengongzi;
}
// 获取:基本工资
public Integer getJibengongzi() {
return jibengongzi;
}
//设置:全勤奖励
public void setQuanqinjiangli(Integer quanqinjiangli) {
this.quanqinjiangli = quanqinjiangli;
}
// 获取:全勤奖励
public Integer getQuanqinjiangli() {
return quanqinjiangli;
}
// 设置:绩效奖励
public void setJixiaojiangli(Integer jixiaojiangli) {
this.jixiaojiangli = jixiaojiangli;
}
// 获取:绩效奖励
public Integer getJixiaojiangli() {
return jixiaojiangli;
}
//设置:社保补助
public void setShebaobuzhu(Integer shebaobuzhu) {
this.shebaobuzhu = shebaobuzhu;
}
// 获取:社保补助
public Integer getShebaobuzhu() {
return shebaobuzhu;
}
// 设置:扣款金额
public void setKoukuanjine(Integer koukuanjine) {
this.koukuanjine = koukuanjine;
}
// 获取:扣款金额
public Integer getKoukuanjine() {
return koukuanjine;
}
// 设置:扣款事项
public void setKoukuanshixiang(String koukuanshixiang) {
this.koukuanshixiang = koukuanshixiang;
}
// 获取:扣款事项
public String getKoukuanshixiang() {
return koukuanshixiang;
}
// 设置:实发工资
public void setShifagongzi(String shifagongzi) {
this.shifagongzi = shifagongzi;
}
//获取:实发工资
public String getShifagongzi() {
return shifagongzi;
}
// 设置:日期
public void setRiqi(Date riqi) {
this.riqi = riqi;
}
//获取:日期
public Date getRiqi() {
return riqi;
}
// 设置:管理工号
public void setGuanligonghao(String guanligonghao) {
this.guanligonghao = guanligonghao;
}
// 获取:管理工号
public String getGuanligonghao() {
return guanligonghao;
}
//设置:管理姓名
public void setGuanlixingming(String guanlixingming) {
this.guanlixingming = guanlixingming;
}
// 获取:管理姓名
public String getGuanlixingming() {
return guanlixingming;
}
}

@ -1,100 +0,0 @@
package com.interceptor;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;
import com.alibaba.fastjson.JSONObject;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import com.annotation.IgnoreAuth;
import com.entity.EIException;
import com.entity.TokenEntity;
import com.service.TokenService;
import com.utils.R;
//权限(Token)验证拦截器
// 实现HandlerInterceptor接口用于在请求到达控制器前进行Token验证
@Component
public class AuthorizationInterceptor implements HandlerInterceptor {
// 定义Token在请求头中的key
public static final String LOGIN_TOKEN_KEY = "Token";
@Autowired
private TokenService tokenService; // 注入Token服务
// 预处理方法,在控制器方法执行前调用
// @param request HTTP请求对象
// @param response HTTP响应对象
// @param handler 目标处理器
// @return 验证通过返回true否则返回false
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
// 设置跨域请求支持
response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE");
response.setHeader("Access-Control-Max-Age", "3600");
response.setHeader("Access-Control-Allow-Credentials", "true");
response.setHeader("Access-Control-Allow-Headers", "x-requested-with,request-source,Token, Origin,imgType, Content-Type, cache-control,postman-token,Cookie, Accept,authorization");
response.setHeader("Access-Control-Allow-Origin", request.getHeader("Origin"));
// 检查是否有IgnoreAuth注解不需要权限验证的注解
IgnoreAuth annotation;
if (handler instanceof HandlerMethod) {
// 获取方法上的IgnoreAuth注解
annotation = ((HandlerMethod) handler).getMethodAnnotation(IgnoreAuth.class);
} else {
return true; // 如果不是Controller方法直接放行
}
// 从请求头中获取Token
String token = request.getHeader(LOGIN_TOKEN_KEY);
// 如果方法上有IgnoreAuth注解直接放行
if(annotation != null) {
return true;
}
// Token验证逻辑
TokenEntity tokenEntity = null;
if(StringUtils.isNotBlank(token)) {
// 通过TokenService获取Token实体
tokenEntity = tokenService.getTokenEntity(token);
}
// 如果Token有效将用户信息存入session
if(tokenEntity != null) {
request.getSession().setAttribute("userId", tokenEntity.getUserid());
request.getSession().setAttribute("role", tokenEntity.getRole());
request.getSession().setAttribute("tableName", tokenEntity.getTablename());
request.getSession().setAttribute("username", tokenEntity.getUsername());
return true; // 验证通过
}
// Token无效时的处理
PrintWriter writer = null;
response.setCharacterEncoding("UTF-8");
response.setContentType("application/json; charset=utf-8");
try {
writer = response.getWriter();
// 返回401未授权错误
writer.print(JSONObject.toJSONString(R.error(401, "请先登录")));
} finally {
if(writer != null){
writer.close(); // 关闭输出流
}
}
return false; // 拦截请求
}
}

@ -1,46 +0,0 @@
package com.model.enums;
import java.io.Serializable;
import com.baomidou.mybatisplus.enums.IEnum;
//必须现在 IEnum 配置 该包扫描自动注入,查看文件 spring-mybatis.xml 参数 typeEnumsPackage
//此枚举类用于表示某种状态的类型,实现了 MyBatis-Plus 的 IEnum 接口,
//可以方便地在 MyBatis-Plus 中使用枚举类型进行数据库操作。
public enum TypeEnum implements IEnum {
// 定义枚举常量,表示禁用状态,值为 0描述为 "禁用"
DISABLED(0, "禁用"),
// 定义枚举常量,表示正常状态,值为 1描述为 "正常"
NORMAL(1, "正常");
// 枚举常量对应的值,用于在数据库中存储
private final int value;
// 枚举常量的描述信息,用于显示给用户
private final String desc;
// 枚举的构造函数,用于初始化枚举常量的值和描述信息
// @param value 枚举常量对应的值
//@param desc 枚举常量的描述信息
TypeEnum(final int value, final String desc) {
this.value = value;
this.desc = desc;
}
//实现 IEnum 接口的方法,用于获取枚举常量对应的值
// @return 枚举常量对应的值
@Override
public Serializable getValue() {
return this.value;
}
// 获取枚举常量的描述信息,添加此方法可能是为了在使用 Jackson 序列化时,
//通过 @JsonValue 注解返回中文描述信息
//@return 枚举常量的描述信息
public String getDesc() {
return this.desc;
}
}

@ -1,60 +0,0 @@
package com.service;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.service.IService;
import com.utils.PageUtils;
import com.entity.ChengbenjieyuEntity;
import java.util.List;
import java.util.Map;
import com.entity.vo.ChengbenjieyuVO;
import org.apache.ibatis.annotations.Param;
import com.entity.view.ChengbenjieyuView;
//成本结余
//该接口定义了与成本结余相关的业务逻辑操作,继承自 MyBatis-Plus 的 IService 接口,
// 具备对 ChengbenjieyuEntity 实体的基本增删改查功能,同时提供了一些自定义的查询和分页方法。
// @author
//@email
//@date 2021-04-24 15:19:31
public interface ChengbenjieyuService extends IService<ChengbenjieyuEntity> {
// 根据传入的参数进行分页查询成本结余数据。
// @param params 包含查询条件和分页信息的参数映射,如页码、每页记录数等。
//@return 封装了分页信息和查询结果的 PageUtils 对象,包含当前页的数据列表、总记录数、总页数等信息。
PageUtils queryPage(Map<String, Object> params);
//根据指定的查询条件查询成本结余值对象VO列表。
//值对象VO通常用于封装特定业务场景下需要展示或处理的数据可能只包含实体类的部分字段。
// @param wrapper 用于构建查询条件的包装器,可设置各种条件(如等于、大于、小于等)来筛选数据。
//@return 符合查询条件的成本结余值对象列表,如果没有符合条件的数据则返回空列表。
List<ChengbenjieyuVO> selectListVO(Wrapper<ChengbenjieyuEntity> wrapper);
//根据指定的查询条件查询单个成本结余值对象VO
// @param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的单个成本结余值对象,如果没有符合条件的数据则返回 null。
ChengbenjieyuVO selectVO(@Param("ew") Wrapper<ChengbenjieyuEntity> wrapper);
//根据指定的查询条件,查询成本结余视图对象列表。
//视图对象通常用于展示数据,可能包含关联查询或格式化后的数据。
//@param wrapper 用于构建查询条件的包装器。
//@return 符合查询条件的成本结余视图对象列表,如果没有符合条件的数据则返回空列表。
List<ChengbenjieyuView> selectListView(Wrapper<ChengbenjieyuEntity> wrapper);
// 根据指定的查询条件,查询单个成本结余视图对象。
// @param wrapper 用于构建查询条件的包装器。
//@return 符合查询条件的单个成本结余视图对象,如果没有符合条件的数据则返回 null。
ChengbenjieyuView selectView(@Param("ew") Wrapper<ChengbenjieyuEntity> wrapper);
// 根据传入的参数和查询条件进行分页查询成本结余数据。
// @param params 包含查询条件和分页信息的参数映射。
// @param wrapper 用于构建查询条件的包装器,可进一步细化查询条件。
// @return 封装了分页信息和查询结果的 PageUtils 对象。
PageUtils queryPage(Map<String, Object> params, Wrapper<ChengbenjieyuEntity> wrapper);
}

@ -1,57 +0,0 @@
package com.service;
import java.util.List;
import java.util.Map;
// 通用服务接口,提供一系列通用的数据处理和业务逻辑方法。
// 该接口中的方法可用于不同业务场景下的数据查询、处理和统计等操作。
public interface CommonService {
// 根据传入的参数获取选项列表。
// 该方法可能用于获取下拉框、单选框等选项控件的选项数据。
// @param params 包含查询条件的参数映射,可根据不同业务需求传入不同的键值对。
// @return 包含选项值的字符串列表,如果没有符合条件的选项则返回空列表。
List<String> getOption(Map<String, Object> params);
// 根据传入的参数获取关联数据。
//该方法可能用于根据某个选项的值获取与之关联的其他数据,例如根据部门名称获取该部门下的员工信息。
// @param params 包含查询条件的参数映射,通常包含选项的值以及其他关联查询所需的条件。
// @return 包含关联数据的映射,键为数据的属性名,值为对应的数据值,如果没有关联数据则返回空映射。
Map<String, Object> getFollowByOption(Map<String, Object> params);
//执行审核相关操作。
// 该方法的具体功能取决于业务需求,可能用于审核数据的合法性、状态更新等操作。
// @param params 包含审核所需信息的参数映射,例如审核对象的 ID、审核状态等。
void sh(Map<String, Object> params);
// 统计提醒数量。
// 该方法可能用于统计满足特定条件的提醒数量,例如未读消息数量、待办事项数量等。
// @param params 包含统计条件的参数映射,例如提醒类型、时间范围等。
// @return 满足条件的提醒数量。
int remindCount(Map<String, Object> params);
// 根据传入的参数进行计算并返回结果。
//该方法可能用于执行一些复杂的计算逻辑,例如数据汇总、统计分析等。
// @param params 包含计算所需数据和条件的参数映射。
// @return 包含计算结果的映射,键为结果的名称,值为对应的计算结果。
Map<String, Object> selectCal(Map<String, Object> params);
// 根据传入的参数进行分组查询并返回结果列表。
// 该方法可能用于对数据进行分组统计,例如按部门分组统计员工数量。
// @param params 包含分组查询条件的参数映射,例如分组字段、统计字段等。
// @return 包含分组查询结果的列表,每个元素是一个映射,键为统计结果的属性名,值为对应的数据值。
List<Map<String, Object>> selectGroup(Map<String, Object> params);
// 根据传入的参数查询数据值列表。
//该方法可能用于查询满足特定条件的数据值,例如查询某个时间段内的销售金额列表。
// @param params 包含查询条件的参数映射。
// @return 包含查询结果的数据值列表,每个元素是一个映射,键为数据的属性名,值为对应的数据值。
List<Map<String, Object>> selectValue(Map<String, Object> params);
}

@ -1,21 +0,0 @@
package com.service;
import java.util.Map;
import com.baomidou.mybatisplus.service.IService;
import com.entity.ConfigEntity;
import com.utils.PageUtils;
// 系统用户
// 该接口用于处理系统用户相关的业务逻辑,继承自 MyBatis-Plus 的 IService 接口,
// 具备对 ConfigEntity 实体的基本增删改查功能,同时定义了分页查询方法。
public interface ConfigService extends IService<ConfigEntity> {
//根据传入的参数进行分页查询系统用户相关配置数据。
// @param params 包含查询条件和分页信息的参数映射,例如页码、每页记录数、查询关键字等。
// @return 封装了分页信息和查询结果的 PageUtils 对象,包含当前页的数据列表、总记录数、总页数等信息。
PageUtils queryPage(Map<String, Object> params);
}

@ -1,60 +0,0 @@
package com.service;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.service.IService;
import com.utils.PageUtils;
import com.entity.ShangpinchukuEntity;
import java.util.List;
import java.util.Map;
import com.entity.vo.ShangpinchukuVO;
import org.apache.ibatis.annotations.Param;
import com.entity.view.ShangpinchukuView;
// 商品出库
// 此接口主要用于处理商品出库相关的业务逻辑,继承自 MyBatis-Plus 的 IService 接口,
//具备对 ShangpinchukuEntity 实体对象的基本增删改查功能,同时定义了一些自定义的查询和分页方法。
//@author
// @email
// @date 2021-04-24 15:19:31
public interface ShangpinchukuService extends IService<ShangpinchukuEntity> {
// 根据传入的参数对商品出库信息进行分页查询。
//@param params 包含查询条件和分页信息的参数映射,例如页码、每页记录数、筛选条件等。
// @return 封装了分页信息和查询结果的 PageUtils 对象,包含当前页的商品出库信息列表、总记录数、总页数等。
PageUtils queryPage(Map<String, Object> params);
//根据指定的查询条件查询商品出库值对象VO列表。
// 值对象VO一般用于封装特定业务场景下需要展示或处理的数据可能只包含实体类的部分字段。
// @param wrapper 用于构建查询条件的包装器,可设置各种条件(如等于、大于、小于等)来筛选商品出库信息。
//@return 符合查询条件的商品出库值对象列表,如果没有符合条件的数据则返回空列表。
List<ShangpinchukuVO> selectListVO(Wrapper<ShangpinchukuEntity> wrapper);
// 根据指定的查询条件查询单个商品出库值对象VO
//@param wrapper 用于构建查询条件的包装器。
//@return 符合查询条件的单个商品出库值对象,如果没有符合条件的数据则返回 null。
ShangpinchukuVO selectVO(@Param("ew") Wrapper<ShangpinchukuEntity> wrapper);
//根据指定的查询条件,查询商品出库视图对象列表。
// 视图对象通常用于展示数据,可能包含关联查询或格式化后的数据。
//@param wrapper 用于构建查询条件的包装器。
//@return 符合查询条件的商品出库视图对象列表,如果没有符合条件的数据则返回空列表。
List<ShangpinchukuView> selectListView(Wrapper<ShangpinchukuEntity> wrapper);
// 根据指定的查询条件,查询单个商品出库视图对象。
// @param wrapper 用于构建查询条件的包装器。
//@return 符合查询条件的单个商品出库视图对象,如果没有符合条件的数据则返回 null。
ShangpinchukuView selectView(@Param("ew") Wrapper<ShangpinchukuEntity> wrapper);
// 根据传入的参数和查询条件对商品出库信息进行分页查询。
// @param params 包含查询条件和分页信息的参数映射。
// @param wrapper 用于构建查询条件的包装器,可进一步细化查询条件。
//@return 封装了分页信息和查询结果的 PageUtils 对象。
PageUtils queryPage(Map<String, Object> params, Wrapper<ShangpinchukuEntity> wrapper);
}

@ -1,61 +0,0 @@
package com.service;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.service.IService;
import com.utils.PageUtils;
import com.entity.ShangpinkucunEntity;
import java.util.List;
import java.util.Map;
import com.entity.vo.ShangpinkucunVO;
import org.apache.ibatis.annotations.Param;
import com.entity.view.ShangpinkucunView;
// 商品库存
// 该接口负责处理商品库存相关的业务逻辑,继承自 MyBatis-Plus 的 IService 接口,
// 具备对 ShangpinkucunEntity 实体的基本增删改查功能,同时提供了自定义的查询和分页方法。
// @author
// @email
// @date 2021-04-24 15:19:31
public interface ShangpinkucunService extends IService<ShangpinkucunEntity> {
//根据传入的参数对商品库存信息进行分页查询。
// @param params 包含查询条件和分页信息的参数映射,例如页码、每页记录数、查询关键字等。
// @return 封装了分页信息和查询结果的 PageUtils 对象,包含当前页的商品库存信息列表、总记录数、总页数等。
PageUtils queryPage(Map<String, Object> params);
// 根据指定的查询条件查询商品库存值对象VO列表。
//值对象VO通常用于封装特定业务场景下需要展示或处理的数据可能只包含实体类的部分字段。
//@param wrapper 用于构建查询条件的包装器,可设置各种条件(如等于、大于、小于等)来筛选商品库存信息。
// @return 符合查询条件的商品库存值对象列表,如果没有符合条件的数据则返回空列表。
List<ShangpinkucunVO> selectListVO(Wrapper<ShangpinkucunEntity> wrapper);
// 根据指定的查询条件查询单个商品库存值对象VO
//@param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的单个商品库存值对象,如果没有符合条件的数据则返回 null。
ShangpinkucunVO selectVO(@Param("ew") Wrapper<ShangpinkucunEntity> wrapper);
// 根据指定的查询条件,查询商品库存视图对象列表。
// 视图对象通常用于展示数据,可能包含关联查询或格式化后的数据。
// @param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的商品库存视图对象列表,如果没有符合条件的数据则返回空列表。
List<ShangpinkucunView> selectListView(Wrapper<ShangpinkucunEntity> wrapper);
// 根据指定的查询条件,查询单个商品库存视图对象。
//@param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的单个商品库存视图对象,如果没有符合条件的数据则返回 null。
ShangpinkucunView selectView(@Param("ew") Wrapper<ShangpinkucunEntity> wrapper);
//根据传入的参数和查询条件对商品库存信息进行分页查询。
// @param params 包含查询条件和分页信息的参数映射。
//@param wrapper 用于构建查询条件的包装器,可进一步细化查询条件。
// @return 封装了分页信息和查询结果的 PageUtils 对象。
PageUtils queryPage(Map<String, Object> params, Wrapper<ShangpinkucunEntity> wrapper);
}

@ -1,61 +0,0 @@
package com.service;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.service.IService;
import com.utils.PageUtils;
import com.entity.ShangpinleixingEntity;
import java.util.List;
import java.util.Map;
import com.entity.vo.ShangpinleixingVO;
import org.apache.ibatis.annotations.Param;
import com.entity.view.ShangpinleixingView;
//商品类型
//此接口用于处理商品类型相关的业务逻辑,继承自 MyBatis-Plus 的 IService 接口,
//具备对 ShangpinleixingEntity 实体的基本增删改查功能,同时提供了自定义的查询和分页方法。
// @author
// @email
//@date 2021-04-24 15:19:31
public interface ShangpinleixingService extends IService<ShangpinleixingEntity> {
//根据传入的参数对商品类型信息进行分页查询。
//@param params 包含查询条件和分页信息的参数映射,如页码、每页记录数、查询关键字等。
// @return 封装了分页信息和查询结果的 PageUtils 对象,包含当前页的商品类型信息列表、总记录数、总页数等。
PageUtils queryPage(Map<String, Object> params);
// 根据指定的查询条件查询商品类型值对象VO列表。
// 值对象VO通常用于封装特定业务场景下需要展示或处理的数据可能只包含实体类的部分字段。
// @param wrapper 用于构建查询条件的包装器,可设置各种条件(如等于、大于、小于等)来筛选商品类型信息。
//@return 符合查询条件的商品类型值对象列表,如果没有符合条件的数据则返回空列表。
List<ShangpinleixingVO> selectListVO(Wrapper<ShangpinleixingEntity> wrapper);
// 根据指定的查询条件查询单个商品类型值对象VO
//@param wrapper 用于构建查询条件的包装器。
//@return 符合查询条件的单个商品类型值对象,如果没有符合条件的数据则返回 null。
ShangpinleixingVO selectVO(@Param("ew") Wrapper<ShangpinleixingEntity> wrapper);
// 根据指定的查询条件,查询商品类型视图对象列表。
// 视图对象通常用于展示数据,可能包含关联查询或格式化后的数据。
// @param wrapper 用于构建查询条件的包装器。
//@return 符合查询条件的商品类型视图对象列表,如果没有符合条件的数据则返回空列表。
List<ShangpinleixingView> selectListView(Wrapper<ShangpinleixingEntity> wrapper);
//根据指定的查询条件,查询单个商品类型视图对象。
//@param wrapper 用于构建查询条件的包装器。
//@return 符合查询条件的单个商品类型视图对象,如果没有符合条件的数据则返回 null。
ShangpinleixingView selectView(@Param("ew") Wrapper<ShangpinleixingEntity> wrapper);
// 根据传入的参数和查询条件对商品类型信息进行分页查询。
//@param params 包含查询条件和分页信息的参数映射。
//@param wrapper 用于构建查询条件的包装器,可进一步细化查询条件。
// @return 封装了分页信息和查询结果的 PageUtils 对象。
PageUtils queryPage(Map<String, Object> params, Wrapper<ShangpinleixingEntity> wrapper);
}

@ -1,61 +0,0 @@
package com.service;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.service.IService;
import com.utils.PageUtils;
import com.entity.ShangpinrukuEntity;
import java.util.List;
import java.util.Map;
import com.entity.vo.ShangpinrukuVO;
import org.apache.ibatis.annotations.Param;
import com.entity.view.ShangpinrukuView;
//商品入库
// 该接口主要用于处理商品入库相关的业务逻辑,继承自 MyBatis-Plus 的 IService 接口,
// 具备对 ShangpinrukuEntity 实体的基本增删改查功能,同时提供了自定义的查询和分页方法。
// @author
//@email
// @date 2021-04-24 15:19:31
public interface ShangpinrukuService extends IService<ShangpinrukuEntity> {
// 根据传入的参数对商品入库信息进行分页查询。
//@param params 包含查询条件和分页信息的参数映射,如页码、每页记录数、查询关键字等。
// @return 封装了分页信息和查询结果的 PageUtils 对象,包含当前页的商品入库信息列表、总记录数、总页数等。
PageUtils queryPage(Map<String, Object> params);
//根据指定的查询条件查询商品入库值对象VO列表。
// 值对象VO通常用于封装特定业务场景下需要展示或处理的数据可能只包含实体类的部分字段。
// @param wrapper 用于构建查询条件的包装器,可设置各种条件(如等于、大于、小于等)来筛选商品入库信息。
//@return 符合查询条件的商品入库值对象列表,如果没有符合条件的数据则返回空列表。
List<ShangpinrukuVO> selectListVO(Wrapper<ShangpinrukuEntity> wrapper);
// 根据指定的查询条件查询单个商品入库值对象VO
// @param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的单个商品入库值对象,如果没有符合条件的数据则返回 null。
ShangpinrukuVO selectVO(@Param("ew") Wrapper<ShangpinrukuEntity> wrapper);
//根据指定的查询条件,查询商品入库视图对象列表。
// 视图对象通常用于展示数据,可能包含关联查询或格式化后的数据。
// @param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的商品入库视图对象列表,如果没有符合条件的数据则返回空列表。
List<ShangpinrukuView> selectListView(Wrapper<ShangpinrukuEntity> wrapper);
// 根据指定的查询条件,查询单个商品入库视图对象。
// @param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的单个商品入库视图对象,如果没有符合条件的数据则返回 null。
ShangpinrukuView selectView(@Param("ew") Wrapper<ShangpinrukuEntity> wrapper);
// 根据传入的参数和查询条件对商品入库信息进行分页查询。
// @param params 包含查询条件和分页信息的参数映射。
// @param wrapper 用于构建查询条件的包装器,可进一步细化查询条件。
// @return 封装了分页信息和查询结果的 PageUtils 对象。
PageUtils queryPage(Map<String, Object> params, Wrapper<ShangpinrukuEntity> wrapper);
}

@ -1,52 +0,0 @@
package com.service;
import java.util.List;
import java.util.Map;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.service.IService;
import com.entity.TokenEntity;
import com.utils.PageUtils;
// token
//该接口用于处理与 Token 相关的业务逻辑,继承自 MyBatis-Plus 的 IService 接口,
// 具备对 TokenEntity 实体的基本增删改查功能,同时定义了一些自定义的业务方法。
public interface TokenService extends IService<TokenEntity> {
// 根据传入的参数对 Token 数据进行分页查询。
// @param params 包含查询条件和分页信息的参数映射,例如页码、每页记录数、查询关键字等。
// @return 封装了分页信息和查询结果的 PageUtils 对象,包含当前页的 Token 数据列表、总记录数、总页数等信息。
PageUtils queryPage(Map<String, Object> params);
//根据指定的查询条件,查询 Token 实体的列表视图。
// @param wrapper 用于构建查询条件的包装器,可设置各种条件(如等于、大于、小于等)来筛选 Token 实体数据。
//@return 符合查询条件的 Token 实体列表,如果没有符合条件的数据则返回空列表。
List<TokenEntity> selectListView(Wrapper<TokenEntity> wrapper);
// 根据传入的参数和查询条件对 Token 数据进行分页查询。
// 此方法相比 queryPage(Map<String, Object> params) 增加了查询条件包装器,
//可以更灵活地进行条件查询和分页。
// @param params 包含查询条件和分页信息的参数映射。
// @param wrapper 用于构建查询条件的包装器,可进一步细化查询条件。
// @return 封装了分页信息和查询结果的 PageUtils 对象。
PageUtils queryPage(Map<String, Object> params, Wrapper<TokenEntity> wrapper);
// 生成 Token。
// @param userid 用户 ID用于标识生成 Token 对应的用户。
// @param username 用户名,可能用于记录生成 Token 的用户标识。
// @param tableName 表名,可能与 Token 关联的数据库表相关。
// @param role 用户角色,可能用于权限控制或 Token 的相关属性设置。
// @return 生成的 Token 字符串。
String generateToken(Long userid, String username, String tableName, String role);
// 根据给定的 Token 获取对应的 Token 实体。
// @param token 要查询的 Token 字符串。
// @return 对应的 Token 实体,如果不存在则返回 null。
TokenEntity getTokenEntity(String token);
}

@ -1,37 +0,0 @@
package com.service;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.annotations.Param;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.service.IService;
import com.entity.UserEntity;
import com.utils.PageUtils;
//系统用户
// 该接口用于处理系统用户相关的业务逻辑,继承自 MyBatis-Plus 的 IService 接口,
// 具备对 UserEntity 实体的基本增删改查功能,同时提供了一些自定义的查询和分页方法。
public interface UserService extends IService<UserEntity> {
//根据传入的参数对系统用户数据进行分页查询。
// @param params 包含查询条件和分页信息的参数映射,例如页码、每页记录数、查询关键字等。
//@return 封装了分页信息和查询结果的 PageUtils 对象,包含当前页的系统用户数据列表、总记录数、总页数等。
PageUtils queryPage(Map<String, Object> params);
// 根据指定的查询条件,查询系统用户实体列表。
// @param wrapper 用于构建查询条件的包装器,可设置各种条件(如等于、大于、小于等)来筛选系统用户数据。
// @return 符合查询条件的系统用户实体列表,如果没有符合条件的数据则返回空列表。
List<UserEntity> selectListView(Wrapper<UserEntity> wrapper);
// 根据传入的参数和查询条件对系统用户数据进行分页查询。
//@param params 包含查询条件和分页信息的参数映射。
//@param wrapper 用于构建查询条件的包装器,可进一步细化查询条件。
// @return 封装了分页信息和查询结果的 PageUtils 对象。
PageUtils queryPage(Map<String, Object> params, Wrapper<UserEntity> wrapper);
}

@ -1,99 +0,0 @@
package com.service.impl;
import org.springframework.stereotype.Service;
import java.util.Map;
import java.util.List;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.utils.PageUtils;
import com.utils.Query;
import com.dao.ChengbenjieyuDao;
import com.entity.ChengbenjieyuEntity;
import com.service.ChengbenjieyuService;
import com.entity.vo.ChengbenjieyuVO;
import com.entity.view.ChengbenjieyuView;
//成本结余服务的实现类,实现了 ChengbenjieyuService 接口。
// 该类继承自 MyBatis-Plus 的 ServiceImpl 类,借助 MyBatis-Plus 提供的通用 CRUD 方法来操作数据库。
//它主要负责处理成本结余相关的数据查询和分页操作。
@Service("chengbenjieyuService")
public class ChengbenjieyuServiceImpl extends ServiceImpl<ChengbenjieyuDao, ChengbenjieyuEntity> implements ChengbenjieyuService {
// 根据传入的参数进行分页查询成本结余实体数据。
// @param params 包含分页和查询条件的参数 Map。常见的参数可能有页码、每页数量等。
//@return 封装了分页信息和查询结果的 PageUtils 对象,方便前端展示和处理分页数据。
@Override
public PageUtils queryPage(Map<String, Object> params) {
// 根据传入的参数创建分页对象,用于指定分页查询的要求,如页码、每页数量等。
Page<ChengbenjieyuEntity> page = this.selectPage(
// 调用 Query 工具类的方法,根据传入的参数生成对应的分页对象。
new Query<ChengbenjieyuEntity>(params).getPage(),
// 创建一个空的实体包装器,这里不设置具体的查询条件,表示查询所有数据。
new EntityWrapper<ChengbenjieyuEntity>()
);
// 将分页查询得到的结果封装到 PageUtils 对象中,方便后续使用。
return new PageUtils(page);
}
// 根据传入的参数和查询条件包装器进行分页查询成本结余视图数据。
// @param params 包含分页和查询条件的参数 Map。
// @param wrapper 用于构建查询条件的包装器,可设置如 where 子句等条件。
//@return 封装了分页信息和查询结果的 PageUtils 对象。
@Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<ChengbenjieyuEntity> wrapper) {
// 根据传入的参数创建成本结余视图的分页对象。
Page<ChengbenjieyuView> page = new Query<ChengbenjieyuView>(params).getPage();
// 调用基础映射器的方法,根据分页对象和查询条件包装器查询成本结余视图列表,并将结果设置到分页对象中。
page.setRecords(baseMapper.selectListView(page, wrapper));
// 将分页查询得到的结果封装到 PageUtils 对象中。
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
// 根据查询条件包装器查询成本结余值对象VO列表。
// @param wrapper 用于构建查询条件的包装器。
//@return 符合查询条件的成本结余值对象VO列表。
@Override
public List<ChengbenjieyuVO> selectListVO(Wrapper<ChengbenjieyuEntity> wrapper) {
// 调用基础映射器的方法根据查询条件包装器查询成本结余值对象VO列表。
return baseMapper.selectListVO(wrapper);
}
// 根据查询条件包装器查询单个成本结余值对象VO
// @param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的单个成本结余值对象VO若未找到则可能返回 null。
@Override
public ChengbenjieyuVO selectVO(Wrapper<ChengbenjieyuEntity> wrapper) {
// 调用基础映射器的方法根据查询条件包装器查询单个成本结余值对象VO
return baseMapper.selectVO(wrapper);
}
//根据查询条件包装器查询成本结余视图列表。
// @param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的成本结余视图列表。
@Override
public List<ChengbenjieyuView> selectListView(Wrapper<ChengbenjieyuEntity> wrapper) {
// 调用基础映射器的方法,根据查询条件包装器查询成本结余视图列表。
return baseMapper.selectListView(wrapper);
}
// 根据查询条件包装器查询单个成本结余视图。
// @param wrapper 用于构建查询条件的包装器。
//@return 符合查询条件的单个成本结余视图,若未找到则可能返回 null。
@Override
public ChengbenjieyuView selectView(Wrapper<ChengbenjieyuEntity> wrapper) {
// 调用基础映射器的方法,根据查询条件包装器查询单个成本结余视图。
return baseMapper.selectView(wrapper);
}
}

@ -1,91 +0,0 @@
package com.service.impl;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.dao.CommonDao;
import com.service.CommonService;
//通用服务的实现类,实现了 CommonService 接口,用于处理系统中一些通用的业务逻辑。
// 该类依赖于 CommonDao 来进行数据库操作。
@Service("commonService")
public class CommonServiceImpl implements CommonService {
// 自动注入 CommonDao 实例,用于执行数据库操作
@Autowired
private CommonDao commonDao;
// 根据传入的参数获取选项列表。
// @param params 包含查询条件的参数 Map用于指定获取选项的条件。
// @return 返回符合条件的选项列表,列表中的元素为字符串类型。
@Override
public List<String> getOption(Map<String, Object> params) {
// 调用 CommonDao 的 getOption 方法,根据传入的参数查询选项列表
return commonDao.getOption(params);
}
// 根据传入的参数获取关联信息。
//@param params 包含查询条件的参数 Map用于指定获取关联信息的条件。
// @return 返回符合条件的关联信息,以键值对的形式存储在 Map 中。
@Override
public Map<String, Object> getFollowByOption(Map<String, Object> params) {
// 调用 CommonDao 的 getFollowByOption 方法,根据传入的参数查询关联信息
return commonDao.getFollowByOption(params);
}
// 执行审核操作。
// @param params 包含审核相关信息的参数 Map如审核对象的标识、审核状态等。
@Override
public void sh(Map<String, Object> params) {
// 调用 CommonDao 的 sh 方法,根据传入的参数执行审核操作
commonDao.sh(params);
}
// 根据传入的参数统计提醒数量。
// @param params 包含统计条件的参数 Map用于指定统计提醒数量的条件。
//@return 返回符合条件的提醒数量。
@Override
public int remindCount(Map<String, Object> params) {
// 调用 CommonDao 的 remindCount 方法,根据传入的参数统计提醒数量
return commonDao.remindCount(params);
}
// 根据传入的参数进行计算并返回计算结果。
// @param params 包含计算条件的参数 Map用于指定计算的条件和相关数据。
//@return 返回计算结果,以键值对的形式存储在 Map 中。
@Override
public Map<String, Object> selectCal(Map<String, Object> params) {
// 调用 CommonDao 的 selectCal 方法,根据传入的参数进行计算并返回结果
return commonDao.selectCal(params);
}
// 根据传入的参数进行分组查询并返回结果列表。
// @param params 包含分组查询条件的参数 Map用于指定分组查询的条件。
//@return 返回符合条件的分组查询结果列表,列表中的元素为键值对形式的 Map。
@Override
public List<Map<String, Object>> selectGroup(Map<String, Object> params) {
// 调用 CommonDao 的 selectGroup 方法,根据传入的参数进行分组查询并返回结果列表
return commonDao.selectGroup(params);
}
//根据传入的参数查询值列表。
//@param params 包含查询条件的参数 Map用于指定查询值的条件。
// @return 返回符合条件的值列表,列表中的元素为键值对形式的 Map。
@Override
public List<Map<String, Object>> selectValue(Map<String, Object> params) {
// 调用 CommonDao 的 selectValue 方法,根据传入的参数查询值列表
return commonDao.selectValue(params);
}
}

@ -1,41 +0,0 @@
package com.service.impl;
import java.util.Map;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.dao.ConfigDao;
import com.entity.ConfigEntity;
import com.entity.UserEntity;
import com.service.ConfigService;
import com.utils.PageUtils;
import com.utils.Query;
// 配置服务的实现类,实现了 ConfigService 接口。
// 该类继承自 MyBatis-Plus 的 ServiceImpl 类,借助 MyBatis-Plus 提供的通用 CRUD 方法来操作数据库。
// 主要负责处理配置相关的数据分页查询操作。
@Service("configService")
public class ConfigServiceImpl extends ServiceImpl<ConfigDao, ConfigEntity> implements ConfigService {
// 根据传入的参数进行分页查询配置实体数据。
// @param params 包含分页和查询条件的参数 Map。常见的参数可能有页码、每页数量等。
// @return 封装了分页信息和查询结果的 PageUtils 对象,方便前端展示和处理分页数据。
@Override
public PageUtils queryPage(Map<String, Object> params) {
// 根据传入的参数创建分页对象,用于指定分页查询的要求,如页码、每页数量等。
Page<ConfigEntity> page = this.selectPage(
// 调用 Query 工具类的方法,根据传入的参数生成对应的分页对象。
new Query<ConfigEntity>(params).getPage(),
// 创建一个空的实体包装器,这里不设置具体的查询条件,表示查询所有数据。
new EntityWrapper<ConfigEntity>()
);
// 将分页查询得到的结果封装到 PageUtils 对象中,方便后续使用。
return new PageUtils(page);
}
}

@ -1,103 +0,0 @@
package com.service.impl;
import org.springframework.stereotype.Service;
import java.util.Map;
import java.util.List;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.utils.PageUtils;
import com.utils.Query;
import com.dao.ShangpinchukuDao;
import com.entity.ShangpinchukuEntity;
import com.service.ShangpinchukuService;
import com.entity.vo.ShangpinchukuVO;
import com.entity.view.ShangpinchukuView;
// 商品出库服务的实现类,实现了 ShangpinchukuService 接口,
// 继承自 MyBatis-Plus 的 ServiceImpl 类,用于处理商品出库相关的业务逻辑。
// 该类通过依赖注入的方式使用 ShangpinchukuDao 来访问数据库中的商品出库数据。
@Service("shangpinchukuService")
public class ShangpinchukuServiceImpl extends ServiceImpl<ShangpinchukuDao, ShangpinchukuEntity> implements ShangpinchukuService {
//根据传入的参数进行分页查询商品出库实体数据。
// @param params 包含分页和查询条件的参数 Map常见参数如页码、每页数量、搜索关键词等。
// @return 封装了分页信息(如总页数、当前页、每页记录数、总记录数等)和查询结果(商品出库实体列表)的 PageUtils 对象,
// 便于在业务层或前端展示层进行处理和展示分页数据。
@Override
public PageUtils queryPage(Map<String, Object> params) {
// 根据传入的参数创建一个分页对象,用于指定分页查询的相关设置,如页码和每页数量。
Page<ShangpinchukuEntity> page = this.selectPage(
// 调用 Query 工具类的方法,根据传入的参数生成对应的分页对象。
new Query<ShangpinchukuEntity>(params).getPage(),
// 创建一个空的实体包装器,此时不设置任何查询条件,即查询所有的商品出库实体记录。
new EntityWrapper<ShangpinchukuEntity>()
);
// 将分页查询得到的结果封装到 PageUtils 对象中并返回,以便后续使用。
return new PageUtils(page);
}
//根据传入的参数和查询条件包装器进行分页查询商品出库视图数据。
// @param params 包含分页和查询条件的参数 Map可用于指定分页设置和一些通用的查询条件。
// @param wrapper 用于构建具体查询条件的包装器,比如设置 where 子句等条件来筛选特定的商品出库数据。
// @return 封装了分页信息和查询结果(商品出库视图列表)的 PageUtils 对象。
@Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<ShangpinchukuEntity> wrapper) {
// 根据传入的参数创建商品出库视图的分页对象。
Page<ShangpinchukuView> page = new Query<ShangpinchukuView>(params).getPage();
// 调用基础映射器baseMapper的方法根据分页对象和查询条件包装器查询商品出库视图列表
// 并将查询结果设置到分页对象中。
page.setRecords(baseMapper.selectListView(page, wrapper));
// 将分页查询得到的结果封装到 PageUtils 对象中并返回。
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
// 根据查询条件包装器查询商品出库值对象VO的列表。
// @param wrapper 用于构建查询条件的包装器,通过设置条件筛选出符合要求的商品出库数据,
// 并以值对象VO的形式返回。
// @return 符合查询条件的商品出库值对象VO列表用于在业务逻辑中进行数据处理和传递。
@Override
public List<ShangpinchukuVO> selectListVO(Wrapper<ShangpinchukuEntity> wrapper) {
// 调用基础映射器的方法根据查询条件包装器查询商品出库值对象VO列表并返回。
return baseMapper.selectListVO(wrapper);
}
// 根据查询条件包装器查询单个商品出库值对象VO
// @param wrapper 用于构建查询条件的包装器,通过设置精确的条件筛选出唯一的商品出库数据,
// 并以值对象VO的形式返回。
// @return 符合查询条件的单个商品出库值对象VO如果没有找到符合条件的数据则可能返回 null。
@Override
public ShangpinchukuVO selectVO(Wrapper<ShangpinchukuEntity> wrapper) {
// 调用基础映射器的方法根据查询条件包装器查询单个商品出库值对象VO并返回。
return baseMapper.selectVO(wrapper);
}
// 根据查询条件包装器查询商品出库视图的列表。
// @param wrapper 用于构建查询条件的包装器,通过设置条件筛选出符合要求的商品出库视图数据。
// @return 符合查询条件的商品出库视图列表,用于在业务层展示或进一步处理数据。
@Override
public List<ShangpinchukuView> selectListView(Wrapper<ShangpinchukuEntity> wrapper) {
// 调用基础映射器的方法,根据查询条件包装器查询商品出库视图列表并返回。
return baseMapper.selectListView(wrapper);
}
// 根据查询条件包装器查询单个商品出库视图。
// @param wrapper 用于构建查询条件的包装器,通过设置精确的条件筛选出唯一的商品出库视图数据。
// @return 符合查询条件的单个商品出库视图,如果没有找到符合条件的数据,则可能返回 null。
@Override
public ShangpinchukuView selectView(Wrapper<ShangpinchukuEntity> wrapper) {
// 调用基础映射器的方法,根据查询条件包装器查询单个商品出库视图并返回。
return baseMapper.selectView(wrapper);
}
}

@ -1,104 +0,0 @@
package com.service.impl;
import org.springframework.stereotype.Service;
import java.util.Map;
import java.util.List;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.utils.PageUtils;
import com.utils.Query;
import com.dao.ShangpinkucunDao;
import com.entity.ShangpinkucunEntity;
import com.service.ShangpinkucunService;
import com.entity.vo.ShangpinkucunVO;
import com.entity.view.ShangpinkucunView;
// 商品库存服务的实现类,实现了 ShangpinkucunService 接口,
// 继承自 MyBatis-Plus 的 ServiceImpl 类,用于处理与商品库存相关的业务逻辑。
//通过依赖注入的方式使用 ShangpinkucunDao 来访问和操作数据库中的商品库存数据。
@Service("shangpinkucunService")
public class ShangpinkucunServiceImpl extends ServiceImpl<ShangpinkucunDao, ShangpinkucunEntity> implements ShangpinkucunService {
//根据传入的参数进行分页查询商品库存实体数据。
// @param params 包含分页和查询条件的参数 Map例如页码、每页数量、商品名称关键字等。
// @return 封装了分页信息(如总页数、当前页数、每页记录数、总记录数等)和查询结果(商品库存实体列表)的 PageUtils 对象,
// 方便在业务层或展示层进行处理和展示分页数据。
@Override
public PageUtils queryPage(Map<String, Object> params) {
// 根据传入的参数创建一个分页对象,用于指定分页查询的相关设置,如页码和每页数量等。
Page<ShangpinkucunEntity> page = this.selectPage(
// 调用 Query 工具类的方法,根据传入的参数生成对应的分页对象。
new Query<ShangpinkucunEntity>(params).getPage(),
// 创建一个空的实体包装器,这里不设置具体的查询条件,即查询所有的商品库存实体。
new EntityWrapper<ShangpinkucunEntity>()
);
// 将分页查询得到的结果封装到 PageUtils 对象中并返回,以便后续使用。
return new PageUtils(page);
}
// 根据传入的参数和查询条件包装器进行分页查询商品库存视图数据。
// @param params 包含分页和查询条件的参数 Map与上面的 queryPage 方法中的 params 类似,
// 可用于指定分页和一些通用的查询条件。
// @param wrapper 用于构建具体查询条件的包装器,例如可以设置 where 子句等条件来筛选特定的商品库存数据。
// @return 封装了分页信息和查询结果(商品库存视图列表)的 PageUtils 对象。
@Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<ShangpinkucunEntity> wrapper) {
// 根据传入的参数创建商品库存视图的分页对象。
Page<ShangpinkucunView> page = new Query<ShangpinkucunView>(params).getPage();
// 调用基础映射器baseMapper的方法根据分页对象和查询条件包装器查询商品库存视图列表
// 并将查询结果设置到分页对象中。
page.setRecords(baseMapper.selectListView(page, wrapper));
// 将分页查询得到的结果封装到 PageUtils 对象中并返回。
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
//根据查询条件包装器查询商品库存值对象VO的列表。
// @param wrapper 用于构建查询条件的包装器,通过设置条件筛选出符合要求的商品库存数据,
// 并以值对象VO的形式返回。
// @return 符合查询条件的商品库存值对象VO列表用于在业务层进行数据处理和展示。
@Override
public List<ShangpinkucunVO> selectListVO(Wrapper<ShangpinkucunEntity> wrapper) {
// 调用基础映射器的方法根据查询条件包装器查询商品库存值对象VO列表并返回。
return baseMapper.selectListVO(wrapper);
}
//根据查询条件包装器查询单个商品库存值对象VO
// @param wrapper 用于构建查询条件的包装器,通过设置精确的条件筛选出唯一的商品库存数据,
// 并以值对象VO的形式返回。
// @return 符合查询条件的单个商品库存值对象VO如果没有找到符合条件的数据则可能返回 null。
@Override
public ShangpinkucunVO selectVO(Wrapper<ShangpinkucunEntity> wrapper) {
// 调用基础映射器的方法根据查询条件包装器查询单个商品库存值对象VO并返回。
return baseMapper.selectVO(wrapper);
}
// 根据查询条件包装器查询商品库存视图的列表。
// @param wrapper 用于构建查询条件的包装器,通过设置条件筛选出符合要求的商品库存视图数据。
// @return 符合查询条件的商品库存视图列表,用于在业务层进行数据展示或进一步处理。
@Override
public List<ShangpinkucunView> selectListView(Wrapper<ShangpinkucunEntity> wrapper) {
// 调用基础映射器的方法,根据查询条件包装器查询商品库存视图列表并返回。
return baseMapper.selectListView(wrapper);
}
// 根据查询条件包装器查询单个商品库存视图。
//@param wrapper 用于构建查询条件的包装器,通过设置精确的条件筛选出唯一的商品库存视图数据。
// @return 符合查询条件的单个商品库存视图,如果没有找到符合条件的数据,则可能返回 null。
@Override
public ShangpinkucunView selectView(Wrapper<ShangpinkucunEntity> wrapper) {
// 调用基础映射器的方法,根据查询条件包装器查询单个商品库存视图并返回。
return baseMapper.selectView(wrapper);
}
}

@ -1,104 +0,0 @@
package com.service.impl;
import org.springframework.stereotype.Service;
import java.util.Map;
import java.util.List;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.utils.PageUtils;
import com.utils.Query;
import com.dao.ShangpinleixingDao;
import com.entity.ShangpinleixingEntity;
import com.service.ShangpinleixingService;
import com.entity.vo.ShangpinleixingVO;
import com.entity.view.ShangpinleixingView;
// 商品类型服务的实现类,实现了 ShangpinleixingService 接口,
//继承自 MyBatis-Plus 的 ServiceImpl 类,用于处理商品类型相关的业务逻辑。
//通过依赖注入的方式使用 ShangpinleixingDao 来访问和操作数据库中的商品类型数据。
@Service("shangpinleixingService")
public class ShangpinleixingServiceImpl extends ServiceImpl<ShangpinleixingDao, ShangpinleixingEntity> implements ShangpinleixingService {
// 根据传入的参数进行分页查询商品类型实体数据。
// @param params 包含分页和查询条件的参数 Map例如页码、每页数量、商品类型名称关键字等。
// @return 封装了分页信息(如总页数、当前页数、每页记录数、总记录数等)和查询结果(商品类型实体列表)的 PageUtils 对象,
// 方便在业务层或展示层进行处理和展示分页数据。
@Override
public PageUtils queryPage(Map<String, Object> params) {
// 根据传入的参数创建一个分页对象,用于指定分页查询的相关设置,如页码和每页数量等。
Page<ShangpinleixingEntity> page = this.selectPage(
// 调用 Query 工具类的方法,根据传入的参数生成对应的分页对象。
new Query<ShangpinleixingEntity>(params).getPage(),
// 创建一个空的实体包装器,这里不设置具体的查询条件,即查询所有的商品类型实体。
new EntityWrapper<ShangpinleixingEntity>()
);
// 将分页查询得到的结果封装到 PageUtils 对象中并返回,以便后续使用。
return new PageUtils(page);
}
// 根据传入的参数和查询条件包装器进行分页查询商品类型视图数据。
//@param params 包含分页和查询条件的参数 Map与上面的 queryPage 方法中的 params 类似,
// 可用于指定分页和一些通用的查询条件。
// @param wrapper 用于构建具体查询条件的包装器,例如可以设置 where 子句等条件来筛选特定的商品类型数据。
// @return 封装了分页信息和查询结果(商品类型视图列表)的 PageUtils 对象。
@Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<ShangpinleixingEntity> wrapper) {
// 根据传入的参数创建商品类型视图的分页对象。
Page<ShangpinleixingView> page = new Query<ShangpinleixingView>(params).getPage();
// 调用基础映射器baseMapper的方法根据分页对象和查询条件包装器查询商品类型视图列表
// 并将查询结果设置到分页对象中。
page.setRecords(baseMapper.selectListView(page, wrapper));
// 将分页查询得到的结果封装到 PageUtils 对象中并返回。
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
// 根据查询条件包装器查询商品类型值对象VO的列表。
// @param wrapper 用于构建查询条件的包装器,通过设置条件筛选出符合要求的商品类型数据,
// 并以值对象VO的形式返回。
// @return 符合查询条件的商品类型值对象VO列表用于在业务层进行数据处理和展示。
@Override
public List<ShangpinleixingVO> selectListVO(Wrapper<ShangpinleixingEntity> wrapper) {
// 调用基础映射器的方法根据查询条件包装器查询商品类型值对象VO列表并返回。
return baseMapper.selectListVO(wrapper);
}
// 根据查询条件包装器查询单个商品类型值对象VO
// @param wrapper 用于构建查询条件的包装器,通过设置精确的条件筛选出唯一的商品类型数据,
// 并以值对象VO的形式返回。
//@return 符合查询条件的单个商品类型值对象VO如果没有找到符合条件的数据则可能返回 null。
@Override
public ShangpinleixingVO selectVO(Wrapper<ShangpinleixingEntity> wrapper) {
// 调用基础映射器的方法根据查询条件包装器查询单个商品类型值对象VO并返回。
return baseMapper.selectVO(wrapper);
}
// 根据查询条件包装器查询商品类型视图的列表。
//@param wrapper 用于构建查询条件的包装器,通过设置条件筛选出符合要求的商品类型视图数据。
// @return 符合查询条件的商品类型视图列表,用于在业务层进行数据展示或进一步处理。
@Override
public List<ShangpinleixingView> selectListView(Wrapper<ShangpinleixingEntity> wrapper) {
// 调用基础映射器的方法,根据查询条件包装器查询商品类型视图列表并返回。
return baseMapper.selectListView(wrapper);
}
// 根据查询条件包装器查询单个商品类型视图。
// @param wrapper 用于构建查询条件的包装器,通过设置精确的条件筛选出唯一的商品类型视图数据。
// @return 符合查询条件的单个商品类型视图,如果没有找到符合条件的数据,则可能返回 null。
@Override
public ShangpinleixingView selectView(Wrapper<ShangpinleixingEntity> wrapper) {
// 调用基础映射器的方法,根据查询条件包装器查询单个商品类型视图并返回。
return baseMapper.selectView(wrapper);
}
}

@ -1,99 +0,0 @@
package com.service.impl;
import org.springframework.stereotype.Service;
import java.util.Map;
import java.util.List;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.utils.PageUtils;
import com.utils.Query;
import com.dao.ShangpinrukuDao;
import com.entity.ShangpinrukuEntity;
import com.service.ShangpinrukuService;
import com.entity.vo.ShangpinrukuVO;
import com.entity.view.ShangpinrukuView;
//商品入库服务的实现类,实现了 ShangpinrukuService 接口,
// 继承自 MyBatis-Plus 的 ServiceImpl 类,用于处理商品入库相关的业务逻辑。
@Service("shangpinrukuService")
public class ShangpinrukuServiceImpl extends ServiceImpl<ShangpinrukuDao, ShangpinrukuEntity> implements ShangpinrukuService {
// 根据传入的参数进行分页查询商品入库实体数据。
// @param params 包含分页和查询条件的参数 Map如页码、每页数量等。
// @return 封装了分页信息和查询结果的 PageUtils 对象,方便前端展示分页数据。
@Override
public PageUtils queryPage(Map<String, Object> params) {
// 根据传入的参数创建分页对象,指定分页查询的相关设置
Page<ShangpinrukuEntity> page = this.selectPage(
// 调用 Query 工具类,根据参数生成对应的分页对象
new Query<ShangpinrukuEntity>(params).getPage(),
// 创建一个空的实体包装器,不设置查询条件,即查询所有商品入库实体
new EntityWrapper<ShangpinrukuEntity>()
);
// 将分页查询结果封装到 PageUtils 对象中并返回
return new PageUtils(page);
}
// 根据传入的参数和查询条件包装器进行分页查询商品入库视图数据。
// @param params 包含分页和查询条件的参数 Map。
// @param wrapper 用于构建查询条件的包装器,可筛选特定的商品入库数据。
// @return 封装了分页信息和查询结果的 PageUtils 对象。
@Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<ShangpinrukuEntity> wrapper) {
// 根据传入的参数创建商品入库视图的分页对象
Page<ShangpinrukuView> page = new Query<ShangpinrukuView>(params).getPage();
// 调用基础映射器的方法,根据分页对象和查询条件包装器查询商品入库视图列表
page.setRecords(baseMapper.selectListView(page, wrapper));
// 将分页查询结果封装到 PageUtils 对象中并返回
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
// 根据查询条件包装器查询商品入库值对象VO的列表。
// @param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的商品入库值对象VO列表。
@Override
public List<ShangpinrukuVO> selectListVO(Wrapper<ShangpinrukuEntity> wrapper) {
// 调用基础映射器的方法根据查询条件包装器查询商品入库值对象VO列表并返回
return baseMapper.selectListVO(wrapper);
}
// 根据查询条件包装器查询单个商品入库值对象VO
// @param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的单个商品入库值对象VO若未找到则可能返回 null。
@Override
public ShangpinrukuVO selectVO(Wrapper<ShangpinrukuEntity> wrapper) {
// 调用基础映射器的方法根据查询条件包装器查询单个商品入库值对象VO并返回
return baseMapper.selectVO(wrapper);
}
// 根据查询条件包装器查询商品入库视图的列表。
//@param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的商品入库视图列表。
@Override
public List<ShangpinrukuView> selectListView(Wrapper<ShangpinrukuEntity> wrapper) {
// 调用基础映射器的方法,根据查询条件包装器查询商品入库视图列表并返回
return baseMapper.selectListView(wrapper);
}
//根据查询条件包装器查询单个商品入库视图。
//@param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的单个商品入库视图,若未找到则可能返回 null。
@Override
public ShangpinrukuView selectView(Wrapper<ShangpinrukuEntity> wrapper) {
// 调用基础映射器的方法,根据查询条件包装器查询单个商品入库视图并返回
return baseMapper.selectView(wrapper);
}
}

@ -1,117 +0,0 @@
package com.service.impl;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Map;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.dao.TokenDao;
import com.entity.TokenEntity;
import com.service.TokenService;
import com.utils.CommonUtil;
import com.utils.PageUtils;
import com.utils.Query;
// Token 服务的实现类,实现了 TokenService 接口,
// 继承自 MyBatis-Plus 的 ServiceImpl 类,用于处理 Token 相关的业务逻辑。
@Service("tokenService")
public class TokenServiceImpl extends ServiceImpl<TokenDao, TokenEntity> implements TokenService {
//根据传入的参数进行分页查询 Token 实体数据。
// @param params 包含分页和查询条件的参数 Map如页码、每页数量等。
// @return 封装了分页信息和查询结果的 PageUtils 对象,方便前端展示分页数据。
@Override
public PageUtils queryPage(Map<String, Object> params) {
// 根据传入的参数创建分页对象,指定分页查询的相关设置
Page<TokenEntity> page = this.selectPage(
// 调用 Query 工具类,根据参数生成对应的分页对象
new Query<TokenEntity>(params).getPage(),
// 创建一个空的实体包装器,不设置查询条件,即查询所有 Token 实体
new EntityWrapper<TokenEntity>()
);
// 将分页查询结果封装到 PageUtils 对象中并返回
return new PageUtils(page);
}
// 根据查询条件包装器查询 Token 实体的列表视图。
// @param wrapper 用于构建查询条件的包装器,可筛选特定的 Token 实体。
// @return 符合查询条件的 Token 实体列表。
@Override
public List<TokenEntity> selectListView(Wrapper<TokenEntity> wrapper) {
// 调用基础映射器的方法,根据查询条件包装器查询 Token 实体列表并返回
return baseMapper.selectListView(wrapper);
}
// 根据传入的参数和查询条件包装器进行分页查询 Token 实体数据。
// @param params 包含分页和查询条件的参数 Map。
// @param wrapper 用于构建查询条件的包装器,可筛选特定的 Token 实体。
// @return 封装了分页信息和查询结果的 PageUtils 对象。
@Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<TokenEntity> wrapper) {
// 根据传入的参数创建 Token 实体的分页对象
Page<TokenEntity> page = new Query<TokenEntity>(params).getPage();
// 调用基础映射器的方法,根据分页对象和查询条件包装器查询 Token 实体列表
page.setRecords(baseMapper.selectListView(page, wrapper));
// 将分页查询结果封装到 PageUtils 对象中并返回
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
// 为指定用户生成一个新的 Token。
//如果该用户已经存在对应的 Token 记录,则更新 Token 和过期时间;
// 否则,插入一条新的 Token 记录。
// @param userid 用户 ID
// @param username 用户名
// @param tableName 表名
// @param role 用户角色
//@return 生成的新 Token
@Override
public String generateToken(Long userid, String username, String tableName, String role) {
// 根据用户 ID 和角色查询是否已经存在对应的 Token 记录
TokenEntity tokenEntity = this.selectOne(new EntityWrapper<TokenEntity>().eq("userid", userid).eq("role", role));
// 生成一个 32 位的随机字符串作为新的 Token
String token = CommonUtil.getRandomString(32);
// 获取当前时间,并设置过期时间为 1 小时后
Calendar cal = Calendar.getInstance();
cal.setTime(new Date());
cal.add(Calendar.HOUR_OF_DAY, 1);
if (tokenEntity != null) {
// 如果 Token 记录已存在,更新 Token 和过期时间
tokenEntity.setToken(token);
tokenEntity.setExpiratedtime(cal.getTime());
this.updateById(tokenEntity);
} else {
// 如果 Token 记录不存在,插入一条新的 Token 记录
this.insert(new TokenEntity(userid, username, tableName, role, token, cal.getTime()));
}
return token;
}
// 根据 Token 获取对应的 Token 实体。
// 检查 Token 是否存在以及是否过期,如果过期则返回 null。
// @param token 要查询的 Token
// @return 如果 Token 存在且未过期,返回对应的 Token 实体;否则返回 null。
@Override
public TokenEntity getTokenEntity(String token) {
// 根据 Token 查询对应的 Token 实体
TokenEntity tokenEntity = this.selectOne(new EntityWrapper<TokenEntity>().eq("token", token));
if (tokenEntity == null || tokenEntity.getExpiratedtime().getTime() < new Date().getTime()) {
// 如果 Token 不存在或已过期,返回 null
return null;
}
return tokenEntity;
}
}

@ -1,72 +0,0 @@
package com.service.impl;
import java.util.List;
import java.util.Map;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.dao.UserDao;
import com.entity.UserEntity;
import com.service.UserService;
import com.utils.PageUtils;
import com.utils.Query;
// 系统用户服务的实现类,实现了 UserService 接口,
// 继承自 MyBatis-Plus 的 ServiceImpl 类,用于处理与系统用户相关的业务逻辑。
// 该类通过依赖注入的方式使用 UserDao 来访问和操作数据库中的用户数据。
@Service("userService")
public class UserServiceImpl extends ServiceImpl<UserDao, UserEntity> implements UserService {
//根据传入的参数进行分页查询用户实体数据。
// @param params 包含分页和查询条件的参数 Map例如页码、每页数量、搜索关键词等。
// @return 封装了分页信息(如总页数、当前页数、每页记录数、总记录数等)和查询结果(用户实体列表)的 PageUtils 对象,
// 方便在业务层或展示层进行处理和展示分页数据。
@Override
public PageUtils queryPage(Map<String, Object> params) {
// 根据传入的参数创建一个分页对象,用于指定分页查询的相关设置,如页码和每页数量等。
Page<UserEntity> page = this.selectPage(
// 调用 Query 工具类的方法,根据传入的参数生成对应的分页对象。
new Query<UserEntity>(params).getPage(),
// 创建一个空的实体包装器,这里不设置具体的查询条件,即查询所有的用户实体。
new EntityWrapper<UserEntity>()
);
// 将分页查询得到的结果封装到 PageUtils 对象中并返回,以便后续使用。
return new PageUtils(page);
}
// 根据查询条件包装器查询用户实体的列表视图。
// @param wrapper 用于构建查询条件的包装器,通过设置条件筛选出符合要求的用户实体数据,
// 例如可以设置 where 子句等条件来筛选特定的用户数据。
// @return 符合查询条件的用户实体列表,用于在业务层进行数据处理和展示。
@Override
public List<UserEntity> selectListView(Wrapper<UserEntity> wrapper) {
// 调用基础映射器baseMapper的方法根据查询条件包装器查询用户实体列表并返回。
return baseMapper.selectListView(wrapper);
}
// 根据传入的参数和查询条件包装器进行分页查询用户实体数据。
// @param params 包含分页和查询条件的参数 Map与上面的 queryPage 方法中的 params 类似,
// 可用于指定分页和一些通用的查询条件。
//@param wrapper 用于构建具体查询条件的包装器,例如可以设置 where 子句等条件来筛选特定的用户数据。
//@return 封装了分页信息和查询结果(用户实体列表)的 PageUtils 对象。
@Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<UserEntity> wrapper) {
// 根据传入的参数创建用户实体的分页对象。
Page<UserEntity> page = new Query<UserEntity>(params).getPage();
// 调用基础映射器的方法,根据分页对象和查询条件包装器查询用户实体列表,
// 并将查询结果设置到分页对象中。
page.setRecords(baseMapper.selectListView(page, wrapper));
// 将分页查询得到的结果封装到 PageUtils 对象中并返回。
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
}

@ -1,25 +0,0 @@
package com.utils;
import cn.hutool.crypto.digest.DigestUtil;
//MD5Util 类是一个工具类,主要提供了使用 MD5 算法对字符串进行加密的功能。
// MD5 是一种广泛使用的哈希算法,用于生成数据的固定长度哈希值。
// 这里使用了 Hutool 工具包中的 DigestUtil 类来实现 MD5 加密。
public class MD5Util {
// 对输入的明文进行 MD5 加密。
//@param text 待加密的明文。该参数为要进行 MD5 加密的原始字符串。
// @return 加密后的密文。返回一个长度为 32 位的十六进制字符串,代表输入明文的 MD5 哈希值。
// 如果输入为 null 或空字符串,也会进行加密处理并返回相应的结果。
//注意:该方法原本注释中有 `key` 参数,但实际代码中未使用,
// 仅对输入的 `text` 进行了 MD5 加密,并非带密钥的加密方式。
//真正的带密钥加密通常需要将密钥与明文进行特定的组合后再进行哈希计算。
public static String md5(String text) {
// 调用 Hutool 工具包中的 DigestUtil 类的 md5Hex 方法对输入的 text 进行 MD5 加密,
// 并将加密结果以十六进制字符串的形式返回。
String md5str = DigestUtil.md5Hex(text);
return md5str;
}
}

@ -1,282 +0,0 @@
package com.utils;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.apache.commons.lang3.StringUtils;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.mapper.Wrapper;
//Mybatis-Plus工具类提供了一系列用于Mybatis-Plus查询条件构造和字符串格式转换的工具方法。
public class MPUtil {
// 定义下划线字符常量,用于驼峰转下划线操作
public static final char UNDERLINE = '_';
// 将Java Bean转换为Map并将Map中的键从驼峰格式转换为下划线格式同时添加前缀。
// @param bean 要转换的Java Bean对象
//@param pre 要添加的前缀,可用于指定表别名等
// @return 转换后的Map键为下划线格式且带有前缀
public static Map allEQMapPre(Object bean, String pre) {
// 使用Hutool的BeanUtil将Java Bean转换为Map
Map<String, Object> map = BeanUtil.beanToMap(bean);
// 调用camelToUnderlineMap方法将Map中的键从驼峰格式转换为下划线格式并添加前缀
return camelToUnderlineMap(map, pre);
}
// 将Java Bean转换为Map并将Map中的键从驼峰格式转换为下划线格式。
// @param bean 要转换的Java Bean对象
//@return 转换后的Map键为下划线格式
public static Map allEQMap(Object bean) {
// 使用Hutool的BeanUtil将Java Bean转换为Map
Map<String, Object> map = BeanUtil.beanToMap(bean);
// 调用camelToUnderlineMap方法将Map中的键从驼峰格式转换为下划线格式不添加前缀
return camelToUnderlineMap(map, "");
}
// 为Wrapper对象添加模糊查询条件将Java Bean转换为Map键转换为下划线格式并添加前缀。
// @param wrapper Mybatis-Plus的Wrapper对象用于构造查询条件
// @param bean 包含查询条件的Java Bean对象
//@param pre 要添加的前缀,可用于指定表别名等
// @return 添加了模糊查询条件的Wrapper对象
public static Wrapper allLikePre(Wrapper wrapper, Object bean, String pre) {
// 使用Hutool的BeanUtil将Java Bean转换为Map
Map<String, Object> map = BeanUtil.beanToMap(bean);
// 调用camelToUnderlineMap方法将Map中的键从驼峰格式转换为下划线格式并添加前缀
Map result = camelToUnderlineMap(map, pre);
// 调用genLike方法为Wrapper对象添加模糊查询条件
return genLike(wrapper, result);
}
// 为Wrapper对象添加模糊查询条件将Java Bean转换为Map。
//@param wrapper Mybatis-Plus的Wrapper对象用于构造查询条件
// @param bean 包含查询条件的Java Bean对象
// @return 添加了模糊查询条件的Wrapper对象
public static Wrapper allLike(Wrapper wrapper, Object bean) {
// 使用Hutool的BeanUtil将Java Bean转换为Map忽略空值和默认值
Map result = BeanUtil.beanToMap(bean, true, true);
// 调用genLike方法为Wrapper对象添加模糊查询条件
return genLike(wrapper, result);
}
// 为Wrapper对象添加模糊查询条件。
// @param wrapper Mybatis-Plus的Wrapper对象用于构造查询条件
// @param param 包含查询条件的Map键为字段名值为查询值
//@return 添加了模糊查询条件的Wrapper对象
public static Wrapper genLike(Wrapper wrapper, Map param) {
// 获取Map的迭代器
Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
int i = 0;
while (it.hasNext()) {
if (i > 0) {
// 如果不是第一个条件添加and连接符
wrapper.and();
}
// 获取Map中的键值对
Map.Entry<String, Object> entry = it.next();
String key = entry.getKey();
String value = (String) entry.getValue();
// 为Wrapper对象添加模糊查询条件
wrapper.like(key, value);
i++;
}
return wrapper;
}
//为Wrapper对象添加模糊查询或等值查询条件将Java Bean转换为Map。
// @param wrapper Mybatis-Plus的Wrapper对象用于构造查询条件
//@param bean 包含查询条件的Java Bean对象
//@return 添加了模糊查询或等值查询条件的Wrapper对象
public static Wrapper likeOrEq(Wrapper wrapper, Object bean) {
// 使用Hutool的BeanUtil将Java Bean转换为Map忽略空值和默认值
Map result = BeanUtil.beanToMap(bean, true, true);
// 调用genLikeOrEq方法为Wrapper对象添加模糊查询或等值查询条件
return genLikeOrEq(wrapper, result);
}
// 为Wrapper对象添加模糊查询或等值查询条件。
// @param wrapper Mybatis-Plus的Wrapper对象用于构造查询条件
// @param param 包含查询条件的Map键为字段名值为查询值
// @return 添加了模糊查询或等值查询条件的Wrapper对象
public static Wrapper genLikeOrEq(Wrapper wrapper, Map param) {
// 获取Map的迭代器
Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
int i = 0;
while (it.hasNext()) {
if (i > 0) {
// 如果不是第一个条件添加and连接符
wrapper.and();
}
// 获取Map中的键值对
Map.Entry<String, Object> entry = it.next();
String key = entry.getKey();
if (entry.getValue().toString().contains("%")) {
// 如果值包含%,则添加模糊查询条件,去除%
wrapper.like(key, entry.getValue().toString().replace("%", ""));
} else {
// 否则添加等值查询条件
wrapper.eq(key, entry.getValue());
}
i++;
}
return wrapper;
}
// 为Wrapper对象添加等值查询条件将Java Bean转换为Map。
// @param wrapper Mybatis-Plus的Wrapper对象用于构造查询条件
// @param bean 包含查询条件的Java Bean对象
// @return 添加了等值查询条件的Wrapper对象
public static Wrapper allEq(Wrapper wrapper, Object bean) {
// 使用Hutool的BeanUtil将Java Bean转换为Map忽略空值和默认值
Map result = BeanUtil.beanToMap(bean, true, true);
// 调用genEq方法为Wrapper对象添加等值查询条件
return genEq(wrapper, result);
}
// 为Wrapper对象添加等值查询条件。
// @param wrapper Mybatis-Plus的Wrapper对象用于构造查询条件
// @param param 包含查询条件的Map键为字段名值为查询值
// @return 添加了等值查询条件的Wrapper对象
public static Wrapper genEq(Wrapper wrapper, Map param) {
// 获取Map的迭代器
Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
int i = 0;
while (it.hasNext()) {
if (i > 0) {
// 如果不是第一个条件添加and连接符
wrapper.and();
}
// 获取Map中的键值对
Map.Entry<String, Object> entry = it.next();
String key = entry.getKey();
// 为Wrapper对象添加等值查询条件
wrapper.eq(key, entry.getValue());
i++;
}
return wrapper;
}
// 为Wrapper对象添加范围查询条件。
// @param wrapper Mybatis-Plus的Wrapper对象用于构造查询条件
// @param params 包含范围查询条件的Map键为字段名_start或字段名_end值为查询范围
// @return 添加了范围查询条件的Wrapper对象
public static Wrapper between(Wrapper wrapper, Map<String, Object> params) {
for (String key : params.keySet()) {
String columnName = "";
if (key.endsWith("_start")) {
// 处理以_start结尾的键获取字段名
columnName = key.substring(0, key.indexOf("_start"));
if (StringUtils.isNotBlank(params.get(key).toString())) {
// 如果值不为空,添加大于等于查询条件
wrapper.ge(columnName, params.get(key));
}
}
if (key.endsWith("_end")) {
// 处理以_end结尾的键获取字段名
columnName = key.substring(0, key.indexOf("_end"));
if (StringUtils.isNotBlank(params.get(key).toString())) {
// 如果值不为空,添加小于等于查询条件
wrapper.le(columnName, params.get(key));
}
}
}
return wrapper;
}
//为Wrapper对象添加排序条件。
// @param wrapper Mybatis-Plus的Wrapper对象用于构造查询条件
// @param params 包含排序条件的Map键为order排序方式asc或desc和sort排序字段
//@return 添加了排序条件的Wrapper对象
public static Wrapper sort(Wrapper wrapper, Map<String, Object> params) {
String order = "";
if (params.get("order") != null && StringUtils.isNotBlank(params.get("order").toString())) {
// 获取排序方式
order = params.get("order").toString();
}
if (params.get("sort") != null && StringUtils.isNotBlank(params.get("sort").toString())) {
if (order.equalsIgnoreCase("desc")) {
// 如果排序方式为desc添加降序排序条件
wrapper.orderDesc(Arrays.asList(params.get("sort")));
} else {
// 否则添加升序排序条件
wrapper.orderAsc(Arrays.asList(params.get("sort")));
}
}
return wrapper;
}
// 将驼峰格式的字符串转换为下划线格式的字符串。
// @param param 要转换的驼峰格式字符串
// @return 转换后的下划线格式字符串
public static String camelToUnderline(String param) {
if (param == null || "".equals(param.trim())) {
return "";
}
int len = param.length();
StringBuilder sb = new StringBuilder(len);
for (int i = 0; i < len; i++) {
char c = param.charAt(i);
if (Character.isUpperCase(c)) {
// 如果是大写字母,添加下划线并转换为小写字母
sb.append(UNDERLINE);
sb.append(Character.toLowerCase(c));
} else {
// 否则直接添加字符
sb.append(c);
}
}
return sb.toString();
}
// 测试驼峰转下划线方法。
//@param ages 命令行参数
public static void main(String[] ages) {
// 测试驼峰转下划线方法
System.out.println(camelToUnderline("ABCddfANM"));
}
//将Map中的键从驼峰格式转换为下划线格式并添加前缀。
//@param param 要转换的Map
// @param pre 要添加的前缀,可用于指定表别名等
// @return 转换后的Map键为下划线格式且带有前缀
public static Map camelToUnderlineMap(Map param, String pre) {
Map<String, Object> newMap = new HashMap<String, Object>();
// 获取Map的迭代器
Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
while (it.hasNext()) {
// 获取Map中的键值对
Map.Entry<String, Object> entry = it.next();
String key = entry.getKey();
// 将键从驼峰格式转换为下划线格式
String newKey = camelToUnderline(key);
if (pre.endsWith(".")) {
// 如果前缀以.结尾,直接添加前缀和新键
newMap.put(pre + newKey, entry.getValue());
} else if (StringUtils.isEmpty(pre)) {
// 如果前缀为空,直接添加新键
newMap.put(newKey, entry.getValue());
} else {
// 否则添加前缀.和新键
newMap.put(pre + "." + newKey, entry.getValue());
}
}
return newMap;
}
}

@ -1,118 +0,0 @@
package com.utils;
import java.io.Serializable;
import java.util.List;
import java.util.Map;
import com.baomidou.mybatisplus.plugins.Page;
// 分页工具类,用于封装分页相关的信息,方便在业务层和展示层之间传递分页数据。
// 实现了Serializable接口以便该类的实例可以在网络传输或存储到文件等场景中使用。
public class PageUtils implements Serializable {
// 序列化版本号,用于确保不同版本的类在反序列化时的兼容性
private static final long serialVersionUID = 1L;
// 总记录数,即满足查询条件的所有记录的数量
private long total;
// 每页记录数,指定每页显示的记录数量
private int pageSize;
// 总页数,根据总记录数和每页记录数计算得出的总页数
private long totalPage;
// 当前页数,标识当前请求的是第几页数据
private int currPage;
// 列表数据,包含当前页的具体数据记录
private List<?> list;
// 构造方法,根据提供的列表数据、总记录数、每页记录数和当前页数来初始化分页信息。
//@param list 列表数据,包含当前页的具体记录
// @param totalCount 总记录数,满足查询条件的所有记录的数量
//@param pageSize 每页记录数,指定每页显示的记录数量
// @param currPage 当前页数,标识当前请求的是第几页数据
public PageUtils(List<?> list, int totalCount, int pageSize, int currPage) {
this.list = list;
this.total = totalCount;
this.pageSize = pageSize;
this.currPage = currPage;
// 使用Math.ceil方法向上取整计算总页数确保总页数能够覆盖所有记录
this.totalPage = (int) Math.ceil((double) totalCount / pageSize);
}
// 构造方法根据MyBatis-Plus的Page对象来初始化分页信息。
// @param page MyBatis-Plus的Page对象包含了分页相关的各种信息
public PageUtils(Page<?> page) {
// 从Page对象中获取当前页的记录列表
this.list = page.getRecords();
// 从Page对象中获取总记录数
this.total = page.getTotal();
// 从Page对象中获取每页记录数
this.pageSize = page.getSize();
// 从Page对象中获取当前页数
this.currPage = page.getCurrent();
// 从Page对象中获取总页数
this.totalPage = page.getPages();
}
// 构造方法根据传入的参数Map来初始化分页信息。
//该方法先通过Query工具类根据参数生成Page对象再调用另一个构造方法初始化分页信息。
//@param params 包含分页相关参数的Map例如页码、每页数量等
public PageUtils(Map<String, Object> params) {
// 通过Query工具类根据参数生成Page对象
Page page = new Query(params).getPage();
// 调用另一个构造方法根据生成的Page对象初始化分页信息
new PageUtils(page);
}
// 获取每页记录数的方法
public int getPageSize() {
return pageSize;
}
// 设置每页记录数的方法
public void setPageSize(int pageSize) {
this.pageSize = pageSize;
}
// 获取当前页数的方法
public int getCurrPage() {
return currPage;
}
// 设置当前页数的方法
public void setCurrPage(int currPage) {
this.currPage = currPage;
}
// 获取列表数据的方法
public List<?> getList() {
return list;
}
// 设置列表数据的方法
public void setList(List<?> list) {
this.list = list;
}
// 获取总页数的方法
public long getTotalPage() {
return totalPage;
}
// 设置总页数的方法
public void setTotalPage(long totalPage) {
this.totalPage = totalPage;
}
// 获取总记录数的方法
public long getTotal() {
return total;
}
// 设置总记录数的方法
public void setTotal(long total) {
this.total = total;
}
}

@ -1,120 +0,0 @@
package com.utils;
import java.util.LinkedHashMap;
import java.util.Map;
import org.apache.commons.lang3.StringUtils;
import com.baomidou.mybatisplus.plugins.Page;
// 查询参数类继承自LinkedHashMap<String, Object>
// 用于封装查询相关的参数,如分页参数、排序参数等,并提供了一些方法来处理这些参数,
// 以适配MyBatis-Plus的分页和排序功能。
public class Query<T> extends LinkedHashMap<String, Object> {
// 序列化版本号,用于确保不同版本的类在反序列化时的兼容性
private static final long serialVersionUID = 1L;
// mybatis-plus分页参数用于封装MyBatis-Plus的分页信息如当前页码、每页条数等。
private Page<T> page;
// 当前页码默认值为1表示第一页。
private int currPage = 1;
//每页条数默认值为10表示每页显示10条记录。
private int limit = 10;
// 构造方法根据JQPageInfo对象来初始化查询参数。
// @param pageInfo 包含分页和排序信息的JQPageInfo对象。
public Query(JQPageInfo pageInfo) {
// 分页参数处理
// 如果JQPageInfo中存在页码信息则更新当前页码
if (pageInfo.getPage() != null) {
currPage = pageInfo.getPage();
}
// 如果JQPageInfo中存在每页条数信息则更新每页条数
if (pageInfo.getLimit() != null) {
limit = pageInfo.getLimit();
}
// 防止SQL注入
// 对排序字段sidx和排序方式order进行SQL注入过滤
String sidx = SQLFilter.sqlInject(pageInfo.getSidx());
String order = SQLFilter.sqlInject(pageInfo.getOrder());
// mybatis-plus分页
// 创建MyBatis-Plus的Page对象传入当前页码和每页条数
this.page = new Page<>(currPage, limit);
// 排序处理
// 如果排序字段和排序方式都不为空则设置MyBatis-Plus的Page对象的排序信息
if (StringUtils.isNotBlank(sidx) && StringUtils.isNotBlank(order)) {
this.page.setOrderByField(sidx);
this.page.setAsc("ASC".equalsIgnoreCase(order));
}
}
// 构造方法根据传入的参数Map来初始化查询参数。
//@param params 包含查询参数的Map如page页码、limit每页条数、sidx排序字段、order排序方式等。
public Query(Map<String, Object> params) {
// 将传入的参数Map中的所有键值对放入当前对象中
this.putAll(params);
// 分页参数处理
// 如果参数Map中存在页码信息则更新当前页码
if (params.get("page") != null) {
currPage = Integer.parseInt((String) params.get("page"));
}
// 如果参数Map中存在每页条数信息则更新每页条数
if (params.get("limit") != null) {
limit = Integer.parseInt((String) params.get("limit"));
}
// 计算偏移量offset即当前页数据在总数据中的起始位置
this.put("offset", (currPage - 1) * limit);
// 将当前页码和每页条数重新放入参数Map中以便其他地方使用
this.put("page", currPage);
this.put("limit", limit);
// 防止SQL注入
// 对排序字段sidx和排序方式order进行SQL注入过滤
String sidx = SQLFilter.sqlInject((String) params.get("sidx"));
String order = SQLFilter.sqlInject((String) params.get("order"));
// 将过滤后的排序字段和排序方式重新放入参数Map中
this.put("sidx", sidx);
this.put("order", order);
// mybatis-plus分页
// 创建MyBatis-Plus的Page对象传入当前页码和每页条数
this.page = new Page<>(currPage, limit);
// 排序处理
// 如果排序字段和排序方式都不为空则设置MyBatis-Plus的Page对象的排序信息
if (StringUtils.isNotBlank(sidx) && StringUtils.isNotBlank(order)) {
this.page.setOrderByField(sidx);
this.page.setAsc("ASC".equalsIgnoreCase(order));
}
}
//获取MyBatis-Plus的Page对象包含分页和排序信息。
// @return MyBatis-Plus的Page对象。
public Page<T> getPage() {
return page;
}
//获取当前页码。
// @return 当前页码。
public int getCurrPage() {
return currPage;
}
// 获取每页条数。
// @return 每页条数。
public int getLimit() {
return limit;
}
}

@ -1,83 +0,0 @@
package com.utils;
import java.util.HashMap;
import java.util.Map;
//返回数据类继承自HashMap<String, Object>
// 用于封装和返回业务处理的结果数据,通常用于前后端交互时返回响应信息。
public class R extends HashMap<String, Object> {
// 序列化版本号,用于确保不同版本的类在反序列化时的兼容性
private static final long serialVersionUID = 1L;
//构造方法初始化一个R对象并设置默认的返回码为0通常表示成功
public R() {
put("code", 0);
}
//静态方法返回一个表示错误的R对象错误码为500错误信息为“未知异常请联系管理员”。
// @return 表示错误的R对象。
public static R error() {
return error(500, "未知异常,请联系管理员");
}
// 静态方法返回一个表示错误的R对象错误码为500错误信息为传入的msg。
// @param msg 错误信息。
// @return 表示错误的R对象。
public static R error(String msg) {
return error(500, msg);
}
// 静态方法返回一个表示错误的R对象错误码为传入的code错误信息为传入的msg。
// @param code 错误码。
//@param msg 错误信息。
//@return 表示错误的R对象。
public static R error(int code, String msg) {
R r = new R();
r.put("code", code);
r.put("msg", msg);
return r;
}
// 静态方法返回一个表示成功的R对象包含传入的成功提示信息msg。
// @param msg 成功提示信息。
// @return 表示成功的R对象。
public static R ok(String msg) {
R r = new R();
r.put("msg", msg);
return r;
}
//静态方法返回一个表示成功的R对象将传入的map中的键值对添加到R对象中。
//@param map 包含数据的Map对象。
// @return 表示成功的R对象。
public static R ok(Map<String, Object> map) {
R r = new R();
r.putAll(map);
return r;
}
// 静态方法返回一个表示成功的R对象只包含默认的返回码0。
//@return 表示成功的R对象。
public static R ok() {
return new R();
}
//重写put方法将键值对添加到R对象中并返回当前R对象
// 支持链式调用,方便连续添加多个键值对。
// @param key 键。
// @param value 值。
// @return 当前R对象。
public R put(String key, Object value) {
super.put(key, value);
return this;
}
}

@ -1,50 +0,0 @@
package com.utils;
import org.apache.commons.lang3.StringUtils;
import com.entity.EIException;
//SQL过滤类用于对输入的字符串进行SQL注入风险的检查和过滤
// 以增强应用程序的安全性防止恶意用户通过SQL注入攻击数据库。
public class SQLFilter {
// SQL注入过滤方法对传入的字符串进行检查和处理
//去除可能导致SQL注入的危险字符并检查是否包含非法的SQL关键字。
// @param str 待验证的字符串通常是用户输入的内容可能用于构建SQL语句。
// @return 经过处理后的字符串如果字符串为空则返回null
// 如果字符串包含非法字符则抛出EIException异常。
public static String sqlInject(String str) {
// 判断字符串是否为空或空白字符串如果是则直接返回null
if (StringUtils.isBlank(str)) {
return null;
}
// 去掉字符串中的单引号(')、双引号(")、分号(;)和反斜杠(\)
// 这些字符在SQL语句中可能被用于构造恶意的SQL注入语句。
str = StringUtils.replace(str, "'", "");
str = StringUtils.replace(str, "\"", "");
str = StringUtils.replace(str, ";", "");
str = StringUtils.replace(str, "\\", "");
// 将字符串转换为小写,以便统一检查非法关键字,
// 因为SQL关键字不区分大小写转换为小写后可以更方便地进行比较。
str = str.toLowerCase();
// 定义一个包含常见非法SQL关键字的数组这些关键字可能被用于恶意的SQL操作
// 如删除数据delete、修改数据update、创建或修改表结构alter、drop等。
String[] keywords = {"master", "truncate", "insert", "select", "delete", "update", "declare", "alter", "drop"};
// 遍历非法关键字数组,检查字符串中是否包含这些关键字。
// 如果包含则认为该字符串存在SQL注入风险抛出EIException异常。
for (String keyword : keywords) {
if (str.indexOf(keyword) != -1) {
throw new EIException("包含非法字符");
}
}
// 如果字符串经过上述处理后没有发现非法字符,则返回处理后的字符串。
return str;
}
}

@ -1,71 +0,0 @@
package com.utils;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
//Spring Context 工具类,实现了 ApplicationContextAware 接口,
// 用于在非 Spring 管理的类中获取 Spring 应用上下文ApplicationContext
//从而可以方便地获取 Spring 容器中管理的 Bean。
@Component
public class SpringContextUtils implements ApplicationContextAware {
// 静态变量,用于存储 Spring 应用上下文
public static ApplicationContext applicationContext;
//实现 ApplicationContextAware 接口的方法,当 Spring 容器初始化完成后,
// 会自动调用该方法并传入 ApplicationContext 实例,将其赋值给静态变量。
// @param applicationContext Spring 应用上下文实例
// @throws BeansException 如果在设置应用上下文时出现 Bean 相关的异常
@Override
public void setApplicationContext(ApplicationContext applicationContext)
throws BeansException {
SpringContextUtils.applicationContext = applicationContext;
}
// 根据 Bean 的名称从 Spring 容器中获取对应的 Bean 实例。
// @param name Bean 的名称
// @return 对应的 Bean 实例
public static Object getBean(String name) {
return applicationContext.getBean(name);
}
// 根据 Bean 的名称和类型从 Spring 容器中获取对应的 Bean 实例,
// 并将其转换为指定的类型。
// @param name Bean 的名称
// @param requiredType 所需 Bean 的类型
// @param <T> 泛型类型
// @return 对应的 Bean 实例
public static <T> T getBean(String name, Class<T> requiredType) {
return applicationContext.getBean(name, requiredType);
}
//检查 Spring 容器中是否包含指定名称的 Bean。
// @param name Bean 的名称
// @return 如果包含则返回 true否则返回 false
public static boolean containsBean(String name) {
return applicationContext.containsBean(name);
}
// 检查指定名称的 Bean 在 Spring 容器中是否为单例模式。
//@param name Bean 的名称
//@return 如果是单例则返回 true否则返回 false
public static boolean isSingleton(String name) {
return applicationContext.isSingleton(name);
}
// 获取指定名称的 Bean 在 Spring 容器中的类型。
//@param name Bean 的名称
//@return Bean 的类型
public static Class<? extends Object> getType(String name) {
return applicationContext.getType(name);
}
}

@ -1,44 +0,0 @@
package com.utils;
import java.util.Set;
import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;
import com.entity.EIException;
// hibernate-validator校验工具类用于利用Hibernate Validator框架
// 对对象进行验证,检查对象的属性是否符合预先定义的验证规则。
public class ValidatorUtils {
// 静态变量用于存储Validator实例该实例用于执行验证操作
private static Validator validator;
// 静态代码块在类加载时执行初始化Validator实例
static {
// 通过Validation.buildDefaultValidatorFactory()获取默认的验证工厂,
// 然后调用其getValidator()方法获取Validator实例
validator = Validation.buildDefaultValidatorFactory().getValidator();
}
//校验对象的方法,根据传入的对象和验证组对对象进行验证。
// @param object 待校验的对象,该对象的属性应使用合适的验证注解进行标注。
// @param groups 待校验的组指定了要应用的验证规则组可以传入多个Class对象表示不同的组。
// @throws EIException 如果校验不通过即存在约束违反ConstraintViolation
// 则抛出EIException异常并将第一个约束违反的错误信息作为异常消息。
public static void validateEntity(Object object, Class<?>... groups)
throws EIException {
// 调用Validator的validate方法对对象进行验证传入对象和验证组
// 该方法返回一个包含所有约束违反的Set集合
Set<ConstraintViolation<Object>> constraintViolations = validator.validate(object, groups);
// 判断约束违反的Set集合是否为空如果不为空说明对象的属性存在不符合验证规则的情况
if (!constraintViolations.isEmpty()) {
// 获取第一个约束违反的实例
ConstraintViolation<Object> constraint = (ConstraintViolation<Object>) constraintViolations.iterator().next();
// 抛出EIException异常并将约束违反的错误信息作为异常消息
throw new EIException(constraint.getMessage());
}
}
}

@ -1,10 +0,0 @@
validationQuery=SELECT 1
jdbc_url=jdbc:mysql://127.0.0.1:3306/ssm3d8m9?useUnicode=true&characterEncoding=UTF-8&tinyInt1isBit=false
jdbc_username=root
jdbc_password=root
#jdbc_url=jdbc:sqlserver://127.0.0.1:1433;DatabaseName=ssm3d8m9
#jdbc_username=sa
#jdbc_password=123456

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

Loading…
Cancel
Save