Compare commits

...

2 Commits

Author SHA1 Message Date
hjl 78413865c0 注释
9 months ago
hjl 8c83b7dcaa 上传
9 months ago

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

1
.gitignore vendored

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

@ -0,0 +1,46 @@
<?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,266 +0,0 @@
package com.controller;
// 定义控制器所在的包名
import java.math.BigDecimal; // 导入BigDecimal类用于进行高精度的数学运算
import java.text.SimpleDateFormat; // 导入SimpleDateFormat类用于格式化和解析日期
import java.text.ParseException; // 导入ParseException类用于处理日期解析异常
import java.util.ArrayList; // 导入ArrayList类用于创建动态数组
import java.util.Arrays; // 导入Arrays类提供了对数组操作的工具方法
import java.util.Calendar; // 导入Calendar类用于日期时间的操作
import java.util.Map; // 导入Map接口用于键值对集合
import java.util.HashMap; // 导入HashMap类基于哈希表的Map实现
import java.util.Iterator; // 导入Iterator接口用于遍历集合
import java.util.Date; // 导入Date类用于日期时间的表示
import java.util.List; // 导入List接口用于列表集合
import javax.servlet.http.HttpServletRequest; // 导入HttpServletRequest接口用于访问HTTP请求信息
import java.io.IOException; // 导入IOException类用于处理IO异常
import com.utils.ValidatorUtils; // 导入自定义的ValidatorUtils工具类用于数据验证
import org.apache.commons.lang3.StringUtils; // 导入Apache Commons Lang库的StringUtils类用于字符串操作
import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的Autowired注解用于自动注入依赖
import org.springframework.transaction.annotation.Transactional; // 导入Spring的Transactional注解用于声明事务
import org.springframework.format.annotation.DateTimeFormat; // 导入Spring的DateTimeFormat注解用于日期格式注解
import org.springframework.web.bind.annotation.PathVariable; // 导入Spring的PathVariable注解用于将URL中的参数绑定到控制器方法的参数上
import org.springframework.web.bind.annotation.RequestBody; // 导入Spring的RequestBody注解用于将HTTP请求的body部分绑定到控制器方法的参数上
import org.springframework.web.bind.annotation.RequestMapping; // 导入Spring的RequestMapping注解用于定义请求映射
import org.springframework.web.bind.annotation.RequestParam; // 导入Spring的RequestParam注解用于将请求参数绑定到控制器方法的参数上
import org.springframework.web.bind.annotation.RestController; // 导入Spring的RestController注解用于定义REST风格的控制器
import com.baomidou.mybatisplus.mapper.EntityWrapper; // 导入MyBatis Plus的EntityWrapper类用于构建查询条件
import com.baomidou.mybatisplus.mapper.Wrapper; // 导入MyBatis Plus的Wrapper接口EntityWrapper实现该接口
import com.annotation.IgnoreAuth; // 导入自定义的IgnoreAuth注解用于忽略权限验证
import com.entity.NewsEntity; // 导入新闻实体类
import com.entity.view.NewsView; // 导入新闻视图类
import com.service.NewsService; // 导入新闻服务类
import com.service.TokenService; // 导入Token服务类
import com.utils.PageUtils; // 导入自定义的PageUtils工具类用于分页处理
import com.utils.R; // 导入自定义的R类用于封装响应结果
import com.utils.MD5Util; // 导入自定义的MD5Util工具类用于MD5加密
import com.utils.MPUtil; // 导入自定义的MPUtil工具类提供MyBatis Plus工具方法
import com.utils.CommonUtil; // 导入自定义的CommonUtil工具类提供常用方法
/**
*
*
* @author
* @email
* @date 2023-02-21 09:46:06
*/
@RestController
@RequestMapping("/news")
public class NewsController {
@Autowired
private NewsService newsService;//注入新闻服务类
/**
*
*/
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, NewsEntity news, HttpServletRequest request) {
// 创建一个EntityWrapper对象用于构建查询条件
EntityWrapper<NewsEntity> ew = new EntityWrapper<NewsEntity>();
// 使用MPUtil工具类对查询条件进行排序和分页处理
PageUtils page = newsService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, news), params), params));
// 将分页结果设置到request对象中
request.setAttribute("data", page);
// 返回成功响应,包含分页结果
return R.ok().put("data", page);
}
/**
*
*/
@IgnoreAuth
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, NewsEntity news, HttpServletRequest request) {
// 创建一个EntityWrapper对象用于构建查询条件
EntityWrapper<NewsEntity> ew = new EntityWrapper<NewsEntity>();
// 使用MPUtil工具类对查询条件进行排序和分页处理
PageUtils page = newsService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, news), params), params));
// 将分页结果设置到request对象中
request.setAttribute("data", page);
// 返回成功响应,包含分页结果
return R.ok().put("data", page);
}
/**
*
*/
@RequestMapping("/lists")
//一个Spring MVC的注解用于将HTTP请求映射到 list 方法。当客户端发送一个HTTP请求到 /lists 路径时Spring MVC会调用 list 方法来处理这个请求
public R list(NewsEntity news) //NewsEntity news 参数表示要查询的 NewsEntity 对象
{
// 创建一个EntityWrapper对象用于构建查询条件
EntityWrapper<NewsEntity> ew = new EntityWrapper<NewsEntity>();
// 使用MPUtil工具类对查询条件进行排序和分页处理
ew.allEq(MPUtil.allEQMapPre(news, "news"));
// 返回成功响应,包含查询结果
return R.ok().put("data", newsService.selectListView(ew));
//这行代码返回一个表示请求成功的响应对象,并将 newsService.selectListView(ew) 的结果添加到响应对象中,键为 "data"。
//newsService.selectListView(ew) 方法用于查询满足 ew 对象的查询条件的记录,并返回一个包含查询结果的列表。
}
/**
*
*/
@RequestMapping("/query")
public R query(NewsEntity news) {
// 创建一个EntityWrapper对象用于构建查询条件
EntityWrapper<NewsEntity> ew = new EntityWrapper<NewsEntity>();
// 使用MPUtil工具类对查询条件进行排序和分页处理
ew.allEq(MPUtil.allEQMapPre(news, "news"));
// 调用 newsService 对象的 selectView 方法,查询满足 ew 对象的查询条件的记录,并返回一个 NewsView 对象
NewsView newsView = newsService.selectView(ew);
return R.ok("查询公告信息成功").put("data", newsView);
}
/**
*
*/
//一个Spring MVC的注解用于将HTTP请求映射到 info 方法。
//当客户端发送一个HTTP请求到 /info/{id} 路径时Spring MVC会调用 info 方法来处理这个请求
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id) {
// 根据ID查询并返回结果
NewsEntity news = newsService.selectById(id);
//调用 newsService 对象的 selectById 方法,根据 id 参数的值查询数据库中的记录,并返回一个 NewsEntity 对象。
return R.ok().put("data", news); //将 news 对象添加到响应对象中,键为 "data"
}
/**
*
*/
@IgnoreAuth
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id) {
// 根据ID查询并返回结果
NewsEntity news = newsService.selectById(id);
return R.ok().put("data", news);
}
/**
*
*/
@RequestMapping("/save")
public R save(@RequestBody NewsEntity news, HttpServletRequest request) {
// 设置ID为当前时间戳加上一个随机数
news.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 验证实体对象,如果需要验证,可以取消注释
// ValidatorUtils.validateEntity(news);
// 插入数据,将 news 对象插入到数据库中
newsService.insert(news);
//返回一个表示请求成功的响应对象
return R.ok();
}
/**
*
*/
@RequestMapping("/add")
public R add(@RequestBody NewsEntity news, HttpServletRequest request) {
// 设置ID为当前时间戳加上一个随机数
news.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 验证实体对象,如果需要验证,可以取消注释
// ValidatorUtils.validateEntity(news);
// 插入数据
newsService.insert(news);
return R.ok();
}
/**
*
*/
@RequestMapping("/update")
@Transactional
public R update(@RequestBody NewsEntity news, HttpServletRequest request) {
// 验证实体对象,如果需要验证,可以取消注释
// ValidatorUtils.validateEntity(news);
// 更新数据
newsService.updateById(news);
return R.ok();
}
/**
*
*/
@RequestMapping("/delete")//这是一个Spring MVC的注解用于将HTTP请求映射到 delete方法上
public R delete(@RequestBody Long[] ids) {
// 批量删除数据
newsService.deleteBatchIds(Arrays.asList(ids));
return R.ok();//R.ok() 方法通常表示请求成功,并返回一个默认的成功响应。
}
/**
*
*/
@RequestMapping("/remind/{columnName}/{type}")
//这是一个Spring MVC的注解用于将HTTP请求映射到 remindCount 方法。当客户端发送一个HTTP请求到 /remind/{columnName}/{type} 路径时Spring MVC会调用 remindCount 方法来处理这个请求。
public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
@PathVariable("type") String type, @RequestParam Map<String, Object> map) {
// 将列名和类型添加到map中,@PathVariable 注解表示 columnName 和 type 参数的值将从URL路径中获取
map.put("column", columnName);//将 columnName 参数的值添加到 map 中,键为 "column"。
map.put("type", type);
if (type.equals("2")) //如果 type 参数的值为 "2"
{
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
//创建一个 SimpleDateFormat 对象sdf用于将日期格式化为 "yyyy-MM-dd" 格式。
Calendar c = Calendar.getInstance();
//创建一个 Calendar 对象用于处理日期和时间。Calendar.getInstance() 方法返回一个表示当前日期和时间的 Calendar 对象。
Date remindStartDate = null;//声明一个变量 remindStartDate,初始化为 null,这个变量将用于存储提醒开始日期。
Date remindEndDate = null;
if (map.get("remindstart") != null)//如果 map 中存在键为 "remindstart" 的元素
{
Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
//将 map 中键为 "remindstart" 的元素的值转换为 Integer 类型,并赋值给 remindStart
c.setTime(new Date());//setTime(new Date()) 方法将 Calendar 对象c的时间设置为当前时间。
c.add(Calendar.DAY_OF_MONTH, remindStart);//将 Calendar 对象的时间增加 remindStart 天。
remindStartDate = c.getTime();//返回一个表示 Calendar 对象当前时间的 Date 对象,并将其赋值给 remindStartDate。
map.put("remindstart", sdf.format(remindStartDate));//将 remindStartDate 格式化为 "yyyy-MM-dd" 格式,并将其作为 map 中键为 "remindstart" 的元素的值。
}
if (map.get("remindend") != null)
{
Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
c.setTime(new Date());//c 的时间设置为当前时间
c.add(Calendar.DAY_OF_MONTH, remindEnd);//c 的时间增加 remindStart 天
remindEndDate = c.getTime();
map.put("remindend", sdf.format(remindEndDate));
}
}
// 创建一个EntityWrapper对象用于构建查询条件
Wrapper<NewsEntity> wrapper = new EntityWrapper<NewsEntity>();//创建一个EntityWrapper对象用于构建查询条件
if (map.get("remindstart") != null)//如果map中存在键为"remindstart"的元素
{
wrapper.ge(columnName, map.get("remindstart"));//将 wrapper 对象的查询条件设置为 columnName>=map 中键为 "remindend" 的元素的值
}
if (map.get("remindend") != null) {
wrapper.le(columnName, map.get("remindend"));//将 wrapper 对象的查询条件设置为 columnName<=map 中键为 "remindend" 的元素的值
}
// 查询并返回结果
int count = newsService.selectCount(wrapper);//查询满足wrapper对象的查询条件的记录数并赋值给 count 变量
return R.ok().put("count", count);//返回一个包含 count 变量的 R 对象(请求成功的响应对象)
}
}

@ -0,0 +1,289 @@
<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>jspm0c59i</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>
<!-- 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>
<!-- https://mvnrepository.com/artifact/javax.servlet.jsp/jsp-api -->
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.1</version>
<scope>provided</scope>
</dependency>
<!-- 百度人工智能 -->
<dependency>
<groupId>com.baidu.aip</groupId>
<artifactId>java-sdk</artifactId>
<version>4.4.1</version>
</dependency>
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi</artifactId>
<version>3.11</version>
</dependency>
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml</artifactId>
<version>3.9</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.tomcat.embed/tomcat-embed-jasper -->
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
<version>9.0.27</version>
<scope>provided</scope>
</dependency>
</dependencies>
<build>
<!-- 项目访问名称 -->
<finalName>jspm0c59i</finalName>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.7</source>
<target>1.7</target>
</configuration>
</plugin>
</plugins>
</build>
</project>

