Compare commits

..

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

@ -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 +1,2 @@
# 公司财务管理系统(数据库加VX获取☟) # ass
> 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: 1009 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 1.6 MiB

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,26 +0,0 @@
package com.annotation;
// 导入用于指定注解可以应用的元素类型的类
import java.lang.annotation.ElementType;
// 导入用于指定注解的保留策略的类
import java.lang.annotation.Retention;
// 导入用于指定注解保留策略的枚举类型
import java.lang.annotation.RetentionPolicy;
// 导入用于指定注解可以应用的目标类型的类
import java.lang.annotation.Target;
//登录用户信息
// 此注解用于标记方法参数,表明该参数是当前登录用户的信息。
// 它可以在运行时通过反射机制被读取,以便在方法执行时获取登录用户的相关信息。
// @Target 注解指定该注解可以应用的目标类型,这里是 PARAMETER即可以应用于方法的参数上
@Target(ElementType.PARAMETER)
// @Retention 注解指定该注解的保留策略,这里是 RUNTIME意味着该注解在运行时可以被 JVM 保留,从而可以通过反射机制获取注解信息
@Retention(RetentionPolicy.RUNTIME)
// 定义一个名为 APPLoginUser 的注解
public @interface APPLoginUser {
// 注解体为空,这意味着该注解没有定义任何属性,只是作为一个标记使用
// 可以在方法参数上使用 @APPLoginUser 来标识该参数与登录用户信息相关
}

@ -1,24 +0,0 @@
package com.annotation;
// 导入 Java 注解相关的类,涵盖了用于定义注解属性的通用类
import java.lang.annotation.*;
// 忽略 Token 验证
// 此注解的作用是标记某些方法在执行时无需进行 Token 验证。
// 在项目里,通常会有部分接口无需进行身份验证,就可以直接访问,
//这时就能使用这个注解来标记这些方法。
// @Target 注解用来指定该注解可以应用的目标类型,这里是 METHOD意味着该注解能够应用在方法上
@Target(ElementType.METHOD)
// @Retention 注解用于指定该注解的保留策略,这里是 RUNTIME
// 表明该注解在运行时可被 JVM 保留,进而可以通过反射机制获取注解信息
@Retention(RetentionPolicy.RUNTIME)
// @Documented 注解表明该注解会被包含在 JavaDoc 文档中
@Documented
// 定义一个名为 IgnoreAuth 的注解
public @interface IgnoreAuth {
// 注解体为空,说明该注解只是作为一个标记使用,不定义任何属性
// 可以在方法上使用 @IgnoreAuth 来标记该方法无需进行 Token 验证
}

@ -1,28 +0,0 @@
// 声明该类所在的包名为 com.annotation
package com.annotation;
// 导入用于指定注解可以应用的元素类型的类
import java.lang.annotation.ElementType;
// 导入用于指定注解保留策略的类
import java.lang.annotation.Retention;
// 导入用于指定注解保留策略的枚举类型
import java.lang.annotation.RetentionPolicy;
// 导入用于指定注解可以应用的目标类型的类
import java.lang.annotation.Target;
//登录用户信息
// 此注解用于标记方法参数,表明该参数和当前登录用户的信息相关。
// 在程序运行时,可通过反射机制读取该注解,从而获取登录用户的相关信息。
// @Target 注解指定了该注解可以应用的目标类型,这里设置为 PARAMETER即该注解可用于方法的参数
@Target(ElementType.PARAMETER)
// @Retention 注解指定了该注解的保留策略,这里设置为 RUNTIME意味着该注解在运行时会被 JVM 保留,能通过反射获取注解信息
@Retention(RetentionPolicy.RUNTIME)
//定义一个名为 LoginUser 的注解
// 该注解可用于标记那些期望接收登录用户信息的方法参数
public @interface LoginUser {
// 注解体为空,说明该注解只是作为一个标记使用,不包含额外的属性
// 开发者可以在方法参数上使用 @LoginUser 来表明该参数是登录用户信息
}

@ -1,49 +0,0 @@
// 声明该类所在的包为 com.config
package com.config;
// 导入日期类,用于表示时间
import java.util.Date;
// 导入 MyBatis 的 MetaObject 类,它可以用来访问和修改对象的属性
import org.apache.ibatis.reflection.MetaObject;
// 导入 MyBatis-Plus 的 MetaObjectHandler 类,这是一个元对象处理器接口,用于实现自动填充功能
import com.baomidou.mybatisplus.mapper.MetaObjectHandler;
// 自定义填充处理器
// 该类继承自 MyBatis-Plus 的 MetaObjectHandler 类,用于在插入和更新操作时自动填充一些字段的值。
public class MyMetaObjectHandler extends MetaObjectHandler {
// 插入操作时的自动填充方法
// 当执行插入操作时MyBatis-Plus 会调用此方法,允许我们为某些字段自动设置值。
//@param metaObject 包含了当前要插入对象的元数据信息,可以通过它来访问和修改对象的属性。
@Override
public void insertFill(MetaObject metaObject) {
// 使用 setFieldValByName 方法为指定字段设置值
// 这里为名为 "ctime" 的字段设置当前日期和时间,即记录创建的时间
// 参数依次为:要设置值的字段名、要设置的值、包含对象元数据的 MetaObject
this.setFieldValByName("ctime", new Date(), metaObject);
}
// 是否开启更新填充的方法
// 该方法返回一个布尔值,用于指示是否开启更新操作时的自动填充功能。
// @return false 表示不开启更新填充功能。
@Override
public boolean openUpdateFill() {
return false;
}
// 更新操作时的自动填充方法
// 由于 openUpdateFill 方法返回 false即关闭了更新填充功能所以该方法内不执行任何操作。
//@param metaObject 包含了当前要更新对象的元数据信息。
@Override
public void updateFill(MetaObject metaObject) {
// 关闭更新填充、这里不执行
}
}

@ -1,317 +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.BumenfenleiEntity;
// 导入部门分类视图类
import com.entity.view.BumenfenleiView;
// 导入部门分类服务类
import com.service.BumenfenleiService;
// 导入令牌服务类
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("/bumenfenlei")
public class BumenfenleiController {
// 自动注入部门分类服务类的实例
@Autowired
private BumenfenleiService bumenfenleiService;
//后端列表
//该方法用于处理后端获取部门分类列表的请求,支持分页查询。
// @param params 请求参数,包含分页、排序等信息
// @param bumenfenlei 部门分类实体,用于构建查询条件
//@param request HTTP 请求对象
// @return 包含分页数据的响应结果
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, BumenfenleiEntity bumenfenlei,
HttpServletRequest request) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<BumenfenleiEntity> ew = new EntityWrapper<BumenfenleiEntity>();
// 调用服务类的查询分页方法,传入请求参数和处理后的查询条件
PageUtils page = bumenfenleiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, bumenfenlei), params), params));
// 返回成功响应,并将分页数据放入响应结果中
return R.ok().put("data", page);
}
// 前端列表
// 该方法用于处理前端获取部门分类列表的请求,支持分页查询。
//@param params 请求参数,包含分页、排序等信息
// @param bumenfenlei 部门分类实体,用于构建查询条件
//@param request HTTP 请求对象
// @return 包含分页数据的响应结果
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, BumenfenleiEntity bumenfenlei,
HttpServletRequest request) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<BumenfenleiEntity> ew = new EntityWrapper<BumenfenleiEntity>();
// 调用服务类的查询分页方法,传入请求参数和处理后的查询条件
PageUtils page = bumenfenleiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, bumenfenlei), params), params));
// 返回成功响应,并将分页数据放入响应结果中
return R.ok().put("data", page);
}
// 列表
// 该方法用于获取满足特定条件的部门分类列表。
//@param bumenfenlei 部门分类实体,用于构建查询条件
// @return 包含部门分类列表的响应结果
@RequestMapping("/lists")
public R list(BumenfenleiEntity bumenfenlei) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<BumenfenleiEntity> ew = new EntityWrapper<BumenfenleiEntity>();
// 设置查询条件,使所有字段相等
ew.allEq(MPUtil.allEQMapPre(bumenfenlei, "bumenfenlei"));
// 调用服务类的查询列表视图方法,传入查询条件
return R.ok().put("data", bumenfenleiService.selectListView(ew));
}
// 查询
// 该方法用于根据条件查询单个部门分类信息。
// @param bumenfenlei 部门分类实体,用于构建查询条件
// @return 包含查询结果的响应结果
@RequestMapping("/query")
public R query(BumenfenleiEntity bumenfenlei) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<BumenfenleiEntity> ew = new EntityWrapper<BumenfenleiEntity>();
// 设置查询条件,使所有字段相等
ew.allEq(MPUtil.allEQMapPre(bumenfenlei, "bumenfenlei"));
// 调用服务类的查询视图方法,传入查询条件
BumenfenleiView bumenfenleiView = bumenfenleiService.selectView(ew);
// 返回成功响应,并将查询结果放入响应结果中
return R.ok("查询部门分类成功").put("data", bumenfenleiView);
}
// 后端详情
// 该方法用于获取指定 ID 的部门分类详细信息。
// @param id 部门分类的 ID
// @return 包含部门分类详细信息的响应结果
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id) {
// 根据 ID 查询部门分类实体
BumenfenleiEntity bumenfenlei = bumenfenleiService.selectById(id);
// 返回成功响应,并将部门分类详细信息放入响应结果中
return R.ok().put("data", bumenfenlei);
}
// 前端详情
// 该方法用于获取指定 ID 的部门分类详细信息。
//@param id 部门分类的 ID
// @return 包含部门分类详细信息的响应结果
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id) {
// 根据 ID 查询部门分类实体
BumenfenleiEntity bumenfenlei = bumenfenleiService.selectById(id);
// 返回成功响应,并将部门分类详细信息放入响应结果中
return R.ok().put("data", bumenfenlei);
}
// 后端保存
// 该方法用于在后端保存新的部门分类信息。
//@param bumenfenlei 部门分类实体,包含要保存的信息
// @param request HTTP 请求对象
//@return 保存成功的响应结果
@RequestMapping("/save")
public R save(@RequestBody BumenfenleiEntity bumenfenlei, HttpServletRequest request) {
// 为部门分类实体设置一个唯一的 ID由当前时间戳和随机数组成
bumenfenlei.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(bumenfenlei);
// 调用服务类的插入方法,保存部门分类信息
bumenfenleiService.insert(bumenfenlei);
// 返回成功响应
return R.ok();
}
//前端保存
// 该方法用于在前端保存新的部门分类信息。
// @param bumenfenlei 部门分类实体,包含要保存的信息
// @param request HTTP 请求对象
// @return 保存成功的响应结果
@RequestMapping("/add")
public R add(@RequestBody BumenfenleiEntity bumenfenlei, HttpServletRequest request) {
// 为部门分类实体设置一个唯一的 ID由当前时间戳和随机数组成
bumenfenlei.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(bumenfenlei);
// 调用服务类的插入方法,保存部门分类信息
bumenfenleiService.insert(bumenfenlei);
// 返回成功响应
return R.ok();
}
// 修改
// 该方法用于修改已有的部门分类信息。
// @param bumenfenlei 部门分类实体,包含要修改的信息
//@param request HTTP 请求对象
//@return 修改成功的响应结果
@RequestMapping("/update")
public R update(@RequestBody BumenfenleiEntity bumenfenlei, HttpServletRequest request) {
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(bumenfenlei);
// 调用服务类的更新方法,根据 ID 更新部门分类信息
bumenfenleiService.updateById(bumenfenlei); // 全部更新
// 返回成功响应
return R.ok();
}
//删除
//该方法用于批量删除指定 ID 的部门分类信息。
// @param ids 要删除的部门分类的 ID 数组
// @return 删除成功的响应结果
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) {
// 调用服务类的批量删除方法,根据 ID 列表删除部门分类信息
bumenfenleiService.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<BumenfenleiEntity> wrapper = new EntityWrapper<BumenfenleiEntity>();
if (map.get("remindstart") != null) {
// 设置查询条件,列值大于等于提醒开始日期
wrapper.ge(columnName, map.get("remindstart"));
}
if (map.get("remindend") != null) {
// 设置查询条件,列值小于等于提醒结束日期
wrapper.le(columnName, map.get("remindend"));
}
// 调用服务类的统计数量方法,根据查询条件统计满足条件的部门分类数量
int count = bumenfenleiService.selectCount(wrapper);
// 返回成功响应,并将统计数量放入响应结果中
return R.ok().put("count", count);
}
}

@ -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,284 +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.FapiaoxinxiEntity;
import com.entity.view.FapiaoxinxiView;
import com.service.FapiaoxinxiService;
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("/fapiaoxinxi")
public class FapiaoxinxiController {
// 自动注入 FapiaoxinxiService 服务类的实例,用于处理发票信息的业务逻辑
@Autowired
private FapiaoxinxiService fapiaoxinxiService;
// 后端列表
// 该方法用于获取发票信息的分页列表,供后端使用
// @param params 请求参数,包含分页、排序等信息
// @param fapiaoxinxi 发票信息实体,用于构建查询条件
// @param request HTTP 请求对象
// @return 包含分页数据的响应结果
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, FapiaoxinxiEntity fapiaoxinxi,
HttpServletRequest request) {
// 创建一个 EntityWrapper 对象,用于构建 SQL 查询条件
EntityWrapper<FapiaoxinxiEntity> ew = new EntityWrapper<FapiaoxinxiEntity>();
// 调用 fapiaoxinxiService 的 queryPage 方法进行分页查询MPUtil 用于处理排序和条件查询
PageUtils page = fapiaoxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, fapiaoxinxi), params), params));
// 返回成功响应,并将分页数据放入响应结果中
return R.ok().put("data", page);
}
// 前端列表
// 该方法用于获取发票信息的分页列表,供前端使用
// @param params 请求参数,包含分页、排序等信息
// @param fapiaoxinxi 发票信息实体,用于构建查询条件
// @param request HTTP 请求对象
// @return 包含分页数据的响应结果
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, FapiaoxinxiEntity fapiaoxinxi,
HttpServletRequest request) {
// 创建一个 EntityWrapper 对象,用于构建 SQL 查询条件
EntityWrapper<FapiaoxinxiEntity> ew = new EntityWrapper<FapiaoxinxiEntity>();
// 调用 fapiaoxinxiService 的 queryPage 方法进行分页查询MPUtil 用于处理排序和条件查询
PageUtils page = fapiaoxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, fapiaoxinxi), params), params));
// 返回成功响应,并将分页数据放入响应结果中
return R.ok().put("data", page);
}
// 列表
// 该方法用于获取满足特定条件的发票信息列表
// @param fapiaoxinxi 发票信息实体,用于构建查询条件
// @return 包含发票信息列表的响应结果
@RequestMapping("/lists")
public R list(FapiaoxinxiEntity fapiaoxinxi) {
// 创建一个 EntityWrapper 对象,用于构建 SQL 查询条件
EntityWrapper<FapiaoxinxiEntity> ew = new EntityWrapper<FapiaoxinxiEntity>();
// 设置查询条件,使所有字段相等
ew.allEq(MPUtil.allEQMapPre(fapiaoxinxi, "fapiaoxinxi"));
// 调用 fapiaoxinxiService 的 selectListView 方法查询列表
return R.ok().put("data", fapiaoxinxiService.selectListView(ew));
}
// 查询
//该方法用于根据条件查询单个发票信息
// @param fapiaoxinxi 发票信息实体,用于构建查询条件
// @return 包含查询结果的响应结果
@RequestMapping("/query")
public R query(FapiaoxinxiEntity fapiaoxinxi) {
// 创建一个 EntityWrapper 对象,用于构建 SQL 查询条件
EntityWrapper<FapiaoxinxiEntity> ew = new EntityWrapper<FapiaoxinxiEntity>();
// 设置查询条件,使所有字段相等
ew.allEq(MPUtil.allEQMapPre(fapiaoxinxi, "fapiaoxinxi"));
// 调用 fapiaoxinxiService 的 selectView 方法查询单个视图对象
FapiaoxinxiView fapiaoxinxiView = fapiaoxinxiService.selectView(ew);
// 返回成功响应,并将查询结果放入响应结果中
return R.ok("查询发票信息成功").put("data", fapiaoxinxiView);
}
// 后端详情
// 该方法用于获取指定 ID 的发票信息详细内容
// @param id 发票信息的 ID
//@return 包含发票信息详细内容的响应结果
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id) {
// 根据 ID 调用 fapiaoxinxiService 的 selectById 方法查询发票信息实体
FapiaoxinxiEntity fapiaoxinxi = fapiaoxinxiService.selectById(id);
// 返回成功响应,并将发票信息实体放入响应结果中
return R.ok().put("data", fapiaoxinxi);
}
// 前端详情
// 该方法用于获取指定 ID 的发票信息详细内容,供前端使用
// @param id 发票信息的 ID
// @return 包含发票信息详细内容的响应结果
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id) {
// 根据 ID 调用 fapiaoxinxiService 的 selectById 方法查询发票信息实体
FapiaoxinxiEntity fapiaoxinxi = fapiaoxinxiService.selectById(id);
// 返回成功响应,并将发票信息实体放入响应结果中
return R.ok().put("data", fapiaoxinxi);
}
// 后端保存
// 该方法用于在后端保存新的发票信息
// @param fapiaoxinxi 发票信息实体,包含要保存的信息
// @param request HTTP 请求对象
//@return 保存成功的响应结果
@RequestMapping("/save")
public R save(@RequestBody FapiaoxinxiEntity fapiaoxinxi, HttpServletRequest request) {
// 为发票信息实体设置一个唯一的 ID由当前时间戳和随机数组成
fapiaoxinxi.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(fapiaoxinxi);
// 调用 fapiaoxinxiService 的 insert 方法保存发票信息
fapiaoxinxiService.insert(fapiaoxinxi);
// 返回成功响应
return R.ok();
}
// 前端保存
//该方法用于在前端保存新的发票信息
//@param fapiaoxinxi 发票信息实体,包含要保存的信息
// @param request HTTP 请求对象
// @return 保存成功的响应结果
@RequestMapping("/add")
public R add(@RequestBody FapiaoxinxiEntity fapiaoxinxi, HttpServletRequest request) {
// 为发票信息实体设置一个唯一的 ID由当前时间戳和随机数组成
fapiaoxinxi.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(fapiaoxinxi);
// 调用 fapiaoxinxiService 的 insert 方法保存发票信息
fapiaoxinxiService.insert(fapiaoxinxi);
// 返回成功响应
return R.ok();
}
// 修改
// 该方法用于修改已有的发票信息
// @param fapiaoxinxi 发票信息实体,包含要修改的信息
// @param request HTTP 请求对象
//@return 修改成功的响应结果
@RequestMapping("/update")
public R update(@RequestBody FapiaoxinxiEntity fapiaoxinxi, HttpServletRequest request) {
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(fapiaoxinxi);
// 调用 fapiaoxinxiService 的 updateById 方法根据 ID 更新发票信息
fapiaoxinxiService.updateById(fapiaoxinxi); // 全部更新
// 返回成功响应
return R.ok();
}
// 删除
// 该方法用于批量删除指定 ID 的发票信息
// @param ids 要删除的发票信息的 ID 数组
// @return 删除成功的响应结果
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) {
// 调用 fapiaoxinxiService 的 deleteBatchIds 方法批量删除发票信息
fapiaoxinxiService.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));
}
}
// 创建一个 Wrapper 对象,用于构建 SQL 查询条件
Wrapper<FapiaoxinxiEntity> wrapper = new EntityWrapper<FapiaoxinxiEntity>();
if (map.get("remindstart") != null) {
// 设置查询条件,列值大于等于提醒开始日期
wrapper.ge(columnName, map.get("remindstart"));
}
if (map.get("remindend") != null) {
// 设置查询条件,列值小于等于提醒结束日期
wrapper.le(columnName, map.get("remindend"));
}
// 调用 fapiaoxinxiService 的 selectCount 方法统计满足条件的发票信息数量
int count = fapiaoxinxiService.selectCount(wrapper);
// 返回成功响应,并将统计数量放入响应结果中
return R.ok().put("count", count);
}
}

@ -1,115 +0,0 @@
package com.controller;
import java.io.File;
import java.io.IOException;
import java.util.Date;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import com.annotation.IgnoreAuth;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.entity.ConfigEntity;
import com.entity.EIException;
import com.service.ConfigService;
import com.utils.R;
// 上传文件映射表
// 该控制器类主要用于处理文件的上传和下载操作,提供了与文件相关的接口。
@RestController
@RequestMapping("file")
@SuppressWarnings({"unchecked", "rawtypes"})
public class FileController {
// 自动注入配置服务类的实例,用于操作配置相关数据
@Autowired
private ConfigService configService;
// 上传文件
// 该方法用于处理文件上传请求,将上传的文件保存到服务器指定目录,并根据条件更新配置信息。
// @param file 上传的文件,通过 @RequestParam 注解绑定到 MultipartFile 对象
// @param type 文件类型标识,用于判断是否需要更新配置信息
// @param request HTTP 请求对象,用于获取服务器相关路径信息
// @return R 响应对象,包含操作结果和上传后的文件名
// @throws Exception 可能抛出的异常,如文件上传过程中的异常
@RequestMapping("/upload")
public R upload(@RequestParam("file") MultipartFile file, String type, HttpServletRequest request) throws Exception {
// 检查文件是否为空
if (file.isEmpty()) {
// 如果文件为空,抛出自定义异常
throw new EIException("上传文件不能为空");
}
// 获取文件扩展名
String fileExt = file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf(".") + 1);
// 生成新的文件名,由当前时间戳和文件扩展名组成
String fileName = new Date().getTime() + "." + fileExt;
// 创建目标文件对象,指定文件保存路径为服务器的 /upload 目录下
File dest = new File(request.getSession().getServletContext().getRealPath("/upload") + "/" + fileName);
// 将上传的文件保存到目标路径
file.transferTo(dest);
// 如果 type 不为空且等于 "1",则进行配置信息的更新操作
if (StringUtils.isNotBlank(type) && type.equals("1")) {
// 根据配置名称 "faceFile" 查询配置实体
ConfigEntity configEntity = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "faceFile"));
// 如果配置实体不存在,则创建一个新的配置实体
if (configEntity == null) {
configEntity = new ConfigEntity();
configEntity.setName("faceFile");
configEntity.setValue(fileName);
} else {
// 如果配置实体存在,则更新其值为上传后的文件名
configEntity.setValue(fileName);
}
// 插入或更新配置实体
configService.insertOrUpdate(configEntity);
}
// 返回成功响应,并将上传后的文件名放入响应结果中
return R.ok().put("file", fileName);
}
// 下载文件
// 该方法用于处理文件下载请求,将指定文件从服务器下载到客户端。
// @param fileName 要下载的文件名,通过 @RequestParam 注解获取
// @param request HTTP 请求对象,用于获取服务器相关路径信息
// @param response HTTP 响应对象,用于设置响应头和输出文件内容
@IgnoreAuth
@RequestMapping("/download")
public void download(@RequestParam String fileName, HttpServletRequest request, HttpServletResponse response) {
try {
// 创建要下载的文件对象,指定文件路径为服务器的 /upload 目录下
File file = new File(request.getSession().getServletContext().getRealPath("/upload") + "/" + fileName);
// 检查文件是否存在
if (file.exists()) {
// 重置响应
response.reset();
// 设置响应头,指定文件为附件并设置文件名
response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\"");
// 设置缓存控制,不缓存文件
response.setHeader("Cache-Control", "no-cache");
// 设置允许跨域携带凭证
response.setHeader("Access-Control-Allow-Credentials", "true");
// 设置响应内容类型为二进制流
response.setContentType("application/octet-stream; charset=UTF-8");
// 将文件内容写入响应输出流,实现文件下载
IOUtils.write(FileUtils.readFileToByteArray(file), response.getOutputStream());
}
} catch (IOException e) {
// 如果发生 I/O 异常,打印异常堆栈信息
e.printStackTrace();
}
}
}

@ -1,277 +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.GongyingshangxinxiEntity;
import com.entity.view.GongyingshangxinxiView;
import com.service.GongyingshangxinxiService;
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("/gongyingshangxinxi")
public class GongyingshangxinxiController {
// 自动注入供应商信息服务类的实例,用于处理供应商信息相关业务逻辑
@Autowired
private GongyingshangxinxiService gongyingshangxinxiService;
//后端列表
// 该方法用于获取供应商信息的分页列表(后端使用),支持根据供应商信息实体构建查询条件
// @param params 请求参数,包含分页、排序等信息
// @param gongyingshangxinxi 供应商信息实体,用于构建查询条件
// @param request HTTP 请求对象
// @return R 响应对象,包含操作结果和分页后的供应商信息数据
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, GongyingshangxinxiEntity gongyingshangxinxi,
HttpServletRequest request) {
// 创建一个实体包装器,用于构建 SQL 查询条件(当前未添加具体条件)
EntityWrapper<GongyingshangxinxiEntity> ew = new EntityWrapper<GongyingshangxinxiEntity>();
// 调用供应商信息服务类的 queryPage 方法进行分页查询MPUtil 用于处理排序和条件查询
PageUtils page = gongyingshangxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, gongyingshangxinxi), params), params));
// 返回成功响应,并将分页数据放入响应结果中
return R.ok().put("data", page);
}
// 前端列表
// 该方法用于获取供应商信息的分页列表(前端使用),支持根据供应商信息实体构建查询条件
// @param params 请求参数,包含分页、排序等信息
// @param gongyingshangxinxi 供应商信息实体,用于构建查询条件
// @param request HTTP 请求对象
// @return R 响应对象,包含操作结果和分页后的供应商信息数据
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, GongyingshangxinxiEntity gongyingshangxinxi,
HttpServletRequest request) {
// 创建一个实体包装器,用于构建 SQL 查询条件(当前未添加具体条件)
EntityWrapper<GongyingshangxinxiEntity> ew = new EntityWrapper<GongyingshangxinxiEntity>();
// 调用供应商信息服务类的 queryPage 方法进行分页查询MPUtil 用于处理排序和条件查询
PageUtils page = gongyingshangxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, gongyingshangxinxi), params), params));
// 返回成功响应,并将分页数据放入响应结果中
return R.ok().put("data", page);
}
// 列表
// 该方法用于获取满足特定条件的供应商信息列表
// @param gongyingshangxinxi 供应商信息实体,用于构建查询条件
// @return R 响应对象,包含操作结果和查询到的供应商信息列表数据
@RequestMapping("/lists")
public R list(GongyingshangxinxiEntity gongyingshangxinxi) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<GongyingshangxinxiEntity> ew = new EntityWrapper<GongyingshangxinxiEntity>();
// 设置查询条件,使所有字段相等
ew.allEq(MPUtil.allEQMapPre(gongyingshangxinxi, "gongyingshangxinxi"));
// 调用供应商信息服务类的 selectListView 方法获取列表数据
return R.ok().put("data", gongyingshangxinxiService.selectListView(ew));
}
// 查询
// 该方法用于根据供应商信息实体的条件查询单个供应商信息视图
// @param gongyingshangxinxi 供应商信息实体,用于构建查询条件
// @return R 响应对象,包含操作结果和查询到的供应商信息视图数据
@RequestMapping("/query")
public R query(GongyingshangxinxiEntity gongyingshangxinxi) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<GongyingshangxinxiEntity> ew = new EntityWrapper<GongyingshangxinxiEntity>();
// 设置查询条件,使所有字段相等
ew.allEq(MPUtil.allEQMapPre(gongyingshangxinxi, "gongyingshangxinxi"));
// 调用供应商信息服务类的 selectView 方法获取供应商信息视图
GongyingshangxinxiView gongyingshangxinxiView = gongyingshangxinxiService.selectView(ew);
// 返回成功响应,并将查询结果放入响应结果中
return R.ok("查询供应商信息成功").put("data", gongyingshangxinxiView);
}
//后端详情
// 该方法用于获取指定 ID 的供应商信息详情(后端使用)
// @param id 供应商信息的 ID
// @return R 响应对象,包含操作结果和指定 ID 的供应商信息数据
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id) {
// 根据 ID 调用供应商信息服务类的 selectById 方法获取供应商信息实体
GongyingshangxinxiEntity gongyingshangxinxi = gongyingshangxinxiService.selectById(id);
// 返回成功响应,并将供应商信息实体放入响应结果中
return R.ok().put("data", gongyingshangxinxi);
}
// 前端详情
// 该方法用于获取指定 ID 的供应商信息详情(前端使用)
// @param id 供应商信息的 ID
// @return R 响应对象,包含操作结果和指定 ID 的供应商信息数据
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id) {
// 根据 ID 调用供应商信息服务类的 selectById 方法获取供应商信息实体
GongyingshangxinxiEntity gongyingshangxinxi = gongyingshangxinxiService.selectById(id);
// 返回成功响应,并将供应商信息实体放入响应结果中
return R.ok().put("data", gongyingshangxinxi);
}
// 后端保存
// 该方法用于在后端保存新的供应商信息
// @param gongyingshangxinxi 要保存的供应商信息实体
// @param request HTTP 请求对象
// @return R 响应对象,包含操作结果
@RequestMapping("/save")
public R save(@RequestBody GongyingshangxinxiEntity gongyingshangxinxi, HttpServletRequest request) {
// 为供应商信息实体设置一个唯一的 ID由当前时间戳和随机数组成
gongyingshangxinxi.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(gongyingshangxinxi);
// 调用供应商信息服务类的 insert 方法保存供应商信息
gongyingshangxinxiService.insert(gongyingshangxinxi);
// 返回成功响应
return R.ok();
}
// 前端保存
// 该方法用于在前端保存新的供应商信息
// @param gongyingshangxinxi 要保存的供应商信息实体
// @param request HTTP 请求对象
// @return R 响应对象,包含操作结果
@RequestMapping("/add")
public R add(@RequestBody GongyingshangxinxiEntity gongyingshangxinxi, HttpServletRequest request) {
// 为供应商信息实体设置一个唯一的 ID由当前时间戳和随机数组成
gongyingshangxinxi.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(gongyingshangxinxi);
// 调用供应商信息服务类的 insert 方法保存供应商信息
gongyingshangxinxiService.insert(gongyingshangxinxi);
// 返回成功响应
return R.ok();
}
// 修改
// 该方法用于修改已有的供应商信息
// @param gongyingshangxinxi 要修改的供应商信息实体
// @param request HTTP 请求对象
// @return R 响应对象,包含操作结果
@RequestMapping("/update")
public R update(@RequestBody GongyingshangxinxiEntity gongyingshangxinxi, HttpServletRequest request) {
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(gongyingshangxinxi);
// 调用供应商信息服务类的 updateById 方法根据 ID 更新供应商信息
gongyingshangxinxiService.updateById(gongyingshangxinxi); // 全部更新
// 返回成功响应
return R.ok();
}
// 删除
//该方法用于批量删除指定 ID 的供应商信息
// @param ids 要删除的供应商信息的 ID 数组
// @return R 响应对象,包含操作结果
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) {
// 调用供应商信息服务类的 deleteBatchIds 方法批量删除供应商信息
gongyingshangxinxiService.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<GongyingshangxinxiEntity> wrapper = new EntityWrapper<GongyingshangxinxiEntity>();
// 根据提醒开始时间和结束时间设置查询条件
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 = gongyingshangxinxiService.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.JizhangpingzhengEntity;
import com.entity.view.JizhangpingzhengView;
import com.service.JizhangpingzhengService;
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("/jizhangpingzheng")
public class JizhangpingzhengController {
// 自动注入记账凭证服务类的实例,用于处理记账凭证相关业务逻辑
@Autowired
private JizhangpingzhengService jizhangpingzhengService;
// 后端列表
// 该方法用于获取记账凭证的分页列表(后端使用),支持根据记账凭证实体和时间范围构建查询条件
// @param params 请求参数,包含分页、排序等信息
// @param jizhangpingzheng 记账凭证实体,用于构建查询条件
// @param dengjiriqistart 登记日期开始时间,可选参数
// @param dengjiriqiend 登记日期结束时间,可选参数
// @param request HTTP 请求对象
// @return R 响应对象,包含操作结果和分页后的记账凭证数据
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, JizhangpingzhengEntity jizhangpingzheng,
@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<JizhangpingzhengEntity> ew = new EntityWrapper<JizhangpingzhengEntity>();
// 如果登记日期开始时间不为空,添加大于等于该时间的查询条件
if (dengjiriqistart != null)
ew.ge("dengjiriqi", dengjiriqistart);
// 如果登记日期结束时间不为空,添加小于等于该时间的查询条件
if (dengjiriqiend != null)
ew.le("dengjiriqi", dengjiriqiend);
// 调用记账凭证服务类的 queryPage 方法进行分页查询MPUtil 用于处理排序和条件查询
PageUtils page = jizhangpingzhengService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, jizhangpingzheng), params), params));
// 返回成功响应,并将分页数据放入响应结果中
return R.ok().put("data", page);
}
// 前端列表
// 该方法用于获取记账凭证的分页列表(前端使用),支持根据记账凭证实体和时间范围构建查询条件
// @param params 请求参数,包含分页、排序等信息
// @param jizhangpingzheng 记账凭证实体,用于构建查询条件
// @param dengjiriqistart 登记日期开始时间,可选参数
// @param dengjiriqiend 登记日期结束时间,可选参数
// @param request HTTP 请求对象
// @return R 响应对象,包含操作结果和分页后的记账凭证数据
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, JizhangpingzhengEntity jizhangpingzheng,
@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<JizhangpingzhengEntity> ew = new EntityWrapper<JizhangpingzhengEntity>();
// 如果登记日期开始时间不为空,添加大于等于该时间的查询条件
if (dengjiriqistart != null)
ew.ge("dengjiriqi", dengjiriqistart);
// 如果登记日期结束时间不为空,添加小于等于该时间的查询条件
if (dengjiriqiend != null)
ew.le("dengjiriqi", dengjiriqiend);
// 调用记账凭证服务类的 queryPage 方法进行分页查询MPUtil 用于处理排序和条件查询
PageUtils page = jizhangpingzhengService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, jizhangpingzheng), params), params));
// 返回成功响应,并将分页数据放入响应结果中
return R.ok().put("data", page);
}
// 列表
// 该方法用于获取满足特定条件的记账凭证列表
// @param jizhangpingzheng 记账凭证实体,用于构建查询条件
// @return R 响应对象,包含操作结果和查询到的记账凭证列表数据
@RequestMapping("/lists")
public R list(JizhangpingzhengEntity jizhangpingzheng) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<JizhangpingzhengEntity> ew = new EntityWrapper<JizhangpingzhengEntity>();
// 设置查询条件,使所有字段相等
ew.allEq(MPUtil.allEQMapPre(jizhangpingzheng, "jizhangpingzheng"));
// 调用记账凭证服务类的 selectListView 方法获取列表数据
return R.ok().put("data", jizhangpingzhengService.selectListView(ew));
}
// 查询
// 该方法用于根据记账凭证实体的条件查询单个记账凭证视图
// @param jizhangpingzheng 记账凭证实体,用于构建查询条件
// @return R 响应对象,包含操作结果和查询到的记账凭证视图数据
@RequestMapping("/query")
public R query(JizhangpingzhengEntity jizhangpingzheng) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<JizhangpingzhengEntity> ew = new EntityWrapper<JizhangpingzhengEntity>();
// 设置查询条件,使所有字段相等
ew.allEq(MPUtil.allEQMapPre(jizhangpingzheng, "jizhangpingzheng"));
// 调用记账凭证服务类的 selectView 方法获取记账凭证视图
JizhangpingzhengView jizhangpingzhengView = jizhangpingzhengService.selectView(ew);
// 返回成功响应,并将查询结果放入响应结果中
return R.ok("查询记账凭证成功").put("data", jizhangpingzhengView);
}
// 后端详情
// 该方法用于获取指定 ID 的记账凭证详情(后端使用)
// @param id 记账凭证的 ID
// @return R 响应对象,包含操作结果和指定 ID 的记账凭证数据
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id) {
// 根据 ID 调用记账凭证服务类的 selectById 方法获取记账凭证实体
JizhangpingzhengEntity jizhangpingzheng = jizhangpingzhengService.selectById(id);
// 返回成功响应,并将记账凭证实体放入响应结果中
return R.ok().put("data", jizhangpingzheng);
}
// 前端详情
// 该方法用于获取指定 ID 的记账凭证详情(前端使用)
// @param id 记账凭证的 ID
// @return R 响应对象,包含操作结果和指定 ID 的记账凭证数据
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id) {
// 根据 ID 调用记账凭证服务类的 selectById 方法获取记账凭证实体
JizhangpingzhengEntity jizhangpingzheng = jizhangpingzhengService.selectById(id);
// 返回成功响应,并将记账凭证实体放入响应结果中
return R.ok().put("data", jizhangpingzheng);
}
// 后端保存
// 该方法用于在后端保存新的记账凭证
// @param jizhangpingzheng 要保存的记账凭证实体
// @param request HTTP 请求对象
// @return R 响应对象,包含操作结果
@RequestMapping("/save")
public R save(@RequestBody JizhangpingzhengEntity jizhangpingzheng, HttpServletRequest request) {
// 为记账凭证实体设置一个唯一的 ID由当前时间戳和随机数组成
jizhangpingzheng.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(jizhangpingzheng);
// 调用记账凭证服务类的 insert 方法保存记账凭证
jizhangpingzhengService.insert(jizhangpingzheng);
// 返回成功响应
return R.ok();
}
// 前端保存
// 该方法用于在前端保存新的记账凭证
// @param jizhangpingzheng 要保存的记账凭证实体
// @param request HTTP 请求对象
// @return R 响应对象,包含操作结果
@RequestMapping("/add")
public R add(@RequestBody JizhangpingzhengEntity jizhangpingzheng, HttpServletRequest request) {
// 为记账凭证实体设置一个唯一的 ID由当前时间戳和随机数组成
jizhangpingzheng.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(jizhangpingzheng);
// 调用记账凭证服务类的 insert 方法保存记账凭证
jizhangpingzhengService.insert(jizhangpingzheng);
// 返回成功响应
return R.ok();
}
//修改
// 该方法用于修改已有的记账凭证
// @param jizhangpingzheng 要修改的记账凭证实体
//@param request HTTP 请求对象
// @return R 响应对象,包含操作结果
@RequestMapping("/update")
public R update(@RequestBody JizhangpingzhengEntity jizhangpingzheng, HttpServletRequest request) {
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(jizhangpingzheng);
// 调用记账凭证服务类的 updateById 方法根据 ID 更新记账凭证
jizhangpingzhengService.updateById(jizhangpingzheng); // 全部更新
// 返回成功响应
return R.ok();
}
// 删除
// 该方法用于批量删除指定 ID 的记账凭证
// @param ids 要删除的记账凭证的 ID 数组
// @return R 响应对象,包含操作结果
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) {
// 调用记账凭证服务类的 deleteBatchIds 方法批量删除记账凭证
jizhangpingzhengService.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<JizhangpingzhengEntity> wrapper = new EntityWrapper<JizhangpingzhengEntity>();
// 根据提醒开始时间和结束时间设置查询条件
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 = jizhangpingzhengService.selectCount(wrapper);
// 返回成功响应,并将统计数量放入响应结果中
return R.ok().put("count", count);
}
}