@ -1,7 +1,5 @@
package com.controller;
import java.util.Arrays;
import java.util.Map;
@ -13,100 +11,118 @@ 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.MPUtil;
import com.annotation.IgnoreAuth;
import com.baomidou.mybatisplus.mapper.EntityWrapper; // MyBatis-Plus的实体包装器
import com.entity.ConfigEntity; // 配置实体类
import com.service.ConfigService; // 配置服务类
import com.utils.MPUtil; // MyBatis-Plus工具类
import com.utils.PageUtils;
import com.utils.R;
import com.utils.ValidatorUtils;
import com.utils.ValidatorUtils;
/**
*
*/
@RequestMapping("config")
@RestController
public class ConfigController{
@Autowired
private ConfigService configService;
@RequestMapping("config") // 设置基本请求路径为"/config"
@RestController // 标记为REST风格的控制器
public class ConfigController {
@Autowired // 自动注入ConfigService
private ConfigService configService;
/**
/**
*
* @param params
* @param config
* @return
*/
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params,ConfigEntity config){
EntityWrapper<ConfigEntity> ew = new EntityWrapper<ConfigEntity>();
PageUtils page = configService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, config), params), params));
return R.ok().put("data", page);
public R page(@RequestParam Map<String, Object> params, ConfigEntity config) {
EntityWrapper<ConfigEntity> ew = new EntityWrapper<ConfigEntity>(); // 创建EntityWrapper用于条件构造
PageUtils page = configService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, config), params), params)); // 查询分页数据
return R.ok().put("data", page);
}
/**
/**
*
* @param params
* @param config
* @return
*/
@IgnoreAuth
@IgnoreAuth // 忽略身份验证
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params,ConfigEntity config){
EntityWrapper<ConfigEntity> ew = new EntityWrapper<ConfigEntity>();
PageUtils page = configService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, config), params), params));
return R.ok().put("data", page);
public R list(@RequestParam Map<String, Object> params, ConfigEntity config) {
EntityWrapper<ConfigEntity> ew = new EntityWrapper<ConfigEntity>(); // 创建EntityWrapper用于条件构造
PageUtils page = configService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, config), params), params)); // 查询分页数据
return R.ok().put("data", page);
}
/**
*
* @param id ID
* @return ID
*/
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") String id){
ConfigEntity config = configService.selectById(id);
@RequestMapping("/info/{id}") // 用于获取指定ID的配置信息
public R info(@PathVariable("id") String id) {
ConfigEntity config = configService.selectById(id); // 根据ID查询配置
return R.ok().put("data", config);
}
/**
*
* @param id ID
* @return ID
*/
@IgnoreAuth
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") String id){
ConfigEntity config = configService.selectById(id);
@IgnoreAuth // 忽略身份验证
@RequestMapping("/detail/{id}") // 用于获取指定ID的配置信息详情
public R detail(@PathVariable("id") String id) {
ConfigEntity config = configService.selectById(id); // 根据ID查询配置
return R.ok().put("data", config);
}
/**
* name
* @param name
* @return
*/
@RequestMapping("/info")
public R infoByName(@RequestParam String name){
ConfigEntity config = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "faceFile"));
return R.ok().put("data", config);
@RequestMapping("/info") // 用于根据名称获取配置信息
public R infoByName(@RequestParam String name) {
ConfigEntity config = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "faceFile")); // 根据名称查询配置
return R.ok().put("data", config);
}
/**
*
* @param config
* @return
*/
@PostMapping("/save")
public R save(@RequestBody ConfigEntity config){
// ValidatorUtils.validateEntity(config);
configService.insert(config);
@PostMapping("/save") // 用于保存配置
public R save(@RequestBody ConfigEntity config) {
// ValidatorUtils.validateEntity(config); // 验证配置实体(注释掉此行可以在需要时启用)
configService.insert(config); // 保存配置
return R.ok();
}
/**
*
* @param config
* @return
*/
@RequestMapping("/update")
public R update(@RequestBody ConfigEntity config){
// ValidatorUtils.validateEntity(config);
configService.updateById(config);//全部更新
return R.ok();
@RequestMapping("/update") // 用于修改配置
public R update(@RequestBody ConfigEntity config) {
// ValidatorUtils.validateEntity(config); // 验证配置实体(注释掉此行可以在需要时启用)
configService.updateById(config); // 根据ID更新配置
return R.ok();
}
/**
*
* @param ids ID
* @return
*/
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids){
configService.deleteBatchIds(Arrays.asList(ids));
@RequestMapping("/delete") // 用于删除配置
public R delete(@RequestBody Long[] ids) {
configService.deleteBatchIds(Arrays.asList(ids)); // 批量删除配置
return R.ok();
}
}

@ -7,84 +7,103 @@ 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.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 org.springframework.beans.factory.annotation.Autowired; // 导入Spring的依赖注入注解
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController; // 导入Spring的REST控制器注解
import org.springframework.web.multipart.MultipartFile; // 导入Spring的文件上传接口
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;
import com.annotation.IgnoreAuth; // 导入自定义注解,表示忽略身份验证
import com.baomidou.mybatisplus.mapper.EntityWrapper; // 导入MyBatis-Plus的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
@RestController // 标记该类为REST控制器
@RequestMapping("file") // 设置基本请求路径为"/file"
@SuppressWarnings({"unchecked","rawtypes"}) // 忽略编译警告
public class FileController {
@Autowired // 自动注入ConfigService服务
private ConfigService configService;
/**
*
*/
@RequestMapping("/upload")
@IgnoreAuth
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;
File dest = new File(request.getSession().getServletContext().getRealPath("/upload")+"/"+fileName);
file.transferTo(dest);
/**
* 使ideaeclipse
* "D:\\ssmpiv99\\src\\main\\webapp\\upload"upload
*
*/
//FileUtils.copyFile(dest, new File("D:\\ssmpiv99\\src\\main\\webapp\\upload"+"/"+fileName)); /**修改了路径以后请将该行最前面的//注释去掉**/
if(StringUtils.isNotBlank(type) && type.equals("1")) {
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);
}
/**
*
*/
@IgnoreAuth
@RequestMapping("/download")
public void download(@RequestParam String fileName, HttpServletRequest request, HttpServletResponse response) {
try {
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) {
e.printStackTrace();
}
}
/**
*
* @param file
* @param type
* @param request HttpServletRequest
* @return
*/
@RequestMapping("/upload") // 映射请求路径为"/upload"
@IgnoreAuth // 忽略身份验证
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;
// 定义文件保存的目标路径
File dest = new File(request.getSession().getServletContext().getRealPath("/upload") + "/" + fileName);
file.transferTo(dest);
/**
* 使IDEAEclipse
*
* "D:\\ssmpiv99\\src\\main\\webapp\\upload"upload
*
*/
// FileUtils.copyFile(dest, new File("D:\\ssmpiv99\\src\\main\\webapp\\upload" + "/" + fileName)); /** 修改了路径后请将该行最前面的//注释去掉 **/
// 如果type不为空且等于"1",则更新或保存配置信息
if (StringUtils.isNotBlank(type) && type.equals("1")) {
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
* @param request HttpServletRequest
* @param response HttpServletResponse
*/
@IgnoreAuth // 忽略身份验证
@RequestMapping("/download") // 映射请求路径为"/download"
public void download(@RequestParam String fileName, HttpServletRequest request, HttpServletResponse response) {
try {
// 定义文件的完整路径
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) {
e.printStackTrace(); // 打印异常信息
}
}
}

@ -1,42 +1,42 @@
package com.controller;
import java.math.BigDecimal;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Map;
import java.text.ParseException; // 导入解析异常
import java.util.ArrayList;
import java.util.Arrays; // 导入Arrays工具类
import java.util.Calendar;
import java.util.Map; // 导入Map接口
import java.util.HashMap;
import java.util.Iterator;
import java.util.Date;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import java.util.Iterator; // 导入迭代器接口
import java.util.Date;
import java.util.List;
import javax.servlet.http.HttpServletRequest; // 导入Servlet请求类
import java.io.IOException;
import com.utils.ValidatorUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import com.utils.ValidatorUtils; // 导入验证工具类
import org.apache.commons.lang3.StringUtils; // 导入Apache Commons Lang的StringUtils类用于字符串操作
import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的依赖注入注解
import org.springframework.transaction.annotation.Transactional;
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.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 org.springframework.web.bind.annotation.RestController; // 导入REST控制器注解
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.annotation.IgnoreAuth;
import com.annotation.IgnoreAuth;
import com.entity.ForumEntity;
import com.entity.view.ForumView;
import com.entity.ForumEntity; // 导入论坛实体类
import com.entity.view.ForumView; // 导入论坛视图类
import com.service.ForumService;
import com.service.ForumService; // 导入论坛服务类
import com.service.TokenService;
import com.utils.PageUtils;
import com.utils.PageUtils; // 导入分页工具类
import com.utils.R;
import com.utils.MD5Util;
import com.utils.MPUtil;
import com.utils.MPUtil; // 导入MyBatis-Plus工具类
import com.utils.CommonUtil;
/**
@ -46,217 +46,238 @@ import com.utils.CommonUtil;
* @email
* @date 2023-02-21 09:46:06
*/
@RestController
@RestController // 标记该类为REST控制器
@RequestMapping("/forum")
public class ForumController {
@Autowired
private ForumService forumService;
private ForumService forumService; // 注入论坛服务
/**
*
* @param params
* @param forum
* @param request HttpServletRequest
* @return
*/
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params,ForumEntity forum,
HttpServletRequest request){
if(!request.getSession().getAttribute("role").toString().equals("管理员")) {
forum.setUserid((Long)request.getSession().getAttribute("userId"));
}
@RequestMapping("/page") // 映射请求路径为"/page"
public R page(@RequestParam Map<String, Object> params, ForumEntity forum, HttpServletRequest request) {
// 如果当前用户不是管理员则设置用户ID
if (!request.getSession().getAttribute("role").toString().equals("管理员")) {
forum.setUserid((Long) request.getSession().getAttribute("userId"));
}
EntityWrapper<ForumEntity> ew = new EntityWrapper<ForumEntity>();
PageUtils page = forumService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, forum), params), params));
request.setAttribute("data", page);
return R.ok().put("data", page);
// 查询论坛列表分页数据
PageUtils page = forumService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, forum), params), params));
request.setAttribute("data", page); // 将数据设置到请求属性中
return R.ok().put("data", page);
}
/**
*
* @param params
* @param forum
* @param request HttpServletRequest
* @return
*/
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params,ForumEntity forum,
HttpServletRequest request){
if(!request.getSession().getAttribute("role").toString().equals("管理员")) {
forum.setUserid((Long)request.getSession().getAttribute("userId"));
}
@RequestMapping("/list") // 映射请求路径为"/list"
public R list(@RequestParam Map<String, Object> params, ForumEntity forum, HttpServletRequest request) {
// 如果当前用户不是管理员则设置用户ID
if (!request.getSession().getAttribute("role").toString().equals("管理员")) {
forum.setUserid((Long) request.getSession().getAttribute("userId"));
}
EntityWrapper<ForumEntity> ew = new EntityWrapper<ForumEntity>();
PageUtils page = forumService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, forum), params), params));
request.setAttribute("data", page);
return R.ok().put("data", page);
// 查询论坛列表分页数据
PageUtils page = forumService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, forum), params), params));
request.setAttribute("data", page); // 将数据设置到请求属性中
return R.ok().put("data", page);
}
/**
*
/**
* 访
* @param params
* @param forum
* @param request HttpServletRequest
* @return
*/
@IgnoreAuth
@RequestMapping("/flist")
public R flist(@RequestParam Map<String, Object> params,ForumEntity forum, HttpServletRequest request){
@IgnoreAuth // 忽略身份验证
@RequestMapping("/flist") // 映射请求路径为"/flist"
public R flist(@RequestParam Map<String, Object> params, ForumEntity forum, HttpServletRequest request) {
EntityWrapper<ForumEntity> ew = new EntityWrapper<ForumEntity>();
PageUtils page = forumService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, forum), params), params));
return R.ok().put("data", page);
// 查询论坛列表分页数据
PageUtils page = forumService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, forum), params), params));
return R.ok().put("data", page);
}
/**
*
/**
*
* @param forum
* @return
*/
@RequestMapping("/query")
public R query(ForumEntity forum){
EntityWrapper< ForumEntity> ew = new EntityWrapper< ForumEntity>();
ew.allEq(MPUtil.allEQMapPre( forum, "forum"));
ForumView forumView = forumService.selectView(ew);
return R.ok("查询论坛表成功").put("data", forumView);
@RequestMapping("/query") // 映射请求路径为"/query"
public R query(ForumEntity forum) {
EntityWrapper<ForumEntity> ew = new EntityWrapper<ForumEntity>();
ew.allEq(MPUtil.allEQMapPre(forum, "forum")); // 构建查询条件
ForumView forumView = forumService.selectView(ew); // 查询论坛视图
return R.ok("查询论坛表成功").put("data", forumView);
}
/**
*
*
* @param id ID
* @return
*/
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id){
ForumEntity forum = forumService.selectById(id);
@RequestMapping("/info/{id}") // 映射请求路径为"/info/{id}"
public R info(@PathVariable("id") Long id) {
ForumEntity forum = forumService.selectById(id); // 根据ID查询论坛
return R.ok().put("data", forum);
}
/**
*
*
* @param id ID
* @return
*/
@IgnoreAuth
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id){
ForumEntity forum = forumService.selectById(id);
return R.ok().put("data", forum);
@IgnoreAuth // 忽略身份验证
@RequestMapping("/detail/{id}") // 映射请求路径为"/detail/{id}"
public R detail(@PathVariable("id") Long id) {
ForumEntity forum = forumService.selectById(id); // 根据ID查询论坛
return R.ok().put("data", forum);
}
/**
*
/**
*
* @param id ID
* @return
*/
@IgnoreAuth
@RequestMapping("/list/{id}")
public R list(@PathVariable("id") String id){
ForumEntity forum = forumService.selectById(id);
getChilds(forum);
return R.ok().put("data", forum);
@IgnoreAuth // 忽略身份验证
@RequestMapping("/list/{id}") // 映射请求路径为"/list/{id}"
public R list(@PathVariable("id") String id) {
ForumEntity forum = forumService.selectById(id); // 根据ID查询论坛
getChilds(forum); // 获取子项
return R.ok().put("data", forum); // 返回论坛信息及子项
}
private ForumEntity getChilds(ForumEntity forum) {
List<ForumEntity> childs = new ArrayList<ForumEntity>();
childs = forumService.selectList(new EntityWrapper<ForumEntity>().eq("parentid", forum.getId()));
if(childs == null || childs.size()==0) {
return null;
}
forum.setChilds(childs);
for(ForumEntity forumEntity : childs) {
getChilds(forumEntity);
}
return forum;
/**
*
* @param forum
* @return
*/
private ForumEntity getChilds(ForumEntity forum) {
List<ForumEntity> childs = new ArrayList<ForumEntity>();
childs = forumService.selectList(new EntityWrapper<ForumEntity>().eq("parentid", forum.getId())); // 根据父ID查询子项
if (childs == null || childs.size() == 0) {
return null; // 如果没有子项则返回null
}
forum.setChilds(childs); // 设置子项
for (ForumEntity forumEntity : childs) {
getChilds(forumEntity); // 递归获取每个子项的子项
}
return forum; // 返回具有子项的论坛
}
/**
*
*
* @param forum
* @param request HttpServletRequest
* @return
*/
@RequestMapping("/save")
public R save(@RequestBody ForumEntity forum, HttpServletRequest request){
forum.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
//ValidatorUtils.validateEntity(forum);
forum.setUserid((Long)request.getSession().getAttribute("userId"));
forumService.insert(forum);
@RequestMapping("/save") // 映射请求路径为"/save"
public R save(@RequestBody ForumEntity forum, HttpServletRequest request) {
forum.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); // 生成唯一ID
// ValidatorUtils.validateEntity(forum); // 验证实体(可选择启用)
forum.setUserid((Long) request.getSession().getAttribute("userId")); // 设置用户ID
forumService.insert(forum); // 保存论坛信息
return R.ok();
}
/**
*
*
* @param forum
* @param request HttpServletRequest
* @return
*/
@RequestMapping("/add")
public R add(@RequestBody ForumEntity forum, HttpServletRequest request){
forum.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
//ValidatorUtils.validateEntity(forum);
forum.setUserid((Long)request.getSession().getAttribute("userId"));
forumService.insert(forum);
return R.ok();
@RequestMapping("/add") // 映射请求路径为"/add"
public R add(@RequestBody ForumEntity forum, HttpServletRequest request) {
forum.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); // 生成唯一ID
// ValidatorUtils.validateEntity(forum); // 验证实体(可选择启用)
forum.setUserid((Long) request.getSession().getAttribute("userId")); // 设置用户ID
forumService.insert(forum); // 保存论坛信息
return R.ok();
}
/**
*
*
* @param forum
* @param request HttpServletRequest
* @return
*/
@RequestMapping("/update")
@Transactional
public R update(@RequestBody ForumEntity forum, HttpServletRequest request){
//ValidatorUtils.validateEntity(forum);
forumService.updateById(forum);//全部更新
@RequestMapping("/update") // 映射请求路径为"/update"
@Transactional // 开启事务
public R update(@RequestBody ForumEntity forum, HttpServletRequest request) {
// ValidatorUtils.validateEntity(forum); // 验证实体(可选择启用)
forumService.updateById(forum); // 更新论坛信息
return R.ok();
}
/**
*
*
* @param ids ID
* @return
*/
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids){
forumService.deleteBatchIds(Arrays.asList(ids));
@RequestMapping("/delete") // 映射请求路径为"/delete"
public R delete(@RequestBody Long[] ids) {
forumService.deleteBatchIds(Arrays.asList(ids)); // 批量删除论坛
return R.ok();
}
/**
*
* @param columnName
* @param type
* @param map
* @param request HttpServletRequest
* @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<ForumEntity> wrapper = new EntityWrapper<ForumEntity>();
if(map.get("remindstart")!=null) {
wrapper.ge(columnName, map.get("remindstart"));
}
if(map.get("remindend")!=null) {
wrapper.le(columnName, map.get("remindend"));
}
int count = forumService.selectCount(wrapper);
return R.ok().put("count", count);
}
@RequestMapping("/remind/{columnName}/{type}") // 映射请求路径为"/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)); // 格式化日期并放入请求参数
}
}
// 构建查询条件
Wrapper<ForumEntity> wrapper = new EntityWrapper<ForumEntity>();
if (map.get("remindstart") != null) {
wrapper.ge(columnName, map.get("remindstart")); // 大于等于开始日期
}
if (map.get("remindend") != null) {
wrapper.le(columnName, map.get("remindend")); // 小于等于结束日期
}
int count = forumService.selectCount(wrapper); // 查询数量
return R.ok().put("count", count); // 返回数量
}
}

@ -1,43 +1,43 @@
package com.controller;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.math.BigDecimal; // 导入BigDecimal以处理高精度数值
import java.text.SimpleDateFormat;
import java.text.ParseException;
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.Iterator; // 导入迭代器接口
import java.util.Date;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import java.util.List; // 导入List接口
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import com.utils.ValidatorUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.format.annotation.DateTimeFormat;
import com.utils.ValidatorUtils;
import org.apache.commons.lang3.StringUtils; // 导入Apache Commons Lang的字符串处理类
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
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.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.baomidou.mybatisplus.mapper.EntityWrapper; // 导入MyBatis-Plus的EntityWrapper用于构建查询条件
import com.baomidou.mybatisplus.mapper.Wrapper; // 导入MyBatis-Plus的Wrapper接口
import com.annotation.IgnoreAuth;
import com.entity.LeixingEntity;
import com.entity.view.LeixingView;
import com.entity.LeixingEntity;
import com.entity.view.LeixingView; // 导入类型视图类
import com.service.LeixingService;
import com.service.TokenService;
import com.utils.PageUtils;
import com.utils.R;
import com.service.LeixingService; // 导入类型服务类
import com.service.TokenService;
import com.utils.PageUtils; // 导入分页工具类
import com.utils.R; // 导入响应工具类
import com.utils.MD5Util;
import com.utils.MPUtil;
import com.utils.CommonUtil;
import com.utils.MPUtil; // 导入MyBatis-Plus工具类
import com.utils.CommonUtil;
/**
*
@ -46,185 +46,201 @@ import com.utils.CommonUtil;
* @email
* @date 2023-02-21 09:46:06
*/
@RestController
@RequestMapping("/leixing")
@RestController // 标记该类为REST控制器
@RequestMapping("/leixing") // 设置基本请求路径为"/leixing"
public class LeixingController {
@Autowired
private LeixingService leixingService;
private LeixingService leixingService; // 自动注入类型服务
/**
*
* @param params
* @param leixing
* @param request HttpServletRequest
* @return
*/
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params,LeixingEntity leixing,
HttpServletRequest request){
@RequestMapping("/page") // 映射请求路径为"/page"
public R page(@RequestParam Map<String, Object> params, LeixingEntity leixing,
HttpServletRequest request) {
EntityWrapper<LeixingEntity> ew = new EntityWrapper<LeixingEntity>();
EntityWrapper<LeixingEntity> ew = new EntityWrapper<LeixingEntity>(); // 创建查询条件
PageUtils page = leixingService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, leixing), params), params));
request.setAttribute("data", page);
return R.ok().put("data", page);
// 查询分页数据
PageUtils page = leixingService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, leixing), params), params));
request.setAttribute("data", page); // 将数据设置到请求属性中
return R.ok().put("data", page);
}
/**
*
* @param params
* @param leixing
* @param request HttpServletRequest
* @return
*/
@IgnoreAuth
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params,LeixingEntity leixing,
HttpServletRequest request){
EntityWrapper<LeixingEntity> ew = new EntityWrapper<LeixingEntity>();
PageUtils page = leixingService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, leixing), params), params));
request.setAttribute("data", page);
return R.ok().put("data", page);
@IgnoreAuth // 忽略身份验证
@RequestMapping("/list") // 映射请求路径为"/list"
public R list(@RequestParam Map<String, Object> params, LeixingEntity leixing,
HttpServletRequest request) {
EntityWrapper<LeixingEntity> ew = new EntityWrapper<LeixingEntity>(); // 创建查询条件
// 查询分页数据
PageUtils page = leixingService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, leixing), params), params));
request.setAttribute("data", page); // 将数据设置到请求属性中
return R.ok().put("data", page);
}
/**
*
/**
*
* @param leixing
* @return
*/
@RequestMapping("/lists")
public R list( LeixingEntity leixing){
EntityWrapper<LeixingEntity> ew = new EntityWrapper<LeixingEntity>();
ew.allEq(MPUtil.allEQMapPre( leixing, "leixing"));
@RequestMapping("/lists") // 映射请求路径为"/lists"
public R list(LeixingEntity leixing) {
EntityWrapper<LeixingEntity> ew = new EntityWrapper<LeixingEntity>(); // 创建查询条件
ew.allEq(MPUtil.allEQMapPre(leixing, "leixing")); // 设置查询条件
return R.ok().put("data", leixingService.selectListView(ew));
}
/**
*
/**
*
* @param leixing
* @return
*/
@RequestMapping("/query")
public R query(LeixingEntity leixing){
EntityWrapper< LeixingEntity> ew = new EntityWrapper< LeixingEntity>();
ew.allEq(MPUtil.allEQMapPre( leixing, "leixing"));
LeixingView leixingView = leixingService.selectView(ew);
return R.ok("查询类型成功").put("data", leixingView);
@RequestMapping("/query") // 映射请求路径为"/query"
public R query(LeixingEntity leixing) {
EntityWrapper<LeixingEntity> ew = new EntityWrapper<LeixingEntity>(); // 创建查询条件
ew.allEq(MPUtil.allEQMapPre(leixing, "leixing")); // 设置查询条件
LeixingView leixingView = leixingService.selectView(ew); // 查询类型视图
return R.ok("查询类型成功").put("data", leixingView);
}
/**
*
*
* @param id ID
* @return
*/
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id){
LeixingEntity leixing = leixingService.selectById(id);
@RequestMapping("/info/{id}") // 映射请求路径为"/info/{id}"
public R info(@PathVariable("id") Long id) {
LeixingEntity leixing = leixingService.selectById(id); // 根据ID查询类型
return R.ok().put("data", leixing);
}
/**
*
*
* @param id ID
* @return
*/
@IgnoreAuth
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id){
LeixingEntity leixing = leixingService.selectById(id);
return R.ok().put("data", leixing);
@IgnoreAuth // 忽略身份验证
@RequestMapping("/detail/{id}") // 映射请求路径为"/detail/{id}"
public R detail(@PathVariable("id") Long id) {
LeixingEntity leixing = leixingService.selectById(id); // 根据ID查询类型
return R.ok().put("data", leixing);
}
/**
*
*
* @param leixing
* @param request HttpServletRequest
* @return
*/
@RequestMapping("/save")
public R save(@RequestBody LeixingEntity leixing, HttpServletRequest request){
leixing.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
//ValidatorUtils.validateEntity(leixing);
@RequestMapping("/save") // 映射请求路径为"/save"
public R save(@RequestBody LeixingEntity leixing, HttpServletRequest request) {
leixing.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); // 生成唯一ID
// ValidatorUtils.validateEntity(leixing); // 验证实体(可选择启用)
leixingService.insert(leixing);
return R.ok();
leixingService.insert(leixing); // 保存类型信息
return R.ok();
}
/**
*
*
* @param leixing
* @param request HttpServletRequest
* @return
*/
@RequestMapping("/add")
public R add(@RequestBody LeixingEntity leixing, HttpServletRequest request){
leixing.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
//ValidatorUtils.validateEntity(leixing);
@RequestMapping("/add") // 映射请求路径为"/add"
public R add(@RequestBody LeixingEntity leixing, HttpServletRequest request) {
leixing.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); // 生成唯一ID
// ValidatorUtils.validateEntity(leixing); // 验证实体(可选择启用)
leixingService.insert(leixing);
return R.ok();
leixingService.insert(leixing); // 保存类型信息
return R.ok();
}
/**
*
*
* @param leixing
* @param request HttpServletRequest
* @return
*/
@RequestMapping("/update")
@Transactional
public R update(@RequestBody LeixingEntity leixing, HttpServletRequest request){
//ValidatorUtils.validateEntity(leixing);
leixingService.updateById(leixing);//全部更新
return R.ok();
@RequestMapping("/update") // 映射请求路径为"/update"
@Transactional // 开启事务
public R update(@RequestBody LeixingEntity leixing, HttpServletRequest request) {
// ValidatorUtils.validateEntity(leixing); // 验证实体(可选择启用)
leixingService.updateById(leixing); // 更新类型信息
return R.ok();
}
/**
*
*
* @param ids ID
* @return
*/
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids){
leixingService.deleteBatchIds(Arrays.asList(ids));
return R.ok();
@RequestMapping("/delete") // 映射请求路径为"/delete"
public R delete(@RequestBody Long[] ids) {
leixingService.deleteBatchIds(Arrays.asList(ids)); // 批量删除类型
return R.ok();
}
/**
*
* @param columnName
* @param type
* @param map
* @param request HttpServletRequest
* @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<LeixingEntity> wrapper = new EntityWrapper<LeixingEntity>();
if(map.get("remindstart")!=null) {
wrapper.ge(columnName, map.get("remindstart"));
}
if(map.get("remindend")!=null) {
wrapper.le(columnName, map.get("remindend"));
}
int count = leixingService.selectCount(wrapper);
return R.ok().put("count", count);
}
@RequestMapping("/remind/{columnName}/{type}") // 映射请求路径为"/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)); // 格式化并放入请求参数
}
}
// 构建查询条件
Wrapper<LeixingEntity> wrapper = new EntityWrapper<LeixingEntity>();
if (map.get("remindstart") != null) {
wrapper.ge(columnName, map.get("remindstart")); // 大于等于开始日期
}
if (map.get("remindend") != null) {
wrapper.le(columnName, map.get("remindend")); // 小于等于结束日期
}
int count = leixingService.selectCount(wrapper); // 查询数量
return R.ok().put("count", count); // 返回数量
}
}

@ -52,331 +52,240 @@ import com.entity.StoreupEntity;
@RequestMapping("/wenjuandiaocha")
public class WenjuandiaochaController {
@Autowired
private WenjuandiaochaService wenjuandiaochaService;
private WenjuandiaochaService wenjuandiaochaService; // 注入问卷调查服务
@Autowired
private StoreupService storeupService;
private StoreupService storeupService; // 注入收藏服务
/**
*
*/
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params,WenjuandiaochaEntity wenjuandiaocha,
HttpServletRequest request){
EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>();
PageUtils page = wenjuandiaochaService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandiaocha), params), params));
request.setAttribute("data", page);
return R.ok().put("data", page);
}
/**
*
*/
@IgnoreAuth
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params,WenjuandiaochaEntity wenjuandiaocha,
HttpServletRequest request){
EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>();
PageUtils page = wenjuandiaochaService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandiaocha), params), params));
request.setAttribute("data", page);
return R.ok().put("data", page);
}
/**
*
*
*/
@RequestMapping("/lists")
public R list( WenjuandiaochaEntity wenjuandiaocha){
EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>();
ew.allEq(MPUtil.allEQMapPre( wenjuandiaocha, "wenjuandiaocha"));
return R.ok().put("data", wenjuandiaochaService.selectListView(ew));
}
@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;
// 处理 remindstart 参数
if (map.get("remindstart") != null) {
Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); // 将 remindstart 转换为整数
c.setTime(new Date()); // 设置当前时间
c.add(Calendar.DAY_OF_MONTH, remindStart); // 添加 remindStart 天
remindStartDate = c.getTime(); // 获取新的开始日期
map.put("remindstart", sdf.format(remindStartDate)); // 格式化并添加到 map 中
}
// 处理 remindend 参数
if (map.get("remindend") != null) {
Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); // 将 remindend 转换为整数
c.setTime(new Date()); // 设置当前时间
c.add(Calendar.DAY_OF_MONTH, remindEnd); // 添加 remindEnd 天
remindEndDate = c.getTime(); // 获取新的结束日期
map.put("remindend", sdf.format(remindEndDate)); // 格式化并添加到 map 中
}
}
// 创建 EntityWrapper 对象,用于构建查询条件
Wrapper<WenjuandiaochaEntity> wrapper = new EntityWrapper<WenjuandiaochaEntity>();
if (map.get("remindstart") != null) {
wrapper.ge(columnName, map.get("remindstart")); // 大于等于 remindstart
}
if (map.get("remindend") != null) {
wrapper.le(columnName, map.get("remindend")); // 小于等于 remindend
}
/**
*
*/
@RequestMapping("/query")
public R query(WenjuandiaochaEntity wenjuandiaocha){
EntityWrapper< WenjuandiaochaEntity> ew = new EntityWrapper< WenjuandiaochaEntity>();
ew.allEq(MPUtil.allEQMapPre( wenjuandiaocha, "wenjuandiaocha"));
WenjuandiaochaView wenjuandiaochaView = wenjuandiaochaService.selectView(ew);
return R.ok("查询问卷调查成功").put("data", wenjuandiaochaView);
// 查询符合条件的记录数
int count = wenjuandiaochaService.selectCount(wrapper);
return R.ok().put("count", count); // 返回记录数
}
/**
*
*/
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id){
WenjuandiaochaEntity wenjuandiaocha = wenjuandiaochaService.selectById(id);
wenjuandiaocha.setClicktime(new Date());
wenjuandiaochaService.updateById(wenjuandiaocha);
return R.ok().put("data", wenjuandiaocha);
}
/**
*
*/
@IgnoreAuth
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id){
WenjuandiaochaEntity wenjuandiaocha = wenjuandiaochaService.selectById(id);
wenjuandiaocha.setClicktime(new Date());
wenjuandiaochaService.updateById(wenjuandiaocha);
return R.ok().put("data", wenjuandiaocha);
}
/**
*
*/
@RequestMapping("/save")
public R save(@RequestBody WenjuandiaochaEntity wenjuandiaocha, HttpServletRequest request){
wenjuandiaocha.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
//ValidatorUtils.validateEntity(wenjuandiaocha);
wenjuandiaochaService.insert(wenjuandiaocha);
return R.ok();
}
/**
*
*/
@RequestMapping("/add")
public R add(@RequestBody WenjuandiaochaEntity wenjuandiaocha, HttpServletRequest request){
wenjuandiaocha.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
//ValidatorUtils.validateEntity(wenjuandiaocha);
wenjuandiaochaService.insert(wenjuandiaocha);
return R.ok();
}
/**
*
*/
@RequestMapping("/update")
@Transactional
public R update(@RequestBody WenjuandiaochaEntity wenjuandiaocha, HttpServletRequest request){
//ValidatorUtils.validateEntity(wenjuandiaocha);
wenjuandiaochaService.updateById(wenjuandiaocha);//全部更新
return R.ok();
}
/**
*
*/
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids){
wenjuandiaochaService.deleteBatchIds(Arrays.asList(ids));
return R.ok();
}
/**
*
*/
@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<WenjuandiaochaEntity> wrapper = new EntityWrapper<WenjuandiaochaEntity>();
if(map.get("remindstart")!=null) {
wrapper.ge(columnName, map.get("remindstart"));
}
if(map.get("remindend")!=null) {
wrapper.le(columnName, map.get("remindend"));
}
int count = wenjuandiaochaService.selectCount(wrapper);
return R.ok().put("count", count);
}
/**
*
*/
@IgnoreAuth
@IgnoreAuth // 忽略认证
@RequestMapping("/autoSort")
public R autoSort(@RequestParam Map<String, Object> params,WenjuandiaochaEntity wenjuandiaocha, HttpServletRequest request,String pre){
public R autoSort(@RequestParam Map<String, Object> params, WenjuandiaochaEntity wenjuandiaocha, HttpServletRequest request, String pre) {
// 创建 EntityWrapper 对象,用于构建查询条件
EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>();
Map<String, Object> newMap = new HashMap<String, Object>();
Map<String, Object> param = new HashMap<String, Object>();
Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<String, Object> entry = it.next();
String key = entry.getKey();
String newKey = entry.getKey();
if (pre.endsWith(".")) {
newMap.put(pre + newKey, entry.getValue());
} else if (StringUtils.isEmpty(pre)) {
newMap.put(newKey, entry.getValue());
} else {
newMap.put(pre + "." + newKey, entry.getValue());
}
}
params.put("sort", "clicktime");
Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<String, Object> entry = it.next();
String key = entry.getKey();
String newKey = entry.getKey();
// 处理 pre 参数
if (pre.endsWith(".")) {
newMap.put(pre + newKey, entry.getValue());
} else if (StringUtils.isEmpty(pre)) {
newMap.put(newKey, entry.getValue());
} else {
newMap.put(pre + "." + newKey, entry.getValue());
}
}
// 设置排序条件
params.put("sort", "clicktime");
params.put("order", "desc");
PageUtils page = wenjuandiaochaService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandiaocha), params), params));
return R.ok().put("data", page);
// 查询分页数据
PageUtils page = wenjuandiaochaService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandiaocha), params), params));
return R.ok().put("data", page); // 返回分页数据
}
/**
*
*/
@RequestMapping("/autoSort2")
public R autoSort2(@RequestParam Map<String, Object> params,WenjuandiaochaEntity wenjuandiaocha, HttpServletRequest request){
public R autoSort2(@RequestParam Map<String, Object> params, WenjuandiaochaEntity wenjuandiaocha, HttpServletRequest request) {
// 获取用户 ID
String userId = request.getSession().getAttribute("userId").toString();
String inteltypeColumn = "leixing";
String inteltypeColumn = "leixing"; // 定义智能类型列名
List<StoreupEntity> storeups = storeupService.selectList(new EntityWrapper<StoreupEntity>().eq("type", 1).eq("userid", userId).eq("tablename", "wenjuandiaocha").orderBy("addtime", false));
List<String> inteltypes = new ArrayList<String>();
Integer limit = params.get("limit")==null?10:Integer.parseInt(params.get("limit").toString());
Integer limit = params.get("limit") == null ? 10 : Integer.parseInt(params.get("limit").toString()); // 设置限制数量,默认为 10
List<WenjuandiaochaEntity> wenjuandiaochaList = new ArrayList<WenjuandiaochaEntity>();
//去重
if(storeups!=null && storeups.size()>0) {
for(StoreupEntity s : storeups) {
// 去重
if (storeups != null && storeups.size() > 0) {
for (StoreupEntity s : storeups) {
wenjuandiaochaList.addAll(wenjuandiaochaService.selectList(new EntityWrapper<WenjuandiaochaEntity>().eq(inteltypeColumn, s.getInteltype())));
}
}
// 创建 EntityWrapper 对象,用于构建查询条件
EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>();
params.put("sort", "id");
params.put("order", "desc");
// 查询分页数据
PageUtils page = wenjuandiaochaService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandiaocha), params), params));
List<WenjuandiaochaEntity> pageList = (List<WenjuandiaochaEntity>)page.getList();
if(wenjuandiaochaList.size()<limit) {
int toAddNum = (limit-wenjuandiaochaList.size())<=pageList.size()?(limit-wenjuandiaochaList.size()):pageList.size();
for(WenjuandiaochaEntity o1 : pageList) {
List<WenjuandiaochaEntity> pageList = (List<WenjuandiaochaEntity>) page.getList();
// 如果结果数量小于限制数量,则从分页数据中添加
if (wenjuandiaochaList.size() < limit) {
int toAddNum = (limit - wenjuandiaochaList.size()) <= pageList.size() ? (limit - wenjuandiaochaList.size()) : pageList.size();
for (WenjuandiaochaEntity o1 : pageList) {
boolean addFlag = true;
for(WenjuandiaochaEntity o2 : wenjuandiaochaList) {
if(o1.getId().intValue()==o2.getId().intValue()) {
for (WenjuandiaochaEntity o2 : wenjuandiaochaList) {
if (o1.getId().intValue() == o2.getId().intValue()) {
addFlag = false;
break;
}
}
if(addFlag) {
if (addFlag) {
wenjuandiaochaList.add(o1);
if(--toAddNum==0) break;
if (--toAddNum == 0) break;
}
}
} else if(wenjuandiaochaList.size()>limit) {
wenjuandiaochaList = wenjuandiaochaList.subList(0, limit);
} else if (wenjuandiaochaList.size() > limit) {
wenjuandiaochaList = wenjuandiaochaList.subList(0, limit); // 如果结果数量大于限制数量,则截取前 limit 个
}
page.setList(wenjuandiaochaList);
return R.ok().put("data", page);
page.setList(wenjuandiaochaList); // 设置新的列表
return R.ok().put("data", page); // 返回分页数据
}
/**
*
*/
@RequestMapping("/value/{xColumnName}/{yColumnName}")
public R value(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName,HttpServletRequest request) {
public R value(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, HttpServletRequest request) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("xColumn", xColumnName);
params.put("yColumn", yColumnName);
// 创建 EntityWrapper 对象,用于构建查询条件
EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>();
// 查询统计结果
List<Map<String, Object>> result = wenjuandiaochaService.selectValue(params, ew);
// 处理日期格式
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)));
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);
return R.ok().put("data", result); // 返回统计结果
}
/**
*
*/
@RequestMapping("/value/{xColumnName}/{yColumnName}/{timeStatType}")
public R valueDay(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType,HttpServletRequest request) {
public R valueDay(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType, HttpServletRequest request) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("xColumn", xColumnName);
params.put("yColumn", yColumnName);
params.put("timeStatType", timeStatType);
// 创建 EntityWrapper 对象,用于构建查询条件
EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>();
// 查询时间统计结果
List<Map<String, Object>> result = wenjuandiaochaService.selectTimeStatValue(params, ew);
// 处理日期格式
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)));
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);
return R.ok().put("data", result); // 返回时间统计结果
}
/**
*
*/
@RequestMapping("/group/{columnName}")
public R group(@PathVariable("columnName") String columnName,HttpServletRequest request) {
public R group(@PathVariable("columnName") String columnName, HttpServletRequest request) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("column", columnName);
// 创建 EntityWrapper 对象,用于构建查询条件
EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>();
// 查询分组统计结果
List<Map<String, Object>> result = wenjuandiaochaService.selectGroup(params, ew);
// 处理日期格式
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)));
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);
return R.ok().put("data", result); // 返回分组统计结果
}
/**
*
*/
@RequestMapping("/count")
public R count(@RequestParam Map<String, Object> params,WenjuandiaochaEntity wenjuandiaocha, HttpServletRequest request){
public R count(@RequestParam Map<String, Object> params, WenjuandiaochaEntity wenjuandiaocha, HttpServletRequest request) {
// 创建 EntityWrapper 对象,用于构建查询条件
EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>();
// 查询符合条件的记录数
int count = wenjuandiaochaService.selectCount(MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandiaocha), params), params));
return R.ok().put("data", count);
return R.ok().put("data", count); // 返回记录数
}
}