@ -1,297 +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.KehuxinxiEntity;
import com.entity.view.KehuxinxiView;
import com.service.KehuxinxiService;
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("/kehuxinxi")
public class KehuxinxiController {
// 自动注入客户信息服务类的实例,用于处理客户信息相关的业务逻辑
@Autowired
private KehuxinxiService kehuxinxiService;
// 后端列表
// 该方法用于获取客户信息的分页列表(供后端使用),支持根据客户信息实体和登记日期范围进行查询
// @param params 请求参数,包含分页、排序等信息
// @param kehuxinxi 客户信息实体,用于构建查询条件
// @param dengjiriqistart 登记日期的起始时间,非必填参数,格式为 yyyy-MM-dd
// @param dengjiriqiend 登记日期的结束时间,非必填参数,格式为 yyyy-MM-dd
// @param request HTTP 请求对象
// @return R 响应对象,包含操作结果和分页后的客户信息数据
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, KehuxinxiEntity kehuxinxi,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date dengjiriqistart,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date dengjiriqiend,
HttpServletRequest request) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<KehuxinxiEntity> ew = new EntityWrapper<KehuxinxiEntity>();
// 如果登记日期起始时间不为空,添加大于等于该时间的查询条件
if (dengjiriqistart != null)
ew.ge("dengjiriqi", dengjiriqistart);
// 如果登记日期结束时间不为空,添加小于等于该时间的查询条件
if (dengjiriqiend != null)
ew.le("dengjiriqi", dengjiriqiend);
// 调用客户信息服务类的 queryPage 方法进行分页查询MPUtil 用于处理排序和条件查询
PageUtils page = kehuxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, kehuxinxi), params), params));
// 返回成功响应,并将分页数据放入响应结果中
return R.ok().put("data", page);
}
// 前端列表
// 该方法用于获取客户信息的分页列表(供前端使用),支持根据客户信息实体和登记日期范围进行查询
// @param params 请求参数,包含分页、排序等信息
// @param kehuxinxi 客户信息实体,用于构建查询条件
// @param dengjiriqistart 登记日期的起始时间,非必填参数,格式为 yyyy-MM-dd
// @param dengjiriqiend 登记日期的结束时间,非必填参数,格式为 yyyy-MM-dd
// @param request HTTP 请求对象
// @return R 响应对象,包含操作结果和分页后的客户信息数据
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, KehuxinxiEntity kehuxinxi,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date dengjiriqistart,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date dengjiriqiend,
HttpServletRequest request) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<KehuxinxiEntity> ew = new EntityWrapper<KehuxinxiEntity>();
// 如果登记日期起始时间不为空,添加大于等于该时间的查询条件
if (dengjiriqistart != null)
ew.ge("dengjiriqi", dengjiriqistart);
// 如果登记日期结束时间不为空,添加小于等于该时间的查询条件
if (dengjiriqiend != null)
ew.le("dengjiriqi", dengjiriqiend);
// 调用客户信息服务类的 queryPage 方法进行分页查询MPUtil 用于处理排序和条件查询
PageUtils page = kehuxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, kehuxinxi), params), params));
// 返回成功响应,并将分页数据放入响应结果中
return R.ok().put("data", page);
}
// 列表
// 该方法用于获取满足特定条件的客户信息列表
// @param kehuxinxi 客户信息实体,用于构建查询条件
// @return R 响应对象,包含操作结果和查询到的客户信息列表数据
@RequestMapping("/lists")
public R list(KehuxinxiEntity kehuxinxi) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<KehuxinxiEntity> ew = new EntityWrapper<KehuxinxiEntity>();
// 设置查询条件,使所有字段相等
ew.allEq(MPUtil.allEQMapPre(kehuxinxi, "kehuxinxi"));
// 调用客户信息服务类的 selectListView 方法获取列表数据
return R.ok().put("data", kehuxinxiService.selectListView(ew));
}
// 查询
// 该方法用于根据客户信息实体的条件查询单个客户信息视图
// @param kehuxinxi 客户信息实体,用于构建查询条件
// @return R 响应对象,包含操作结果和查询到的客户信息视图数据
@RequestMapping("/query")
public R query(KehuxinxiEntity kehuxinxi) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<KehuxinxiEntity> ew = new EntityWrapper<KehuxinxiEntity>();
// 设置查询条件,使所有字段相等
ew.allEq(MPUtil.allEQMapPre(kehuxinxi, "kehuxinxi"));
// 调用客户信息服务类的 selectView 方法获取客户信息视图
KehuxinxiView kehuxinxiView = kehuxinxiService.selectView(ew);
// 返回成功响应,并将查询结果放入响应结果中
return R.ok("查询客户信息成功").put("data", kehuxinxiView);
}
// 后端详情
// 该方法用于获取指定 ID 的客户信息详情(供后端使用)
// @param id 客户信息的 ID
// @return R 响应对象,包含操作结果和指定 ID 的客户信息数据
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id) {
// 根据 ID 调用客户信息服务类的 selectById 方法获取客户信息实体
KehuxinxiEntity kehuxinxi = kehuxinxiService.selectById(id);
// 返回成功响应,并将客户信息实体放入响应结果中
return R.ok().put("data", kehuxinxi);
}
// 前端详情
// 该方法用于获取指定 ID 的客户信息详情(供前端使用)
// @param id 客户信息的 ID
// @return R 响应对象,包含操作结果和指定 ID 的客户信息数据
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id) {
// 根据 ID 调用客户信息服务类的 selectById 方法获取客户信息实体
KehuxinxiEntity kehuxinxi = kehuxinxiService.selectById(id);
// 返回成功响应,并将客户信息实体放入响应结果中
return R.ok().put("data", kehuxinxi);
}
//后端保存
//该方法用于在后端保存新的客户信息
// @param kehuxinxi 要保存的客户信息实体
// @param request HTTP 请求对象
// @return R 响应对象,包含操作结果
@RequestMapping("/save")
public R save(@RequestBody KehuxinxiEntity kehuxinxi, HttpServletRequest request) {
// 为客户信息实体设置一个唯一的 ID由当前时间戳和随机数组成
kehuxinxi.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(kehuxinxi);
// 调用客户信息服务类的 insert 方法保存客户信息
kehuxinxiService.insert(kehuxinxi);
// 返回成功响应
return R.ok();
}
// 前端保存
// 该方法用于在前端保存新的客户信息
// @param kehuxinxi 要保存的客户信息实体
//@param request HTTP 请求对象
// @return R 响应对象,包含操作结果
@RequestMapping("/add")
public R add(@RequestBody KehuxinxiEntity kehuxinxi, HttpServletRequest request) {
// 为客户信息实体设置一个唯一的 ID由当前时间戳和随机数组成
kehuxinxi.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(kehuxinxi);
// 调用客户信息服务类的 insert 方法保存客户信息
kehuxinxiService.insert(kehuxinxi);
// 返回成功响应
return R.ok();
}
// 修改
// 该方法用于修改已有的客户信息
// @param kehuxinxi 要修改的客户信息实体
// @param request HTTP 请求对象
//@return R 响应对象,包含操作结果
@RequestMapping("/update")
public R update(@RequestBody KehuxinxiEntity kehuxinxi, HttpServletRequest request) {
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(kehuxinxi);
// 调用客户信息服务类的 updateById 方法根据 ID 更新客户信息
kehuxinxiService.updateById(kehuxinxi); // 全部更新
// 返回成功响应
return R.ok();
}
//删除
// 该方法用于批量删除指定 ID 的客户信息
// @param ids 要删除的客户信息的 ID 数组
// @return R 响应对象,包含操作结果
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) {
// 调用客户信息服务类的 deleteBatchIds 方法批量删除客户信息
kehuxinxiService.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<KehuxinxiEntity> wrapper = new EntityWrapper<KehuxinxiEntity>();
// 根据提醒开始时间和结束时间设置查询条件
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 = kehuxinxiService.selectCount(wrapper);
// 返回成功响应,并将统计数量放入响应结果中
return R.ok().put("count", count);
}
}

@ -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.RijizhangEntity;
import com.entity.view.RijizhangView;
import com.service.RijizhangService;
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("/rijizhang")
public class RijizhangController {
// 自动注入日记账服务类的实例,用于处理日记账相关业务逻辑
@Autowired
private RijizhangService rijizhangService;
// 后端列表
// 该方法用于获取日记账的分页列表(后端使用),支持根据日记账实体和日期范围构建查询条件,
// 并且根据会话中的 tableName 和 username 信息添加额外的查询条件
// @param params 请求参数,包含分页、排序等信息
// @param rijizhang 日记账实体,用于构建查询条件
// @param riqistart 日期开始时间,可选参数,格式为 yyyy-MM-dd
// @param riqiend 日期结束时间,可选参数,格式为 yyyy-MM-dd
//@param request HTTP 请求对象
// @return R 响应对象,包含操作结果和分页后的日记账数据
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, RijizhangEntity rijizhang,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date riqistart,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date riqiend,
HttpServletRequest request) {
// 从会话中获取 tableName
String tableName = request.getSession().getAttribute("tableName").toString();
// 如果 tableName 是 "yuangongguanli",则设置日记账实体的管理工号为会话中的 username
if (tableName.equals("yuangongguanli")) {
rijizhang.setGuanligonghao((String) request.getSession().getAttribute("username"));
}
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<RijizhangEntity> ew = new EntityWrapper<RijizhangEntity>();
// 如果日期开始时间不为空,添加大于等于该时间的查询条件
if (riqistart != null)
ew.ge("riqi", riqistart);
// 如果日期结束时间不为空,添加小于等于该时间的查询条件
if (riqiend != null)
ew.le("riqi", riqiend);
// 调用日记账服务类的 queryPage 方法进行分页查询MPUtil 用于处理排序和条件查询
PageUtils page = rijizhangService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, rijizhang), params), params));
// 返回成功响应,并将分页数据放入响应结果中
return R.ok().put("data", page);
}
// 前端列表
// 该方法用于获取日记账的分页列表(前端使用),支持根据日记账实体和日期范围构建查询条件
// @param params 请求参数,包含分页、排序等信息
// @param rijizhang 日记账实体,用于构建查询条件
// @param riqistart 日期开始时间,可选参数,格式为 yyyy-MM-dd
// @param riqiend 日期结束时间,可选参数,格式为 yyyy-MM-dd
// @param request HTTP 请求对象
// @return R 响应对象,包含操作结果和分页后的日记账数据
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, RijizhangEntity rijizhang,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date riqistart,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date riqiend,
HttpServletRequest request) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<RijizhangEntity> ew = new EntityWrapper<RijizhangEntity>();
// 如果日期开始时间不为空,添加大于等于该时间的查询条件
if (riqistart != null)
ew.ge("riqi", riqistart);
// 如果日期结束时间不为空,添加小于等于该时间的查询条件
if (riqiend != null)
ew.le("riqi", riqiend);
// 调用日记账服务类的 queryPage 方法进行分页查询MPUtil 用于处理排序和条件查询
PageUtils page = rijizhangService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, rijizhang), params), params));
// 返回成功响应,并将分页数据放入响应结果中
return R.ok().put("data", page);
}
// 列表
// 该方法用于获取满足特定条件的日记账列表
// @param rijizhang 日记账实体,用于构建查询条件
// @return R 响应对象,包含操作结果和查询到的日记账列表数据
@RequestMapping("/lists")
public R list(RijizhangEntity rijizhang) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<RijizhangEntity> ew = new EntityWrapper<RijizhangEntity>();
// 设置查询条件,使所有字段相等
ew.allEq(MPUtil.allEQMapPre(rijizhang, "rijizhang"));
// 调用日记账服务类的 selectListView 方法获取列表数据
return R.ok().put("data", rijizhangService.selectListView(ew));
}
// 查询
// 该方法用于根据日记账实体的条件查询单个日记账视图
//@param rijizhang 日记账实体,用于构建查询条件
// @return R 响应对象,包含操作结果和查询到的日记账视图数据
@RequestMapping("/query")
public R query(RijizhangEntity rijizhang) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<RijizhangEntity> ew = new EntityWrapper<RijizhangEntity>();
// 设置查询条件,使所有字段相等
ew.allEq(MPUtil.allEQMapPre(rijizhang, "rijizhang"));
// 调用日记账服务类的 selectView 方法获取日记账视图
RijizhangView rijizhangView = rijizhangService.selectView(ew);
// 返回成功响应,并将查询结果放入响应结果中
return R.ok("查询日记账成功").put("data", rijizhangView);
}
// 后端详情
// 该方法用于获取指定 ID 的日记账详情(后端使用)
// @param id 日记账的 ID
// @return R 响应对象,包含操作结果和指定 ID 的日记账数据
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id) {
// 根据 ID 调用日记账服务类的 selectById 方法获取日记账实体
RijizhangEntity rijizhang = rijizhangService.selectById(id);
// 返回成功响应,并将日记账实体放入响应结果中
return R.ok().put("data", rijizhang);
}
// 前端详情
// 该方法用于获取指定 ID 的日记账详情(前端使用)
//@param id 日记账的 ID
// @return R 响应对象,包含操作结果和指定 ID 的日记账数据
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id) {
// 根据 ID 调用日记账服务类的 selectById 方法获取日记账实体
RijizhangEntity rijizhang = rijizhangService.selectById(id);
// 返回成功响应,并将日记账实体放入响应结果中
return R.ok().put("data", rijizhang);
}
// 后端保存
// 该方法用于在后端保存新的日记账
// @param rijizhang 要保存的日记账实体
// @param request HTTP 请求对象
// @return R 响应对象,包含操作结果
@RequestMapping("/save")
public R save(@RequestBody RijizhangEntity rijizhang, HttpServletRequest request) {
// 为日记账实体设置一个唯一的 ID由当前时间戳和随机数组成
rijizhang.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(rijizhang);
// 调用日记账服务类的 insert 方法保存日记账
rijizhangService.insert(rijizhang);
// 返回成功响应
return R.ok();
}
// 前端保存
// 该方法用于在前端保存新的日记账
// @param rijizhang 要保存的日记账实体
// @param request HTTP 请求对象
// @return R 响应对象,包含操作结果
@RequestMapping("/add")
public R add(@RequestBody RijizhangEntity rijizhang, HttpServletRequest request) {
// 为日记账实体设置一个唯一的 ID由当前时间戳和随机数组成
rijizhang.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(rijizhang);
// 调用日记账服务类的 insert 方法保存日记账
rijizhangService.insert(rijizhang);
// 返回成功响应
return R.ok();
}
// 修改
// 该方法用于修改已有的日记账
// @param rijizhang 要修改的日记账实体
// @param request HTTP 请求对象
//@return R 响应对象,包含操作结果
@RequestMapping("/update")
public R update(@RequestBody RijizhangEntity rijizhang, HttpServletRequest request) {
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(rijizhang);
// 调用日记账服务类的 updateById 方法根据 ID 更新日记账
rijizhangService.updateById(rijizhang); // 全部更新
// 返回成功响应
return R.ok();
}
// 删除
// 该方法用于批量删除指定 ID 的日记账
//@param ids 要删除的日记账的 ID 数组
// @return R 响应对象,包含操作结果
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) {
// 调用日记账服务类的 deleteBatchIds 方法批量删除日记账
rijizhangService.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<RijizhangEntity> wrapper = new EntityWrapper<RijizhangEntity>();
// 根据提醒开始时间和结束时间设置查询条件
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 是 "yuangongguanli",则添加管理工号等于会话中 username 的查询条件
if (tableName.equals("yuangongguanli")) {
wrapper.eq("guanligonghao", (String) request.getSession().getAttribute("username"));
}
// 调用日记账服务类的 selectCount 方法统计满足条件的数量
int count = rijizhangService.selectCount(wrapper);
// 返回成功响应,并将统计数量放入响应结果中
return R.ok().put("count", count);
}
}

@ -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,398 +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.YuangongEntity;
import com.entity.view.YuangongView;
import com.service.YuangongService;
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("/yuangong")
public class YuangongController {
// 自动注入员工服务类,用于处理员工相关业务逻辑
@Autowired
private YuangongService yuangongService;
// 自动注入令牌服务类,用于生成和管理令牌
@Autowired
private TokenService tokenService;
// 登录
// 处理员工登录请求
//@param username 员工工号,用于查询对应的员工信息
//@param password 密码,用于验证员工身份
// @param captcha 验证码(当前未使用)
// @param request HttpServletRequest对象用于获取请求相关信息
// @return R类型响应对象包含操作结果信息。如果登录成功返回带有令牌的成功响应否则返回错误响应
@IgnoreAuth
@RequestMapping(value = "/login")
public R login(String username, String password, String captcha, HttpServletRequest request) {
// 根据员工工号查询员工实体
YuangongEntity user = yuangongService.selectOne(new EntityWrapper<YuangongEntity>().eq("yuangonggonghao", username));
// 检查员工是否存在且密码是否正确
if (user == null || !user.getMima().equals(password)) {
return R.error("账号或密码不正确");
}
// 生成令牌参数包括员工ID、员工工号、用户类型这里是"yuangong")和角色(这里是"员工"
String token = tokenService.generateToken(user.getId(), username, "yuangong", "员工");
// 返回成功响应并附带生成的令牌
return R.ok().put("token", token);
}
// 注册
// 处理员工注册请求
// @param yuangong 包含员工注册信息的YuangongEntity对象
// @return R类型响应对象包含操作结果信息。如果注册成功返回成功响应若员工工号已存在返回错误响应
@IgnoreAuth
@RequestMapping("/register")
public R register(@RequestBody YuangongEntity yuangong) {
// (注释掉的)验证员工实体的合法性
//ValidatorUtils.validateEntity(yuangong);
// 检查员工工号是否已被注册
YuangongEntity user = yuangongService.selectOne(new EntityWrapper<YuangongEntity>().eq("yuangonggonghao", yuangong.getYuangonggonghao()));
if (user != null) {
return R.error("注册用户已存在");
}
// 生成一个以当前时间戳为ID的员工ID
Long uId = new Date().getTime();
yuangong.setId(uId);
// 将员工信息插入数据库
yuangongService.insert(yuangong);
// 返回注册成功的响应
return R.ok();
}
//退出
//处理员工退出请求
// @param request HttpServletRequest对象用于使会话失效
// @return R类型响应对象返回退出成功的信息
@RequestMapping("/logout")
public R logout(HttpServletRequest request) {
// 使当前会话失效
request.getSession().invalidate();
// 返回退出成功的响应
return R.ok("退出成功");
}
//获取用户的session用户信息
// 从会话中获取用户ID并查询对应的员工信息
// @param request HttpServletRequest对象用于获取会话中的用户ID
//@return R类型响应对象包含查询到的员工信息。如果获取成功返回带有员工数据的成功响应
@RequestMapping("/session")
public R getCurrUser(HttpServletRequest request) {
// 从会话中获取用户ID
Long id = (Long) request.getSession().getAttribute("userId");
// 根据用户ID查询员工实体
YuangongEntity user = yuangongService.selectById(id);
// 返回包含员工信息的成功响应
return R.ok().put("data", user);
}
// 密码重置
// 处理员工密码重置请求
//@param username 员工工号,用于查询对应的员工信息
//@param request HttpServletRequest对象
// @return R类型响应对象包含操作结果信息。如果员工存在重置密码并返回成功响应否则返回错误响应
@IgnoreAuth
@RequestMapping(value = "/resetPass")
public R resetPass(String username, HttpServletRequest request) {
// 根据员工工号查询员工实体
YuangongEntity user = yuangongService.selectOne(new EntityWrapper<YuangongEntity>().eq("yuangonggonghao", username));
// 检查员工是否存在
if (user == null) {
return R.error("账号不存在");
}
// 将员工密码重置为默认值"123456"
user.setMima("123456");
// 更新员工信息(密码)到数据库
yuangongService.updateById(user);
// 返回密码重置成功的响应
return R.ok("密码已重置为123456");
}
// 后端列表
// 获取员工信息的分页列表(后端使用)
// @param params 包含分页、排序等参数的Map对象
// @param yuangong 用于构建查询条件的员工实体
//@param request HttpServletRequest对象
// @return R类型响应对象包含分页后的员工信息数据。如果查询成功返回带有分页数据的成功响应
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, YuangongEntity yuangong,
HttpServletRequest request) {
// 创建用于构建查询条件的EntityWrapper对象
EntityWrapper<YuangongEntity> ew = new EntityWrapper<YuangongEntity>();
// 调用员工服务类的queryPage方法进行分页查询MPUtil用于处理查询条件和排序
PageUtils page = yuangongService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yuangong), params), params));
// 返回包含分页数据的成功响应
return R.ok().put("data", page);
}
// 前端列表
// 获取员工信息的分页列表(前端使用),逻辑与后端列表类似
//@param params 包含分页、排序等参数的Map对象
// @param yuangong 用于构建查询条件的员工实体
// @param request HttpServletRequest对象
// @return R类型响应对象包含分页后的员工信息数据。如果查询成功返回带有分页数据的成功响应
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, YuangongEntity yuangong,
HttpServletRequest request) {
// 创建用于构建查询条件的EntityWrapper对象
EntityWrapper<YuangongEntity> ew = new EntityWrapper<YuangongEntity>();
// 调用员工服务类的queryPage方法进行分页查询MPUtil用于处理查询条件和排序
PageUtils page = yuangongService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yuangong), params), params));
// 返回包含分页数据的成功响应
return R.ok().put("data", page);
}
// 列表
// 根据员工实体的条件获取员工信息列表
// @param yuangong 用于构建查询条件的员工实体
//@return R类型响应对象包含查询到的员工信息列表。如果查询成功返回带有员工信息列表的成功响应
@RequestMapping("/lists")
public R list(YuangongEntity yuangong) {
// 创建用于构建查询条件的EntityWrapper对象
EntityWrapper<YuangongEntity> ew = new EntityWrapper<YuangongEntity>();
// 设置查询条件为所有属性等于员工实体的对应属性
ew.allEq(MPUtil.allEQMapPre(yuangong, "yuangong"));
// 调用员工服务类的selectListView方法获取员工信息列表
return R.ok().put("data", yuangongService.selectListView(ew));
}
// 查询
// 根据员工实体的条件查询员工视图信息
//@param yuangong 用于构建查询条件的员工实体
//@return R类型响应对象包含查询到的员工视图信息。如果查询成功返回带有员工视图数据的成功响应
@RequestMapping("/query")
public R query(YuangongEntity yuangong) {
// 创建用于构建查询条件的EntityWrapper对象
EntityWrapper<YuangongEntity> ew = new EntityWrapper<YuangongEntity>();
// 设置查询条件为所有属性等于员工实体的对应属性
ew.allEq(MPUtil.allEQMapPre(yuangong, "yuangong"));
// 调用员工服务类的selectView方法获取员工视图
YuangongView yuangongView = yuangongService.selectView(ew);
// 返回包含员工视图信息的成功响应
return R.ok("查询员工成功").put("data", yuangongView);
}
//后端详情
// 获取指定ID的员工详情信息后端使用
// @param id 员工记录的ID
// @return R类型响应对象包含指定ID的员工信息。如果查询成功返回带有员工数据的成功响应
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id) {
// 根据ID查询员工实体
YuangongEntity yuangong = yuangongService.selectById(id);
// 返回包含员工信息的成功响应
return R.ok().put("data", yuangong);
}
// 前端详情
//获取指定ID的员工详情信息前端使用逻辑与后端详情类似
//@param id 员工记录的ID
//@return R类型响应对象包含指定ID的员工信息。如果查询成功返回带有员工数据的成功响应
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id) {
// 根据ID查询员工实体
YuangongEntity yuangong = yuangongService.selectById(id);
// 返回包含员工信息的成功响应
return R.ok().put("data", yuangong);
}
// 后端保存
//保存新的员工信息(后端使用)
//@param yuangong 包含员工信息的实体对象
// @param request HttpServletRequest对象
// @return R类型响应对象包含操作结果信息。如果员工工号不存在冲突保存员工信息并返回成功响应否则返回错误响应
@RequestMapping("/save")
public R save(@RequestBody YuangongEntity yuangong, HttpServletRequest request) {
// 生成一个唯一的ID由当前时间戳和随机数组成后又改为仅当前时间戳
yuangong.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// (注释掉的)验证员工实体的合法性
//ValidatorUtils.validateEntity(yuangong);
// 检查员工工号是否已存在
YuangongEntity user = yuangongService.selectOne(new EntityWrapper<YuangongEntity>().eq("yuangonggonghao", yuangong.getYuangonggonghao()));
if (user != null) {
return R.error("用户已存在");
}
// 重新设置ID为当前时间戳
yuangong.setId(new Date().getTime());
// 将员工信息插入数据库
yuangongService.insert(yuangong);
// 返回保存成功的响应
return R.ok();
}
//前端保存
// 保存新的员工信息(前端使用),逻辑与后端保存类似
//@param yuangong 包含员工信息的实体对象
//@param request HttpServletRequest对象
//@return R类型响应对象包含操作结果信息。如果员工工号不存在冲突保存员工信息并返回成功响应否则返回错误响应
@RequestMapping("/add")
public R add(@RequestBody YuangongEntity yuangong, HttpServletRequest request) {
// 生成一个唯一的ID由当前时间戳和随机数组成后又改为仅当前时间戳
yuangong.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// (注释掉的)验证员工实体的合法性
//ValidatorUtils.validateEntity(yuangong);
// 检查员工工号是否已存在
YuangongEntity user = yuangongService.selectOne(new EntityWrapper<YuangongEntity>().eq("yuangonggonghao", yuangong.getYuangonggonghao()));
if (user != null) {
return R.error("用户已存在");
}
// 重新设置ID为当前时间戳
yuangong.setId(new Date().getTime());
// 将员工信息插入数据库
yuangongService.insert(yuangong);
// 返回保存成功的响应
return R.ok();
}
//修改
// 修改员工信息
// @param yuangong 包含修改后员工信息的实体对象
//@param request HttpServletRequest对象
//@return R类型响应对象包含操作结果信息。如果修改成功返回成功响应
@RequestMapping("/update")
public R update(@RequestBody YuangongEntity yuangong, HttpServletRequest request) {
// (注释掉的)验证员工实体的合法性
//ValidatorUtils.validateEntity(yuangong);
// 根据员工ID更新员工信息到数据库
yuangongService.updateById(yuangong);
// 返回修改成功的响应
return R.ok();
}
// 删除
// 批量删除员工信息
// @param ids 要删除的员工记录的ID数组
// @return R类型响应对象包含操作结果信息。如果删除成功返回成功响应
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) {
// 调用员工服务类的deleteBatchIds方法批量删除员工信息
yuangongService.deleteBatchIds(Arrays.asList(ids));
// 返回删除成功的响应
return R.ok();
}
// 提醒接口
// 根据指定列和时间范围统计满足条件的员工记录数量
//@param columnName 要统计的列名
// @param request HttpServletRequest对象
// @param type 类型(例如"2"表示日期类型)
// @param map 包含提醒开始时间、结束时间等参数的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中
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));
}
}
Wrapper<YuangongEntity> wrapper = new EntityWrapper<YuangongEntity>();
if(map.get("remindstart")!=null) {
wrapper.ge(columnName, map.get("remindstart"));
}
if(map.get("remindend")!=null) {
wrapper.le(columnName, map.get("remindend"));
}
int count = yuangongService.selectCount(wrapper);
return R.ok().put("count", count);
}
}

@ -1,321 +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.YuangongbaoxiaoEntity;
import com.entity.view.YuangongbaoxiaoView;
import com.service.YuangongbaoxiaoService;
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("/yuangongbaoxiao")
public class YuangongbaoxiaoController {
// 自动注入员工报销服务类的实例,用于处理员工报销相关业务逻辑
@Autowired
private YuangongbaoxiaoService yuangongbaoxiaoService;
// 后端列表
//该方法用于获取员工报销信息的分页列表(后端使用),支持根据员工报销实体和申请日期范围构建查询条件,
//并且根据会话中的 tableName 和 username 信息添加额外的查询条件
// @param params 请求参数,包含分页、排序等信息
// @param yuangongbaoxiao 员工报销实体,用于构建查询条件
//@param shenqingriqistart 申请日期开始时间,可选参数,格式为 yyyy-MM-dd
// @param shenqingriqiend 申请日期结束时间,可选参数,格式为 yyyy-MM-dd
//@param request HTTP 请求对象
// @return R 响应对象,包含操作结果和分页后的员工报销数据
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, YuangongbaoxiaoEntity yuangongbaoxiao,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date shenqingriqistart,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date shenqingriqiend,
HttpServletRequest request) {
// 从会话中获取 tableName
String tableName = request.getSession().getAttribute("tableName").toString();
// 如果 tableName 是 "yuangong",则设置员工报销实体的员工工号为会话中的 username
if (tableName.equals("yuangong")) {
yuangongbaoxiao.setYuangonggonghao((String) request.getSession().getAttribute("username"));
}
// 如果 tableName 是 "yuangongguanli",则设置员工报销实体的管理工号为会话中的 username
if (tableName.equals("yuangongguanli")) {
yuangongbaoxiao.setGuanligonghao((String) request.getSession().getAttribute("username"));
}
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<YuangongbaoxiaoEntity> ew = new EntityWrapper<YuangongbaoxiaoEntity>();
// 如果申请日期开始时间不为空,添加大于等于该时间的查询条件
if (shenqingriqistart != null)
ew.ge("shenqingriqi", shenqingriqistart);
// 如果申请日期结束时间不为空,添加小于等于该时间的查询条件
if (shenqingriqiend != null)
ew.le("shenqingriqi", shenqingriqiend);
// 调用员工报销服务类的 queryPage 方法进行分页查询MPUtil 用于处理排序和条件查询
PageUtils page = yuangongbaoxiaoService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yuangongbaoxiao), params), params));
// 返回成功响应,并将分页数据放入响应结果中
return R.ok().put("data", page);
}
// 前端列表
// 该方法用于获取员工报销信息的分页列表(前端使用),支持根据员工报销实体和申请日期范围构建查询条件
// @param params 请求参数,包含分页、排序等信息
// @param yuangongbaoxiao 员工报销实体,用于构建查询条件
// @param shenqingriqistart 申请日期开始时间,可选参数,格式为 yyyy-MM-dd
// @param shenqingriqiend 申请日期结束时间,可选参数,格式为 yyyy-MM-dd
// @param request HTTP 请求对象
// @return R 响应对象,包含操作结果和分页后的员工报销数据
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, YuangongbaoxiaoEntity yuangongbaoxiao,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date shenqingriqistart,
@RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date shenqingriqiend,
HttpServletRequest request) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<YuangongbaoxiaoEntity> ew = new EntityWrapper<YuangongbaoxiaoEntity>();
// 如果申请日期开始时间不为空,添加大于等于该时间的查询条件
if (shenqingriqistart != null)
ew.ge("shenqingriqi", shenqingriqistart);
// 如果申请日期结束时间不为空,添加小于等于该时间的查询条件
if (shenqingriqiend != null)
ew.le("shenqingriqi", shenqingriqiend);
// 调用员工报销服务类的 queryPage 方法进行分页查询MPUtil 用于处理排序和条件查询
PageUtils page = yuangongbaoxiaoService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yuangongbaoxiao), params), params));
// 返回成功响应,并将分页数据放入响应结果中
return R.ok().put("data", page);
}
//列表
// 该方法用于获取满足特定条件的员工报销信息列表
//@param yuangongbaoxiao 员工报销实体,用于构建查询条件
// @return R 响应对象,包含操作结果和查询到的员工报销信息列表数据
@RequestMapping("/lists")
public R list(YuangongbaoxiaoEntity yuangongbaoxiao) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<YuangongbaoxiaoEntity> ew = new EntityWrapper<YuangongbaoxiaoEntity>();
// 设置查询条件,使所有字段相等
ew.allEq(MPUtil.allEQMapPre(yuangongbaoxiao, "yuangongbaoxiao"));
// 调用员工报销服务类的 selectListView 方法获取列表数据
return R.ok().put("data", yuangongbaoxiaoService.selectListView(ew));
}
// 查询
//该方法用于根据员工报销实体的条件查询单个员工报销视图
//@param yuangongbaoxiao 员工报销实体,用于构建查询条件
//@return R 响应对象,包含操作结果和查询到的员工报销视图数据
@RequestMapping("/query")
public R query(YuangongbaoxiaoEntity yuangongbaoxiao) {
// 创建一个实体包装器,用于构建 SQL 查询条件
EntityWrapper<YuangongbaoxiaoEntity> ew = new EntityWrapper<YuangongbaoxiaoEntity>();
// 设置查询条件,使所有字段相等
ew.allEq(MPUtil.allEQMapPre(yuangongbaoxiao, "yuangongbaoxiao"));
// 调用员工报销服务类的 selectView 方法获取员工报销视图
YuangongbaoxiaoView yuangongbaoxiaoView = yuangongbaoxiaoService.selectView(ew);
// 返回成功响应,并将查询结果放入响应结果中
return R.ok("查询员工报销成功").put("data", yuangongbaoxiaoView);
}
//后端详情
//该方法用于获取指定 ID 的员工报销详情(后端使用)
//@param id 员工报销记录的 ID
//@return R 响应对象,包含操作结果和指定 ID 的员工报销数据
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id) {
// 根据 ID 调用员工报销服务类的 selectById 方法获取员工报销实体
YuangongbaoxiaoEntity yuangongbaoxiao = yuangongbaoxiaoService.selectById(id);
// 返回成功响应,并将员工报销实体放入响应结果中
return R.ok().put("data", yuangongbaoxiao);
}
// 前端详情
//该方法用于获取指定 ID 的员工报销详情(前端使用)
//@param id 员工报销记录的 ID
// @return R 响应对象,包含操作结果和指定 ID 的员工报销数据
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id) {
// 根据 ID 调用员工报销服务类的 selectById 方法获取员工报销实体
YuangongbaoxiaoEntity yuangongbaoxiao = yuangongbaoxiaoService.selectById(id);
// 返回成功响应,并将员工报销实体放入响应结果中
return R.ok().put("data", yuangongbaoxiao);
}
//后端保存
//该方法用于在后端保存新的员工报销记录
//@param yuangongbaoxiao 要保存的员工报销实体
//@param request HTTP 请求对象
// @return R 响应对象,包含操作结果
@RequestMapping("/save")
public R save(@RequestBody YuangongbaoxiaoEntity yuangongbaoxiao, HttpServletRequest request) {
// 为员工报销实体设置一个唯一的 ID由当前时间戳和随机数组成
yuangongbaoxiao.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(yuangongbaoxiao);
// 调用员工报销服务类的 insert 方法保存员工报销记录
yuangongbaoxiaoService.insert(yuangongbaoxiao);
// 返回成功响应
return R.ok();
}
//前端保存
//该方法用于在前端保存新的员工报销记录
//@param yuangongbaoxiao 要保存的员工报销实体
// @param request HTTP 请求对象
//@return R 响应对象,包含操作结果
@RequestMapping("/add")
public R add(@RequestBody YuangongbaoxiaoEntity yuangongbaoxiao, HttpServletRequest request) {
// 为员工报销实体设置一个唯一的 ID由当前时间戳和随机数组成
yuangongbaoxiao.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(yuangongbaoxiao);
// 调用员工报销服务类的 insert 方法保存员工报销记录
yuangongbaoxiaoService.insert(yuangongbaoxiao);
// 返回成功响应
return R.ok();
}
//修改
// 该方法用于修改已有的员工报销记录
//@param yuangongbaoxiao 要修改的员工报销实体
// @param request HTTP 请求对象
//@return R 响应对象,包含操作结果
@RequestMapping("/update")
public R update(@RequestBody YuangongbaoxiaoEntity yuangongbaoxiao, HttpServletRequest request) {
// 注释掉的验证实体方法,可用于验证实体数据的合法性
//ValidatorUtils.validateEntity(yuangongbaoxiao);
// 调用员工报销服务类的 updateById 方法根据 ID 更新员工报销记录
yuangongbaoxiaoService.updateById(yuangongbaoxiao); // 全部更新
// 返回成功响应
return R.ok();
}
//删除
// 该方法用于批量删除指定 ID 的员工报销记录
//@param ids 要删除的员工报销记录的 ID 数组
//@return R 响应对象,包含操作结果
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) {
// 调用员工报销服务类的 deleteBatchIds 方法批量删除员工报销记录
yuangongbaoxiaoService.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<YuangongbaoxiaoEntity> wrapper = new EntityWrapper<YuangongbaoxiaoEntity>();
// 根据提醒开始时间和结束时间设置查询条件
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"));
}
// 如果 tableName 是 "yuangongguanli",则添加管理工号等于会话中 username 的查询条件
if (tableName.equals("yuangongguanli")) {
wrapper.eq("guanligonghao", (String) request.getSession().getAttribute("username"));
}
// 调用员工报销服务类的 selectCount 方法统计满足条件的数量
int count = yuangongbaoxiaoService.selectCount(wrapper);
// 返回成功响应,并将统计数量放入响应结果中
return R.ok().put("count", count);
}
}

@ -1,392 +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.YuangongguanliEntity;
import com.entity.view.YuangongguanliView;
import com.service.YuangongguanliService;
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("/yuangongguanli")
public class YuangongguanliController {
// 自动注入员工管理服务类,用于处理员工管理相关业务逻辑
@Autowired
private YuangongguanliService yuangongguanliService;
// 自动注入令牌服务类,用于生成和管理令牌
@Autowired
private TokenService tokenService;
// 登录
//处理员工管理的登录请求
// @param username 管理工号,用于查询对应的员工管理信息
// @param password 密码,用于验证身份
// @param captcha 验证码(当前未使用)
// @param request HttpServletRequest对象用于获取请求相关信息
// @return R类型响应对象包含操作结果信息。登录成功则返回带有令牌的成功响应否则返回错误响应
@IgnoreAuth
@RequestMapping(value = "/login")
public R login(String username, String password, String captcha, HttpServletRequest request) {
// 根据管理工号查询员工管理实体
YuangongguanliEntity user = yuangongguanliService.selectOne(new EntityWrapper<YuangongguanliEntity>().eq("guanligonghao", username));
// 检查用户是否存在且密码是否匹配
if (user == null || !user.getMima().equals(password)) {
return R.error("账号或密码不正确");
}
// 生成令牌包含用户ID、用户名、用户类型员工管理和角色员工管理
String token = tokenService.generateToken(user.getId(), username, "yuangongguanli", "员工管理");
// 返回成功响应并附带令牌
return R.ok().put("token", token);
}
// 注册
// 处理员工管理的注册请求
// @param yuangongguanli 包含员工管理注册信息的实体对象
// @return R类型响应对象包含操作结果信息。若注册成功返回成功响应若工号已存在返回错误响应
@IgnoreAuth
@RequestMapping("/register")
public R register(@RequestBody YuangongguanliEntity yuangongguanli) {
// (注释掉的)验证实体合法性的方法
//ValidatorUtils.validateEntity(yuangongguanli);
// 检查管理工号是否已被注册
YuangongguanliEntity user = yuangongguanliService.selectOne(new EntityWrapper<YuangongguanliEntity>().eq("guanligonghao", yuangongguanli.getGuanligonghao()));
if (user != null) {
return R.error("注册用户已存在");
}
// 生成以当前时间戳为ID
Long uId = new Date().getTime();
yuangongguanli.setId(uId);
// 插入员工管理信息到数据库
yuangongguanliService.insert(yuangongguanli);
// 返回注册成功的响应
return R.ok();
}
// 退出
// 处理员工管理的退出请求
// @param request HttpServletRequest对象用于使会话失效
// @return R类型响应对象返回退出成功的信息
@RequestMapping("/logout")
public R logout(HttpServletRequest request) {
// 使当前会话失效
request.getSession().invalidate();
// 返回退出成功的响应
return R.ok("退出成功");
}
// 获取用户的session用户信息
// 从会话中获取用户ID并查询对应的员工管理信息
// @param request HttpServletRequest对象用于获取会话中的用户ID
// @return R类型响应对象包含查询到的员工管理信息。获取成功则返回带有员工管理数据的成功响应
@RequestMapping("/session")
public R getCurrUser(HttpServletRequest request) {
// 从会话中获取用户ID
Long id = (Long) request.getSession().getAttribute("userId");
// 根据用户ID查询员工管理实体
YuangongguanliEntity user = yuangongguanliService.selectById(id);
// 返回包含员工管理信息的成功响应
return R.ok().put("data", user);
}
// 密码重置
//处理员工管理的密码重置请求
// @param username 管理工号,用于查询对应的员工管理信息
//@param request HttpServletRequest对象
// @return R类型响应对象包含操作结果信息。若员工管理存在则重置密码并返回成功响应否则返回错误响应
@IgnoreAuth
@RequestMapping(value = "/resetPass")
public R resetPass(String username, HttpServletRequest request) {
// 根据管理工号查询员工管理实体
YuangongguanliEntity user = yuangongguanliService.selectOne(new EntityWrapper<YuangongguanliEntity>().eq("guanligonghao", username));
// 检查用户是否存在
if (user == null) {
return R.error("账号不存在");
}
// 将密码重置为默认值"123456"
user.setMima("123456");
// 更新员工管理信息(密码)到数据库
yuangongguanliService.updateById(user);
// 返回密码重置成功的响应
return R.ok("密码已重置为123456");
}
// 后端列表
// 获取员工管理信息的分页列表(后端使用)
// @param params 包含分页、排序等参数的Map对象
// @param yuangongguanli 用于构建查询条件的员工管理实体
//@param request HttpServletRequest对象
// @return R类型响应对象包含分页后的员工管理信息数据。查询成功则返回带有分页数据的成功响应
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, YuangongguanliEntity yuangongguanli,
HttpServletRequest request) {
// 创建用于构建查询条件的EntityWrapper对象
EntityWrapper<YuangongguanliEntity> ew = new EntityWrapper<YuangongguanliEntity>();
// 调用员工管理服务类的queryPage方法进行分页查询MPUtil用于处理查询条件和排序
PageUtils page = yuangongguanliService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yuangongguanli), params), params));
// 返回包含分页数据的成功响应
return R.ok().put("data", page);
}
//前端列表
// 获取员工管理信息的分页列表(前端使用)
// @param params 包含分页、排序等参数的Map对象
// @param yuangongguanli 用于构建查询条件的员工管理实体
//@param request HttpServletRequest对象
//@return R类型响应对象包含分页后的员工管理信息数据。查询成功则返回带有分页数据的成功响应
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, YuangongguanliEntity yuangongguanli,
HttpServletRequest request) {
// 创建用于构建查询条件的EntityWrapper对象
EntityWrapper<YuangongguanliEntity> ew = new EntityWrapper<YuangongguanliEntity>();
// 调用员工管理服务类的queryPage方法进行分页查询MPUtil用于处理查询条件和排序
PageUtils page = yuangongguanliService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yuangongguanli), params), params));
// 返回包含分页数据的成功响应
return R.ok().put("data", page);
}
// 列表
// 根据员工管理实体的条件获取员工管理信息列表
// @param yuangongguanli 用于构建查询条件的员工管理实体
//@return R类型响应对象包含查询到的员工管理信息列表。查询成功则返回带有员工管理信息列表的成功响应
@RequestMapping("/lists")
public R list(YuangongguanliEntity yuangongguanli) {
// 创建用于构建查询条件的EntityWrapper对象
EntityWrapper<YuangongguanliEntity> ew = new EntityWrapper<YuangongguanliEntity>();
// 设置查询条件为所有属性等于员工管理实体的对应属性
ew.allEq(MPUtil.allEQMapPre(yuangongguanli, "yuangongguanli"));
// 调用员工管理服务类的selectListView方法获取员工管理信息列表
return R.ok().put("data", yuangongguanliService.selectListView(ew));
}
//查询
//根据员工管理实体的条件查询员工管理视图信息
// @param yuangongguanli 用于构建查询条件的员工管理实体
//@return R类型响应对象包含查询到的员工管理视图信息。查询成功则返回带有员工管理视图数据的成功响应
@RequestMapping("/query")
public R query(YuangongguanliEntity yuangongguanli) {
// 创建用于构建查询条件的EntityWrapper对象
EntityWrapper<YuangongguanliEntity> ew = new EntityWrapper<YuangongguanliEntity>();
// 设置查询条件为所有属性等于员工管理实体的对应属性
ew.allEq(MPUtil.allEQMapPre(yuangongguanli, "yuangongguanli"));
// 调用员工管理服务类的selectView方法获取员工管理视图
YuangongguanliView yuangongguanliView = yuangongguanliService.selectView(ew);
// 返回包含员工管理视图信息的成功响应
return R.ok("查询员工管理成功").put("data", yuangongguanliView);
}
//后端详情
// 获取指定ID的员工管理详情信息后端使用
// @param id 员工管理记录的ID
// @return R类型响应对象包含指定ID的员工管理信息。查询成功则返回带有员工管理数据的成功响应
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id) {
// 根据ID查询员工管理实体
YuangongguanliEntity yuangongguanli = yuangongguanliService.selectById(id);
// 返回包含员工管理信息的成功响应
return R.ok().put("data", yuangongguanli);
}
// 前端详情
// 获取指定ID的员工管理详情信息前端使用
// @param id 员工管理记录的ID
//@return R类型响应对象包含指定ID的员工管理信息。查询成功则返回带有员工管理数据的成功响应
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id) {
// 根据ID查询员工管理实体
YuangongguanliEntity yuangongguanli = yuangongguanliService.selectById(id);
// 返回包含员工管理信息的成功响应
return R.ok().put("data", yuangongguanli);
}
// 后端保存
// 保存新的员工管理信息(后端使用)
// @param yuangongguanli 包含员工管理信息的实体对象
// @param request HttpServletRequest对象
// @return R类型响应对象包含操作结果信息。若管理工号不存在冲突则保存信息并返回成功响应否则返回错误响应
@RequestMapping("/save")
public R save(@RequestBody YuangongguanliEntity yuangongguanli, HttpServletRequest request) {
// 生成一个唯一的ID先由时间戳和随机数组成后改为仅时间戳
yuangongguanli.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// (注释掉的)验证实体合法性的方法
//ValidatorUtils.validateEntity(yuangongguanli);
// 检查管理工号是否已存在
YuangongguanliEntity user = yuangongguanliService.selectOne(new EntityWrapper<YuangongguanliEntity>().eq("guanligonghao", yuangongguanli.getGuanligonghao()));
if (user != null) {
return R.error("用户已存在");
}
// 重新设置ID为当前时间戳
yuangongguanli.setId(new Date().getTime());
// 插入员工管理信息到数据库
yuangongguanliService.insert(yuangongguanli);
// 返回保存成功的响应
return R.ok();
}
// 前端保存
// 保存新的员工管理信息(前端使用)
//@param yuangongguanli 包含员工管理信息的实体对象
// @param request HttpServletRequest对象
// @return R类型响应对象包含操作结果信息。若管理工号不存在冲突则保存信息并返回成功响应否则返回错误响应
@RequestMapping("/add")
public R add(@RequestBody YuangongguanliEntity yuangongguanli, HttpServletRequest request) {
// 生成一个唯一的ID先由时间戳和随机数组成后改为仅时间戳
yuangongguanli.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// (注释掉的)验证实体合法性的方法
//ValidatorUtils.validateEntity(yuangongguanli);
// 检查管理工号是否已存在
YuangongguanliEntity user = yuangongguanliService.selectOne(new EntityWrapper<YuangongguanliEntity>().eq("guanligonghao", yuangongguanli.getGuanligonghao()));
if (user != null) {
return R.error("用户已存在");
}
// 重新设置ID为当前时间戳
yuangongguanli.setId(new Date().getTime());
// 插入员工管理信息到数据库
yuangongguanliService.insert(yuangongguanli);
// 返回保存成功的响应
return R.ok();
}
// 修改
//修改员工管理信息
// @param yuangongguanli 包含修改后员工管理信息的实体对象
// @param request HttpServletRequest对象
// @return R类型响应对象包含操作结果信息。修改成功则返回成功响应
@RequestMapping("/update")
public R update(@RequestBody YuangongguanliEntity yuangongguanli, HttpServletRequest request) {
// (注释掉的)验证实体合法性的方法
//ValidatorUtils.validateEntity(yuangongguanli);
// 根据员工管理ID更新信息到数据库
yuangongguanliService.updateById(yuangongguanli);
// 返回修改成功的响应
return R.ok();
}
//删除
// 批量删除员工管理信息
// @param ids 要删除的员工管理记录的ID数组
// @return R类型响应对象包含操作结果信息。删除成功则返回成功响应
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) {
// 调用员工管理服务类的deleteBatchIds方法批量删除员工管理信息
yuangongguanliService.deleteBatchIds(Arrays.asList(ids));
// 返回删除成功的响应
return R.ok();
}
// 提醒接口
// 根据指定列和时间范围统计满足条件的员工管理记录数量
// @param columnName 要统计的列名
// @param request HttpServletRequest对象
// @param type 类型(如"2"表示日期类型)
// @param map 包含提醒开始时间、结束时间等参数的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中
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));
}
}
Wrapper<YuangongguanliEntity> wrapper = new EntityWrapper<YuangongguanliEntity>();
if(map.get("remindstart")!=null) {
wrapper.ge(columnName, map.get("remindstart"));
}
if(map.get("remindend")!=null) {
wrapper.le(columnName, map.get("remindend"));
}
int count = yuangongguanliService.selectCount(wrapper);
return R.ok().put("count", count);
}
}