@ -1,12 +1,15 @@
package com.dao;
import com.baomidou.mybatisplus.mapper.BaseMapper;
import com.entity.ConfigEntity;
import com.baomidou.mybatisplus.mapper.BaseMapper; // 导入MyBatis-Plus的BaseMapper接口
import com.entity.ConfigEntity; // 导入配置实体类
/**
*
* DAO
* 访ConfigEntity
*/
public interface ConfigDao extends BaseMapper<ConfigEntity> {
// ConfigDao接口继承了BaseMapper接口意味着它自动获得了CRUD方法
// 可以根据需要在此处添加自定义的方法
}

@ -1,35 +1,59 @@
package com.dao;
import com.entity.ForumEntity;
import com.baomidou.mybatisplus.mapper.BaseMapper;
import java.util.List;
import java.util.Map;
import com.entity.ForumEntity; // 导入论坛实体类
import com.baomidou.mybatisplus.mapper.BaseMapper; // 导入MyBatis-Plus的BaseMapper接口
import java.util.List;
import java.util.Map;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
import org.apache.ibatis.annotations.Param;
import com.entity.vo.ForumVO;
import com.entity.view.ForumView;
import com.entity.vo.ForumVO; // 导入论坛VO类
import com.entity.view.ForumView; // 导入论坛视图类
/**
*
* DAO
* 访ForumEntity
*
* @author
* @email
* @date 2023-02-21 09:46:06
*/
public interface ForumDao extends BaseMapper<ForumEntity> {
List<ForumVO> selectListVO(@Param("ew") Wrapper<ForumEntity> wrapper);
ForumVO selectVO(@Param("ew") Wrapper<ForumEntity> wrapper);
List<ForumView> selectListView(@Param("ew") Wrapper<ForumEntity> wrapper);
List<ForumView> selectListView(Pagination page,@Param("ew") Wrapper<ForumEntity> wrapper);
ForumView selectView(@Param("ew") Wrapper<ForumEntity> wrapper);
/**
* VO
* @param wrapper
* @return VO
*/
List<ForumVO> selectListVO(@Param("ew") Wrapper<ForumEntity> wrapper);
/**
* VO
* @param wrapper
* @return VO
*/
ForumVO selectVO(@Param("ew") Wrapper<ForumEntity> wrapper);
/**
*
* @param wrapper
* @return
*/
List<ForumView> selectListView(@Param("ew") Wrapper<ForumEntity> wrapper);
/**
*
* @param page
* @param wrapper
* @return
*/
List<ForumView> selectListView(Pagination page, @Param("ew") Wrapper<ForumEntity> wrapper);
/**
*
* @param wrapper
* @return
*/
ForumView selectView(@Param("ew") Wrapper<ForumEntity> wrapper);
}

@ -1,35 +1,59 @@
package com.dao;
import com.entity.LeixingEntity;
import com.baomidou.mybatisplus.mapper.BaseMapper;
import java.util.List;
import java.util.Map;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.entity.LeixingEntity;
import com.baomidou.mybatisplus.mapper.BaseMapper;
import java.util.List;
import java.util.Map;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
import org.apache.ibatis.annotations.Param;
import com.entity.vo.LeixingVO;
import com.entity.view.LeixingView;
import org.apache.ibatis.annotations.Param;
import com.entity.vo.LeixingVO; // 导入类型VO类
import com.entity.view.LeixingView;
/**
*
* DAO
* LeixingEntity
*
* @author
* @email
* @date 2023-02-21 09:46:06
*/
public interface LeixingDao extends BaseMapper<LeixingEntity> {
List<LeixingVO> selectListVO(@Param("ew") Wrapper<LeixingEntity> wrapper);
LeixingVO selectVO(@Param("ew") Wrapper<LeixingEntity> wrapper);
List<LeixingView> selectListView(@Param("ew") Wrapper<LeixingEntity> wrapper);
List<LeixingView> selectListView(Pagination page,@Param("ew") Wrapper<LeixingEntity> wrapper);
LeixingView selectView(@Param("ew") Wrapper<LeixingEntity> wrapper);
/**
* VO
* @param wrapper
* @return VO
*/
List<LeixingVO> selectListVO(@Param("ew") Wrapper<LeixingEntity> wrapper);
/**
* VO
* @param wrapper
* @return VO
*/
LeixingVO selectVO(@Param("ew") Wrapper<LeixingEntity> wrapper);
/**
*
* @param wrapper
* @return
*/
List<LeixingView> selectListView(@Param("ew") Wrapper<LeixingEntity> wrapper);
/**
*
* @param page
* @param wrapper
* @return
*/
List<LeixingView> selectListView(Pagination page, @Param("ew") Wrapper<LeixingEntity> wrapper);
/**
*
* @param wrapper
* @return
*/
LeixingView selectView(@Param("ew") Wrapper<LeixingEntity> wrapper);
}

@ -13,31 +13,73 @@ import com.entity.view.WenjuandiaochaView;
/**
*
*
* @author
* @email
* 访
* BaseMapperCRUD
* @author
* @email
* @date 2023-02-21 09:46:06
*/
public interface WenjuandiaochaDao extends BaseMapper<WenjuandiaochaEntity> {
List<WenjuandiaochaVO> selectListVO(@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper);
WenjuandiaochaVO selectVO(@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper);
List<WenjuandiaochaView> selectListView(@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper);
List<WenjuandiaochaView> selectListView(Pagination page,@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper);
WenjuandiaochaView selectView(@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper);
/**
* WenjuandiaochaVO
* @param ew
* @return VO
*/
List<WenjuandiaochaVO> selectListVO(@Param("ew") Wrapper<WenjuandiaochaEntity> ew);
List<Map<String, Object>> selectValue(@Param("params") Map<String, Object> params,@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper);
/**
* WenjuandiaochaVO
* @param ew
* @return VO
*/
WenjuandiaochaVO selectVO(@Param("ew") Wrapper<WenjuandiaochaEntity> ew);
List<Map<String, Object>> selectTimeStatValue(@Param("params") Map<String, Object> params,@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper);
List<Map<String, Object>> selectGroup(@Param("params") Map<String, Object> params,@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper);
/**
* WenjuandiaochaView
* @param ew
* @return View
*/
List<WenjuandiaochaView> selectListView(@Param("ew") Wrapper<WenjuandiaochaEntity> ew);
/**
* WenjuandiaochaView
* @param page
* @param ew
* @return View
*/
List<WenjuandiaochaView> selectListView(Pagination page, @Param("ew") Wrapper<WenjuandiaochaEntity> ew);
/**
* WenjuandiaochaView
* @param ew
* @return View
*/
WenjuandiaochaView selectView(@Param("ew") Wrapper<WenjuandiaochaEntity> ew);
/**
* Map
* @param params
* @param ew
* @return Map
*/
List<Map<String, Object>> selectValue(@Param("params") Map<String, Object> params, @Param("ew") Wrapper<WenjuandiaochaEntity> ew);
/**
* Map
* @param params
* @param ew
* @return Map
*/
List<Map<String, Object>> selectTimeStatValue(@Param("params") Map<String, Object> params, @Param("ew") Wrapper<WenjuandiaochaEntity> ew);
/**
* Map
* @param params
* @param ew
* @return Map
*/
List<Map<String, Object>> selectGroup(@Param("params") Map<String, Object> params, @Param("ew") Wrapper<WenjuandiaochaEntity> ew);
}

@ -9,25 +9,25 @@ import com.baomidou.mybatisplus.enums.IdType;
/**
* :
*/
@TableName("config")
@TableName("config")// 指定该类对应的数据库表名为"config"
public class ConfigEntity implements Serializable{
private static final long serialVersionUID = 1L;
@TableId(type = IdType.AUTO)
@TableId(type = IdType.AUTO) // 主键ID使用自增长方式
private Long id;
/**
* key
*/
*
*/
private String name;
/**
* value
*/
*
*/
private String value;
public Long getId() {
return id;
return id; // 返回配置ID
}
public void setId(Long id) {
@ -39,7 +39,7 @@ private static final long serialVersionUID = 1L;
}
public void setName(String name) {
this.name = name;
this.name = name;//设置配置名称
}
public String getValue() {
@ -47,7 +47,7 @@ private static final long serialVersionUID = 1L;
}
public void setValue(String value) {
this.value = value;
this.value = value;// 设置配置值
}
}