@ -1,320 +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.YuangongjiaokuanEntity;
import com.entity.view.YuangongjiaokuanView;
import com.service.YuangongjiaokuanService;
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("/yuangongjiaokuan")
public class YuangongjiaokuanController {
// 自动注入员工缴款服务类,用于处理员工缴款相关的业务逻辑
@Autowired
private YuangongjiaokuanService yuangongjiaokuanService;
// 后端列表
// 获取员工缴款信息的分页列表(后端使用)
// @param params 包含分页、排序等参数的Map对象
//@param yuangongjiaokuan 用于构建查询条件的员工缴款实体
// @param jiaokuanriqistart 缴款日期的起始时间,可选参数
// @param jiaokuanriqiend 缴款日期的结束时间,可选参数
// @param request HttpServletRequest对象用于获取会话信息
//@return R类型响应对象包含分页后的员工缴款信息数据。如果查询成功返回带有分页数据的成功响应
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, YuangongjiaokuanEntity yuangongjiaokuan,
@RequestParam(required = false) @DateTimeFormat(pattern="yyyy-MM-dd") Date jiaokuanriqistart,
@RequestParam(required = false) @DateTimeFormat(pattern="yyyy-MM-dd") Date jiaokuanriqiend,
HttpServletRequest request) {
// 从会话中获取表名
String tableName = request.getSession().getAttribute("tableName").toString();
// 如果当前用户是员工,设置查询条件为该员工的工号
if (tableName.equals("yuangong")) {
yuangongjiaokuan.setYuangonggonghao((String)request.getSession().getAttribute("username"));
}
// 如果当前用户是员工管理,设置查询条件为该管理员的工号
if (tableName.equals("yuangongguanli")) {
yuangongjiaokuan.setGuanligonghao((String)request.getSession().getAttribute("username"));
}
// 创建用于构建查询条件的EntityWrapper对象
EntityWrapper<YuangongjiaokuanEntity> ew = new EntityWrapper<YuangongjiaokuanEntity>();
// 如果指定了缴款日期的起始时间,添加大于等于该时间的查询条件
if (jiaokuanriqistart != null) {
ew.ge("jiaokuanriqi", jiaokuanriqistart);
}
// 如果指定了缴款日期的结束时间,添加小于等于该时间的查询条件
if (jiaokuanriqiend != null) {
ew.le("jiaokuanriqi", jiaokuanriqiend);
}
// 调用员工缴款服务类的queryPage方法进行分页查询MPUtil用于处理查询条件和排序
PageUtils page = yuangongjiaokuanService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yuangongjiaokuan), params), params));
// 返回包含分页数据的成功响应
return R.ok().put("data", page);
}
//前端列表
//获取员工缴款信息的分页列表(前端使用)
//@param params 包含分页、排序等参数的Map对象
// @param yuangongjiaokuan 用于构建查询条件的员工缴款实体
// @param jiaokuanriqistart 缴款日期的起始时间,可选参数
// @param jiaokuanriqiend 缴款日期的结束时间,可选参数
//@param request HttpServletRequest对象
// @return R类型响应对象包含分页后的员工缴款信息数据。如果查询成功返回带有分页数据的成功响应
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, YuangongjiaokuanEntity yuangongjiaokuan,
@RequestParam(required = false) @DateTimeFormat(pattern="yyyy-MM-dd") Date jiaokuanriqistart,
@RequestParam(required = false) @DateTimeFormat(pattern="yyyy-MM-dd") Date jiaokuanriqiend,
HttpServletRequest request) {
// 创建用于构建查询条件的EntityWrapper对象
EntityWrapper<YuangongjiaokuanEntity> ew = new EntityWrapper<YuangongjiaokuanEntity>();
// 如果指定了缴款日期的起始时间,添加大于等于该时间的查询条件
if (jiaokuanriqistart != null) {
ew.ge("jiaokuanriqi", jiaokuanriqistart);
}
// 如果指定了缴款日期的结束时间,添加小于等于该时间的查询条件
if (jiaokuanriqiend != null) {
ew.le("jiaokuanriqi", jiaokuanriqiend);
}
// 调用员工缴款服务类的queryPage方法进行分页查询MPUtil用于处理查询条件和排序
PageUtils page = yuangongjiaokuanService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yuangongjiaokuan), params), params));
// 返回包含分页数据的成功响应
return R.ok().put("data", page);
}
//列表
// 根据员工缴款实体的条件获取员工缴款信息列表
//@param yuangongjiaokuan 用于构建查询条件的员工缴款实体
//@return R类型响应对象包含查询到的员工缴款信息列表。如果查询成功返回带有员工缴款信息列表的成功响应
@RequestMapping("/lists")
public R list(YuangongjiaokuanEntity yuangongjiaokuan) {
// 创建用于构建查询条件的EntityWrapper对象
EntityWrapper<YuangongjiaokuanEntity> ew = new EntityWrapper<YuangongjiaokuanEntity>();
// 设置查询条件为所有属性等于员工缴款实体的对应属性
ew.allEq(MPUtil.allEQMapPre(yuangongjiaokuan, "yuangongjiaokuan"));
// 调用员工缴款服务类的selectListView方法获取员工缴款信息列表
return R.ok().put("data", yuangongjiaokuanService.selectListView(ew));
}
// 查询
// 根据员工缴款实体的条件查询员工缴款视图信息
// @param yuangongjiaokuan 用于构建查询条件的员工缴款实体
//@return R类型响应对象包含查询到的员工缴款视图信息。如果查询成功返回带有员工缴款视图数据的成功响应
@RequestMapping("/query")
public R query(YuangongjiaokuanEntity yuangongjiaokuan) {
// 创建用于构建查询条件的EntityWrapper对象
EntityWrapper<YuangongjiaokuanEntity> ew = new EntityWrapper<YuangongjiaokuanEntity>();
// 设置查询条件为所有属性等于员工缴款实体的对应属性
ew.allEq(MPUtil.allEQMapPre(yuangongjiaokuan, "yuangongjiaokuan"));
// 调用员工缴款服务类的selectView方法获取员工缴款视图
YuangongjiaokuanView yuangongjiaokuanView = yuangongjiaokuanService.selectView(ew);
// 返回包含员工缴款视图信息的成功响应
return R.ok("查询员工缴款成功").put("data", yuangongjiaokuanView);
}
//后端详情
//获取指定ID的员工缴款详情信息后端使用
// @param id 员工缴款记录的ID
// @return R类型响应对象包含指定ID的员工缴款信息。如果查询成功返回带有员工缴款数据的成功响应
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id) {
// 根据ID查询员工缴款实体
YuangongjiaokuanEntity yuangongjiaokuan = yuangongjiaokuanService.selectById(id);
// 返回包含员工缴款信息的成功响应
return R.ok().put("data", yuangongjiaokuan);
}
//前端详情
//获取指定ID的员工缴款详情信息前端使用
//@param id 员工缴款记录的ID
// @return R类型响应对象包含指定ID的员工缴款信息。如果查询成功返回带有员工缴款数据的成功响应
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id) {
// 根据ID查询员工缴款实体
YuangongjiaokuanEntity yuangongjiaokuan = yuangongjiaokuanService.selectById(id);
// 返回包含员工缴款信息的成功响应
return R.ok().put("data", yuangongjiaokuan);
}
//后端保存
//保存新的员工缴款信息(后端使用)
// @param yuangongjiaokuan 包含员工缴款信息的实体对象
//@param request HttpServletRequest对象
// @return R类型响应对象包含操作结果信息。如果保存成功返回成功响应
@RequestMapping("/save")
public R save(@RequestBody YuangongjiaokuanEntity yuangongjiaokuan, HttpServletRequest request) {
// 生成一个唯一的ID由当前时间戳和一个随机数组成
yuangongjiaokuan.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// (注释掉的)验证员工缴款实体的合法性
//ValidatorUtils.validateEntity(yuangongjiaokuan);
// 将员工缴款信息插入数据库
yuangongjiaokuanService.insert(yuangongjiaokuan);
// 返回保存成功的响应
return R.ok();
}
// 前端保存
// 保存新的员工缴款信息(前端使用)
// @param yuangongjiaokuan 包含员工缴款信息的实体对象
// @param request HttpServletRequest对象
//@return R类型响应对象包含操作结果信息。如果保存成功返回成功响应
@RequestMapping("/add")
public R add(@RequestBody YuangongjiaokuanEntity yuangongjiaokuan, HttpServletRequest request) {
// 生成一个唯一的ID由当前时间戳和一个随机数组成
yuangongjiaokuan.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// (注释掉的)验证员工缴款实体的合法性
//ValidatorUtils.validateEntity(yuangongjiaokuan);
// 将员工缴款信息插入数据库
yuangongjiaokuanService.insert(yuangongjiaokuan);
// 返回保存成功的响应
return R.ok();
}
//修改
// 修改员工缴款信息
// @param yuangongjiaokuan 包含修改后员工缴款信息的实体对象
// @param request HttpServletRequest对象
//@return R类型响应对象包含操作结果信息。如果修改成功返回成功响应
@RequestMapping("/update")
public R update(@RequestBody YuangongjiaokuanEntity yuangongjiaokuan, HttpServletRequest request) {
// (注释掉的)验证员工缴款实体的合法性
//ValidatorUtils.validateEntity(yuangongjiaokuan);
// 根据员工缴款ID更新员工缴款信息到数据库
yuangongjiaokuanService.updateById(yuangongjiaokuan);
// 返回修改成功的响应
return R.ok();
}
// 删除
//批量删除员工缴款信息
//@param ids 要删除的员工缴款记录的ID数组
//@return R类型响应对象包含操作结果信息。如果删除成功返回成功响应
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) {
// 调用员工缴款服务类的deleteBatchIds方法批量删除员工缴款信息
yuangongjiaokuanService.deleteBatchIds(Arrays.asList(ids));
// 返回删除成功的响应
return R.ok();
}
// 提醒接口
//根据指定列和时间范围统计满足条件的员工缴款记录数量
//@param columnName 要统计的列名
//@param request HttpServletRequest对象
// @param type 类型(例如"2"表示日期类型)
// @param map 包含提醒开始时间、结束时间等参数的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中
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));
}
}
// 创建用于构建查询条件的Wrapper对象
Wrapper<YuangongjiaokuanEntity> wrapper = new EntityWrapper<YuangongjiaokuanEntity>();
// 如果存在提醒开始时间,添加大于等于该时间的查询条件
if (map.get("remindstart") != null) {
wrapper.ge(columnName, map.get("remindstart"));
}
// 如果存在提醒结束时间,添加小于等于该时间的查询条件
if (map.get("remindend") != null) {
wrapper.le(columnName, map.get("remindend"));
}
// 从会话中获取表名
String tableName = request.getSession().getAttribute("tableName").toString();
// 如果当前用户是员工,添加员工工号的查询条件
if (tableName.equals("yuangong")) {
wrapper.eq("yuangonggonghao", (String)request.getSession().getAttribute("username"));
}
// 如果当前用户是员工管理,添加管理员工号的查询条件
if (tableName.equals("yuangongguanli")) {
wrapper.eq("guanligonghao", (String)request.getSession().getAttribute("username"));
}
// 调用员工缴款服务类的selectCount方法统计满足条件的记录数量
int count = yuangongjiaokuanService.selectCount(wrapper);
// 返回包含统计数量的成功响应
return R.ok().put("count", count);
}
}