@ -16,6 +16,8 @@ import java.util.List;
import org.springframework.format.annotation.DateTimeFormat;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.poi.ss.formula.functions.T;
import com.baomidou.mybatisplus.annotations.TableField;
import com.baomidou.mybatisplus.enums.FieldFill;
import com.baomidou.mybatisplus.enums.IdType;
@ -37,14 +39,15 @@ public class ForumEntity<T> implements Serializable {
}
public ForumEntity(T t) {
try {
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// 接收ForumEntity对象的构造函数
public ForumEntity(T t) {
try {
// 复制属性,将传入对象的属性复制到当前对象
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// 异常处理,打印堆栈信息
e.printStackTrace();
}
/**
* id
@ -99,10 +102,10 @@ public class ForumEntity<T> implements Serializable {
private Date addtime;
public Date getAddtime() {
return addtime;
return addtime;// 返回添加时间
}
public void setAddtime(Date addtime) {
this.addtime = addtime;
this.addtime = addtime;// 设置添加时间
}
public Long getId() {
@ -110,9 +113,12 @@ public class ForumEntity<T> implements Serializable {
}
public void setId(Long id) {
this.id = id;
this.id = id;// 设置帖子ID
}
@TableField(exist = false)
/**
*
*/
@TableField(exist = false) // 该字段不在数据库表中存在
private List<ForumEntity> childs;
public List<ForumEntity> getChilds() {
@ -120,7 +126,7 @@ public class ForumEntity<T> implements Serializable {
}
public void setChilds(List<ForumEntity> childs) {
this.childs = childs;
this.childs = childs;// 设置子帖子
}
/**
*

@ -16,6 +16,8 @@ import java.util.List;
import org.springframework.format.annotation.DateTimeFormat;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.poi.ss.formula.functions.T;
import com.baomidou.mybatisplus.annotations.TableField;
import com.baomidou.mybatisplus.enums.FieldFill;
import com.baomidou.mybatisplus.enums.IdType;
@ -37,11 +39,13 @@ public class LeixingEntity<T> implements Serializable {
}
// 接收LeixingEntity对象的构造函数
public LeixingEntity(T t) {
try {
// 复制属性,将传入对象的属性复制到当前对象
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
// 异常处理,打印堆栈信息
e.printStackTrace();
}
}
@ -58,15 +62,15 @@ public class LeixingEntity<T> implements Serializable {
private String leixing;
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date addtime;
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")// 指定JSON格式化
@DateTimeFormat// 用于Spring格式化
private Date addtime;// 存放添加时间
public Date getAddtime() {
return addtime;
}
public void setAddtime(Date addtime) {
this.addtime = addtime;
this.addtime = addtime;// 设置添加时间
}
public Long getId() {
@ -74,7 +78,7 @@ public class LeixingEntity<T> implements Serializable {
}
public void setId(Long id) {
this.id = id;
this.id = id;// 设置类型ID
}
/**
*

@ -3,7 +3,6 @@ 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;
@ -11,37 +10,39 @@ 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
* @author
* @email
* @date 2023-02-21 09:46:06
*/
@TableName("wenjuandiaocha")
public class WenjuandiaochaEntity<T> implements Serializable {
private static final long serialVersionUID = 1L;
@TableName("wenjuandiaocha") // 指定该实体类对应的数据库表名为“wenjuandiaocha”
@JsonIgnoreProperties(ignoreUnknown = true) // 忽略未知属性,防止反序列化时出现错误
public class WenjuandiaochaEntity<T> implements Serializable { // 实现Serializable接口以支持序列化
private static final long serialVersionUID = 1L; // 序列化版本号
/**
*
*/
public WenjuandiaochaEntity() {
}
/**
* t
* @param t
*/
public WenjuandiaochaEntity(T t) {
try {
BeanUtils.copyProperties(this, t);
BeanUtils.copyProperties(this, t); // 使用BeanUtils工具类复制属性
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
// 打印堆栈跟踪信息以便调试
e.printStackTrace();
}
}
@ -49,210 +50,274 @@ public class WenjuandiaochaEntity<T> implements Serializable {
/**
* id
*/
@TableId
@TableId // 指定该字段为主键
private Long id;
/**
*
* 使NotBlank
*/
@NotBlank(message = "问卷标题不能为空")
private String wenjuanbiaoti;
/**
*
* 使NotBlank
*/
@NotBlank(message = "封面图片路径不能为空")
private String fengmiantupian;
/**
*
* 使NotBlank
*/
@NotBlank(message = "类型不能为空")
private String leixing;
/**
*
* 使NotBlank
*/
@NotBlank(message = "问题一不能为空")
private String wentiyi;
/**
*
* 使NotBlank
*/
@NotBlank(message = "问题二不能为空")
private String wentier;
/**
*
* 使NotBlank
*/
@NotBlank(message = "问题三不能为空")
private String wentisan;
/**
*
* 使NotBlank
*/
@NotBlank(message = "问题四不能为空")
private String wentisi;
/**
*
* 使NotBlank
*/
@NotBlank(message = "问题五不能为空")
private String wentiwu;
/**
*
* 使JsonFormatyyyy-MM-dd HH:mm:ss
* 使DateTimeFormatyyyy-MM-dd HH:mm:ss
* 使NotNullnull
*/
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd")
@DateTimeFormat
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
@NotNull(message = "发布日期不能为空")
private Date faburiqi;
/**
*
* 使JsonFormatyyyy-MM-dd HH:mm:ss
* 使DateTimeFormatyyyy-MM-dd HH:mm:ss
*/
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private Date clicktime;
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date addtime;
public Date getAddtime() {
return addtime;
}
/**
*
* @param addtime
*/
public void setAddtime(Date addtime) {
this.addtime = addtime;
}
public Long getId() {
return id;
/**
*
* @return
*/
public Date getAddtime() {
return addtime;
}
/**
* id
* @param id id
*/
public void setId(Long id) {
this.id = id;
}
/**
*
*/
/**
* id
* @return id
*/
public Long getId() {
return id;
}
/**
*
* @param wenjuanbiaoti
*/
public void setWenjuanbiaoti(String wenjuanbiaoti) {
this.wenjuanbiaoti = wenjuanbiaoti;
}
/**
*
*/
/**
*
* @return
*/
public String getWenjuanbiaoti() {
return wenjuanbiaoti;
}
/**
*
*/
/**
*
* @param fengmiantupian
*/
public void setFengmiantupian(String fengmiantupian) {
this.fengmiantupian = fengmiantupian;
}
/**
*
*/
/**
*
* @return
*/
public String getFengmiantupian() {
return fengmiantupian;
}
/**
*
*/
/**
*
* @param leixing
*/
public void setLeixing(String leixing) {
this.leixing = leixing;
}
/**
*
*/
/**
*
* @return
*/
public String getLeixing() {
return leixing;
}
/**
*
*/
/**
*
* @param wentiyi
*/
public void setWentiyi(String wentiyi) {
this.wentiyi = wentiyi;
}
/**
*
*/
/**
*
* @return
*/
public String getWentiyi() {
return wentiyi;
}
/**
*
*/
/**
*
* @param wentier
*/
public void setWentier(String wentier) {
this.wentier = wentier;
}
/**
*
*/
/**
*
* @return
*/
public String getWentier() {
return wentier;
}
/**
*
*/
/**
*
* @param wentisan
*/
public void setWentisan(String wentisan) {
this.wentisan = wentisan;
}
/**
*
*/
/**
*
* @return
*/
public String getWentisan() {
return wentisan;
}
/**
*
*/
/**
*
* @param wentisi
*/
public void setWentisi(String wentisi) {
this.wentisi = wentisi;
}
/**
*
*/
/**
*
* @return
*/
public String getWentisi() {
return wentisi;
}
/**
*
*/
/**
*
* @param wentiwu
*/
public void setWentiwu(String wentiwu) {
this.wentiwu = wentiwu;
}
/**
*
*/
/**
*
* @return
*/
public String getWentiwu() {
return wentiwu;
}
/**
*
*/
/**
*
* @param faburiqi
*/
public void setFaburiqi(Date faburiqi) {
this.faburiqi = faburiqi;
}
/**
*
*/
/**
*
* @return
*/
public Date getFaburiqi() {
return faburiqi;
}
/**
*
*/
/**
*
* @param clicktime
*/
public void setClicktime(Date clicktime) {
this.clicktime = clicktime;
}
/**
*
*/
/**
*
* @return
*/
public Date getClicktime() {
return clicktime;
}
}

@ -1,157 +1,144 @@
package com.entity.model;
import com.entity.ForumEntity;
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;
import com.entity.ForumEntity;
import java.io.Serializable; // 导入可序列化接口
/**
*
*
* entity
* ModelAndView model
* entity
* ModelAndViewmodel
*
* @author
* @email
* @date 2023-02-21 09:46:06
*/
public class ForumModel implements Serializable {
private static final long serialVersionUID = 1L;
public class ForumModel implements Serializable {
private static final long serialVersionUID = 1L; // 版本控制
/**
*
*/
private String content; // 存放帖子内容
private String content;
/**
* id
*/
private Long parentid; // 存放父节点ID
private Long parentid;
/**
* id
*/
private Long userid; // 存放用户ID
private Long userid;
/**
*
*/
private String username; // 存放用户名
private String username;
/**
*
*/
private String avatarurl; // 存放用户头像URL
private String avatarurl;
/**
*
*/
private String isdone;
private String isdone; // 存放帖子状态(例如:已完成/未完成等)
/**
*
* @param content
*/
public void setContent(String content) {
this.content = content;
this.content = content; // 设置帖子内容
}
/**
*
* @return
*/
public String getContent() {
return content;
return content;
}
/**
* id
* @param parentid ID
*/
public void setParentid(Long parentid) {
this.parentid = parentid;
this.parentid = parentid; // 设置父节点ID
}
/**
* id
* @return ID
*/
public Long getParentid() {
return parentid;
return parentid; // 返回父节点ID
}
/**
* id
* @param userid ID
*/
public void setUserid(Long userid) {
this.userid = userid;
this.userid = userid; // 设置用户ID
}
/**
* id
* @return ID
*/
public Long getUserid() {
return userid;
}
/**
*
* @param username
*/
public void setUsername(String username) {
this.username = username;
this.username = username; // 设置用户名
}
/**
*
* @return
*/
public String getUsername() {
return username;
return username;
}
/**
*
* @param avatarurl URL
*/
public void setAvatarurl(String avatarurl) {
this.avatarurl = avatarurl;
this.avatarurl = avatarurl; // 设置头像URL
}
/**
*
* @return URL
*/
public String getAvatarurl() {
return avatarurl;
return avatarurl;
}
/**
*
* @param isdone
*/
public void setIsdone(String isdone) {
this.isdone = isdone;
this.isdone = isdone; // 设置帖子状态
}
/**
*
* @return
*/
public String getIsdone() {
return isdone;
return isdone;
}
}

@ -19,7 +19,7 @@ import java.io.Serializable;
* @date 2023-02-21 09:46:06
*/
public class LeixingModel implements Serializable {
private static final long serialVersionUID = 1L;
private static final long serialVersionUID = 1L;// 版本控制
// 可以根据需求定义属性,例如类型的名称、描述等
}

@ -1,227 +1,195 @@
package com.entity.model;
import com.entity.WenjuandiaochaEntity;
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
*
*
* ModelAndViewmodel
* @author
* @email
* @date 2023-02-21 09:46:06
*/
public class WenjuandiaochaModel implements Serializable {
public class WenjuandiaochaModel implements Serializable {
private static final long serialVersionUID = 1L;
/**
*
*/
private String fengmiantupian;
/**
*
*/
private String leixing;
/**
*
*/
private String wentiyi;
/**
*
*/
private String wentier;
/**
*
*/
private String wentisan;
/**
*
*/
private String wentisi;
/**
*
*/
private String wentiwu;
/**
*
*/
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date faburiqi;
/**
*
*/
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date clicktime;
/**
*
*/
public void setFengmiantupian(String fengmiantupian) {
this.fengmiantupian = fengmiantupian;
}
/**
*
*/
public String getFengmiantupian() {
return fengmiantupian;
}
/**
*
*/
public void setLeixing(String leixing) {
this.leixing = leixing;
}
/**
*
*/
public String getLeixing() {
return leixing;
}
/**
*
*/
public void setWentiyi(String wentiyi) {
this.wentiyi = wentiyi;
}
/**
*
*/
public String getWentiyi() {
return wentiyi;
}
/**
*
*/
public void setWentier(String wentier) {
this.wentier = wentier;
}
/**
*
*/
public String getWentier() {
return wentier;
}
/**
*
*/
public void setWentisan(String wentisan) {
this.wentisan = wentisan;
}
/**
*
*/
public String getWentisan() {
return wentisan;
}
/**
*
*/
public void setWentisi(String wentisi) {
this.wentisi = wentisi;
}
/**
*
*/
public String getWentisi() {
return wentisi;
}
/**
*
*/
public void setWentiwu(String wentiwu) {
this.wentiwu = wentiwu;
}
/**
*
*/
public String getWentiwu() {
return wentiwu;
}
/**
*
*/
public void setFaburiqi(Date faburiqi) {
this.faburiqi = faburiqi;
}
/**
*
*/
public Date getFaburiqi() {
return faburiqi;
}
/**
*
*/
public void setClicktime(Date clicktime) {
this.clicktime = clicktime;
}
/**
*
*/
public Date getClicktime() {
return clicktime;
}
}

@ -24,13 +24,15 @@ public class ForumView extends ForumEntity implements Serializable {
public ForumView(){
}
public ForumView(ForumEntity forumEntity){
try {
// 接收 ForumEntity 对象的构造函数
public ForumView(ForumEntity forumEntity) {
try {
// 将ForumEntity的属性复制到当前ForumView对象
BeanUtils.copyProperties(this, forumEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
// 异常处理,打印堆栈信息
e.printStackTrace();
}
}
}

@ -24,13 +24,14 @@ public class LeixingView extends LeixingEntity implements Serializable {
public LeixingView(){
}
public LeixingView(LeixingEntity leixingEntity){
try {
// 接收 LeixingEntity 对象的构造函数
public LeixingView(LeixingEntity leixingEntity) {
try {
// 将LeixingEntity的属性复制到当前LeixingView对象
BeanUtils.copyProperties(this, leixingEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
// 异常处理,打印堆栈信息
e.printStackTrace();
}
}
}

@ -1,36 +1,40 @@
package com.entity.view;
import com.entity.WenjuandiaochaEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import org.apache.commons.beanutils.BeanUtils;
import java.lang.reflect.InvocationTargetException;
import java.io.Serializable;
/**
*
*
* 使
* @author
* @email
*
* 使
* 使
* @author
* @email
* @date 2023-02-21 09:46:06
*/
@TableName("wenjuandiaocha")
public class WenjuandiaochaView extends WenjuandiaochaEntity implements Serializable {
private static final long serialVersionUID = 1L;
public class WenjuandiaochaView extends WenjuandiaochaEntity implements Serializable {
private static final long serialVersionUID = 1L;
/**
*
*/
public WenjuandiaochaView() {
}
public WenjuandiaochaView(){
}
public WenjuandiaochaView(WenjuandiaochaEntity wenjuandiaochaEntity){
try {
BeanUtils.copyProperties(this, wenjuandiaochaEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* WenjuandiaochaEntityWenjuandiaochaView
* @param wenjuandiaochaEntity
*/
public WenjuandiaochaView(WenjuandiaochaEntity wenjuandiaochaEntity) {
try {
BeanUtils.copyProperties(this, wenjuandiaochaEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// 打印堆栈跟踪信息以便调试
e.printStackTrace();
}
}
}

@ -19,7 +19,7 @@ import java.io.Serializable;
* @date 2023-02-21 09:46:06
*/
public class LeixingVO implements Serializable {
private static final long serialVersionUID = 1L;
private static final long serialVersionUID = 1L;// 版本控制,用于序列化
}

@ -3,8 +3,8 @@ package com.service;
import java.util.Map;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.service.IService;
import com.baomidou.mybatisplus.mapper.Wrapper;// 导入MyBatis-Plus的Wrapper接口用于构建查询条件
import com.baomidou.mybatisplus.service.IService;// 导入MyBatis-Plus的服务接口
import com.entity.ConfigEntity;
import com.utils.PageUtils;
@ -13,5 +13,12 @@ import com.utils.PageUtils;
*
*/
public interface ConfigService extends IService<ConfigEntity> {
PageUtils queryPage(Map<String, Object> params,Wrapper<ConfigEntity> wrapper);
/**
*
* @param params
* @param wrapper
* @return
*/
PageUtils queryPage(Map<String, Object> params, Wrapper<ConfigEntity> wrapper);
}

@ -3,14 +3,12 @@ package com.service;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.service.IService;
import com.utils.PageUtils;
import com.entity.ForumEntity;
import com.entity.ForumEntity; // 导入论坛实体类
import java.util.List;
import java.util.Map;
import com.entity.vo.ForumVO;
import com.entity.vo.ForumVO;// 导入论坛VO类
import org.apache.ibatis.annotations.Param;
import com.entity.view.ForumView;
import com.entity.view.ForumView;v// 导入论坛视图类
/**
*
*
@ -20,18 +18,47 @@ import com.entity.view.ForumView;
*/
public interface ForumService extends IService<ForumEntity> {
/**
*
* @param params
* @return
*/
PageUtils queryPage(Map<String, Object> params);
List<ForumVO> selectListVO(Wrapper<ForumEntity> wrapper);
ForumVO selectVO(@Param("ew") Wrapper<ForumEntity> wrapper);
List<ForumView> selectListView(Wrapper<ForumEntity> wrapper);
ForumView selectView(@Param("ew") Wrapper<ForumEntity> wrapper);
PageUtils queryPage(Map<String, Object> params,Wrapper<ForumEntity> wrapper);
/**
* VO
* @param wrapper
* @return ForumVO
*/
List<ForumVO> selectListVO(Wrapper<ForumEntity> wrapper);
/**
* VO
* @param wrapper
* @return ForumVO
*/
ForumVO selectVO(@Param("ew") Wrapper<ForumEntity> wrapper);
/**
*
* @param wrapper
* @return ForumView
*/
List<ForumView> selectListView(Wrapper<ForumEntity> wrapper);
/**
*
* @param wrapper
* @return ForumView
*/
ForumView selectView(@Param("ew") Wrapper<ForumEntity> wrapper);
/**
*
* @param params
* @param wrapper
* @return
*/
PageUtils queryPage(Map<String, Object> params, Wrapper<ForumEntity> wrapper);
}

@ -3,12 +3,12 @@ package com.service;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.service.IService;
import com.utils.PageUtils;
import com.entity.LeixingEntity;
import com.entity.LeixingEntity; // 导入类型实体类
import java.util.List;
import java.util.Map;
import com.entity.vo.LeixingVO;
import org.apache.ibatis.annotations.Param;
import com.entity.view.LeixingView;
import com.entity.view.LeixingView;// 导入类型视图类
/**
@ -20,18 +20,47 @@ import com.entity.view.LeixingView;
*/
public interface LeixingService extends IService<LeixingEntity> {
/**
*
* @param params
* @return
*/
PageUtils queryPage(Map<String, Object> params);
List<LeixingVO> selectListVO(Wrapper<LeixingEntity> wrapper);
LeixingVO selectVO(@Param("ew") Wrapper<LeixingEntity> wrapper);
List<LeixingView> selectListView(Wrapper<LeixingEntity> wrapper);
LeixingView selectView(@Param("ew") Wrapper<LeixingEntity> wrapper);
PageUtils queryPage(Map<String, Object> params,Wrapper<LeixingEntity> wrapper);
/**
* VO
* @param wrapper
* @return LeixingVO
*/
List<LeixingVO> selectListVO(Wrapper<LeixingEntity> wrapper);
/**
* VO
* @param wrapper
* @return LeixingVO
*/
LeixingVO selectVO(@Param("ew") Wrapper<LeixingEntity> wrapper);
/**
*
* @param wrapper
* @return LeixingView
*/
List<LeixingView> selectListView(Wrapper<LeixingEntity> wrapper);
/**
*
* @param wrapper
* @return LeixingView
*/
LeixingView selectView(@Param("ew") Wrapper<LeixingEntity> wrapper);
/**
*
* @param params
* @param wrapper
* @return
*/
PageUtils queryPage(Map<String, Object> params, Wrapper<LeixingEntity> wrapper);
}

@ -20,26 +20,70 @@ import com.entity.view.WenjuandafuView;
*/
public interface WenjuandafuService extends IService<WenjuandafuEntity> {
/**
*
* @param params
* @return
*/
PageUtils queryPage(Map<String, Object> params);
List<WenjuandafuVO> selectListVO(Wrapper<WenjuandafuEntity> wrapper);
WenjuandafuVO selectVO(@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
List<WenjuandafuView> selectListView(Wrapper<WenjuandafuEntity> wrapper);
WenjuandafuView selectView(@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
PageUtils queryPage(Map<String, Object> params,Wrapper<WenjuandafuEntity> wrapper);
List<Map<String, Object>> selectValue(Map<String, Object> params,Wrapper<WenjuandafuEntity> wrapper);
List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params,Wrapper<WenjuandafuEntity> wrapper);
/**
* VO
* @param wrapper
* @return VO
*/
List<WenjuandafuVO> selectListVO(Wrapper<WenjuandafuEntity> wrapper);
List<Map<String, Object>> selectGroup(Map<String, Object> params,Wrapper<WenjuandafuEntity> wrapper);
/**
* VO
* @param wrapper
* @return VO
*/
WenjuandafuVO selectVO(@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
/**
*
* @param wrapper
* @return
*/
List<WenjuandafuView> selectListView(Wrapper<WenjuandafuEntity> wrapper);
/**
*
* @param wrapper
* @return
*/
WenjuandafuView selectView(@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
/**
*
* @param params
* @param wrapper
* @return
*/
PageUtils queryPage(Map<String, Object> params, Wrapper<WenjuandafuEntity> wrapper);
/**
* Map
* @param params
* @param wrapper
* @return Map
*/
List<Map<String, Object>> selectValue(Map<String, Object> params, Wrapper<WenjuandafuEntity> wrapper);
}
/**
*
* @param params
* @param wrapper
* @return Map
*/
List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params, Wrapper<WenjuandafuEntity> wrapper);
/**
*
* @param params
* @param wrapper
* @return Map
*/
List<Map<String, Object>> selectGroup(Map<String, Object> params, Wrapper<WenjuandafuEntity> wrapper);

@ -10,36 +10,80 @@ import com.entity.vo.WenjuandiaochaVO;
import org.apache.ibatis.annotations.Param;
import com.entity.view.WenjuandiaochaView;
/**
*
*
*
* @author
* @email
* @author
* @email
* @date 2023-02-21 09:46:06
*/
public interface WenjuandiaochaService extends IService<WenjuandiaochaEntity> {
/**
*
* @param params
* @return
*/
PageUtils queryPage(Map<String, Object> params);
List<WenjuandiaochaVO> selectListVO(Wrapper<WenjuandiaochaEntity> wrapper);
/**
*
* @param wrapper
* @return
*/
List<WenjuandiaochaVO> selectListVO(Wrapper<WenjuandiaochaEntity> wrapper);
WenjuandiaochaVO selectVO(@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper);
/**
*
* @param wrapper
* @return
*/
WenjuandiaochaVO selectVO(@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper);
List<WenjuandiaochaView> selectListView(Wrapper<WenjuandiaochaEntity> wrapper);
/**
*
* @param wrapper
* @return
*/
List<WenjuandiaochaView> selectListView(Wrapper<WenjuandiaochaEntity> wrapper);
WenjuandiaochaView selectView(@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper);
/**
*
* @param wrapper
* @return
*/
WenjuandiaochaView selectView(@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper);
PageUtils queryPage(Map<String, Object> params,Wrapper<WenjuandiaochaEntity> wrapper);
/**
*
* @param params
* @param wrapper
* @return
*/
PageUtils queryPage(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper);
List<Map<String, Object>> selectValue(Map<String, Object> params,Wrapper<WenjuandiaochaEntity> wrapper);
/**
*
* @param params
* @param wrapper
* @return
*/
List<Map<String, Object>> selectValue(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper);
List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params,Wrapper<WenjuandiaochaEntity> wrapper);
/**
*
* @param params
* @param wrapper
* @return
*/
List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper);
List<Map<String, Object>> selectGroup(Map<String, Object> params,Wrapper<WenjuandiaochaEntity> wrapper);
/**
*
* @param params
* @param wrapper
* @return
*/
List<Map<String, Object>> selectGroup(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper);
}

@ -24,10 +24,10 @@ import com.utils.Query;
public class ConfigServiceImpl extends ServiceImpl<ConfigDao, ConfigEntity> implements ConfigService {
@Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<ConfigEntity> wrapper) {
// 使用MyBatis-Plus的selectPage方法进行分页查询
Page<ConfigEntity> page = this.selectPage(
new Query<ConfigEntity>(params).getPage(),
wrapper
new Query<ConfigEntity>(params).getPage(), // 获取分页参数
wrapper // 查询条件
);
return new PageUtils(page);
}
return new PageUtils(page); // 返回分页结果
}

@ -18,46 +18,76 @@ import com.service.ForumService;
import com.entity.vo.ForumVO;
import com.entity.view.ForumView;
@Service("forumService")
@Service("forumService") // 将该类标记为Spring的Service组件
public class ForumServiceImpl extends ServiceImpl<ForumDao, ForumEntity> implements ForumService {
/**
*
* @param params
* @return
*/
@Override
public PageUtils queryPage(Map<String, Object> params) {
// 调用selectPage方法进行分页查询
Page<ForumEntity> page = this.selectPage(
new Query<ForumEntity>(params).getPage(),
new EntityWrapper<ForumEntity>()
new Query<ForumEntity>(params).getPage(), // 获取分页信息
new EntityWrapper<ForumEntity>() // 创建查询条件
);
return new PageUtils(page);
return new PageUtils(page); // 返回分页结果
}
/**
*
* @param params
* @param wrapper
* @return
*/
@Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<ForumEntity> wrapper) {
Page<ForumView> page =new Query<ForumView>(params).getPage();
page.setRecords(baseMapper.selectListView(page,wrapper));
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
public PageUtils queryPage(Map<String, Object> params, Wrapper<ForumEntity> wrapper) {
// 创建分页对象
Page<ForumView> page = new Query<ForumView>(params).getPage();
// 设置记录
page.setRecords(baseMapper.selectListView(page, wrapper));
return new PageUtils(page); // 返回分页结果
}
/**
* VO
* @param wrapper
* @return VO
*/
@Override
public List<ForumVO> selectListVO(Wrapper<ForumEntity> wrapper) {
return baseMapper.selectListVO(wrapper);
}
@Override
public ForumVO selectVO(Wrapper<ForumEntity> wrapper) {
return baseMapper.selectVO(wrapper);
}
@Override
public List<ForumView> selectListView(Wrapper<ForumEntity> wrapper) {
return baseMapper.selectListView(wrapper);
}
@Override
public ForumView selectView(Wrapper<ForumEntity> wrapper) {
return baseMapper.selectView(wrapper);
}
public List<ForumVO> selectListVO(Wrapper<ForumEntity> wrapper) {
return baseMapper.selectListVO(wrapper); // 调用数据访问对象方法返回VO对象列表
}
/**
* VO
* @param wrapper
* @return VO
*/
@Override
public ForumVO selectVO(Wrapper<ForumEntity> wrapper) {
return baseMapper.selectVO(wrapper); // 调用数据访问对象方法返回单个VO对象
}
/**
*
* @param wrapper
* @return
*/
@Override
public List<ForumView> selectListView(Wrapper<ForumEntity> wrapper) {
return baseMapper.selectListView(wrapper); // 调用数据访问对象方法,返回视图对象列表
}
/**
*
* @param wrapper
* @return
*/
@Override
public ForumView selectView(Wrapper<ForumEntity> wrapper) {
return baseMapper.selectView(wrapper); // 调用数据访问对象方法,返回单个视图对象
}
}

@ -17,47 +17,75 @@ import com.entity.LeixingEntity;
import com.service.LeixingService;
import com.entity.vo.LeixingVO;
import com.entity.view.LeixingView;
@Service("leixingService")
@Service("leixingService") // 将该类标记为Spring的Service组件
public class LeixingServiceImpl extends ServiceImpl<LeixingDao, LeixingEntity> implements LeixingService {
/**
*
* @param params
* @return
*/
@Override
public PageUtils queryPage(Map<String, Object> params) {
// 使用selectPage方法进行分页查询
Page<LeixingEntity> page = this.selectPage(
new Query<LeixingEntity>(params).getPage(),
new EntityWrapper<LeixingEntity>()
new Query<LeixingEntity>(params).getPage(), // 获取分页信息
new EntityWrapper<LeixingEntity>() // 创建查询条件
);
return new PageUtils(page);
return new PageUtils(page); // 返回分页结果
}
/**
*
* @param params
* @param wrapper
* @return
*/
@Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<LeixingEntity> wrapper) {
Page<LeixingView> page =new Query<LeixingView>(params).getPage();
page.setRecords(baseMapper.selectListView(page,wrapper));
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
public PageUtils queryPage(Map<String, Object> params, Wrapper<LeixingEntity> wrapper) {
// 创建分页对象
Page<LeixingView> page = new Query<LeixingView>(params).getPage();
// 设置记录
page.setRecords(baseMapper.selectListView(page, wrapper));
return new PageUtils(page); // 返回分页结果
}
/**
* VO
* @param wrapper
* @return VO
*/
@Override
public List<LeixingVO> selectListVO(Wrapper<LeixingEntity> wrapper) {
return baseMapper.selectListVO(wrapper);
}
@Override
public LeixingVO selectVO(Wrapper<LeixingEntity> wrapper) {
return baseMapper.selectVO(wrapper);
}
@Override
public List<LeixingView> selectListView(Wrapper<LeixingEntity> wrapper) {
return baseMapper.selectListView(wrapper);
}
@Override
public LeixingView selectView(Wrapper<LeixingEntity> wrapper) {
return baseMapper.selectView(wrapper);
}
public List<LeixingVO> selectListVO(Wrapper<LeixingEntity> wrapper) {
return baseMapper.selectListVO(wrapper); // 调用数据访问对象方法返回VO对象列表
}
/**
* VO
* @param wrapper
* @return VO
*/
@Override
public LeixingVO selectVO(Wrapper<LeixingEntity> wrapper) {
return baseMapper.selectVO(wrapper); // 调用数据访问对象方法返回单个VO对象
}
/**
*
* @param wrapper
* @return
*/
@Override
public List<LeixingView> selectListView(Wrapper<LeixingEntity> wrapper) {
return baseMapper.selectListView(wrapper); // 调用数据访问对象方法,返回视图对象列表
}
}
/**
*
* @param wrapper
* @return
*/
@Override
public LeixingView selectView(Wrapper<LeixingEntity> wrapper) {
return baseMapper.selectView(wrapper); // 调用数据访问对象方法,返回单个视图对象
}

@ -11,19 +11,27 @@ import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.utils.PageUtils;
import com.utils.Query;
import com.dao.WenjuandiaochaDao;
import com.entity.WenjuandiaochaEntity;
import com.service.WenjuandiaochaService;
import com.entity.vo.WenjuandiaochaVO;
import com.entity.view.WenjuandiaochaView;
import com.entity.view.Wenjuandiaocha;
/**
*
* MyBatis-PlusServiceImplWenjuandiaochaService
*/
@Service("wenjuandiaochaService")
public class WenjuandiaochaServiceImpl extends ServiceImpl<WenjuandiaochaDao, WenjuandiaochaEntity> implements WenjuandiaochaService {
/**
*
* @param params
* @return
*/
@Override
public PageUtils queryPage(Map<String, Object> params) {
// 使用MyBatis-Plus的分页插件进行分页查询
Page<WenjuandiaochaEntity> page = this.selectPage(
new Query<WenjuandiaochaEntity>(params).getPage(),
new EntityWrapper<WenjuandiaochaEntity>()
@ -31,50 +39,93 @@ public class WenjuandiaochaServiceImpl extends ServiceImpl<WenjuandiaochaDao, We
return new PageUtils(page);
}
/**
*
* @param params
* @param wrapper
* @return
*/
@Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper) {
Page<WenjuandiaochaView> page =new Query<WenjuandiaochaView>(params).getPage();
page.setRecords(baseMapper.selectListView(page,wrapper));
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
// 创建分页对象
Page<WenjuandiaochaView> page = new Query<WenjuandiaochaView>(params).getPage();
// 设置分页记录
page.setRecords(baseMapper.selectListView(page, wrapper));
// 返回分页工具类
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
/**
*
* @param wrapper
* @return
*/
@Override
public List<WenjuandiaochaVO> selectListVO(Wrapper<WenjuandiaochaEntity> wrapper) {
return baseMapper.selectListVO(wrapper);
}
/**
*
* @param wrapper
* @return
*/
@Override
public WenjuandiaochaVO selectVO(Wrapper<WenjuandiaochaEntity> wrapper) {
return baseMapper.selectVO(wrapper);
}
/**
*
* @param wrapper
* @return
*/
@Override
public List<WenjuandiaochaView> selectListView(Wrapper<WenjuandiaochaEntity> wrapper) {
return baseMapper.selectListView(wrapper);
}
/**
*
* @param wrapper
* @return
*/
@Override
public WenjuandiaochaView selectView(Wrapper<WenjuandiaochaEntity> wrapper) {
return baseMapper.selectView(wrapper);
}
/**
*
* @param params
* @param wrapper
* @return
*/
@Override
public List<Map<String, Object>> selectValue(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper) {
return baseMapper.selectValue(params, wrapper);
}
/**
*
* @param params
* @param wrapper
* @return
*/
@Override
public List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper) {
return baseMapper.selectTimeStatValue(params, wrapper);
}
/**
*
* @param params
* @param wrapper
* @return
*/
@Override
public List<Map<String, Object>> selectGroup(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper) {
return baseMapper.selectGroup(params, wrapper);
}
}

@ -1,7 +1,7 @@
package com.utils;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.File;// 导入File类
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
@ -11,17 +11,26 @@ import java.io.InputStream;
*/
public class FileUtil {
public static byte[] FileToByte(File file) throws IOException {
// 将数据转为流
@SuppressWarnings("resource")
InputStream content = new FileInputStream(file);
ByteArrayOutputStream swapStream = new ByteArrayOutputStream();
byte[] buff = new byte[100];
int rc = 0;
while ((rc = content.read(buff, 0, 100)) > 0) {
swapStream.write(buff, 0, rc);
}
// 获得二进制数组
return swapStream.toByteArray();
}
/**
*
* @param file
* @return
* @throws IOException
*/
public static byte[] FileToByte(File file) throws IOException {
// 将文件数据转为输入流
@SuppressWarnings("resource") // 这个资源在方法末尾会自动关闭,抑制编译警告
InputStream content = new FileInputStream(file); // 创建FileInputStream对象读取文件
ByteArrayOutputStream swapStream = new ByteArrayOutputStream(); // 创建字节数组输出流对象
byte[] buff = new byte[100];
int rc = 0;
// 循环读取文件数据,直到文件结束
while ((rc = content.read(buff, 0, 100)) > 0) {
swapStream.write(buff, 0, rc); // 将读取的数据写入字节数组输出流
}
return swapStream.toByteArray();
}
}

@ -1,266 +0,0 @@
package com.controller;
// 定义控制器所在的包名
import java.math.BigDecimal; // 导入BigDecimal类用于进行高精度的数学运算
import java.text.SimpleDateFormat; // 导入SimpleDateFormat类用于格式化和解析日期
import java.text.ParseException; // 导入ParseException类用于处理日期解析异常
import java.util.ArrayList; // 导入ArrayList类用于创建动态数组
import java.util.Arrays; // 导入Arrays类提供了对数组操作的工具方法
import java.util.Calendar; // 导入Calendar类用于日期时间的操作
import java.util.Map; // 导入Map接口用于键值对集合
import java.util.HashMap; // 导入HashMap类基于哈希表的Map实现
import java.util.Iterator; // 导入Iterator接口用于遍历集合
import java.util.Date; // 导入Date类用于日期时间的表示
import java.util.List; // 导入List接口用于列表集合
import javax.servlet.http.HttpServletRequest; // 导入HttpServletRequest接口用于访问HTTP请求信息
import java.io.IOException; // 导入IOException类用于处理IO异常
import com.utils.ValidatorUtils; // 导入自定义的ValidatorUtils工具类用于数据验证
import org.apache.commons.lang3.StringUtils; // 导入Apache Commons Lang库的StringUtils类用于字符串操作
import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的Autowired注解用于自动注入依赖
import org.springframework.transaction.annotation.Transactional; // 导入Spring的Transactional注解用于声明事务
import org.springframework.format.annotation.DateTimeFormat; // 导入Spring的DateTimeFormat注解用于日期格式注解
import org.springframework.web.bind.annotation.PathVariable; // 导入Spring的PathVariable注解用于将URL中的参数绑定到控制器方法的参数上
import org.springframework.web.bind.annotation.RequestBody; // 导入Spring的RequestBody注解用于将HTTP请求的body部分绑定到控制器方法的参数上
import org.springframework.web.bind.annotation.RequestMapping; // 导入Spring的RequestMapping注解用于定义请求映射
import org.springframework.web.bind.annotation.RequestParam; // 导入Spring的RequestParam注解用于将请求参数绑定到控制器方法的参数上
import org.springframework.web.bind.annotation.RestController; // 导入Spring的RestController注解用于定义REST风格的控制器
import com.baomidou.mybatisplus.mapper.EntityWrapper; // 导入MyBatis Plus的EntityWrapper类用于构建查询条件
import com.baomidou.mybatisplus.mapper.Wrapper; // 导入MyBatis Plus的Wrapper接口EntityWrapper实现该接口
import com.annotation.IgnoreAuth; // 导入自定义的IgnoreAuth注解用于忽略权限验证
import com.entity.NewsEntity; // 导入新闻实体类
import com.entity.view.NewsView; // 导入新闻视图类
import com.service.NewsService; // 导入新闻服务类
import com.service.TokenService; // 导入Token服务类
import com.utils.PageUtils; // 导入自定义的PageUtils工具类用于分页处理
import com.utils.R; // 导入自定义的R类用于封装响应结果
import com.utils.MD5Util; // 导入自定义的MD5Util工具类用于MD5加密
import com.utils.MPUtil; // 导入自定义的MPUtil工具类提供MyBatis Plus工具方法
import com.utils.CommonUtil; // 导入自定义的CommonUtil工具类提供常用方法
/**
*
*
* @author
* @email
* @date 2023-02-21 09:46:06
*/
@RestController
@RequestMapping("/news")
public class NewsController {
@Autowired
private NewsService newsService;//注入新闻服务类
/**
*
*/
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, NewsEntity news, HttpServletRequest request) {
// 创建一个EntityWrapper对象用于构建查询条件
EntityWrapper<NewsEntity> ew = new EntityWrapper<NewsEntity>();
// 使用MPUtil工具类对查询条件进行排序和分页处理
PageUtils page = newsService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, news), params), params));
// 将分页结果设置到request对象中
request.setAttribute("data", page);
// 返回成功响应,包含分页结果
return R.ok().put("data", page);
}
/**
*
*/
@IgnoreAuth
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, NewsEntity news, HttpServletRequest request) {
// 创建一个EntityWrapper对象用于构建查询条件
EntityWrapper<NewsEntity> ew = new EntityWrapper<NewsEntity>();
// 使用MPUtil工具类对查询条件进行排序和分页处理
PageUtils page = newsService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, news), params), params));
// 将分页结果设置到request对象中
request.setAttribute("data", page);
// 返回成功响应,包含分页结果
return R.ok().put("data", page);
}
/**
*
*/
@RequestMapping("/lists")
//一个Spring MVC的注解用于将HTTP请求映射到 list 方法。当客户端发送一个HTTP请求到 /lists 路径时Spring MVC会调用 list 方法来处理这个请求
public R list(NewsEntity news) //NewsEntity news 参数表示要查询的 NewsEntity 对象
{
// 创建一个EntityWrapper对象用于构建查询条件
EntityWrapper<NewsEntity> ew = new EntityWrapper<NewsEntity>();
// 使用MPUtil工具类对查询条件进行排序和分页处理
ew.allEq(MPUtil.allEQMapPre(news, "news"));
// 返回成功响应,包含查询结果
return R.ok().put("data", newsService.selectListView(ew));
//这行代码返回一个表示请求成功的响应对象,并将 newsService.selectListView(ew) 的结果添加到响应对象中,键为 "data"。
//newsService.selectListView(ew) 方法用于查询满足 ew 对象的查询条件的记录,并返回一个包含查询结果的列表。
}
/**
*
*/
@RequestMapping("/query")
public R query(NewsEntity news) {
// 创建一个EntityWrapper对象用于构建查询条件
EntityWrapper<NewsEntity> ew = new EntityWrapper<NewsEntity>();
// 使用MPUtil工具类对查询条件进行排序和分页处理
ew.allEq(MPUtil.allEQMapPre(news, "news"));
// 调用 newsService 对象的 selectView 方法,查询满足 ew 对象的查询条件的记录,并返回一个 NewsView 对象
NewsView newsView = newsService.selectView(ew);
return R.ok("查询公告信息成功").put("data", newsView);
}
/**
*
*/
//一个Spring MVC的注解用于将HTTP请求映射到 info 方法。
//当客户端发送一个HTTP请求到 /info/{id} 路径时Spring MVC会调用 info 方法来处理这个请求
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id) {
// 根据ID查询并返回结果
NewsEntity news = newsService.selectById(id);
//调用 newsService 对象的 selectById 方法,根据 id 参数的值查询数据库中的记录,并返回一个 NewsEntity 对象。
return R.ok().put("data", news); //将 news 对象添加到响应对象中,键为 "data"
}
/**
*
*/
@IgnoreAuth
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id) {
// 根据ID查询并返回结果
NewsEntity news = newsService.selectById(id);
return R.ok().put("data", news);
}
/**
*
*/
@RequestMapping("/save")
public R save(@RequestBody NewsEntity news, HttpServletRequest request) {
// 设置ID为当前时间戳加上一个随机数
news.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 验证实体对象,如果需要验证,可以取消注释
// ValidatorUtils.validateEntity(news);
// 插入数据,将 news 对象插入到数据库中
newsService.insert(news);
//返回一个表示请求成功的响应对象
return R.ok();
}
/**
*
*/
@RequestMapping("/add")
public R add(@RequestBody NewsEntity news, HttpServletRequest request) {
// 设置ID为当前时间戳加上一个随机数
news.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 验证实体对象,如果需要验证,可以取消注释
// ValidatorUtils.validateEntity(news);
// 插入数据
newsService.insert(news);
return R.ok();
}
/**
*
*/
@RequestMapping("/update")
@Transactional
public R update(@RequestBody NewsEntity news, HttpServletRequest request) {
// 验证实体对象,如果需要验证,可以取消注释
// ValidatorUtils.validateEntity(news);
// 更新数据
newsService.updateById(news);
return R.ok();
}
/**
*
*/
@RequestMapping("/delete")//这是一个Spring MVC的注解用于将HTTP请求映射到 delete方法上
public R delete(@RequestBody Long[] ids) {
// 批量删除数据
newsService.deleteBatchIds(Arrays.asList(ids));
return R.ok();//R.ok() 方法通常表示请求成功,并返回一个默认的成功响应。
}
/**
*
*/
@RequestMapping("/remind/{columnName}/{type}")
//这是一个Spring MVC的注解用于将HTTP请求映射到 remindCount 方法。当客户端发送一个HTTP请求到 /remind/{columnName}/{type} 路径时Spring MVC会调用 remindCount 方法来处理这个请求。
public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
@PathVariable("type") String type, @RequestParam Map<String, Object> map) {
// 将列名和类型添加到map中,@PathVariable 注解表示 columnName 和 type 参数的值将从URL路径中获取
map.put("column", columnName);//将 columnName 参数的值添加到 map 中,键为 "column"。
map.put("type", type);
if (type.equals("2")) //如果 type 参数的值为 "2"
{
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
//创建一个 SimpleDateFormat 对象sdf用于将日期格式化为 "yyyy-MM-dd" 格式。
Calendar c = Calendar.getInstance();
//创建一个 Calendar 对象用于处理日期和时间。Calendar.getInstance() 方法返回一个表示当前日期和时间的 Calendar 对象。
Date remindStartDate = null;//声明一个变量 remindStartDate,初始化为 null,这个变量将用于存储提醒开始日期。
Date remindEndDate = null;
if (map.get("remindstart") != null)//如果 map 中存在键为 "remindstart" 的元素
{
Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
//将 map 中键为 "remindstart" 的元素的值转换为 Integer 类型,并赋值给 remindStart
c.setTime(new Date());//setTime(new Date()) 方法将 Calendar 对象c的时间设置为当前时间。
c.add(Calendar.DAY_OF_MONTH, remindStart);//将 Calendar 对象的时间增加 remindStart 天。
remindStartDate = c.getTime();//返回一个表示 Calendar 对象当前时间的 Date 对象,并将其赋值给 remindStartDate。
map.put("remindstart", sdf.format(remindStartDate));//将 remindStartDate 格式化为 "yyyy-MM-dd" 格式,并将其作为 map 中键为 "remindstart" 的元素的值。
}
if (map.get("remindend") != null)
{
Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
c.setTime(new Date());//c 的时间设置为当前时间
c.add(Calendar.DAY_OF_MONTH, remindEnd);//c 的时间增加 remindStart 天
remindEndDate = c.getTime();
map.put("remindend", sdf.format(remindEndDate));
}
}
// 创建一个EntityWrapper对象用于构建查询条件
Wrapper<NewsEntity> wrapper = new EntityWrapper<NewsEntity>();//创建一个EntityWrapper对象用于构建查询条件
if (map.get("remindstart") != null)//如果map中存在键为"remindstart"的元素
{
wrapper.ge(columnName, map.get("remindstart"));//将 wrapper 对象的查询条件设置为 columnName>=map 中键为 "remindend" 的元素的值
}
if (map.get("remindend") != null) {
wrapper.le(columnName, map.get("remindend"));//将 wrapper 对象的查询条件设置为 columnName<=map 中键为 "remindend" 的元素的值
}
// 查询并返回结果
int count = newsService.selectCount(wrapper);//查询满足wrapper对象的查询条件的记录数并赋值给 count 变量
return R.ok().put("count", count);//返回一个包含 count 变量的 R 对象(请求成功的响应对象)
}
}

@ -1,222 +0,0 @@
package com.controller;
import java.math.BigDecimal; // 导入BigDecimal类用于高精度的数学计算
import java.text.SimpleDateFormat; // 导入SimpleDateFormat类用于日期格式化
import java.text.ParseException; // 导入ParseException类用于处理日期解析异常
import java.util.ArrayList; // 导入ArrayList类用于创建动态数组
import java.util.Arrays; // 导入Arrays类提供对数组操作的工具方法
import java.util.Calendar; // 导入Calendar类用于日期时间操作
import java.util.Map; // 导入Map接口用于键值对集合
import java.util.HashMap; // 导入HashMap类基于哈希表的Map实现
import java.util.Iterator; // 导入Iterator接口用于遍历集合
import java.util.Date; // 导入Date类用于日期时间表示
import java.util.List; // 导入List接口用于列表集合
import javax.servlet.http.HttpServletRequest; // 导入HttpServletRequest接口用于访问HTTP请求信息
import java.io.IOException; // 导入IOException类用于处理输入输出异常
import com.utils.ValidatorUtils; // 导入ValidatorUtils工具类用于实体验证
import org.apache.commons.lang3.StringUtils; // 导入StringUtils类提供字符串操作的工具方法
import org.springframework.beans.factory.annotation.Autowired; // 导入Autowired注解用于自动注入依赖
import org.springframework.transaction.annotation.Transactional; // 导入Transactional注解用于声明事务管理
import org.springframework.format.annotation.DateTimeFormat; // 导入DateTimeFormat注解用于日期时间格式化
import org.springframework.web.bind.annotation.PathVariable; // 导入PathVariable注解用于将URL中的参数绑定到控制器方法的参数上
import org.springframework.web.bind.annotation.RequestBody; // 导入RequestBody注解用于将HTTP请求体绑定到控制器方法的参数上
import org.springframework.web.bind.annotation.RequestMapping; // 导入RequestMapping注解用于映射HTTP请求到控制器方法
import org.springframework.web.bind.annotation.RequestParam; // 导入RequestParam注解用于将请求参数绑定到控制器方法的参数上
import org.springframework.web.bind.annotation.RestController; // 导入RestController注解用于声明一个REST风格的控制器
import com.baomidou.mybatisplus.mapper.EntityWrapper; // 导入EntityWrapper类用于构建查询条件
import com.baomidou.mybatisplus.mapper.Wrapper; // 导入Wrapper接口用于封装查询条件
import com.annotation.IgnoreAuth; // 导入IgnoreAuth注解用于标记不需要认证的接口
import com.entity.StoreupEntity; // 导入StoreupEntity实体类代表存储数据
import com.entity.view.StoreupView; // 导入StoreupView视图类用于展示存储数据
import com.service.StoreupService; // 导入StoreupService接口用于存储业务操作
import com.service.TokenService; // 导入TokenService接口用于令牌操作未使用
import com.utils.PageUtils; // 导入PageUtils工具类用于分页处理
import com.utils.R; // 导入R工具类用于构建统一的响应格式
import com.utils.MD5Util; // 导入MD5Util工具类用于MD5加密未使用
import com.utils.MPUtil; // 导入MPUtil工具类提供MyBatis Plus操作的工具方法
import com.utils.CommonUtil; // 导入CommonUtil工具类提供通用的工具方法
/**
*
*
* @author
* @email
* @date 2023-02-21 09:46:06
*/
@RestController
@RequestMapping("/storeup")
public class StoreupController {
@Autowired
private StoreupService storeupService;
/**
*
*/
@RequestMapping("/page")//定义了一个处理HTTP请求的映射当请求路径为/page时会调用这个方法
public R page(@RequestParam Map<String, Object> params,StoreupEntity storeup,HttpServletRequest request)
{//定义了一个公共方法接收请求参数、实体对象和HTTP请求对象
if(!request.getSession().getAttribute("role").toString().equals("管理员"))
{//检查当前用户的角色是否为管理员如果不是管理员则设置用户ID
storeup.setUserid((Long)request.getSession().getAttribute("userId"));//设置用户ID
}
EntityWrapper<StoreupEntity> ew = new EntityWrapper<StoreupEntity>();//创建一个实体包装器对象,用于构建查询条件
PageUtils page = storeupService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, storeup), params), params));//调用storeupService的queryPage方法根据查询条件和分页参数进行分页查询并返回分页结果
request.setAttribute("data", page);//将分页结果设置到HTTP请求对象中
return R.ok().put("data", page);//返回一个包含分页结果的响应对象
}
/**
*
*/
@IgnoreAuth//定义了一个注解,用于标记不需要权限认证的接口
@RequestMapping("/list")//定义了一个处理HTTP请求的映射当请求路径为/list时会调用这个方法
public R list(@RequestParam Map<String, Object> params,StoreupEntity storeup,HttpServletRequest request)
{
EntityWrapper<StoreupEntity> ew = new EntityWrapper<StoreupEntity>();//创建一个实体包装器对象,用于构建查询条件
PageUtils page = storeupService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, storeup), params), params));//调用storeupService的queryPage方法根据查询条件和分页参数进行分页查询并返回分页结果
request.setAttribute("data", page);//将分页查询结果设置到HTTP请求对象中
return R.ok().put("data", page);//返回一个包含分页查询结果的响应对象
}
/**
*
*/
@RequestMapping("/lists")
public R list( StoreupEntity storeup)//定义了一个公共方法,接收实体对象
{
EntityWrapper<StoreupEntity> ew = new EntityWrapper<StoreupEntity>();//创建一个实体包装器对象,用于构建查询条件
ew.allEq(MPUtil.allEQMapPre( storeup, "storeup")); //使用allEq方法设置查询条件MPUtil.allEQMapPre方法将实体对象的属性转换为Map,并添加前缀"storeup",allEq方法将Map中的键值对作为查询条件查询出符合条件的实体对象
return R.ok().put("data", storeupService.selectListView(ew));//根据查询条件查询出符合条件的实体对象列表,并返回一个包含实体对象列表的响应对象
}
/**
*
*/
@RequestMapping("/query")//定义了一个处理HTTP请求的映射当请求路径为/query时会调用这个方法。
public R query(StoreupEntity storeup)
{
EntityWrapper< StoreupEntity> ew = new EntityWrapper< StoreupEntity>();
//创建一个实体包装器,用于构建查询条件
ew.allEq(MPUtil.allEQMapPre( storeup, "storeup"));
//使用allEq方法设置查询条件,MPUtil.allEQMapPre方法将实体对象的属性转换为Map,并添加前缀"storeup",allEq方法将Map中的键值对作为查询条件查询出符合条件的实体对象。
StoreupView storeupView = storeupService.selectView(ew);
//调用服务层的方法查询单个数据,并返回视图对象
return R.ok("查询收藏表成功").put("data", storeupView);
//返回一个包含查询结果的响应对象,并附带成功消息
}
/**
*
*/
@RequestMapping("/info/{id}")// 定义一个请求映射,当访问 /info/{id} 路径时,会调用这个方法
public R info(@PathVariable("id") Long id)// 定义一个方法,接收一个路径变量 id类型为 Long
{
StoreupEntity storeup = storeupService.selectById(id);//调用服务层的方法根据ID查询数据并返回实体对象
return R.ok().put("data", storeup);//返回一个包含查询结果的 R 对象,其中包含键 "data" 和对应的 storeup 实体对象
}
/**
*
*/
@IgnoreAuth//定义了一个注解,用于标记不需要权限认证的接口
@RequestMapping("/detail/{id}")//定义了一个处理HTTP请求的映射当请求路径为/detail/{id}时,会调用这个方法
public R detail(@PathVariable("id") Long id)//定义了一个方法,接收一个路径变量 id类型为 Long
{
StoreupEntity storeup = storeupService.selectById(id);//调用服务层的方法根据ID查询数据并返回实体对象
return R.ok().put("data", storeup);//返回一个包含查询结果的响应对象,并附带成功消息
}
/**
*
*/
@RequestMapping("/save")//定义了一个处理HTTP请求的映射当请求路径为/save时会调用这个方法
public R save(@RequestBody StoreupEntity storeup, HttpServletRequest request)//定义了一个方法接收一个JSON格式的请求体类型为 StoreupEntity并接收一个 HttpServletRequest 对象
{
storeup.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
//ValidatorUtils.validateEntity(storeup);
storeup.setUserid((Long)request.getSession().getAttribute("userId"));//从请求的 session 中获取用户ID并设置到 storeup 实体对象中
storeupService.insert(storeup);//调用服务层的方法将 storeup 实体对象插入数据库
return R.ok();//返回一个包含成功信息的 R 对象
}
/**
*
*/
@RequestMapping("/add")//定义了一个处理HTTP请求的映射当请求路径为/add时会调用这个方法
public R add(@RequestBody StoreupEntity storeup, HttpServletRequest request) //定义一个方法,接收一个请求体中的 StoreupEntity 对象和 HttpServletRequest 对象
{
storeup.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());//生成一个新的唯一ID由当前时间戳加上一个随机数
//ValidatorUtils.validateEntity(storeup);
storeupService.insert(storeup);//调用服务层的方法将 storeup 实体对象插入数据库
return R.ok();
}
/**
*
*/
@RequestMapping("/update")
@Transactional//定义了一个事务注解,表示该方法中的数据库操作应该在一个事务中执行
public R update(@RequestBody StoreupEntity storeup, HttpServletRequest request)//定义了一个方法,接收一个请求体中的 StoreupEntity 对象和 HttpServletRequest 对象
{
//ValidatorUtils.validateEntity(storeup);
storeupService.updateById(storeup);//调用服务层的方法根据 ID 更新 storeup 实体对象的所有字段
return R.ok();//返回一个包含成功信息的 R 对象
}
/**
*
*/
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids)// 定义一个方法,接收一个请求体中的 Long 数组,类型为 Long[]
{
storeupService.deleteBatchIds(Arrays.asList(ids));//调用服务层的方法,根据传入的 ID 数组批量删除数据
return R.ok();//返回一个包含成功信息的 R 对象 R.ok()函数是R工具类中的一个静态方法用于创建一个包含成功信息的响应对象
}
/**
*
*/
@RequestMapping("/remind/{columnName}/{type}") // 定义一个请求映射,当访问 /remind/{columnName}/{type} 路径时,会调用这个方法
public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
@PathVariable("type") String type,@RequestParam Map<String, Object> map) { // 定义一个方法,接收一个路径变量 columnName 和 type类型为 String以及一个请求参数 map类型为 Map<String, Object>
map.put("column", columnName); // 将 columnName 添加到 map 中,键为 "column"
map.put("type", type); // 将 type 添加到 map 中,键为 "type"
if(type.equals("2")) { // 如果 type 等于 "2"
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); // 创建一个日期格式化对象,格式为 "yyyy-MM-dd"
Calendar c = Calendar.getInstance(); // 创建一个日历对象,获取当前时间
Date remindStartDate = null; // 创建一个日期对象,用于存储提醒开始时间
Date remindEndDate = null; // 创建一个日期对象,用于存储提醒结束时间
if(map.get("remindstart")!=null) { // 如果 map 中存在 "remindstart" 键
Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); // 将 "remindstart" 键对应的值转换为整数
c.setTime(new Date()); // 设置日历对象的时间为当前时间
c.add(Calendar.DAY_OF_MONTH,remindStart); // 将日历对象的时间增加 remindStart 天
remindStartDate = c.getTime(); // 获取增加后的时间,并赋值给 remindStartDate
map.put("remindstart", sdf.format(remindStartDate)); // 将 remindStartDate 格式化为 "yyyy-MM-dd" 格式,并添加到 map 中,键为 "remindstart"
}
if(map.get("remindend")!=null) { // 如果 map 中存在 "remindend" 键
Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); // 将 "remindend" 键对应的值转换为整数
c.setTime(new Date()); // 设置日历对象的时间为当前时间
c.add(Calendar.DAY_OF_MONTH,remindEnd); // 将日历对象的时间增加 remindEnd 天
remindEndDate = c.getTime(); // 获取增加后的时间,并赋值给 remindEndDate
map.put("remindend", sdf.format(remindEndDate)); // 将 remindEndDate 格式化为 "yyyy-MM-dd" 格式,并添加到 map 中,键为 "remindend"
}
}
Wrapper<StoreupEntity> wrapper = new EntityWrapper<StoreupEntity>(); // 创建一个实体包装器对象,用于构建查询条件
if(map.get("remindstart")!=null) { // 如果 map 中存在 "remindstart" 键
wrapper.ge(columnName, map.get("remindstart")); // 设置查询条件,查询 columnName 字段大于等于 "remindstart" 键对应的值
}
if(map.get("remindend")!=null) { // 如果 map 中存在 "remindend" 键
wrapper.le(columnName, map.get("remindend")); // 设置查询条件,查询 columnName 字段小于等于 "remindend" 键对应的值
}
if(!request.getSession().getAttribute("role").toString().equals("管理员")) { // 如果当前用户的角色不是管理员
wrapper.eq("userid", (Long)request.getSession().getAttribute("userId")); // 设置查询条件,查询 userid 字段等于当前用户的 ID
}
int count = storeupService.selectCount(wrapper); // 调用服务层的方法,根据查询条件查询符合条件的记录数,并赋值给 count
return R.ok().put("count", count); // 返回一个包含查询结果的响应对象,其中包含键 "count" 和对应的 count 值
}
}

@ -1,212 +0,0 @@
package com.controller; // 定义一个包,用于组织和管理类
import java.math.BigDecimal; // 导入BigDecimal类用于高精度的数学计算
import java.text.SimpleDateFormat; // 导入SimpleDateFormat类用于日期格式化
import java.text.ParseException; // 导入ParseException类用于处理日期解析异常
import java.util.ArrayList; // 导入ArrayList类用于创建动态数组
import java.util.Arrays; // 导入Arrays类提供对数组操作的工具方法
import java.util.Calendar; // 导入Calendar类用于日期时间操作
import java.util.Map; // 导入Map接口用于键值对集合
import java.util.HashMap; // 导入HashMap类基于哈希表的Map实现
import java.util.Iterator; // 导入Iterator接口用于遍历集合
import java.util.Date; // 导入Date类用于日期时间表示
import java.util.List; // 导入List接口用于列表集合
import javax.servlet.http.HttpServletRequest; // 导入HttpServletRequest接口用于访问HTTP请求信息
import java.io.IOException; // 导入IOException类用于处理输入输出异常
import com.utils.ValidatorUtils; // 导入ValidatorUtils工具类用于实体验证
import org.apache.commons.lang3.StringUtils; // 导入StringUtils类提供字符串操作的工具方法
import org.springframework.beans.factory.annotation.Autowired; // 导入Autowired注解用于自动注入依赖
import org.springframework.transaction.annotation.Transactional; // 导入Transactional注解用于声明事务管理
import org.springframework.format.annotation.DateTimeFormat; // 导入DateTimeFormat注解用于日期时间格式化
import org.springframework.web.bind.annotation.PathVariable; // 导入PathVariable注解用于将URL中的参数绑定到控制器方法的参数上
import org.springframework.web.bind.annotation.RequestBody; // 导入RequestBody注解用于将HTTP请求体绑定到控制器方法的参数上
import org.springframework.web.bind.annotation.RequestMapping; // 导入RequestMapping注解用于映射HTTP请求到控制器方法
import org.springframework.web.bind.annotation.RequestParam; // 导入RequestParam注解用于将请求参数绑定到控制器方法的参数上
import org.springframework.web.bind.annotation.RestController; // 导入RestController注解用于声明一个REST风格的控制器
import com.baomidou.mybatisplus.mapper.EntityWrapper; // 导入EntityWrapper类用于构建查询条件
import com.baomidou.mybatisplus.mapper.Wrapper; // 导入Wrapper接口用于封装查询条件
import com.annotation.IgnoreAuth; // 导入IgnoreAuth注解用于标记不需要认证的接口
import com.entity.SystemintroEntity; // 导入SystemintroEntity实体类代表存储数据
import com.entity.view.SystemintroView; // 导入SystemintroView视图类用于展示存储数据
import com.service.SystemintroService; // 导入SystemintroService接口用于存储业务操作
import com.service.TokenService; // 导入TokenService接口用于令牌操作未使用
import com.utils.PageUtils; // 导入PageUtils工具类用于分页处理
import com.utils.R; // 导入R工具类用于构建统一的响应格式
import com.utils.MD5Util; // 导入MD5Util工具类用于MD5加密未使用
import com.utils.MPUtil; // 导入MPUtil工具类提供MyBatis Plus操作的工具方法
import com.utils.CommonUtil; // 导入CommonUtil工具类提供通用的工具方法
/**
*
*
* @author
* @email
* @date 2023-02-21 09:46:06
*/
@RestController // 声明一个REST风格的控制器
@RequestMapping("/systemintro") // 定义一个请求映射,当访问 /systemintro 路径时,会调用这个控制器
public class SystemintroController {
@Autowired // 自动注入依赖
private SystemintroService systemintroService; // 声明一个SystemintroService对象用于存储业务操作
/**
*
*/
@RequestMapping("/page") // 定义一个请求映射,当访问 /page 路径时,会调用这个方法
public R page(@RequestParam Map<String, Object> params,SystemintroEntity systemintro,
HttpServletRequest request){ // 定义一个方法接收请求参数、实体对象和HTTP请求对象
EntityWrapper<SystemintroEntity> ew = new EntityWrapper<SystemintroEntity>(); // 创建一个实体包装器对象,用于构建查询条件
PageUtils page = systemintroService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, systemintro), params), params)); // 调用服务层的方法,根据查询条件和分页参数进行分页查询,并返回分页结果
request.setAttribute("data", page); // 将分页结果设置到HTTP请求对象中
return R.ok().put("data", page); // 返回一个包含分页结果的响应对象
}
/**
*
*/
@IgnoreAuth // 定义了一个注解,用于标记不需要权限认证的接口
@RequestMapping("/list") // 定义一个请求映射,当访问 /list 路径时,会调用这个方法
public R list(@RequestParam Map<String, Object> params,SystemintroEntity systemintro,
HttpServletRequest request){ // 定义一个方法接收请求参数、实体对象和HTTP请求对象
EntityWrapper<SystemintroEntity> ew = new EntityWrapper<SystemintroEntity>(); // 创建一个实体包装器对象,用于构建查询条件
PageUtils page = systemintroService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, systemintro), params), params)); // 调用服务层的方法,根据查询条件和分页参数进行分页查询,并返回分页结果
request.setAttribute("data", page); // 将分页结果设置到HTTP请求对象中
return R.ok().put("data", page); // 返回一个包含分页结果的响应对象
}
/**
*
*/
@RequestMapping("/lists") // 定义一个请求映射,当访问 /lists 路径时,会调用这个方法
public R list( SystemintroEntity systemintro){ // 定义一个方法,接收实体对象
EntityWrapper<SystemintroEntity> ew = new EntityWrapper<SystemintroEntity>(); // 创建一个实体包装器对象,用于构建查询条件
ew.allEq(MPUtil.allEQMapPre( systemintro, "systemintro")); // 使用allEq方法设置查询条件MPUtil.allEQMapPre方法将实体对象的属性转换为Map,并添加前缀"systemintro",allEq方法将Map中的键值对作为查询条件查询出符合条件的实体对象
return R.ok().put("data", systemintroService.selectListView(ew)); // 根据查询条件查询出符合条件的实体对象列表,并返回一个包含实体对象列表的响应对象
}
/**
*
*/
@RequestMapping("/query") // 定义一个请求映射,当访问 /query 路径时,会调用这个方法
public R query(SystemintroEntity systemintro){ // 定义一个方法,接收实体对象
EntityWrapper< SystemintroEntity> ew = new EntityWrapper< SystemintroEntity>(); // 创建一个实体包装器对象,用于构建查询条件
ew.allEq(MPUtil.allEQMapPre( systemintro, "systemintro")); // 使用allEq方法设置查询条件MPUtil.allEQMapPre方法将实体对象的属性转换为Map,并添加前缀"systemintro",allEq方法将Map中的键值对作为查询条件查询出符合条件的实体对象
SystemintroView systemintroView = systemintroService.selectView(ew); // 调用服务层的方法查询单个数据,并返回视图对象
return R.ok("查询关于我们成功").put("data", systemintroView); // 返回一个包含查询结果的响应对象,并附带成功消息
}
/**
*
*/
@RequestMapping("/info/{id}") // 定义一个请求映射,当访问 /info/{id} 路径时,会调用这个方法
public R info(@PathVariable("id") Long id){ // 定义一个方法,接收一个路径变量 id类型为 Long
SystemintroEntity systemintro = systemintroService.selectById(id); // 调用服务层的方法根据ID查询数据并返回实体对象
return R.ok().put("data", systemintro); // 返回一个包含查询结果的 R 对象,其中包含键 "data" 和对应的 systemintro 实体对象
}
/**
*
*/
@IgnoreAuth // 定义了一个注解,用于标记不需要权限认证的接口
@RequestMapping("/detail/{id}") // 定义一个请求映射,当访问 /detail/{id} 路径时,会调用这个方法
public R detail(@PathVariable("id") Long id){ // 定义一个方法,接收一个路径变量 id类型为 Long
SystemintroEntity systemintro = systemintroService.selectById(id); // 调用服务层的方法根据ID查询数据并返回实体对象
return R.ok().put("data", systemintro); // 返回一个包含查询结果的响应对象,并附带成功消息
}
/**
*
*/
@RequestMapping("/save") // 定义一个请求映射,当访问 /save 路径时,会调用这个方法
public R save(@RequestBody SystemintroEntity systemintro, HttpServletRequest request){ // 定义一个方法接收一个JSON格式的请求体类型为 SystemintroEntity并接收一个 HttpServletRequest 对象
systemintro.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); // 生成一个新的唯一ID由当前时间戳加上一个随机数
//ValidatorUtils.validateEntity(systemintro); // 注释掉的代码,用于验证 systemintro 实体对象是否符合要求
systemintroService.insert(systemintro); // 调用服务层的方法将 systemintro 实体对象插入数据库
return R.ok(); // 返回一个包含成功信息的 R 对象
}
/**
*
*/
@RequestMapping("/add") // 定义一个请求映射,当访问 /add 路径时,会调用这个方法
public R add(@RequestBody SystemintroEntity systemintro, HttpServletRequest request){ // 定义一个方法,接收一个请求体中的 SystemintroEntity 对象和 HttpServletRequest 对象
systemintro.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); // 生成一个新的唯一ID由当前时间戳加上一个随机数
//ValidatorUtils.validateEntity(systemintro); // 注释掉的代码,用于验证 systemintro 实体对象是否符合要求
systemintroService.insert(systemintro); // 调用服务层的方法将 systemintro 实体对象插入数据库
return R.ok(); // 返回一个包含成功信息的 R 对象
}
/**
*
*/
@RequestMapping("/update") // 定义一个请求映射,当访问 /update 路径时,会调用这个方法
@Transactional // 定义了一个事务注解,表示该方法中的数据库操作应该在一个事务中执行
public R update(@RequestBody SystemintroEntity systemintro, HttpServletRequest request){ // 定义一个方法,接收一个请求体中的 SystemintroEntity 对象和 HttpServletRequest 对象
//ValidatorUtils.validateEntity(systemintro); // 注释掉的代码,用于验证 systemintro 实体对象是否符合要求
systemintroService.updateById(systemintro); // 调用服务层的方法根据 ID 更新 systemintro 实体对象的所有字段
return R.ok(); // 返回一个包含成功信息的 R 对象
}
/**
*
*/
@RequestMapping("/delete") // 定义一个请求映射,当访问 /delete 路径时,会调用这个方法
public R delete(@RequestBody Long[] ids){ // 定义一个方法,接收一个请求体中的 Long 数组,类型为 Long[]
systemintroService.deleteBatchIds(Arrays.asList(ids)); // 调用服务层的方法,根据传入的 ID 数组批量删除数据
return R.ok(); // 返回一个包含成功信息的 R 对象
}
/**
*
*/
@RequestMapping("/remind/{columnName}/{type}") // 定义一个请求映射,当访问 /remind/{columnName}/{type} 路径时,会调用这个方法
public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
@PathVariable("type") String type,@RequestParam Map<String, Object> map) { // 定义一个方法,接收一个路径变量 columnName 和 type类型为 String以及一个请求参数 map类型为 Map<String, Object>
map.put("column", columnName); // 将 columnName 添加到 map 中,键为 "column"
map.put("type", type); // 将 type 添加到 map 中,键为 "type"
if(type.equals("2")) { // 如果 type 等于 "2"
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); // 创建一个日期格式化对象,格式为 "yyyy-MM-dd"
Calendar c = Calendar.getInstance(); // 创建一个日历对象,获取当前时间
Date remindStartDate = null; // 创建一个日期对象,用于存储提醒开始时间
Date remindEndDate = null; // 创建一个日期对象,用于存储提醒结束时间
if(map.get("remindstart")!=null) { // 如果 map 中存在 "remindstart" 键
Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); // 将 "remindstart" 键对应的值转换为整数
c.setTime(new Date()); // 设置日历对象的时间为当前时间
c.add(Calendar.DAY_OF_MONTH,remindStart); // 将日历对象的时间增加 remindStart 天
remindStartDate = c.getTime(); // 获取增加后的时间,并赋值给 remindStartDate
map.put("remindstart", sdf.format(remindStartDate)); // 将 remindStartDate 格式化为 "yyyy-MM-dd" 格式,并添加到 map 中,键为 "remindstart"
}
if(map.get("remindend")!=null) { // 如果 map 中存在 "remindend" 键
Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); // 将 "remindend" 键对应的值转换为整数
c.setTime(new Date()); // 设置日历对象的时间为当前时间
c.add(Calendar.DAY_OF_MONTH,remindEnd); // 将日历对象的时间增加 remindEnd 天
remindEndDate = c.getTime(); // 获取增加后的时间,并赋值给 remindEndDate
map.put("remindend", sdf.format(remindEndDate)); // 将 remindEndDate 格式化为 "yyyy-MM-dd" 格式,并添加到 map 中,键为 "remindend"
}
}
Wrapper<SystemintroEntity> wrapper = new EntityWrapper<SystemintroEntity>(); // 创建一个实体包装器对象,用于构建查询条件
if(map.get("remindstart")!=null) { // 如果 map 中存在 "remindstart" 键
wrapper.ge(columnName, map.get("remindstart")); // 设置查询条件,查询 columnName 字段大于等于 "remindstart" 键对应的值
}
if(map.get("remindend")!=null) { // 如果 map 中存在 "remindend" 键
wrapper.le(columnName, map.get("remindend")); // 设置查询条件,查询 columnName 字段小于等于 "remindend" 键对应的值
}
int count = systemintroService.selectCount(wrapper); // 调用服务层的方法,根据查询条件查询符合条件的记录数,并赋值给 count
return R.ok().put("count", count); // 返回一个包含查询结果的响应对象,其中包含键 "count" 和对应的 count 值
}
}