@ -1,320 +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.YuangongxinchouEntity;
import com.entity.view.YuangongxinchouView;
import com.service.YuangongxinchouService;
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("/yuangongxinchou")
public class YuangongxinchouController {
// 自动注入员工薪酬服务类,用于处理员工薪酬相关的业务逻辑
@Autowired
private YuangongxinchouService yuangongxinchouService;
//后端列表
//该方法用于获取员工薪酬信息的分页列表,供后端使用。
//@param params 包含分页、排序等查询参数的Map对象
// @param yuangongxinchou 用于构建查询条件的员工薪酬实体对象
// @param riqistart 日期范围的起始日期,可选参数
// @param riqiend 日期范围的结束日期,可选参数
// @param request HttpServletRequest对象用于获取会话信息
// @return R类型的响应对象包含分页后的员工薪酬信息数据
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, YuangongxinchouEntity yuangongxinchou,
@RequestParam(required = false) @DateTimeFormat(pattern="yyyy-MM-dd") Date riqistart,
@RequestParam(required = false) @DateTimeFormat(pattern="yyyy-MM-dd") Date riqiend,
HttpServletRequest request) {
// 从会话中获取当前用户所属的表名
String tableName = request.getSession().getAttribute("tableName").toString();
// 如果当前用户是员工,将员工工号设置到查询条件中
if (tableName.equals("yuangong")) {
yuangongxinchou.setYuangonggonghao((String)request.getSession().getAttribute("username"));
}
// 如果当前用户是员工管理,将管理员工号设置到查询条件中
if (tableName.equals("yuangongguanli")) {
yuangongxinchou.setGuanligonghao((String)request.getSession().getAttribute("username"));
}
// 创建EntityWrapper对象用于构建SQL查询条件
EntityWrapper<YuangongxinchouEntity> ew = new EntityWrapper<YuangongxinchouEntity>();
// 如果传入了起始日期,添加大于等于该日期的查询条件
if (riqistart != null) {
ew.ge("riqi", riqistart);
}
// 如果传入了结束日期,添加小于等于该日期的查询条件
if (riqiend != null) {
ew.le("riqi", riqiend);
}
// 调用服务层的queryPage方法进行分页查询MPUtil用于处理排序和范围查询
PageUtils page = yuangongxinchouService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yuangongxinchou), params), params));
// 返回包含分页数据的成功响应
return R.ok().put("data", page);
}
// 前端列表
//该方法用于获取员工薪酬信息的分页列表,供前端使用。
// @param params 包含分页、排序等查询参数的Map对象
// @param yuangongxinchou 用于构建查询条件的员工薪酬实体对象
// @param riqistart 日期范围的起始日期,可选参数
// @param riqiend 日期范围的结束日期,可选参数
// @param request HttpServletRequest对象
// @return R类型的响应对象包含分页后的员工薪酬信息数据
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, YuangongxinchouEntity yuangongxinchou,
@RequestParam(required = false) @DateTimeFormat(pattern="yyyy-MM-dd") Date riqistart,
@RequestParam(required = false) @DateTimeFormat(pattern="yyyy-MM-dd") Date riqiend,
HttpServletRequest request) {
// 创建EntityWrapper对象用于构建SQL查询条件
EntityWrapper<YuangongxinchouEntity> ew = new EntityWrapper<YuangongxinchouEntity>();
// 如果传入了起始日期,添加大于等于该日期的查询条件
if (riqistart != null) {
ew.ge("riqi", riqistart);
}
// 如果传入了结束日期,添加小于等于该日期的查询条件
if (riqiend != null) {
ew.le("riqi", riqiend);
}
// 调用服务层的queryPage方法进行分页查询MPUtil用于处理排序和范围查询
PageUtils page = yuangongxinchouService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yuangongxinchou), params), params));
// 返回包含分页数据的成功响应
return R.ok().put("data", page);
}
//列表
// 根据员工薪酬实体对象构建的条件,获取员工薪酬信息列表。
// @param yuangongxinchou 用于构建查询条件的员工薪酬实体对象
// @return R类型的响应对象包含查询到的员工薪酬信息列表
@RequestMapping("/lists")
public R list(YuangongxinchouEntity yuangongxinchou) {
// 创建EntityWrapper对象用于构建SQL查询条件
EntityWrapper<YuangongxinchouEntity> ew = new EntityWrapper<YuangongxinchouEntity>();
// 设置查询条件为实体对象中所有属性值相等
ew.allEq(MPUtil.allEQMapPre(yuangongxinchou, "yuangongxinchou"));
// 调用服务层的selectListView方法查询员工薪酬信息列表
return R.ok().put("data", yuangongxinchouService.selectListView(ew));
}
// 查询
// 根据员工薪酬实体对象构建的条件,查询员工薪酬视图信息。
//@param yuangongxinchou 用于构建查询条件的员工薪酬实体对象
// @return R类型的响应对象包含查询到的员工薪酬视图信息
@RequestMapping("/query")
public R query(YuangongxinchouEntity yuangongxinchou) {
// 创建EntityWrapper对象用于构建SQL查询条件
EntityWrapper<YuangongxinchouEntity> ew = new EntityWrapper<YuangongxinchouEntity>();
// 设置查询条件为实体对象中所有属性值相等
ew.allEq(MPUtil.allEQMapPre(yuangongxinchou, "yuangongxinchou"));
// 调用服务层的selectView方法查询员工薪酬视图信息
YuangongxinchouView yuangongxinchouView = yuangongxinchouService.selectView(ew);
// 返回包含查询结果的成功响应
return R.ok("查询员工薪酬成功").put("data", yuangongxinchouView);
}
//后端详情
// 根据员工薪酬记录的ID获取该记录的详细信息供后端使用。
// @param id 员工薪酬记录的ID
//@return R类型的响应对象包含查询到的员工薪酬详细信息
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id) {
// 调用服务层的selectById方法根据ID查询员工薪酬实体对象
YuangongxinchouEntity yuangongxinchou = yuangongxinchouService.selectById(id);
// 返回包含详细信息的成功响应
return R.ok().put("data", yuangongxinchou);
}
//前端详情
//根据员工薪酬记录的ID获取该记录的详细信息供前端使用。
//@param id 员工薪酬记录的ID
//@return R类型的响应对象包含查询到的员工薪酬详细信息
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id) {
// 调用服务层的selectById方法根据ID查询员工薪酬实体对象
YuangongxinchouEntity yuangongxinchou = yuangongxinchouService.selectById(id);
// 返回包含详细信息的成功响应
return R.ok().put("data", yuangongxinchou);
}
// 后端保存
// 保存新的员工薪酬信息,供后端使用。
//@param yuangongxinchou 包含员工薪酬信息的实体对象
//@param request HttpServletRequest对象
//@return R类型的响应对象包含保存操作的结果信息
@RequestMapping("/save")
public R save(@RequestBody YuangongxinchouEntity yuangongxinchou, HttpServletRequest request) {
// 为员工薪酬记录生成一个唯一的ID由当前时间戳和一个随机数组成
yuangongxinchou.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// (注释掉的)验证实体对象的合法性
//ValidatorUtils.validateEntity(yuangongxinchou);
// 调用服务层的insert方法将员工薪酬信息插入数据库
yuangongxinchouService.insert(yuangongxinchou);
// 返回保存成功的响应
return R.ok();
}
// 前端保存
//保存新的员工薪酬信息,供前端使用。
// @param yuangongxinchou 包含员工薪酬信息的实体对象
//@param request HttpServletRequest对象
// @return R类型的响应对象包含保存操作的结果信息
@RequestMapping("/add")
public R add(@RequestBody YuangongxinchouEntity yuangongxinchou, HttpServletRequest request) {
// 为员工薪酬记录生成一个唯一的ID由当前时间戳和一个随机数组成
yuangongxinchou.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// (注释掉的)验证实体对象的合法性
//ValidatorUtils.validateEntity(yuangongxinchou);
// 调用服务层的insert方法将员工薪酬信息插入数据库
yuangongxinchouService.insert(yuangongxinchou);
// 返回保存成功的响应
return R.ok();
}
//修改
// 修改已有的员工薪酬信息。
// @param yuangongxinchou 包含修改后员工薪酬信息的实体对象
// @param request HttpServletRequest对象
// @return R类型的响应对象包含修改操作的结果信息
@RequestMapping("/update")
public R update(@RequestBody YuangongxinchouEntity yuangongxinchou, HttpServletRequest request) {
// (注释掉的)验证实体对象的合法性
//ValidatorUtils.validateEntity(yuangongxinchou);
// 调用服务层的updateById方法根据ID更新员工薪酬信息
yuangongxinchouService.updateById(yuangongxinchou);
// 返回修改成功的响应
return R.ok();
}
//删除
//批量删除员工薪酬信息。
// @param ids 要删除的员工薪酬记录的ID数组
// @return R类型的响应对象包含删除操作的结果信息
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) {
// 调用服务层的deleteBatchIds方法批量删除指定ID的员工薪酬记录
yuangongxinchouService.deleteBatchIds(Arrays.asList(ids));
// 返回删除成功的响应
return R.ok();
}
//提醒接口
// 根据指定的列名和日期范围,统计满足条件的员工薪酬记录数量。
// @param columnName 要统计的列名
// @param request HttpServletRequest对象
// @param type 日期范围类型,"2"表示需要处理日期范围
// @param map 包含提醒开始日期和结束日期等参数的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中
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));
}
}
// 创建Wrapper对象用于构建SQL查询条件
Wrapper<YuangongxinchouEntity> wrapper = new EntityWrapper<YuangongxinchouEntity>();
// 如果传入了提醒开始日期,添加大于等于该日期的查询条件
if (map.get("remindstart") != null) {
wrapper.ge(columnName, map.get("remindstart"));
}
// 如果传入了提醒结束日期,添加小于等于该日期的查询条件
if (map.get("remindend") != null) {
wrapper.le(columnName, map.get("remindend"));
}
// 从会话中获取当前用户所属的表名
String tableName = request.getSession().getAttribute("tableName").toString();
// 如果当前用户是员工,添加员工工号的查询条件
if (tableName.equals("yuangong")) {
wrapper.eq("yuangonggonghao", (String)request.getSession().getAttribute("username"));
}
// 如果当前用户是员工管理,添加管理员工号的查询条件
if (tableName.equals("yuangongguanli")) {
wrapper.eq("guanligonghao", (String)request.getSession().getAttribute("username"));
}
// 调用服务层的selectCount方法统计满足条件的记录数量
int count = yuangongxinchouService.selectCount(wrapper);
// 返回包含统计数量的成功响应
return R.ok().put("count", count);
}
}

@ -1,293 +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.ZhipiaoxinxiEntity;
import com.entity.view.ZhipiaoxinxiView;
import com.service.ZhipiaoxinxiService;
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("/zhipiaoxinxi")
public class ZhipiaoxinxiController {
// 自动注入ZhipiaoxinxiService实例
@Autowired
private ZhipiaoxinxiService zhipiaoxinxiService;
// 后端列表
// @param params 请求参数
// @param zhipiaoxinxi 支票信息实体
// @param kaipiaoriqistart 开票日期起始
//@param kaipiaoriqiend 开票日期结束
// @param request HttpServletRequest对象
// @return 包含分页数据的响应
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params,ZhipiaoxinxiEntity zhipiaoxinxi,
@RequestParam(required = false) @DateTimeFormat(pattern="yyyy-MM-dd") Date kaipiaoriqistart,
@RequestParam(required = false) @DateTimeFormat(pattern="yyyy-MM-dd") Date kaipiaoriqiend,
HttpServletRequest request){
// 创建一个EntityWrapper对象用于构建查询条件
EntityWrapper<ZhipiaoxinxiEntity> ew = new EntityWrapper<ZhipiaoxinxiEntity>();
// 如果开票日期起始不为空,添加大于等于该日期的条件
if(kaipiaoriqistart!=null) ew.ge("kaipiaoriqi", kaipiaoriqistart);
// 如果开票日期结束不为空,添加小于等于该日期的条件
if(kaipiaoriqiend!=null) ew.le("kaipiaoriqi", kaipiaoriqiend);
// 调用服务层的queryPage方法进行分页查询
PageUtils page = zhipiaoxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, zhipiaoxinxi), params), params));
// 返回成功响应,并将分页数据放入响应中
return R.ok().put("data", page);
}
// 前端列表
// @param params 请求参数
// @param zhipiaoxinxi 支票信息实体
// @param kaipiaoriqistart 开票日期起始
// @param kaipiaoriqiend 开票日期结束
// @param request HttpServletRequest对象
// @return 包含分页数据的响应
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params,ZhipiaoxinxiEntity zhipiaoxinxi,
@RequestParam(required = false) @DateTimeFormat(pattern="yyyy-MM-dd") Date kaipiaoriqistart,
@RequestParam(required = false) @DateTimeFormat(pattern="yyyy-MM-dd") Date kaipiaoriqiend,
HttpServletRequest request){
// 创建一个EntityWrapper对象用于构建查询条件
EntityWrapper<ZhipiaoxinxiEntity> ew = new EntityWrapper<ZhipiaoxinxiEntity>();
// 如果开票日期起始不为空,添加大于等于该日期的条件
if(kaipiaoriqistart!=null) ew.ge("kaipiaoriqi", kaipiaoriqistart);
// 如果开票日期结束不为空,添加小于等于该日期的条件
if(kaipiaoriqiend!=null) ew.le("kaipiaoriqi", kaipiaoriqiend);
// 调用服务层的queryPage方法进行分页查询
PageUtils page = zhipiaoxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, zhipiaoxinxi), params), params));
// 返回成功响应,并将分页数据放入响应中
return R.ok().put("data", page);
}
// 列表
// @param zhipiaoxinxi 支票信息实体
// @return 包含查询结果的响应
@RequestMapping("/lists")
public R list( ZhipiaoxinxiEntity zhipiaoxinxi){
// 创建一个EntityWrapper对象用于构建查询条件
EntityWrapper<ZhipiaoxinxiEntity> ew = new EntityWrapper<ZhipiaoxinxiEntity>();
// 添加所有属性相等的条件
ew.allEq(MPUtil.allEQMapPre( zhipiaoxinxi, "zhipiaoxinxi"));
// 调用服务层的selectListView方法进行查询
return R.ok().put("data", zhipiaoxinxiService.selectListView(ew));
}
//查询
//@param zhipiaoxinxi 支票信息实体
// @return 包含查询结果的响应
@RequestMapping("/query")
public R query(ZhipiaoxinxiEntity zhipiaoxinxi){
// 创建一个EntityWrapper对象用于构建查询条件
EntityWrapper< ZhipiaoxinxiEntity> ew = new EntityWrapper< ZhipiaoxinxiEntity>();
// 添加所有属性相等的条件
ew.allEq(MPUtil.allEQMapPre( zhipiaoxinxi, "zhipiaoxinxi"));
// 调用服务层的selectView方法进行查询
ZhipiaoxinxiView zhipiaoxinxiView = zhipiaoxinxiService.selectView(ew);
// 返回成功响应,并将查询结果放入响应中
return R.ok("查询支票信息成功").put("data", zhipiaoxinxiView);
}
// 后端详情
// @param id 支票信息的ID
// @return 包含支票信息详情的响应
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id){
// 根据ID查询支票信息实体
ZhipiaoxinxiEntity zhipiaoxinxi = zhipiaoxinxiService.selectById(id);
// 返回成功响应,并将支票信息详情放入响应中
return R.ok().put("data", zhipiaoxinxi);
}
// 前端详情
// @param id 支票信息的ID
//@return 包含支票信息详情的响应
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id){
// 根据ID查询支票信息实体
ZhipiaoxinxiEntity zhipiaoxinxi = zhipiaoxinxiService.selectById(id);
// 返回成功响应,并将支票信息详情放入响应中
return R.ok().put("data", zhipiaoxinxi);
}
//后端保存
// @param zhipiaoxinxi 支票信息实体
// @param request HttpServletRequest对象
// @return 保存成功的响应
@RequestMapping("/save")
public R save(@RequestBody ZhipiaoxinxiEntity zhipiaoxinxi, HttpServletRequest request){
// 为支票信息实体设置IDID为当前时间戳加上一个0-999的随机数
zhipiaoxinxi.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
// 注释掉的代码,原本用于验证实体的合法性
//ValidatorUtils.validateEntity(zhipiaoxinxi);
// 调用服务层的insert方法保存支票信息
zhipiaoxinxiService.insert(zhipiaoxinxi);
// 返回保存成功的响应
return R.ok();
}
//前端保存
// @param zhipiaoxinxi 支票信息实体
// @param request HttpServletRequest对象
// @return 保存成功的响应
@RequestMapping("/add")
public R add(@RequestBody ZhipiaoxinxiEntity zhipiaoxinxi, HttpServletRequest request){
// 为支票信息实体设置IDID为当前时间戳加上一个0-999的随机数
zhipiaoxinxi.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
// 注释掉的代码,原本用于验证实体的合法性
//ValidatorUtils.validateEntity(zhipiaoxinxi);
// 调用服务层的insert方法保存支票信息
zhipiaoxinxiService.insert(zhipiaoxinxi);
// 返回保存成功的响应
return R.ok();
}
// 修改
// @param zhipiaoxinxi 支票信息实体
//@param request HttpServletRequest对象
// @return 修改成功的响应
@RequestMapping("/update")
public R update(@RequestBody ZhipiaoxinxiEntity zhipiaoxinxi, HttpServletRequest request){
// 注释掉的代码,原本用于验证实体的合法性
//ValidatorUtils.validateEntity(zhipiaoxinxi);
// 调用服务层的updateById方法更新支票信息
zhipiaoxinxiService.updateById(zhipiaoxinxi);//全部更新
// 返回修改成功的响应
return R.ok();
}
// 删除
// @param ids 要删除的支票信息的ID数组
// @return 删除成功的响应
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids){
// 调用服务层的deleteBatchIds方法批量删除支票信息
zhipiaoxinxiService.deleteBatchIds(Arrays.asList(ids));
// 返回删除成功的响应
return R.ok();
}
// 提醒接口
// @param columnName 提醒的列名
// @param request HttpServletRequest对象
// @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对象用于格式化日期
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
// 创建Calendar对象用于处理日期
Calendar c = Calendar.getInstance();
Date remindStartDate = null;
Date remindEndDate = null;
// 如果提醒起始日期不为空
if(map.get("remindstart")!=null) {
// 将提醒起始天数转换为整数
Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
// 设置Calendar对象的时间为当前时间
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());
// 设置Calendar对象的时间为当前时间
c.setTime(new Date());
// 在当前时间上加上提醒结束天数
c.add(Calendar.DAY_OF_MONTH,remindEnd);
// 获取提醒结束日期
remindEndDate = c.getTime();
// 将格式化后的提醒结束日期放入请求参数中
map.put("remindend", sdf.format(remindEndDate));
}
}
// 创建一个Wrapper对象用于构建查询条件
Wrapper<ZhipiaoxinxiEntity> wrapper = new EntityWrapper<ZhipiaoxinxiEntity>();
// 如果提醒起始日期不为空,添加大于等于该日期的条件
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 = zhipiaoxinxiService.selectCount(wrapper);
// 返回成功响应,并将提醒数量放入响应中
return R.ok().put("count", count);
}
}

@ -1,74 +0,0 @@
package com.dao;
import com.entity.BumenfenleiEntity;
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.BumenfenleiVO;
import com.entity.view.BumenfenleiView;
// 部门分类数据访问接口继承自MyBatis-Plus的BaseMapper接口
//用于定义与部门分类实体BumenfenleiEntity相关的数据访问方法。
// 借助MyBatis-Plus的BaseMapper已经具备了一些基本的CRUD增删改查操作能力
//而本接口在此基础上定义了一些自定义的查询方法。
//@author
// @email
// @date 2021-04-24 15:19:31
public interface BumenfenleiDao extends BaseMapper<BumenfenleiEntity> {
// 根据查询条件包装器查询部门分类值对象VO的列表。
// 值对象VO通常是为了特定业务场景而封装的可能包含实体类的部分属性或经过处理后的属性。
// @param wrapper 用于构建查询条件的包装器,通过设置条件筛选出符合要求的部门分类数据,
// 并以值对象VO的形式返回。
// @param ("ew ")使用@Param注解指定参数名称为"ew"
// 这在MyBatis映射器中用于明确参数的标识方便在SQL映射文件中引用该参数来构建查询条件。
// @return 符合查询条件的部门分类值对象VO列表可用于业务层进行数据处理和展示。
List<BumenfenleiVO> selectListVO(@Param("ew") Wrapper<BumenfenleiEntity> wrapper);
// 根据查询条件包装器查询单个部门分类值对象VO
//@param wrapper 用于构建查询条件的包装器,通过设置精确的条件筛选出唯一的部门分类数据,
// 并以值对象VO的形式返回。
// @param ("ew") 使用@Param注解指定参数名称为"ew"
// 这在MyBatis映射器中用于明确参数的标识方便在SQL映射文件中引用该参数来构建查询条件。
// @return 符合查询条件的单个部门分类值对象VO如果没有找到符合条件的数据则可能返回null。
BumenfenleiVO selectVO(@Param("ew") Wrapper<BumenfenleiEntity> wrapper);
// 根据查询条件包装器查询部门分类视图的列表。
// 视图View可能是对实体数据进行了特定的组装或处理以满足不同的展示需求。
// @param wrapper 用于构建查询条件的包装器,通过设置条件筛选出符合要求的部门分类视图数据。
//@param ("ew") 使用@Param注解指定参数名称为"ew"
// 这在MyBatis映射器中用于明确参数的标识方便在SQL映射文件中引用该参数来构建查询条件。
// @return 符合查询条件的部门分类视图列表,可用于业务层进行数据展示或进一步处理。
List<BumenfenleiView> selectListView(@Param("ew") Wrapper<BumenfenleiEntity> wrapper);
// 根据分页信息和查询条件包装器查询部门分类视图的列表。
// 此方法提供了分页查询的功能,结合分页信息和查询条件来获取数据。
// @param page 分页信息对象,包含了当前页码、每页数量等信息,用于实现分页查询。
//@param wrapper 用于构建查询条件的包装器,通过设置条件筛选出符合要求的部门分类视图数据。
//@param ("ew") 使用@Param注解指定参数名称为"ew"
// 这在MyBatis映射器中用于明确参数的标识方便在SQL映射文件中引用该参数来构建查询条件。
// @return 符合查询条件的部门分类视图列表,可用于业务层进行数据展示或进一步处理,且进行了分页处理。
List<BumenfenleiView> selectListView(Pagination page, @Param("ew") Wrapper<BumenfenleiEntity> wrapper);
//根据查询条件包装器查询单个部门分类视图。
// @param wrapper 用于构建查询条件的包装器,通过设置精确的条件筛选出唯一的部门分类视图数据。
// @param ("ew") 使用@Param注解指定参数名称为"ew"
// 这在MyBatis映射器中用于明确参数的标识方便在SQL映射文件中引用该参数来构建查询条件。
// @return 符合查询条件的单个部门分类视图如果没有找到符合条件的数据则可能返回null。
BumenfenleiView selectView(@Param("ew") Wrapper<BumenfenleiEntity> wrapper);
}

@ -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.FapiaoxinxiEntity;
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.FapiaoxinxiVO;
import com.entity.view.FapiaoxinxiView;
// 发票信息
// 此接口用于操作发票信息相关的数据,继承了 MyBatis-Plus 的 BaseMapper 接口,具备基本的增删改查功能。
// @author
// @email
// @date 2021-04-24 15:19:31
public interface FapiaoxinxiDao extends BaseMapper<FapiaoxinxiEntity> {
// 根据查询条件 wrapper 查询发票信息的 VO值对象列表。
// VO 通常用于封装需要展示给前端或传递给其他层的数据,可能包含了部分字段的组合或计算结果。
// @param wrapper 用于构建查询条件的包装器,可包含如等于、大于、小于等各种查询条件。
// @return 符合查询条件的发票信息 VO 列表。
List<FapiaoxinxiVO> selectListVO(@Param("ew") Wrapper<FapiaoxinxiEntity> wrapper);
// 根据查询条件 wrapper 查询单个发票信息的 VO。
// @param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的单个发票信息 VO如果没有匹配的记录则返回 null。
FapiaoxinxiVO selectVO(@Param("ew") Wrapper<FapiaoxinxiEntity> wrapper);
// 根据查询条件 wrapper 查询发票信息的视图列表。
//视图通常是对数据库表进行特定查询和处理后得到的虚拟表,这里的视图对象可能包含了一些经过处理或关联查询后的数据。
// @param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的发票信息视图列表。
List<FapiaoxinxiView> selectListView(@Param("ew") Wrapper<FapiaoxinxiEntity> wrapper);
//根据分页信息 page 和查询条件 wrapper 查询发票信息的视图列表。
// 该方法支持分页查询,可用于在大量数据中按页获取发票信息。
// @param page 分页对象,包含了当前页码、每页显示数量等分页信息。
// @param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的当前页发票信息视图列表。
List<FapiaoxinxiView> selectListView(Pagination page, @Param("ew") Wrapper<FapiaoxinxiEntity> wrapper);
//根据查询条件 wrapper 查询单个发票信息的视图。
//@param wrapper 用于构建查询条件的包装器。
//@return 符合查询条件的单个发票信息视图,如果没有匹配的记录则返回 null。
FapiaoxinxiView selectView(@Param("ew") Wrapper<FapiaoxinxiEntity> wrapper);
}