@ -1,179 +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.UsersEntity;
import com.service.TokenService;
import com.service.UsersService;
import com.utils.CommonUtil;
import com.utils.MPUtil;
import com.utils.PageUtils;
import com.utils.R;
import com.utils.ValidatorUtils;
/**
*
*/
@RequestMapping("users") // 定义请求路径的基础 URL 为 "users"
@RestController // 标明该类是一个控制器,返回的对象直接作为 JSON 响应
public class UsersController {
@Autowired // 自动注入 UsersService 依赖
private UsersService userService;
@Autowired // 自动注入 TokenService 依赖
private TokenService tokenService;
/**
*
*/
@IgnoreAuth // 忽略认证,允许未登录用户访问
@PostMapping(value = "/login") // 处理 POST 请求,路径为 "users/login"
public R login(String username, String password, String captcha, HttpServletRequest request) {
// 根据用户名查询用户
UsersEntity user = userService.selectOne(new EntityWrapper<UsersEntity>().eq("username", username));
// 检查用户是否存在且密码是否匹配
if(user == null || !user.getPassword().equals(password)) {
return R.error("账号或密码不正确"); // 返回错误信息
}
// 生成用户的 token
String token = tokenService.generateToken(user.getId(), username, "users", user.getRole());
return R.ok().put("token", token); // 返回成功信息和 token
}
/**
*
*/
@IgnoreAuth // 忽略认证,允许未登录用户访问
@PostMapping(value = "/register") // 处理 POST 请求,路径为 "users/register"
public R register(@RequestBody UsersEntity user) {
// 校验用户是否已存在
if(userService.selectOne(new EntityWrapper<UsersEntity>().eq("username", user.getUsername())) != null) {
return R.error("用户已存在"); // 返回用户已存在的错误信息
}
userService.insert(user); // 插入新用户
return R.ok(); // 返回成功信息
}
/**
* 退
*/
@GetMapping(value = "logout") // 处理 GET 请求,路径为 "users/logout"
public R logout(HttpServletRequest request) {
request.getSession().invalidate(); // 使 session 失效,用户登出
return R.ok("退出成功"); // 返回成功信息
}
/**
*
*/
@IgnoreAuth // 忽略认证,允许未登录用户访问
@RequestMapping(value = "/resetPass") // 处理请求,路径为 "users/resetPass"
public R resetPass(String username, HttpServletRequest request){
// 根据用户名查询用户
UsersEntity user = userService.selectOne(new EntityWrapper<UsersEntity>().eq("username", username));
if(user == null) {
return R.error("账号不存在"); // 返回账号不存在的错误信息
}
user.setPassword("123456"); // 将用户密码重置为 "123456"
userService.update(user, null); // 更新用户信息
return R.ok("密码已重置为123456"); // 返回成功信息
}
/**
*
*/
@RequestMapping("/page") // 处理请求,路径为 "users/page"
public R page(@RequestParam Map<String, Object> params, UsersEntity user) {
EntityWrapper<UsersEntity> ew = new EntityWrapper<UsersEntity>(); // 创建查询条件
// 调用服务层方法查询分页数据
PageUtils page = userService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params));
return R.ok().put("data", page); // 返回查询结果
}
/**
*
*/
@RequestMapping("/list") // 处理请求,路径为 "users/list"
public R list(UsersEntity user) {
EntityWrapper<UsersEntity> ew = new EntityWrapper<UsersEntity>(); // 创建查询条件
ew.allEq(MPUtil.allEQMapPre(user, "user")); // 添加所有相等条件
return R.ok().put("data", userService.selectListView(ew)); // 返回查询结果
}
/**
*
*/
@RequestMapping("/info/{id}") // 处理请求,路径为 "users/info/{id}"
public R info(@PathVariable("id") String id) {
UsersEntity user = userService.selectById(id); // 根据 ID 查找用户
return R.ok().put("data", user); // 返回用户信息
}
/**
* session
*/
@RequestMapping("/session") // 处理请求,路径为 "users/session"
public R getCurrUser(HttpServletRequest request) {
Long id = (Long) request.getSession().getAttribute("userId"); // 从 session 中获取用户 ID
UsersEntity user = userService.selectById(id); // 根据 ID 查找用户
return R.ok().put("data", user); // 返回用户信息
}
/**
*
*/
@PostMapping("/save") // 处理 POST 请求,路径为 "users/save"
public R save(@RequestBody UsersEntity user) {
// 校验用户是否已存在
if(userService.selectOne(new EntityWrapper<UsersEntity>().eq("username", user.getUsername())) != null) {
return R.error("用户已存在"); // 返回用户已存在的错误信息
}
userService.insert(user); // 插入新用户
return R.ok(); // 返回成功信息
}
/**
*
*/
@RequestMapping("/update") // 处理请求,路径为 "users/update"
public R update(@RequestBody UsersEntity user) {
// 校验用户是否已存在
UsersEntity u = userService.selectOne(new EntityWrapper<UsersEntity>().eq("username", user.getUsername()));
if(u != null && u.getId() != user.getId() && u.getUsername().equals(user.getUsername())) {
return R.error("用户名已存在。"); // 返回用户名已存在的错误信息
}
userService.updateById(user); // 更新用户信息
return R.ok(); // 返回成功信息
}
/**
*
*/
@RequestMapping("/delete") // 处理请求,路径为 "users/delete"
public R delete(@RequestBody Long[] ids) {
userService.deleteBatchIds(Arrays.asList(ids)); // 批量删除用户
return R.ok(); // 返回成功信息
}
}

@ -1,38 +0,0 @@
package com.dao;
import com.entity.NewsEntity;
import com.baomidou.mybatisplus.mapper.BaseMapper;
import java.util.List;
import java.util.Map;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
import org.apache.ibatis.annotations.Param;
import com.entity.vo.NewsVO;
import com.entity.view.NewsView;
/**
*
* 访
*
* @author
* @email
* @date 2023-02-21 09:46:06
*/
public interface NewsDao extends BaseMapper<NewsEntity> {
// 根据查询条件Wrapper选择公告的信息列表并返回一个 NewsVO 对象的列表
List<NewsVO> selectListVO(@Param("ew") Wrapper<NewsEntity> wrapper);
// 根据查询条件Wrapper选择单个公告的信息并返回一个 NewsVO 对象
NewsVO selectVO(@Param("ew") Wrapper<NewsEntity> wrapper);
// 根据查询条件Wrapper选择公告的信息视图列表并返回一个 NewsView 对象的列表
List<NewsView> selectListView(@Param("ew") Wrapper<NewsEntity> wrapper);
// 根据查询条件Wrapper与分页信息选择公告的信息视图列表并返回一个 NewsView 对象的列表
List<NewsView> selectListView(Pagination page, @Param("ew") Wrapper<NewsEntity> wrapper);
// 根据查询条件Wrapper选择单个公告的信息视图并返回一个 NewsView 对象
NewsView selectView(@Param("ew") Wrapper<NewsEntity> wrapper);
}

@ -1,35 +0,0 @@
package com.dao;
import com.entity.StoreupEntity;
import com.baomidou.mybatisplus.mapper.BaseMapper;
import java.util.List;
import java.util.Map;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
import org.apache.ibatis.annotations.Param;
import com.entity.vo.StoreupVO;
import com.entity.view.StoreupView;
/**
*
*
* @author
* @email
* @date 2023-02-21 09:46:06
*/
public interface StoreupDao extends BaseMapper<StoreupEntity> {
List<StoreupVO> selectListVO(@Param("ew") Wrapper<StoreupEntity> wrapper);
StoreupVO selectVO(@Param("ew") Wrapper<StoreupEntity> wrapper);
List<StoreupView> selectListView(@Param("ew") Wrapper<StoreupEntity> wrapper);
List<StoreupView> selectListView(Pagination page,@Param("ew") Wrapper<StoreupEntity> wrapper);
StoreupView selectView(@Param("ew") Wrapper<StoreupEntity> wrapper);
}

@ -1,38 +0,0 @@
package com.dao;
import com.entity.SystemintroEntity;
import com.baomidou.mybatisplus.mapper.BaseMapper;
import java.util.List;
import java.util.Map;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
import org.apache.ibatis.annotations.Param;
import com.entity.vo.SystemintroVO;
import com.entity.view.SystemintroView;
/**
*
* "关于我们"访
*
* @author
* @email
* @date 2023-02-21 09:46:06
*/
public interface SystemintroDao extends BaseMapper<SystemintroEntity> {
// 根据查询条件Wrapper选择系统介绍的信息列表并返回一个 SystemintroVO 对象的列表
List<SystemintroVO> selectListVO(@Param("ew") Wrapper<SystemintroEntity> wrapper);
// 根据查询条件Wrapper选择单个系统介绍的信息并返回一个 SystemintroVO 对象
SystemintroVO selectVO(@Param("ew") Wrapper<SystemintroEntity> wrapper);
// 根据查询条件Wrapper选择系统介绍信息视图的列表并返回一个 SystemintroView 对象的列表
List<SystemintroView> selectListView(@Param("ew") Wrapper<SystemintroEntity> wrapper);
// 根据查询条件Wrapper和分页信息选择系统介绍信息视图的列表并返回一个 SystemintroView 对象的列表
List<SystemintroView> selectListView(Pagination page, @Param("ew") Wrapper<SystemintroEntity> wrapper);
// 根据查询条件Wrapper选择单个平台介绍的信息视图并返回一个 SystemintroView 对象
SystemintroView selectView(@Param("ew") Wrapper<SystemintroEntity> wrapper);
}

@ -1,22 +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
*/
public interface TokenDao extends BaseMapper<TokenEntity> {
List<TokenEntity> selectListView(@Param("ew") Wrapper<TokenEntity> wrapper);
List<TokenEntity> selectListView(Pagination page,@Param("ew") Wrapper<TokenEntity> wrapper);
}

@ -1,25 +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.UsersEntity;
/**
*
* 访
*/
public interface UsersDao extends BaseMapper<UsersEntity> {
// 根据查询条件Wrapper选择用户列表并返回一个 UsersEntity 对象的列表
List<UsersEntity> selectListView(@Param("ew") Wrapper<UsersEntity> wrapper);
// 根据查询条件Wrapper和分页信息选择用户列表并返回一个 UsersEntity 对象的列表
List<UsersEntity> selectListView(Pagination page, @Param("ew") Wrapper<UsersEntity> wrapper);
}