@ -1,59 +0,0 @@
package com.dao;
import com.entity.GongyingshangxinxiEntity;
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.GongyingshangxinxiVO;
import com.entity.view.GongyingshangxinxiView;
//供应商信息
// 该接口主要用于与数据库中供应商信息表进行交互,继承自 MyBatis-Plus 的 BaseMapper 接口,可使用其提供的基本 CRUD 操作。
//@author
// @date 2021-04-24 15:19:31
public interface GongyingshangxinxiDao extends BaseMapper<GongyingshangxinxiEntity> {
// 根据指定的查询条件查询供应商信息值对象VO列表。
// VO 通常用于封装特定业务场景下需要的数据,可避免直接暴露实体类的所有字段。
//@param wrapper 用于构建查询条件的包装器,可包含各种条件(如等于、大于、小于等)。
// @return 符合查询条件的供应商信息 VO 列表。
List<GongyingshangxinxiVO> selectListVO(@Param("ew") Wrapper<GongyingshangxinxiEntity> wrapper);
// 根据指定的查询条件查询单个供应商信息值对象VO
//@param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的单个供应商信息 VO若未找到则返回 null。
GongyingshangxinxiVO selectVO(@Param("ew") Wrapper<GongyingshangxinxiEntity> wrapper);
// 根据指定的查询条件查询供应商信息视图对象列表。
//视图对象通常是对实体类进行加工处理后得到的,用于满足特定展示需求。
// @param wrapper 用于构建查询条件的包装器。
//@return 符合查询条件的供应商信息视图对象列表。
List<GongyingshangxinxiView> selectListView(@Param("ew") Wrapper<GongyingshangxinxiEntity> wrapper);
// 根据分页信息和查询条件查询供应商信息视图对象列表。
//支持分页查询,便于处理大量数据。
// @param page 分页对象,包含当前页码、每页记录数等信息。
// @param wrapper 用于构建查询条件的包装器。
// @return 当前页符合查询条件的供应商信息视图对象列表。
List<GongyingshangxinxiView> selectListView(Pagination page, @Param("ew") Wrapper<GongyingshangxinxiEntity> wrapper);
//根据指定的查询条件查询单个供应商信息视图对象。
//@param wrapper 用于构建查询条件的包装器。
//@return 符合查询条件的单个供应商信息视图对象,若未找到则返回 null。
GongyingshangxinxiView selectView(@Param("ew") Wrapper<GongyingshangxinxiEntity> wrapper);
}

@ -1,60 +0,0 @@
package com.dao;
import com.entity.JizhangpingzhengEntity;
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.JizhangpingzhengVO;
import com.entity.view.JizhangpingzhengView;
// 记账凭证
//此接口用于与数据库中记账凭证相关的数据进行交互,继承自 MyBatis-Plus 的 BaseMapper 接口,可使用其提供的基础 CRUD 操作。
// @author
// @email
// @date 2021-04-24 15:19:31
public interface JizhangpingzhengDao extends BaseMapper<JizhangpingzhengEntity> {
// 根据查询条件 wrapper 查询记账凭证值对象VO列表。
// 值对象VO通常用于封装特定业务逻辑需要的数据可能只包含实体类的部分字段或经过计算处理后的字段。
// @param wrapper 用于构建查询条件的包装器,可通过该包装器设置各种查询条件,如等于、大于、小于等。
// @return 满足查询条件的记账凭证值对象列表。
List<JizhangpingzhengVO> selectListVO(@Param("ew") Wrapper<JizhangpingzhengEntity> wrapper);
// 根据查询条件 wrapper 查询单个记账凭证值对象VO
//@param wrapper 用于构建查询条件的包装器。
// @return 满足查询条件的单个记账凭证值对象,如果没有匹配的记录则返回 null。
JizhangpingzhengVO selectVO(@Param("ew") Wrapper<JizhangpingzhengEntity> wrapper);
// 根据查询条件 wrapper 查询记账凭证视图对象列表。
// 视图对象通常用于展示数据,可能会包含一些关联查询或格式化后的数据。
// @param wrapper 用于构建查询条件的包装器。
// @return 满足查询条件的记账凭证视图对象列表。
List<JizhangpingzhengView> selectListView(@Param("ew") Wrapper<JizhangpingzhengEntity> wrapper);
// 根据分页信息 page 和查询条件 wrapper 查询记账凭证视图对象列表。
// 该方法支持分页查询,可用于处理大量数据。
//@param page 分页对象,包含当前页码、每页显示记录数等信息。
// @param wrapper 用于构建查询条件的包装器。
// @return 当前页满足查询条件的记账凭证视图对象列表。
List<JizhangpingzhengView> selectListView(Pagination page, @Param("ew") Wrapper<JizhangpingzhengEntity> wrapper);
// 根据查询条件 wrapper 查询单个记账凭证视图对象。
// @param wrapper 用于构建查询条件的包装器。
// @return 满足查询条件的单个记账凭证视图对象,如果没有匹配的记录则返回 null。
JizhangpingzhengView selectView(@Param("ew") Wrapper<JizhangpingzhengEntity> wrapper);
}

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

@ -1,60 +0,0 @@
package com.dao;
import com.entity.RijizhangEntity;
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.RijizhangVO;
import com.entity.view.RijizhangView;
// 日记账
// 该接口用于与数据库中日记账相关的数据进行交互,继承自 MyBatis-Plus 的 BaseMapper 接口,具备基本的增删改查功能。
//@author
//@email
//@date 2021-04-24 15:19:31
public interface RijizhangDao extends BaseMapper<RijizhangEntity> {
// 根据查询条件 wrapper 查询日记账值对象VO列表。
//值对象VO通常用于封装特定业务逻辑需要的数据可能只包含实体类的部分字段或经过计算处理后的字段。
// @param wrapper 用于构建查询条件的包装器,可通过该包装器设置各种查询条件,如等于、大于、小于等。
// @return 满足查询条件的日记账值对象列表。
List<RijizhangVO> selectListVO(@Param("ew") Wrapper<RijizhangEntity> wrapper);
// 根据查询条件 wrapper 查询单个日记账值对象VO
// @param wrapper 用于构建查询条件的包装器。
//@return 满足查询条件的单个日记账值对象,如果没有匹配的记录则返回 null。
RijizhangVO selectVO(@Param("ew") Wrapper<RijizhangEntity> wrapper);
// 根据查询条件 wrapper 查询日记账视图对象列表。
// 视图对象通常用于展示数据,可能会包含一些关联查询或格式化后的数据。
// @param wrapper 用于构建查询条件的包装器。
//@return 满足查询条件的日记账视图对象列表。
List<RijizhangView> selectListView(@Param("ew") Wrapper<RijizhangEntity> wrapper);
// 根据分页信息 page 和查询条件 wrapper 查询日记账视图对象列表。
//该方法支持分页查询,可用于处理大量数据。
// @param page 分页对象,包含当前页码、每页显示记录数等信息。
// @param wrapper 用于构建查询条件的包装器。
//@return 当前页满足查询条件的日记账视图对象列表。
List<RijizhangView> selectListView(Pagination page, @Param("ew") Wrapper<RijizhangEntity> wrapper);
// 根据查询条件 wrapper 查询单个日记账视图对象。
//@param wrapper 用于构建查询条件的包装器。
// @return 满足查询条件的单个日记账视图对象,如果没有匹配的记录则返回 null。
RijizhangView selectView(@Param("ew") Wrapper<RijizhangEntity> wrapper);
}

@ -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,61 +0,0 @@
package com.dao;
import com.entity.YuangongEntity;
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.YuangongVO;
import com.entity.view.YuangongView;
// 员工
// 该接口用于与数据库中员工相关的数据进行交互,继承自 MyBatis-Plus 的 BaseMapper 接口,
//具备对员工实体YuangongEntity的基本增删改查功能。
//@author
// @email
//@date 2021-04-24 15:19:31
public interface YuangongDao extends BaseMapper<YuangongEntity> {
// 根据查询条件 wrapper 查询员工值对象VO列表。
// 值对象VO通常用于封装特定业务场景下需要展示或处理的数据可能只包含实体类的部分字段。
// @param wrapper 用于构建查询条件的包装器,可设置各种条件(如等于、大于、小于等)来筛选数据。
//@return 符合查询条件的员工值对象列表,如果没有符合条件的数据则返回空列表。
List<YuangongVO> selectListVO(@Param("ew") Wrapper<YuangongEntity> wrapper);
// 根据查询条件 wrapper 查询单个员工值对象VO
// @param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的单个员工值对象,如果没有符合条件的数据则返回 null。
YuangongVO selectVO(@Param("ew") Wrapper<YuangongEntity> wrapper);
// 根据查询条件 wrapper 查询员工视图对象列表。
// 视图对象通常用于展示数据,可能包含一些关联查询或格式化后的数据。
// @param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的员工视图对象列表,如果没有符合条件的数据则返回空列表。
List<YuangongView> selectListView(@Param("ew") Wrapper<YuangongEntity> wrapper);
//根据分页信息 page 和查询条件 wrapper 查询员工视图对象列表。
//该方法支持分页查询,适用于处理大量数据。
//@param page 分页对象,包含当前页码、每页显示记录数等信息。
// @param wrapper 用于构建查询条件的包装器。
// @return 当前页符合查询条件的员工视图对象列表,如果没有符合条件的数据则返回空列表。
List<YuangongView> selectListView(Pagination page, @Param("ew") Wrapper<YuangongEntity> wrapper);
// 根据查询条件 wrapper 查询单个员工视图对象。
// @param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的单个员工视图对象,如果没有符合条件的数据则返回 null。
YuangongView selectView(@Param("ew") Wrapper<YuangongEntity> wrapper);
}

@ -1,61 +0,0 @@
package com.dao;
import com.entity.YuangongbaoxiaoEntity;
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.YuangongbaoxiaoVO;
import com.entity.view.YuangongbaoxiaoView;
// 员工报销
//该接口用于与数据库中员工报销相关的数据进行交互,继承自 MyBatis-Plus 的 BaseMapper 接口,
//可使用 BaseMapper 提供的基本增删改查功能来操作 YuangongbaoxiaoEntity 实体。
// @author
// @email
// @date 2021-04-24 15:19:31
public interface YuangongbaoxiaoDao extends BaseMapper<YuangongbaoxiaoEntity> {
// 根据传入的查询条件包装器 wrapper查询符合条件的员工报销值对象VO列表。
// 值对象VO通常用于封装特定业务场景下需要展示或处理的数据可能是实体类部分字段的组合。
// @param wrapper 用于构建查询条件的包装器,可设置如等于、大于、小于等条件来筛选数据。
// @return 符合查询条件的员工报销值对象列表,如果没有符合条件的数据则返回空列表。
List<YuangongbaoxiaoVO> selectListVO(@Param("ew") Wrapper<YuangongbaoxiaoEntity> wrapper);
// 根据传入的查询条件包装器 wrapper查询符合条件的单个员工报销值对象VO
//@param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的单个员工报销值对象,如果没有符合条件的数据则返回 null。
YuangongbaoxiaoVO selectVO(@Param("ew") Wrapper<YuangongbaoxiaoEntity> wrapper);
// 根据传入的查询条件包装器 wrapper查询符合条件的员工报销视图对象列表。
//视图对象通常用于展示数据,可能包含关联查询或格式化后的数据。
//@param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的员工报销视图对象列表,如果没有符合条件的数据则返回空列表。
List<YuangongbaoxiaoView> selectListView(@Param("ew") Wrapper<YuangongbaoxiaoEntity> wrapper);
//根据传入的分页信息 page 和查询条件包装器 wrapper分页查询符合条件的员工报销视图对象列表。
//此方法支持分页查询,适用于处理大量数据。
// @param page 分页对象,包含当前页码、每页显示记录数等信息。
// @param wrapper 用于构建查询条件的包装器。
// @return 当前页符合查询条件的员工报销视图对象列表,如果没有符合条件的数据则返回空列表。
List<YuangongbaoxiaoView> selectListView(Pagination page, @Param("ew") Wrapper<YuangongbaoxiaoEntity> wrapper);
//根据传入的查询条件包装器 wrapper查询符合条件的单个员工报销视图对象。
//@param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的单个员工报销视图对象,如果没有符合条件的数据则返回 null。
YuangongbaoxiaoView selectView(@Param("ew") Wrapper<YuangongbaoxiaoEntity> wrapper);
}

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

@ -1,61 +0,0 @@
package com.dao;
import com.entity.YuangongjiaokuanEntity;
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.YuangongjiaokuanVO;
import com.entity.view.YuangongjiaokuanView;
// 员工缴款
// 该接口主要用于与数据库中员工缴款相关的数据进行交互,继承自 MyBatis-Plus 的 BaseMapper 接口,
// 能够对 YuangongjiaokuanEntity 实体对象进行基本的增删改查操作。
// @author
// @email
// @date 2021-04-24 15:19:31
public interface YuangongjiaokuanDao extends BaseMapper<YuangongjiaokuanEntity> {
// 根据传入的查询条件包装器 wrapper查询符合条件的员工缴款值对象VO列表。
// 值对象VO一般用于封装特定业务场景下需要的数据可能只包含实体类的部分字段。
// @param wrapper 用于构建查询条件的包装器,可设置各种条件(如等于、大于、小于等)来筛选数据。
// @return 符合查询条件的员工缴款值对象列表,若没有符合条件的数据则返回空列表。
List<YuangongjiaokuanVO> selectListVO(@Param("ew") Wrapper<YuangongjiaokuanEntity> wrapper);
//根据传入的查询条件包装器 wrapper查询符合条件的单个员工缴款值对象VO
// @param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的单个员工缴款值对象,若没有符合条件的数据则返回 null。
YuangongjiaokuanVO selectVO(@Param("ew") Wrapper<YuangongjiaokuanEntity> wrapper);
// 根据传入的查询条件包装器 wrapper查询符合条件的员工缴款视图对象列表。
// 视图对象通常用于展示数据,可能包含关联查询或格式化后的数据。
// @param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的员工缴款视图对象列表,若没有符合条件的数据则返回空列表。
List<YuangongjiaokuanView> selectListView(@Param("ew") Wrapper<YuangongjiaokuanEntity> wrapper);
// 根据传入的分页信息 page 和查询条件包装器 wrapper分页查询符合条件的员工缴款视图对象列表。
// 该方法支持分页查询,适用于处理大量数据。
// @param page 分页对象,包含当前页码、每页显示记录数等信息。
//@param wrapper 用于构建查询条件的包装器。
// @return 当前页符合查询条件的员工缴款视图对象列表,若没有符合条件的数据则返回空列表。
List<YuangongjiaokuanView> selectListView(Pagination page, @Param("ew") Wrapper<YuangongjiaokuanEntity> wrapper);
// 根据传入的查询条件包装器 wrapper查询符合条件的单个员工缴款视图对象。
// @param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的单个员工缴款视图对象,若没有符合条件的数据则返回 null。
YuangongjiaokuanView selectView(@Param("ew") Wrapper<YuangongjiaokuanEntity> wrapper);
}

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

@ -1,60 +0,0 @@
package com.dao;
import com.entity.ZhipiaoxinxiEntity;
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.ZhipiaoxinxiVO;
import com.entity.view.ZhipiaoxinxiView;
// 支票信息
// 此接口用于与数据库中支票信息相关的数据进行交互,继承自 MyBatis-Plus 的 BaseMapper 接口,
// 可以使用 BaseMapper 提供的基本增删改查方法来操作 ZhipiaoxinxiEntity 实体对象。
// @author
// @email
// @date 2021-04-24 15:19:31
public interface ZhipiaoxinxiDao extends BaseMapper<ZhipiaoxinxiEntity> {
// 根据指定的查询条件 wrapper查询符合条件的支票信息值对象VO列表。
// 值对象VO通常用于封装特定业务场景下需要展示或处理的数据可能只包含实体类的部分字段。
// @param wrapper 用于构建查询条件的包装器,可设置如等于、大于、小于等条件来筛选数据。
// @return 符合查询条件的支票信息值对象列表,如果没有符合条件的数据则返回空列表。
List<ZhipiaoxinxiVO> selectListVO(@Param("ew") Wrapper<ZhipiaoxinxiEntity> wrapper);
// 根据指定的查询条件 wrapper查询符合条件的单个支票信息值对象VO
// @param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的单个支票信息值对象,如果没有符合条件的数据则返回 null。
ZhipiaoxinxiVO selectVO(@Param("ew") Wrapper<ZhipiaoxinxiEntity> wrapper);
// 根据指定的查询条件 wrapper查询符合条件的支票信息视图对象列表。
// 视图对象通常用于展示数据,可能包含关联查询或格式化后的数据。
// @param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的支票信息视图对象列表,如果没有符合条件的数据则返回空列表。
List<ZhipiaoxinxiView> selectListView(@Param("ew") Wrapper<ZhipiaoxinxiEntity> wrapper);
// 根据分页信息 page 和查询条件 wrapper分页查询符合条件的支票信息视图对象列表。
// 该方法支持分页查询,适用于处理大量数据。
// @param page 分页对象,包含当前页码、每页显示记录数等信息。
// @param wrapper 用于构建查询条件的包装器。
// @return 当前页符合查询条件的支票信息视图对象列表,如果没有符合条件的数据则返回空列表。
List<ZhipiaoxinxiView> selectListView(Pagination page, @Param("ew") Wrapper<ZhipiaoxinxiEntity> wrapper);
//根据指定的查询条件 wrapper查询符合条件的单个支票信息视图对象。
//@param wrapper 用于构建查询条件的包装器。
// @return 符合查询条件的单个支票信息视图对象,如果没有符合条件的数据则返回 null。
ZhipiaoxinxiView selectView(@Param("ew") Wrapper<ZhipiaoxinxiEntity> wrapper);
}

@ -1,112 +0,0 @@
package com.entity;
// 导入 MyBatis-Plus 注解,用于指定主键
import com.baomidou.mybatisplus.annotations.TableId;
// 导入 MyBatis-Plus 注解,用于指定数据库表名
import com.baomidou.mybatisplus.annotations.TableName;
// 导入验证注解,用于验证字符串不为空字符串
import javax.validation.constraints.NotBlank;
// 导入验证注解,用于验证集合或数组不为空
import javax.validation.constraints.NotEmpty;
// 导入验证注解,用于验证对象不为 null
import javax.validation.constraints.NotNull;
// 导入 Jackson 注解,用于忽略 JSON 序列化和反序列化时的某些属性
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
// 导入反射调用方法时可能抛出的异常类
import java.lang.reflect.InvocationTargetException;
// 导入可序列化接口,使该类的对象可以进行序列化和反序列化操作
import java.io.Serializable;
// 导入日期类,用于表示日期和时间
import java.util.Date;
// 导入列表类,用于表示一组对象
import java.util.List;
// 导入 Spring 框架的日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
// 导入 Jackson 注解,用于指定日期在 JSON 中的格式化方式
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入 Apache Commons BeanUtils 工具类,用于对象属性的复制
import org.apache.commons.beanutils.BeanUtils;
// 导入 MyBatis-Plus 注解,用于指定字段的填充策略
import com.baomidou.mybatisplus.annotations.TableField;
// 导入 MyBatis-Plus 枚举,用于指定字段的填充策略
import com.baomidou.mybatisplus.enums.FieldFill;
// 导入 MyBatis-Plus 枚举,用于指定主键的生成类型
import com.baomidou.mybatisplus.enums.IdType;
// 部门分类
// 数据库通用操作实体类(普通增删改查)
// @author
// @email
// @date 2021-04-24 15:19:31
// 使用 TableName 注解指定该实体类对应的数据库表名为 "bumenfenlei"
@TableName("bumenfenlei")
// 定义泛型实体类,用于接收不同类型的对象并进行属性复制
public class BumenfenleiEntity<T> implements Serializable {
// 定义序列化版本号,用于在反序列化时验证类的版本一致性
private static final long serialVersionUID = 1L;
// 无参构造函数,用于创建一个空的 BumenfenleiEntity 对象
public BumenfenleiEntity() {
}
// 有参构造函数,接受一个泛型对象 t将其属性复制到当前对象
public BumenfenleiEntity(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,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,194 +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("fapiaoxinxi")
public class FapiaoxinxiEntity<T> implements Serializable {
private static final long serialVersionUID = 1L;
public FapiaoxinxiEntity() {
}
public FapiaoxinxiEntity(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 fapiaobianhao;
// 客户姓名
private String kehuxingming;
// 商品名称
private String shangpinmingcheng;
// 商品单价
private Integer shangpindanjia;
//商品数量
private Integer shangpinshuliang;
//总金额
private String zongjine;
// 开票日期
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd")
@DateTimeFormat
private Date kaipiaoriqi;
//备注
private String beizhu;
@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 setFapiaobianhao(String fapiaobianhao) {
this.fapiaobianhao = fapiaobianhao;
}
// 获取:发票编号
public String getFapiaobianhao() {
return fapiaobianhao;
}
// 设置:客户姓名
public void setKehuxingming(String kehuxingming) {
this.kehuxingming = kehuxingming;
}
// 获取:客户姓名
public String getKehuxingming() {
return kehuxingming;
}
//设置:商品名称
public void setShangpinmingcheng(String shangpinmingcheng) {
this.shangpinmingcheng = shangpinmingcheng;
}
//获取:商品名称
public String getShangpinmingcheng() {
return shangpinmingcheng;
}
//设置:商品单价
public void setShangpindanjia(Integer shangpindanjia) {
this.shangpindanjia = shangpindanjia;
}
// 获取:商品单价
public Integer getShangpindanjia() {
return shangpindanjia;
}
// 设置:商品数量
public void setShangpinshuliang(Integer shangpinshuliang) {
this.shangpinshuliang = shangpinshuliang;
}
// 获取:商品数量
public Integer getShangpinshuliang() {
return shangpinshuliang;
}
// 设置:总金额
public void setZongjine(String zongjine) {
this.zongjine = zongjine;
}
//获取:总金额
public String getZongjine() {
return zongjine;
}
// 设置:开票日期
public void setKaipiaoriqi(Date kaipiaoriqi) {
this.kaipiaoriqi = kaipiaoriqi;
}
// 获取:开票日期
public Date getKaipiaoriqi() {
return kaipiaoriqi;
}
// 设置:备注
public void setBeizhu(String beizhu) {
this.beizhu = beizhu;
}
//获取:备注
public String getBeizhu() {
return beizhu;
}
}

@ -1,194 +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("gongyingshangxinxi")
public class GongyingshangxinxiEntity<T> implements Serializable {
private static final long serialVersionUID = 1L;
public GongyingshangxinxiEntity() {
}
public GongyingshangxinxiEntity(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 gongyingshangxingming;
// 公司名称
private String gongsimingcheng;
//公司地址
private String gongsidizhi;
// 供应产品
private String gongyingchanpin;
// 联系电话
private String lianxidianhua;
//合作时长
private String hezuoshizhang;
// 备注
private String beizhu;
//登记日期
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd")
@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 setGongyingshangxingming(String gongyingshangxingming) {
this.gongyingshangxingming = gongyingshangxingming;
}
// 获取:供应商姓名
public String getGongyingshangxingming() {
return gongyingshangxingming;
}
// 设置:公司名称
public void setGongsimingcheng(String gongsimingcheng) {
this.gongsimingcheng = gongsimingcheng;
}
// 获取:公司名称
public String getGongsimingcheng() {
return gongsimingcheng;
}
// 设置:公司地址
public void setGongsidizhi(String gongsidizhi) {
this.gongsidizhi = gongsidizhi;
}
// 获取:公司地址
public String getGongsidizhi() {
return gongsidizhi;
}
//设置:供应产品
public void setGongyingchanpin(String gongyingchanpin) {
this.gongyingchanpin = gongyingchanpin;
}
// 获取:供应产品
public String getGongyingchanpin() {
return gongyingchanpin;
}
//设置:联系电话
public void setLianxidianhua(String lianxidianhua) {
this.lianxidianhua = lianxidianhua;
}
// 获取:联系电话
public String getLianxidianhua() {
return lianxidianhua;
}
//设置:合作时长
public void setHezuoshizhang(String hezuoshizhang) {
this.hezuoshizhang = hezuoshizhang;
}
//获取:合作时长
public String getHezuoshizhang() {
return hezuoshizhang;
}
// 设置:备注
public void setBeizhu(String beizhu) {
this.beizhu = beizhu;
}
// 获取:备注
public String getBeizhu() {
return beizhu;
}
//设置:登记日期
public void setDengjiriqi(Date dengjiriqi) {
this.dengjiriqi = dengjiriqi;
}
// 获取:登记日期
public Date getDengjiriqi() {
return dengjiriqi;
}
}

@ -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("jizhangpingzheng")
public class JizhangpingzhengEntity<T> implements Serializable {
private static final long serialVersionUID = 1L;
public JizhangpingzhengEntity() {
}
public JizhangpingzhengEntity(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 pingzhengbianhao;
// 凭证名称
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;
@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 setPingzhengbianhao(String pingzhengbianhao) {
this.pingzhengbianhao = pingzhengbianhao;
}
// 获取:凭证编号
public String getPingzhengbianhao() {
return pingzhengbianhao;
}
//设置:凭证名称
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,194 +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("kehuxinxi")
public class KehuxinxiEntity<T> implements Serializable {
private static final long serialVersionUID = 1L;
public KehuxinxiEntity() {
}
public KehuxinxiEntity(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 kehuxingming;
// 公司名称
private String gongsimingcheng;
// 公司地址
private String gongsidizhi;
//合作项目
private String hezuoxiangmu;
//合作时长
private String hezuoshizhang;
// 联系电话
private String lianxidianhua;
// 备注
private String beizhu;
// 登记日期
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd")
@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 setKehuxingming(String kehuxingming) {
this.kehuxingming = kehuxingming;
}
// 获取:客户姓名
public String getKehuxingming() {
return kehuxingming;
}
// 设置:公司名称
public void setGongsimingcheng(String gongsimingcheng) {
this.gongsimingcheng = gongsimingcheng;
}
// 获取:公司名称
public String getGongsimingcheng() {
return gongsimingcheng;
}
// 设置:公司地址
public void setGongsidizhi(String gongsidizhi) {
this.gongsidizhi = gongsidizhi;
}
// 获取:公司地址
public String getGongsidizhi() {
return gongsidizhi;
}
// 设置:合作项目
public void setHezuoxiangmu(String hezuoxiangmu) {
this.hezuoxiangmu = hezuoxiangmu;
}
// 获取:合作项目
public String getHezuoxiangmu() {
return hezuoxiangmu;
}
// 设置:合作时长
public void setHezuoshizhang(String hezuoshizhang) {
this.hezuoshizhang = hezuoshizhang;
}
// 获取:合作时长
public String getHezuoshizhang() {
return hezuoshizhang;
}
// 设置:联系电话
public void setLianxidianhua(String lianxidianhua) {
this.lianxidianhua = lianxidianhua;
}
// 获取:联系电话
public String getLianxidianhua() {
return lianxidianhua;
}
// 设置:备注
public void setBeizhu(String beizhu) {
this.beizhu = beizhu;
}
// 获取:备注
public String getBeizhu() {
return beizhu;
}
// 设置:登记日期
public void setDengjiriqi(Date dengjiriqi) {
this.dengjiriqi = dengjiriqi;
}
// 获取:登记日期
public Date getDengjiriqi() {
return dengjiriqi;
}
}

@ -1,193 +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("rijizhang")
public class RijizhangEntity<T> implements Serializable {
private static final long serialVersionUID = 1L;
public RijizhangEntity() {
}
public RijizhangEntity(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 xuhao;
// 日期
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd")
@DateTimeFormat
private Date riqi;
// 摘要
private String zhaiyao;
// 收入
private Integer shouru;
// 支出
private Integer zhichu;
//金额
private String jine;
// 管理工号
private String guanligonghao;
//管理姓名
private String guanlixingming;
@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 setXuhao(String xuhao) {
this.xuhao = xuhao;
}
// 获取:序号
public String getXuhao() {
return xuhao;
}
//设置:日期
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,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,192 +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("yuangong")
public class YuangongEntity<T> implements Serializable {
private static final long serialVersionUID = 1L;
public YuangongEntity() {
}
public YuangongEntity(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 yuangonggonghao;
// 密码
private String mima;
//员工姓名
private String yuangongxingming;
//性别
private String xingbie;
//部门
private String bumen;
// 手机
private String shouji;
//邮箱
private String youxiang;
//身份证
private String shenfenzheng;
@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 setYuangonggonghao(String yuangonggonghao) {
this.yuangonggonghao = yuangonggonghao;
}
// 获取:员工工号
public String getYuangonggonghao() {
return yuangonggonghao;
}
// 设置:密码
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,208 +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("yuangongbaoxiao")
public class YuangongbaoxiaoEntity<T> implements Serializable {
private static final long serialVersionUID = 1L;
public YuangongbaoxiaoEntity() {
}
public YuangongbaoxiaoEntity(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 yuangonggonghao;
//员工姓名
private String yuangongxingming;
// 报销项目
private String baoxiaoxiangmu;
// 报销金额
private Integer baoxiaojine;
// 申请日期
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd")
@DateTimeFormat
private Date shenqingriqi;
// 备注
private String beizhu;
// 管理工号
private String guanligonghao;
// 管理姓名
private String guanlixingming;
// 是否支付
private String ispay;
@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 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 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,192 +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("yuangongguanli")
public class YuangongguanliEntity<T> implements Serializable {
private static final long serialVersionUID = 1L;
public YuangongguanliEntity() {
}
public YuangongguanliEntity(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 guanligonghao;
// 密码
private String mima;
// 管理姓名
private String guanlixingming;
// 性别
private String xingbie;
// 职位
private String zhiwei;
// 手机
private String shouji;
//邮箱
private String youxiang;
// 身份证
private String shenfenzheng;
@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 setGuanligonghao(String guanligonghao) {
this.guanligonghao = guanligonghao;
}
// 获取:管理工号
public String getGuanligonghao() {
return guanligonghao;
}
// 设置:密码
public void setMima(String mima) {
this.mima = mima;
}
//获取:密码
public String getMima() {
return mima;
}
// 设置:管理姓名
public void setGuanlixingming(String guanlixingming) {
this.guanlixingming = guanlixingming;
}
//获取:管理姓名
public String getGuanlixingming() {
return guanlixingming;
}
// 设置:性别
public void setXingbie(String xingbie) {
this.xingbie = xingbie;
}
//获取:性别
public String getXingbie() {
return xingbie;
}
// 设置:职位
public void setZhiwei(String zhiwei) {
this.zhiwei = zhiwei;
}
//获取:职位
public String getZhiwei() {
return zhiwei;
}
//设置:手机
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,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("yuangongjiaokuan")
public class YuangongjiaokuanEntity<T> implements Serializable {
private static final long serialVersionUID = 1L;
public YuangongjiaokuanEntity() {
}
public YuangongjiaokuanEntity(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 yuangonggonghao;
// 员工姓名
private String yuangongxingming;
// 缴费名称
private String jiaofeimingcheng;
// 缴款金额
private Integer jiaokuanjine;
// 缴款日期
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd")
@DateTimeFormat
private Date jiaokuanriqi;
//备注
private String beizhu;
// 管理工号
private String guanligonghao;
// 管理姓名
private String guanlixingming;
// 是否审核
private String sfsh;
// 审核回复
private String shhf;
//是否支付
private String ispay;
@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 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 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,254 +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("yuangongxinchou")
public class YuangongxinchouEntity<T> implements Serializable {
private static final long serialVersionUID = 1L;
public YuangongxinchouEntity() {
}
public YuangongxinchouEntity(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 yuangonggonghao;
//员工姓名
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")
@DateTimeFormat
private Date riqi;
// 管理工号
private String guanligonghao;
// 管理姓名
private String guanlixingming;
@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 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 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,163 +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("zhipiaoxinxi")
public class ZhipiaoxinxiEntity<T> implements Serializable {
private static final long serialVersionUID = 1L;
public ZhipiaoxinxiEntity() {
}
public ZhipiaoxinxiEntity(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 zhipiaohao;
// 收款单位
private String shoukuandanwei;
// 金额
private Integer jine;
// 用途
private String yongtu;
//备注
private String beizhu;
// 开票日期
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd")
@DateTimeFormat
private Date kaipiaoriqi;
@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 setZhipiaohao(String zhipiaohao) {
this.zhipiaohao = zhipiaohao;
}
// 获取:支票号
public String getZhipiaohao() {
return zhipiaohao;
}
// 设置:收款单位
public void setShoukuandanwei(String shoukuandanwei) {
this.shoukuandanwei = shoukuandanwei;
}
//获取:收款单位
public String getShoukuandanwei() {
return shoukuandanwei;
}
//设置:金额
public void setJine(Integer jine) {
this.jine = jine;
}
// 获取:金额
public Integer getJine() {
return jine;
}
//设置:用途
public void setYongtu(String yongtu) {
this.yongtu = yongtu;
}
//获取:用途
public String getYongtu() {
return yongtu;
}
//设置:备注
public void setBeizhu(String beizhu) {
this.beizhu = beizhu;
}
//获取:备注
public String getBeizhu() {
return beizhu;
}
//设置:开票日期
public void setKaipiaoriqi(Date kaipiaoriqi) {
this.kaipiaoriqi = kaipiaoriqi;
}
//获取:开票日期
public Date getKaipiaoriqi() {
return kaipiaoriqi;
}
}

@ -1,25 +0,0 @@
package com.entity.model;
import com.entity.BumenfenleiEntity;
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 BumenfenleiModel implements Serializable {
private static final long serialVersionUID = 1L;
}

@ -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,178 +0,0 @@
package com.entity.model;
import com.entity.FapiaoxinxiEntity;
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名称
// @email
// @date 2021-04-24 15:19:31
public class FapiaoxinxiModel implements Serializable {
private static final long serialVersionUID = 1L;
// 客户姓名
private String kehuxingming;
// 商品名称
private String shangpinmingcheng;
//商品单价
private Integer shangpindanjia;
// 商品数量
private Integer shangpinshuliang;
//总金额
private String zongjine;
// 开票日期
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date kaipiaoriqi;
// 备注
private String beizhu;
// 设置:客户姓名
public void setKehuxingming(String kehuxingming) {
this.kehuxingming = kehuxingming;
}
// 获取:客户姓名
public String getKehuxingming() {
return kehuxingming;
}
// 设置:商品名称
public void setShangpinmingcheng(String shangpinmingcheng) {
this.shangpinmingcheng = shangpinmingcheng;
}
// 获取:商品名称
public String getShangpinmingcheng() {
return shangpinmingcheng;
}
// 设置:商品单价
public void setShangpindanjia(Integer shangpindanjia) {
this.shangpindanjia = shangpindanjia;
}
// 获取:商品单价
public Integer getShangpindanjia() {
return shangpindanjia;
}
//设置:商品数量
public void setShangpinshuliang(Integer shangpinshuliang) {
this.shangpinshuliang = shangpinshuliang;
}
// 获取:商品数量
public Integer getShangpinshuliang() {
return shangpinshuliang;
}
// 设置:总金额
public void setZongjine(String zongjine) {
this.zongjine = zongjine;
}
//获取:总金额
public String getZongjine() {
return zongjine;
}
// 设置:开票日期
public void setKaipiaoriqi(Date kaipiaoriqi) {
this.kaipiaoriqi = kaipiaoriqi;
}
//获取:开票日期
public Date getKaipiaoriqi() {
return kaipiaoriqi;
}
// 设置:备注
public void setBeizhu(String beizhu) {
this.beizhu = beizhu;
}
// 获取:备注
public String getBeizhu() {
return beizhu;
}
}

@ -1,178 +0,0 @@
package com.entity.model;
import com.entity.GongyingshangxinxiEntity;
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 GongyingshangxinxiModel implements Serializable {
private static final long serialVersionUID = 1L;
//公司名称
private String gongsimingcheng;
// 公司地址
private String gongsidizhi;
//供应产品
private String gongyingchanpin;
// 联系电话
private String lianxidianhua;
//合作时长
private String hezuoshizhang;
//备注
private String beizhu;
//登记日期
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date dengjiriqi;
//设置:公司名称
public void setGongsimingcheng(String gongsimingcheng) {
this.gongsimingcheng = gongsimingcheng;
}
// 获取:公司名称
public String getGongsimingcheng() {
return gongsimingcheng;
}
//设置:公司地址
public void setGongsidizhi(String gongsidizhi) {
this.gongsidizhi = gongsidizhi;
}
// 获取:公司地址
public String getGongsidizhi() {
return gongsidizhi;
}
// 设置:供应产品
public void setGongyingchanpin(String gongyingchanpin) {
this.gongyingchanpin = gongyingchanpin;
}
// 获取:供应产品
public String getGongyingchanpin() {
return gongyingchanpin;
}
//设置:联系电话
public void setLianxidianhua(String lianxidianhua) {
this.lianxidianhua = lianxidianhua;
}
// 获取:联系电话
public String getLianxidianhua() {
return lianxidianhua;
}
// 设置:合作时长
public void setHezuoshizhang(String hezuoshizhang) {
this.hezuoshizhang = hezuoshizhang;
}
// 获取:合作时长
public String getHezuoshizhang() {
return hezuoshizhang;
}
// 设置:备注
public void setBeizhu(String beizhu) {
this.beizhu = beizhu;
}
// 获取:备注
public String getBeizhu() {
return beizhu;
}
// 设置:登记日期
public void setDengjiriqi(Date dengjiriqi) {
this.dengjiriqi = dengjiriqi;
}
// 获取:登记日期
public Date getDengjiriqi() {
return dengjiriqi;
}
}

@ -1,141 +0,0 @@
package com.entity.model;
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;
//记账凭证
// 接收传参的实体类
//(实际开发中配合移动端接口开发手动去掉些没用的字段, 后端一般用entity就够用了
// 取自ModelAndView 的model名称
// @author
// @email
// @date 2021-04-24 15:19:31
public class JizhangpingzhengModel 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,160 +0,0 @@
package com.entity.model;
import com.entity.KehuxinxiEntity;
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 KehuxinxiModel implements Serializable {
private static final long serialVersionUID = 1L;
// 公司名称
private String gongsimingcheng;
//公司地址
private String gongsidizhi;
// 合作项目
private String hezuoxiangmu;
// 合作时长
private String hezuoshizhang;
// 联系电话
private String lianxidianhua;
//备注
private String beizhu;
//登记日期
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date dengjiriqi;
//设置:公司名称
public void setGongsimingcheng(String gongsimingcheng) {
this.gongsimingcheng = gongsimingcheng;
}
// 获取:公司名称
public String getGongsimingcheng() {
return gongsimingcheng;
}
//设置:公司地址
public void setGongsidizhi(String gongsidizhi) {
this.gongsidizhi = gongsidizhi;
}
//获取:公司地址
public String getGongsidizhi() {
return gongsidizhi;
}
//设置:合作项目
public void setHezuoxiangmu(String hezuoxiangmu) {
this.hezuoxiangmu = hezuoxiangmu;
}
//获取:合作项目
public String getHezuoxiangmu() {
return hezuoxiangmu;
}
// 设置:合作时长
public void setHezuoshizhang(String hezuoshizhang) {
this.hezuoshizhang = hezuoshizhang;
}
//获取:合作时长
public String getHezuoshizhang() {
return hezuoshizhang;
}
// 设置:联系电话
public void setLianxidianhua(String lianxidianhua) {
this.lianxidianhua = lianxidianhua;
}
//获取:联系电话
public String getLianxidianhua() {
return lianxidianhua;
}
//设置:备注
public void setBeizhu(String beizhu) {
this.beizhu = beizhu;
}
// 获取:备注
public String getBeizhu() {
return beizhu;
}
//设置:登记日期
public void setDengjiriqi(Date dengjiriqi) {
this.dengjiriqi = dengjiriqi;
}
// 获取:登记日期
public Date getDengjiriqi() {
return dengjiriqi;
}
}

@ -1,158 +0,0 @@
package com.entity.model;
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;
//日记账
//接收传参的实体类
//(实际开发中配合移动端接口开发手动去掉些没用的字段, 后端一般用entity就够用了
// 取自ModelAndView 的model名称
// @author
// @email
// @date 2021-04-24 15:19:31
public class RijizhangModel 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;
}
}

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

Loading…
Cancel
Save