@ -1,146 +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 2023-02-21 09:46:06
*/
@TableName("news")
public class NewsEntity<T> implements Serializable {
private static final long serialVersionUID = 1L;
public NewsEntity() {
}
public NewsEntity(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 title;
/**
*
*/
private String introduction;
/**
*
*/
private String picture;
/**
*
*/
private String content;
@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 setTitle(String title) {
this.title = title;
}
/**
*
*/
public String getTitle() {
return title;
}
/**
*
*/
public void setIntroduction(String introduction) {
this.introduction = introduction;
}
/**
*
*/
public String getIntroduction() {
return introduction;
}
/**
*
*/
public void setPicture(String picture) {
this.picture = picture;
}
/**
*
*/
public String getPicture() {
return picture;
}
/**
*
*/
public void setContent(String content) {
this.content = content;
}
/**
*
*/
public String getContent() {
return content;
}
}

@ -1,218 +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 2023-02-21 09:46:06
*/
@TableName("storeup")
public class StoreupEntity<T> implements Serializable {
private static final long serialVersionUID = 1L;
public StoreupEntity() {
}
public StoreupEntity(T t) {
try {
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* id
*/
@TableId
private Long id;
/**
* id
*/
private Long userid;
/**
* id
*/
private Long refid;
/**
*
*/
private String tablename;
/**
*
*/
private String name;
/**
*
*/
private String picture;
/**
* (1:,21:,22:,31:,41:)
*/
private String type;
/**
*
*/
private String inteltype;
/**
*
*/
private String remark;
@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;
}
/**
* id
*/
public void setUserid(Long userid) {
this.userid = userid;
}
/**
* id
*/
public Long getUserid() {
return userid;
}
/**
* id
*/
public void setRefid(Long refid) {
this.refid = refid;
}
/**
* id
*/
public Long getRefid() {
return refid;
}
/**
*
*/
public void setTablename(String tablename) {
this.tablename = tablename;
}
/**
*
*/
public String getTablename() {
return tablename;
}
/**
*
*/
public void setName(String name) {
this.name = name;
}
/**
*
*/
public String getName() {
return name;
}
/**
*
*/
public void setPicture(String picture) {
this.picture = picture;
}
/**
*
*/
public String getPicture() {
return picture;
}
/**
* (1:,21:,22:,31:,41:)
*/
public void setType(String type) {
this.type = type;
}
/**
* (1:,21:,22:,31:,41:)
*/
public String getType() {
return type;
}
/**
*
*/
public void setInteltype(String inteltype) {
this.inteltype = inteltype;
}
/**
*
*/
public String getInteltype() {
return inteltype;
}
/**
*
*/
public void setRemark(String remark) {
this.remark = remark;
}
/**
*
*/
public String getRemark() {
return remark;
}
}

@ -1,182 +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 2023-02-21 09:46:06
*/
@TableName("systemintro")
public class SystemintroEntity<T> implements Serializable {
private static final long serialVersionUID = 1L;
public SystemintroEntity() {
}
public SystemintroEntity(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 title;
/**
*
*/
private String subtitle;
/**
*
*/
private String content;
/**
* 1
*/
private String picture1;
/**
* 2
*/
private String picture2;
/**
* 3
*/
private String picture3;
@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 setTitle(String title) {
this.title = title;
}
/**
*
*/
public String getTitle() {
return title;
}
/**
*
*/
public void setSubtitle(String subtitle) {
this.subtitle = subtitle;
}
/**
*
*/
public String getSubtitle() {
return subtitle;
}
/**
*
*/
public void setContent(String content) {
this.content = content;
}
/**
*
*/
public String getContent() {
return content;
}
/**
* 1
*/
public void setPicture1(String picture1) {
this.picture1 = picture1;
}
/**
* 1
*/
public String getPicture1() {
return picture1;
}
/**
* 2
*/
public void setPicture2(String picture2) {
this.picture2 = picture2;
}
/**
* 2
*/
public String getPicture2() {
return picture2;
}
/**
* 3
*/
public void setPicture3(String picture3) {
this.picture3 = picture3;
}
/**
* 3
*/
public String getPicture3() {
return picture3;
}
}

@ -1,132 +0,0 @@
package com.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.annotations.TableName;
import com.baomidou.mybatisplus.enums.IdType;
/**
* token
*/
@TableName("token")
public class TokenEntity implements Serializable {
private static final long serialVersionUID = 1L;
@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;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Long getUserid() {
return userid;
}
public void setUserid(Long userid) {
this.userid = userid;
}
public String getRole() {
return role;
}
public void setRole(String role) {
this.role = role;
}
public String getToken() {
return token;
}
public String getTablename() {
return tablename;
}
public void setTablename(String tablename) {
this.tablename = tablename;
}
public void setToken(String token) {
this.token = token;
}
public Date getExpiratedtime() {
return expiratedtime;
}
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;
}
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,77 +0,0 @@
package com.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.annotations.TableName;
import com.baomidou.mybatisplus.enums.IdType;
/**
*
*/
@TableName("users")
public class UsersEntity implements Serializable {
private static final long serialVersionUID = 1L;
@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;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
}

@ -1,80 +0,0 @@
package com.entity.model;
import com.entity.NewsEntity;
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 2023-02-21 09:46:06
*/
public class NewsModel implements Serializable {
private static final long serialVersionUID = 1L; // 序列化版本号
/**
*
*/
private String introduction; // 存放公告的简介
/**
*
*/
private String picture; // 存放公告相关的图片
/**
*
*/
private String content; // 存放公告的详细内容
/**
*
*/
public void setIntroduction(String introduction) {
this.introduction = introduction; // 设置简介字段
}
/**
*
*/
public String getIntroduction() {
return introduction; // 返回简介字段的值
}
/**
*
*/
public void setPicture(String picture) {
this.picture = picture; // 设置图片字段
}
/**
*
*/
public String getPicture() {
return picture; // 返回图片字段的值
}
/**
*
*/
public void setContent(String content) {
this.content = content; // 设置内容字段
}
/**
*
*/
public String getContent() {
return content; // 返回内容字段的值
}
}

@ -1,179 +0,0 @@
package com.entity.model;
import com.entity.StoreupEntity;
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 2023-02-21 09:46:06
*/
public class StoreupModel implements Serializable {
private static final long serialVersionUID = 1L;
/**
* id
*/
private Long refid;
/**
*
*/
private String tablename;
/**
*
*/
private String name;
/**
*
*/
private String picture;
/**
* (1:,21:,22:,31:,41:)
*/
private String type;
/**
*
*/
private String inteltype;
/**
*
*/
private String remark;
/**
* id
*/
public void setRefid(Long refid) {
this.refid = refid;
}
/**
* id
*/
public Long getRefid() {
return refid;
}
/**
*
*/
public void setTablename(String tablename) {
this.tablename = tablename;
}
/**
*
*/
public String getTablename() {
return tablename;
}
/**
*
*/
public void setName(String name) {
this.name = name;
}
/**
*
*/
public String getName() {
return name;
}
/**
*
*/
public void setPicture(String picture) {
this.picture = picture;
}
/**
*
*/
public String getPicture() {
return picture;
}
/**
* (1:,21:,22:,31:,41:)
*/
public void setType(String type) {
this.type = type;
}
/**
* (1:,21:,22:,31:,41:)
*/
public String getType() {
return type;
}
/**
*
*/
public void setInteltype(String inteltype) {
this.inteltype = inteltype;
}
/**
*
*/
public String getInteltype() {
return inteltype;
}
/**
*
*/
public void setRemark(String remark) {
this.remark = remark;
}
/**
*
*/
public String getRemark() {
return remark;
}
}

@ -1,135 +0,0 @@
package com.entity.model;
import com.entity.SystemintroEntity;
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 2023-02-21 09:46:06
*/
public class SystemintroModel implements Serializable {
private static final long serialVersionUID = 1L;
/**
*
*/
private String subtitle;
/**
*
*/
private String content;
/**
* 1
*/
private String picture1;
/**
* 2
*/
private String picture2;
/**
* 3
*/
private String picture3;
/**
*
*/
public void setSubtitle(String subtitle) {
this.subtitle = subtitle;
}
/**
*
*/
public String getSubtitle() {
return subtitle;
}
/**
*
*/
public void setContent(String content) {
this.content = content;
}
/**
*
*/
public String getContent() {
return content;
}
/**
* 1
*/
public void setPicture1(String picture1) {
this.picture1 = picture1;
}
/**
* 1
*/
public String getPicture1() {
return picture1;
}
/**
* 2
*/
public void setPicture2(String picture2) {
this.picture2 = picture2;
}
/**
* 2
*/
public String getPicture2() {
return picture2;
}
/**
* 3
*/
public void setPicture3(String picture3) {
this.picture3 = picture3;
}
/**
* 3
*/
public String getPicture3() {
return picture3;
}
}

@ -1,42 +0,0 @@
package com.entity.view;
import com.entity.NewsEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import org.apache.commons.beanutils.BeanUtils;
import java.lang.reflect.InvocationTargetException;
import java.io.Serializable;
/**
*
*
* 使
/**
*
*
* 使
* @author
* @email
* @date 2023-02-21 09:46:06
*/
@TableName("news") // 指定该类对应的数据库表名为 "news"
public class NewsView extends NewsEntity implements Serializable {
private static final long serialVersionUID = 1L; // 序列化版本号
// 默认构造函数
public NewsView() {
}
// 构造函数,接受一个 NewsEntity 对象并复制其属性
public NewsView(NewsEntity newsEntity) {
try {
BeanUtils.copyProperties(this, newsEntity); // 使用 BeanUtils 复制属性
} catch (IllegalAccessException | InvocationTargetException e) {
// 捕获并处理属性复制过程中的异常
e.printStackTrace(); // 打印异常堆栈跟踪
}
}
}

@ -1,37 +0,0 @@
package com.entity.view;
import com.entity.StoreupEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import org.apache.commons.beanutils.BeanUtils;
import java.lang.reflect.InvocationTargetException;
import java.io.Serializable;
/**
*
*
* 使
* @author
* @email
* @date 2023-02-21 09:46:06
*/
@TableName("storeup") // 指定该类对应的数据库表名为 "storeup"
public class StoreupView extends StoreupEntity implements Serializable {
private static final long serialVersionUID = 1L; // 序列化版本号
// 默认构造函数
public StoreupView() {
}
// 构造函数,接受一个 StoreupEntity 对象并复制其属性
public StoreupView(StoreupEntity storeupEntity) {
try {
BeanUtils.copyProperties(this, storeupEntity); // 使用 BeanUtils 复制属性
} catch (IllegalAccessException | InvocationTargetException e) {
// 捕获并处理属性复制过程中的异常
e.printStackTrace(); // 打印异常堆栈跟踪
}
}
}

@ -1,36 +0,0 @@
package com.entity.view;
import com.entity.SystemintroEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import org.apache.commons.beanutils.BeanUtils;
import java.lang.reflect.InvocationTargetException;
import java.io.Serializable;
/**
*
*
* 使
* @author
* @email
* @date 2023-02-21 09:46:06
*/
@TableName("systemintro")
public class SystemintroView extends SystemintroEntity implements Serializable {
private static final long serialVersionUID = 1L;
public SystemintroView(){
}
public SystemintroView(SystemintroEntity systemintroEntity){
try {
BeanUtils.copyProperties(this, systemintroEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

@ -1,91 +0,0 @@
package com.entity.vo;
import com.entity.NewsEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
/**
*
*
*
* @author
* @email
* @date 2023-02-21 09:46:06
*/
public class NewsVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
*
*/
private String introduction;
/**
*
*/
private String picture;
/**
*
*/
private String content;
/**
*
*/
public void setIntroduction(String introduction) {
this.introduction = introduction;
}
/**
*
*/
public String getIntroduction() {
return introduction;
}
/**
*
*/
public void setPicture(String picture) {
this.picture = picture;
}
/**
*
*/
public String getPicture() {
return picture;
}
/**
*
*/
public void setContent(String content) {
this.content = content;
}
/**
*
*/
public String getContent() {
return content;
}
}

@ -1,179 +0,0 @@
package com.entity.vo;
import com.entity.StoreupEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
/**
*
*
*
* @author
* @email
* @date 2023-02-21 09:46:06
*/
public class StoreupVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* id
*/
private Long refid;
/**
*
*/
private String tablename;
/**
*
*/
private String name;
/**
*
*/
private String picture;
/**
* (1:,21:,22:,31:,41:)
*/
private String type;
/**
*
*/
private String inteltype;
/**
*
*/
private String remark;
/**
* id
*/
public void setRefid(Long refid) {
this.refid = refid;
}
/**
* id
*/
public Long getRefid() {
return refid;
}
/**
*
*/
public void setTablename(String tablename) {
this.tablename = tablename;
}
/**
*
*/
public String getTablename() {
return tablename;
}
/**
*
*/
public void setName(String name) {
this.name = name;
}
/**
*
*/
public String getName() {
return name;
}
/**
*
*/
public void setPicture(String picture) {
this.picture = picture;
}
/**
*
*/
public String getPicture() {
return picture;
}
/**
* (1:,21:,22:,31:,41:)
*/
public void setType(String type) {
this.type = type;
}
/**
* (1:,21:,22:,31:,41:)
*/
public String getType() {
return type;
}
/**
*
*/
public void setInteltype(String inteltype) {
this.inteltype = inteltype;
}
/**
*
*/
public String getInteltype() {
return inteltype;
}
/**
*
*/
public void setRemark(String remark) {
this.remark = remark;
}
/**
*
*/
public String getRemark() {
return remark;
}
}

@ -1,135 +0,0 @@
package com.entity.vo;
import com.entity.SystemintroEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
/**
*
*
*
* @author
* @email
* @date 2023-02-21 09:46:06
*/
public class SystemintroVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
*
*/
private String subtitle;
/**
*
*/
private String content;
/**
* 1
*/
private String picture1;
/**
* 2
*/
private String picture2;
/**
* 3
*/
private String picture3;
/**
*
*/
public void setSubtitle(String subtitle) {
this.subtitle = subtitle;
}
/**
*
*/
public String getSubtitle() {
return subtitle;
}
/**
*
*/
public void setContent(String content) {
this.content = content;
}
/**
*
*/
public String getContent() {
return content;
}
/**
* 1
*/
public void setPicture1(String picture1) {
this.picture1 = picture1;
}
/**
* 1
*/
public String getPicture1() {
return picture1;
}
/**
* 2
*/
public void setPicture2(String picture2) {
this.picture2 = picture2;
}
/**
* 2
*/
public String getPicture2() {
return picture2;
}
/**
* 3
*/
public void setPicture3(String picture3) {
this.picture3 = picture3;
}
/**
* 3
*/
public String getPicture3() {
return picture3;
}
}

@ -1,37 +0,0 @@
package com.service;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.service.IService;
import com.utils.PageUtils;
import com.entity.NewsEntity;
import java.util.List;
import java.util.Map;
import com.entity.vo.NewsVO;
import org.apache.ibatis.annotations.Param;
import com.entity.view.NewsView;
/**
*
*
* @author // 作者信息
* @email // 邮箱信息
* @date 2023-02-21 09:46:06 // 创建日期
*/
public interface NewsService extends IService<NewsEntity> { // 声明一个接口,扩展 IService 用于基本的 CRUD 操作
PageUtils queryPage(Map<String, Object> params); // 根据传入的参数进行分页查询,并返回分页结果
List<NewsVO> selectListVO(Wrapper<NewsEntity> wrapper); // 根据条件包装器查询并返回 NewsVO 列表
NewsVO selectVO(@Param("ew") Wrapper<NewsEntity> wrapper); // 根据条件包装器查询并返回单个 NewsVO 对象
List<NewsView> selectListView(Wrapper<NewsEntity> wrapper); // 根据条件包装器查询并返回 NewsView 列表
NewsView selectView(@Param("ew") Wrapper<NewsEntity> wrapper); // 根据条件包装器查询并返回单个 NewsView 对象
PageUtils queryPage(Map<String, Object> params, Wrapper<NewsEntity> wrapper); // 根据参数和条件包装器进行分页查询,并返回分页结果
}

@ -1,36 +0,0 @@
package com.service;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.service.IService;
import com.utils.PageUtils;
import com.entity.StoreupEntity;
import java.util.List;
import java.util.Map;
import com.entity.vo.StoreupVO;
import org.apache.ibatis.annotations.Param;
import com.entity.view.StoreupView;
/**
*
*
* @author // 作者信息
* @email // 邮箱信息
* @date 2023-02-21 09:46:06 // 创建日期
*/
public interface StoreupService extends IService<StoreupEntity> { // 声明一个接口,扩展 IService 用于基本的 CRUD 操作
PageUtils queryPage(Map<String, Object> params); // 根据传入的参数进行分页查询,并返回分页结果
List<StoreupVO> selectListVO(Wrapper<StoreupEntity> wrapper); // 根据条件包装器查询并返回 StoreupVO 列表
StoreupVO selectVO(@Param("ew") Wrapper<StoreupEntity> wrapper); // 根据条件包装器查询并返回单个 StoreupVO 对象
List<StoreupView> selectListView(Wrapper<StoreupEntity> wrapper); // 根据条件包装器查询并返回 StoreupView 列表
StoreupView selectView(@Param("ew") Wrapper<StoreupEntity> wrapper); // 根据条件包装器查询并返回单个 StoreupView 对象
PageUtils queryPage(Map<String, Object> params, Wrapper<StoreupEntity> wrapper); // 根据参数和条件包装器进行分页查询,并返回分页结果
}

@ -1,35 +0,0 @@
package com.service;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.service.IService;
import com.utils.PageUtils;
import com.entity.SystemintroEntity;
import java.util.List;
import java.util.Map;
import com.entity.vo.SystemintroVO;
import org.apache.ibatis.annotations.Param;
import com.entity.view.SystemintroView;
/**
*
*
* @author // 作者信息
* @email // 邮箱信息
* @date 2023-02-21 09:46:06 // 创建日期
*/
public interface SystemintroService extends IService<SystemintroEntity> { // 声明一个接口,扩展 IService 用于基本的 CRUD 操作
PageUtils queryPage(Map<String, Object> params); // 根据传入的参数进行分页查询,并返回分页结果
List<SystemintroVO> selectListVO(Wrapper<SystemintroEntity> wrapper); // 根据条件包装器查询并返回 SystemintroVO 列表
SystemintroVO selectVO(@Param("ew") Wrapper<SystemintroEntity> wrapper); // 根据条件包装器查询并返回单个 SystemintroVO 对象
List<SystemintroView> selectListView(Wrapper<SystemintroEntity> wrapper); // 根据条件包装器查询并返回 SystemintroView 列表
SystemintroView selectView(@Param("ew") Wrapper<SystemintroEntity> wrapper); // 根据条件包装器查询并返回单个 SystemintroView 对象
PageUtils queryPage(Map<String, Object> params, Wrapper<SystemintroEntity> wrapper); // 根据参数和条件包装器进行分页查询,并返回分页结果
}

@ -1,25 +0,0 @@
package com.service;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.annotations.Param;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.service.IService;
import com.entity.UsersEntity;
import com.utils.PageUtils;
/**
*
*/
public interface UsersService extends IService<UsersEntity> { // 声明一个接口,扩展 IService用于基本的 CRUD 操作
PageUtils queryPage(Map<String, Object> params); // 根据传入的参数进行分页查询,并返回分页结果
List<UsersEntity> selectListView(Wrapper<UsersEntity> wrapper); // 根据条件包装器查询并返回 UsersEntity 列表
PageUtils queryPage(Map<String, Object> params, Wrapper<UsersEntity> wrapper); // 根据参数和条件包装器进行分页查询,并返回分页结果
}

@ -1,69 +0,0 @@
package com.service.impl;
import org.springframework.stereotype.Service;
import java.util.Map;
import java.util.List;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.utils.PageUtils;
import com.utils.Query;
import com.dao.NewsDao;
import com.entity.NewsEntity;
import com.service.NewsService;
import com.entity.vo.NewsVO;
import com.entity.view.NewsView;
@Service("newsService") // 声明该类为服务层组件,并指定服务名称为 "newsService"
public class NewsServiceImpl extends ServiceImpl<NewsDao, NewsEntity> implements NewsService {
// 实现分页查询
@Override
public PageUtils queryPage(Map<String, Object> params) {
// 创建一个分页对象,使用传入的参数获取页面信息
Page<NewsEntity> page = this.selectPage(
new Query<NewsEntity>(params).getPage(), // 获取分页对象
new EntityWrapper<NewsEntity>() // 构建查询条件的包装器
);
return new PageUtils(page); // 返回分页结果包装
}
// 实现带条件的分页查询
@Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<NewsEntity> wrapper) {
// 创建分页对象
Page<NewsView> page = new Query<NewsView>(params).getPage();
// 设置页面记录
page.setRecords(baseMapper.selectListView(page, wrapper));
PageUtils pageUtil = new PageUtils(page); // 包装分页结果
return pageUtil; // 返回分页结果
}
// 查询符合条件的所有 NewsVO 对象
@Override
public List<NewsVO> selectListVO(Wrapper<NewsEntity> wrapper) {
return baseMapper.selectListVO(wrapper); // 调用 DAO 层方法执行查询
}
// 查询单个 NewsVO 对象
@Override
public NewsVO selectVO(Wrapper<NewsEntity> wrapper) {
return baseMapper.selectVO(wrapper); // 调用 DAO 层方法执行查询
}
// 查询符合条件的所有 NewsView 对象
@Override
public List<NewsView> selectListView(Wrapper<NewsEntity> wrapper) {
return baseMapper.selectListView(wrapper); // 调用 DAO 层方法执行查询
}
// 查询单个 NewsView 对象
@Override
public NewsView selectView(Wrapper<NewsEntity> wrapper) {
return baseMapper.selectView(wrapper); // 调用 DAO 层方法执行查询
}
}

@ -1,68 +0,0 @@
package com.service.impl;
import org.springframework.stereotype.Service;
import java.util.Map;
import java.util.List;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.utils.PageUtils;
import com.utils.Query;
import com.dao.StoreupDao;
import com.entity.StoreupEntity;
import com.service.StoreupService;
import com.entity.vo.StoreupVO;
import com.entity.view.StoreupView;
@Service("storeupService") // 将该类标记为服务,并指定 bean 的名称为 "storeupService"
public class StoreupServiceImpl extends ServiceImpl<StoreupDao, StoreupEntity> implements StoreupService {
@Override
public PageUtils queryPage(Map<String, Object> params) {
// 根据传入的参数创建分页对象,并调用 selectPage 方法获取数据
Page<StoreupEntity> page = this.selectPage(
new Query<StoreupEntity>(params).getPage(), // 构造分页信息
new EntityWrapper<StoreupEntity>() // 创建 EntityWrapper 用于封装查询条件
);
// 返回封装好的分页结果
return new PageUtils(page);
}
@Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<StoreupEntity> wrapper) {
// 创建分页对象
Page<StoreupView> page = new Query<StoreupView>(params).getPage();
// 设置分页记录
page.setRecords(baseMapper.selectListView(page, wrapper)); // 根据分页信息和条件查询数据
// 返回封装好的分页结果
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
@Override
public List<StoreupVO> selectListVO(Wrapper<StoreupEntity> wrapper) {
// 根据 Wrapper 条件查询并返回 StoreupVO 列表
return baseMapper.selectListVO(wrapper);
}
@Override
public StoreupVO selectVO(Wrapper<StoreupEntity> wrapper) {
// 根据 Wrapper 条件查询并返回单个 StoreupVO 对象
return baseMapper.selectVO(wrapper);
}
@Override
public List<StoreupView> selectListView(Wrapper<StoreupEntity> wrapper) {
// 根据 Wrapper 条件查询并返回 StoreupView 列表
return baseMapper.selectListView(wrapper);
}
@Override
public StoreupView selectView(Wrapper<StoreupEntity> wrapper) {
// 根据 Wrapper 条件查询并返回单个 StoreupView 对象
return baseMapper.selectView(wrapper);
}
}

@ -1,68 +0,0 @@
package com.service.impl;
import org.springframework.stereotype.Service;
import java.util.Map;
import java.util.List;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.utils.PageUtils;
import com.utils.Query;
import com.dao.SystemintroDao;
import com.entity.SystemintroEntity;
import com.service.SystemintroService;
import com.entity.vo.SystemintroVO;
import com.entity.view.SystemintroView;
@Service("systemintroService") // 将该类标记为服务,并指定 bean 的名称为 "systemintroService"
public class SystemintroServiceImpl extends ServiceImpl<SystemintroDao, SystemintroEntity> implements SystemintroService {
@Override
public PageUtils queryPage(Map<String, Object> params) {
// 根据传入的参数创建分页对象,并调用 selectPage 方法获取数据
Page<SystemintroEntity> page = this.selectPage(
new Query<SystemintroEntity>(params).getPage(), // 构造分页信息
new EntityWrapper<SystemintroEntity>() // 创建 EntityWrapper 用于封装查询条件
);
// 返回封装好的分页结果
return new PageUtils(page);
}
@Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<SystemintroEntity> wrapper) {
// 创建分页对象
Page<SystemintroView> page = new Query<SystemintroView>(params).getPage();
// 设置分页记录
page.setRecords(baseMapper.selectListView(page, wrapper)); // 根据分页信息和条件查询数据
// 返回封装好的分页结果
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
@Override
public List<SystemintroVO> selectListVO(Wrapper<SystemintroEntity> wrapper) {
// 根据 Wrapper 条件查询并返回 SystemintroVO 列表
return baseMapper.selectListVO(wrapper);
}
@Override
public SystemintroVO selectVO(Wrapper<SystemintroEntity> wrapper) {
// 根据 Wrapper 条件查询并返回单个 SystemintroVO 对象
return baseMapper.selectVO(wrapper);
}
@Override
public List<SystemintroView> selectListView(Wrapper<SystemintroEntity> wrapper) {
// 根据 Wrapper 条件查询并返回 SystemintroView 列表
return baseMapper.selectListView(wrapper);
}
@Override
public SystemintroView selectView(Wrapper<SystemintroEntity> wrapper) {
// 根据 Wrapper 条件查询并返回单个 SystemintroView 对象
return baseMapper.selectView(wrapper);
}
}

@ -1,54 +0,0 @@
package com.service.impl;
import java.util.List;
import java.util.Map;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.dao.UsersDao;
import com.entity.UsersEntity;
import com.service.UsersService;
import com.utils.PageUtils;
import com.utils.Query;
/**
*
*/
@Service("usersService") // 将该类标记为服务,并指定 bean 的名称为 "usersService"
public class UsersServiceImpl extends ServiceImpl<UsersDao, UsersEntity> implements UsersService {
@Override
public PageUtils queryPage(Map<String, Object> params) {
// 根据传入的参数创建分页对象,并调用 selectPage 方法获取用户数据
Page<UsersEntity> page = this.selectPage(
new Query<UsersEntity>(params).getPage(), // 构造分页信息
new EntityWrapper<UsersEntity>() // 创建 EntityWrapper 用于封装查询条件
);
// 返回封装好的分页结果
return new PageUtils(page);
}
@Override
public List<UsersEntity> selectListView(Wrapper<UsersEntity> wrapper) {
// 根据 Wrapper 条件查询并返回 UsersEntity 列表
return baseMapper.selectListView(wrapper);
}
@Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<UsersEntity> wrapper) {
// 创建分页对象
Page<UsersEntity> page = new Query<UsersEntity>(params).getPage();
// 设置分页记录
page.setRecords(baseMapper.selectListView(page, wrapper)); // 根据分页信息和条件查询数据
// 返回封装好的分页结果
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
}

@ -1 +0,0 @@
Subproject commit cc7b302c004f658cc1d4cc64d5b66b62471ab275
Loading…
Cancel
Save