p6zkavi9o
/
club_system
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Labels Milestones
New Pull Request

zhushi #8

Closed
pfvaqhn2p wants to merge 2 commits from branch-wangjy into develop_idea
Conversation 0 Commits 2 Files Changed 24
24 changed files with 1528 additions and 994 deletions
Show Stats Download Patch File Download Diff File

6
springboota009社团管理系统/代码/AssociationManagerApi - idea/.idea/vcs.xml
Unescape View File

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

150
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/ActiveLogsController.java
Unescape View File

@ -1,119 +1,161 @@
package com.rabbiter.association.controller;
// 引入相关服务接口
import com.rabbiter.association.service.ActiveLogsService;
import com.rabbiter.association.service.UsersService;
// 引入日志框架
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
// 引入Spring框架的注解，用于依赖注入和声明控制器
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
// 引入Web请求映射和响应注解
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
// 引入实体类
import com.rabbiter.association.entity.Users;
import com.rabbiter.association.entity.ActiveLogs;
// 引入缓存处理类
import com.rabbiter.association.handle.CacheHandle;
// 引入工具类
import com.rabbiter.association.utils.DateUtils;
import com.rabbiter.association.utils.IDUtils;
// 引入自定义响应类
import com.rabbiter.association.msg.R;
import com.rabbiter.association.entity.ActiveLogs;
// 引入Java集合框架
import java.util.List;
import java.util.Map;
/**
* 系统请求响应控制器
* 报名记录
* 系统请求响应控制器，负责处理报名记录相关的请求。
*/
@Controller
@RequestMapping("/activeLogs")
@Controller // 标识为Spring MVC控制器
@RequestMapping("/activeLogs") // 设置类级别的请求映射路径
public class ActiveLogsController extends BaseController {
// 使用SLF4J记录日志
protected static final Logger Log = LoggerFactory.getLogger(ActiveLogsController.class);
// 通过@Autowired注解实现依赖注入
@Autowired
private CacheHandle cacheHandle;
private CacheHandle cacheHandle; // 缓存处理类
@Autowired
private UsersService usersService;
private UsersService usersService; // 用户服务类
@Autowired
private ActiveLogsService activeLogsService;
private ActiveLogsService activeLogsService; // 报名记录服务类
@RequestMapping("")
/**
* 渲染报名记录页面。
* 请求映射到空路径，返回报名记录页面的视图名称。
*/
@RequestMapping("") // 映射空路径到index方法
public String index() {
return "pages/ActiveLogs";
return "pages/ActiveLogs"; // 返回报名记录页面的视图名称
}
@GetMapping("/info")
@ResponseBody
/**
* 查询单个报名记录的详细信息。
* 通过HTTP GET请求和报名记录ID获取详细信息。
*
* @param id 报名记录ID
* @return 返回包含报名记录信息的响应对象
*/
@GetMapping("/info") // 映射/info路径到GET方法
@ResponseBody // 标识方法返回值作为响应体
public R getInfo(String id) {
Log.info("查询单个报名记录，ID：{}", id); // 记录查询日志
Log.info("查找指定报名记录，ID：{}", id);
ActiveLogs activeLogs = activeLogsService.getOne(id);
ActiveLogs activeLogs = activeLogsService.getOne(id); // 根据ID查询报名记录
return R.successData(activeLogs);
return R.successData(activeLogs); // 返回包含报名记录信息的响应
}
@GetMapping("/list")
@ResponseBody
/**
* 查询活动的报名记录列表。
* 通过HTTP GET请求和活动ID获取报名记录列表。
*
* @param activeId 活动ID
* @return 返回包含报名记录列表的响应对象
*/
@GetMapping("/list") // 映射/list路径到GET方法
@ResponseBody // 标识方法返回值作为响应体
public R getList(String activeId) {
Log.info("查询活动的报名记录，活动ID：{}", activeId); // 记录查询日志
Log.info("获取指定活动的报名记录，活动ID：{}", activeId);
List<Map<String, Object>> list = activeLogsService.getListByActiveId(activeId); // 根据活动ID查询报名记录列表
List<Map<String, Object>> list = activeLogsService.getListByActiveId(activeId);
return R.successData(list);
return R.successData(list); // 返回包含报名记录列表的响应
}
@PostMapping("/add")
@ResponseBody
/**
* 创建新的报名记录。
* 通过HTTP POST请求和报名记录信息创建新的报名记录。
*
* @param token 用户token
* @param activeLogs 报名记录信息
* @return 返回操作结果的响应对象
*/
@PostMapping("/add") // 映射/add路径到POST方法
@ResponseBody // 标识方法返回值作为响应体
public R addInfo(String token, ActiveLogs activeLogs) {
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); // 根据token查询用户信息
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));
if(activeLogsService.isActive(activeLogs.getActiveId(), user.getId())){
activeLogs.setId(IDUtils.makeIDByCurrent());
activeLogs.setUserId(user.getId());
activeLogs.setCreateTime(DateUtils.getNowDate());
Log.info("添加报名记录，传入参数：{}", activeLogs);
if (activeLogsService.isActive(activeLogs.getActiveId(), user.getId())) { // 检查用户是否已参与该活动
activeLogs.setId(IDUtils.makeIDByCurrent()); // 生成唯一的报名记录ID
activeLogs.setUserId(user.getId()); // 设置报名用户的ID
activeLogs.setCreateTime(DateUtils.getNowDate()); // 设置报名的创建时间
activeLogsService.add(activeLogs);
Log.info("创建新的报名记录，传入参数：{}", activeLogs); // 记录创建日志
return R.success();
}else{
activeLogsService.add(activeLogs); // 调用服务类添加报名记录
return R.warn("该活动您已参与，请勿重复报名");
return R.success(); // 返回成功的响应
} else {
return R.warn("您已参与该活动，无需重复报名"); // 返回警告响应，提示用户已参与
}
}
@PostMapping("/upd")
@ResponseBody
/**
* 更新报名记录信息。
* 通过HTTP POST请求和报名记录信息更新指定的报名记录。
*
* @param activeLogs 报名记录信息
* @return 返回操作结果的响应对象
*/
@PostMapping("/upd") // 映射/upd路径到POST方法
@ResponseBody // 标识方法返回值作为响应体
public R updInfo(ActiveLogs activeLogs) {
Log.info("更新报名记录，传入参数：{}", activeLogs); // 记录更新日志
Log.info("修改报名记录，传入参数：{}", activeLogs);
activeLogsService.update(activeLogs); // 调用服务类更新报名记录
activeLogsService.update(activeLogs);
return R.success();
return R.success(); // 返回成功的响应
}
@PostMapping("/del")
@ResponseBody
/**
* 删除指定的报名记录。
* 通过HTTP POST请求和报名记录ID删除指定的报名记录。
*
* @param id 报名记录ID
* @return 返回操作结果的响应对象
*/
@PostMapping("/del") // 映射/del路径到POST方法
@ResponseBody // 标识方法返回值作为响应体
public R delInfo(String id) {
Log.info("删除报名记录, ID:{}", id); // 记录删除日志
Log.info("删除报名记录, ID:{}", id);
ActiveLogs activeLogs = activeLogsService.getOne(id);
ActiveLogs activeLogs = activeLogsService.getOne(id); // 根据ID查询报名记录
activeLogsService.delete(activeLogs);
activeLogsService.delete(activeLogs); // 调用服务类删除报名记录
return R.success();
return R.success(); // 返回成功的响应
}
}
}

52
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/ActivitiesController.java
Unescape View File

@ -1,26 +1,18 @@
package com.rabbiter.association.controller;
//声明该Java类所在的包名为com.rabbiter.association.controller。
import com.rabbiter.association.service.UsersService;
//导入UsersService类，用于处理用户相关的业务逻辑。
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
//导入slf4j日志框架的Logger和LoggerFactory，用于记录日志。
import org.springframework.beans.factory.annotation.Autowired;
//导入Autowired注解，用于自动装配依赖。
import org.springframework.stereotype.Controller;
//导入Controller注解，表明该类是一个Spring MVC中的控制器。
import org.springframework.util.ObjectUtils;
//用于对象工具操作
import org.springframework.web.bind.annotation.GetMapping;
//等用于处理Web请求映射
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import com.rabbiter.association.entity.Users;
//等导入实体类和工具类。
import com.rabbiter.association.handle.CacheHandle;
import com.rabbiter.association.utils.IDUtils;
import com.rabbiter.association.msg.R;
@ -29,32 +21,33 @@ import com.rabbiter.association.msg.PageData;
import com.rabbiter.association.entity.Activities;
import com.rabbiter.association.service.ActivitiesService;
//系统请求响应控制器
//活动信息
@Controller//注解将该类标记为Spring MVC的控制器。
@RequestMapping("/activities")//指定了该控制器处理的基本URL路径为/activities。
/**
* 系统请求响应控制器
* 活动信息
*/
@Controller
@RequestMapping("/activities")
public class ActivitiesController extends BaseController {
//定义了名为ActivitiesController的类，它继承自BaseController类。
protected static final Logger Log = LoggerFactory.getLogger(ActivitiesController.class);
//创建一个Logger对象，用于记录ActivitiesController类中的日志信息。
@Autowired
private CacheHandle cacheHandle;
//使用Autowired注解自动注入CacheHandle类型的依赖，用于处理缓存相关操作。
@Autowired
private UsersService usersService;
//自动注入UsersService，用于用户相关业务。
@Autowired
private ActivitiesService activitiesService;
//自动注入ActivitiesService，用于活动相关业务。
@RequestMapping("")
public String index() {
return "pages/Activities";
}
//当访问根路径（相对于/activities）时，该方法返回名为"pages/Activities"的视图名称。
@GetMapping("/info")
//@GetMapping表示处理HTTP GET请求，/info是相对于/activities的路径。
@ResponseBody
public R getInfo(String id) {
@ -64,12 +57,12 @@ public class ActivitiesController extends BaseController {
return R.successData(activities);
}
//该方法接收一个id参数，通过activitiesService.getOne(id)获取指定id的活动信息，然后使用R.successData(activities)返回包含活动信息的成功响应。
@GetMapping("/page")//处理/page路径的GET请求。
@GetMapping("/page")
@ResponseBody
public R getPageInfos(Long pageIndex, Long pageSize,
String token, String teamName, String activeName) {
//首先通过usersService.getOne(cacheHandle.getUserInfoCache(token))获取用户信息，如果用户不存在则返回登录信息不存在的错误。
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));
if(ObjectUtils.isEmpty(user)) {
return R.error("登录信息不存在，请重新登录");
@ -94,8 +87,8 @@ public class ActivitiesController extends BaseController {
return R.successData(page);
}
}
//根据用户类型（user.getType()）不同，分别调用activitiesService.getPageAll（普通情况）或activitiesService.getPageByUserId（特定用户类型）来进行分页查询活动信息，最后返回包含分页数据的成功响应。
@PostMapping("/add")//处理/add路径的POST请求。
@PostMapping("/add")
@ResponseBody
public R addInfo(Activities activities) {
@ -107,8 +100,8 @@ public class ActivitiesController extends BaseController {
return R.success();
}
//为传入的Activities对象设置id（通过IDUtils.makeIDByCurrent()），然后使用activitiesService.add(activities)添加活动信息，最后返回成功响应。
@PostMapping("/upd")//处理/upd路径的POST请求。
@PostMapping("/upd")
@ResponseBody
public R updInfo(Activities activities) {
@ -118,8 +111,8 @@ public class ActivitiesController extends BaseController {
return R.success();
}
//通过activitiesService.update(activities)修改活动信息，然后返回成功响应。
@PostMapping("/del")//处理/del路径的POST请求。
@PostMapping("/del")
@ResponseBody
public R delInfo(String id) {
@ -131,5 +124,4 @@ public class ActivitiesController extends BaseController {
return R.success();
}
}
//先通过activitiesService.getOne(id)获取要删除的活动对象，然后使用`activitiesService.delete
}

117
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/ApplyLogsController.java
Unescape View File

@ -1,10 +1,10 @@
package com.rabbiter.association.controller;
package com.rabbiter.association.controller;
import com.rabbiter.association.service.ApplyLogsService;
import com.rabbiter.association.service.UsersService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.util.ObjectUtils;
@ -23,8 +23,7 @@ import com.rabbiter.association.msg.PageData;
import com.rabbiter.association.entity.ApplyLogs;
/**
* 系统请求响应控制器
* 申请记录
* 系统请求响应控制器，负责处理申请记录相关的请求。
*/
@Controller
@RequestMapping("/applyLogs")
@ -33,31 +32,51 @@ public class ApplyLogsController extends BaseController {
protected static final Logger Log = LoggerFactory.getLogger(ApplyLogsController.class);
@Autowired
private CacheHandle cacheHandle;
private CacheHandle cacheHandle; // 提供缓存操作的服务
@Autowired
private UsersService usersService;
private UsersService usersService; // 提供用户信息操作的服务
@Autowired
private ApplyLogsService applyLogsService;
private ApplyLogsService applyLogsService; // 提供申请记录操作的服务
/**
* 渲染申请记录页面。
* 请求映射到空路径，返回申请记录页面的视图名称。
*/
@RequestMapping("")
public String index() {
return "pages/ApplyLogs";
return "pages/ApplyLogs"; // 返回申请记录页面的视图名称
}
/**
* 查询单个申请记录的详细信息。
* 通过HTTP GET请求和申请记录ID获取详细信息。
*
* @param id 申请记录ID
* @return 返回包含申请记录信息的响应对象
*/
@GetMapping("/info")
@ResponseBody
public R getInfo(String id) {
Log.info("查询单个申请记录，ID：{}", id); // 记录查询日志
Log.info("查找指定申请记录，ID：{}", id);
ApplyLogs applyLogs = applyLogsService.getOne(id); // 根据ID查询申请记录
ApplyLogs applyLogs = applyLogsService.getOne(id);
return R.successData(applyLogs);
return R.successData(applyLogs); // 返回包含申请记录信息的响应
}
/**
* 分页查询申请记录信息。
* 根据用户类型，查询不同的申请记录信息。
*
* @param pageIndex 当前页码
* @param pageSize 每页数据量
* @param token 用户token
* @param teamName 团队名称
* @param userName 用户姓名
* @return 返回包含分页申请记录信息的响应对象
*/
@GetMapping("/page")
@ResponseBody
public R getPageInfos(Long pageIndex, Long pageSize,
@ -69,8 +88,7 @@ public class ApplyLogsController extends BaseController {
}
if (user.getType() == 0) {
Log.info("分页查看全部申请记录，当前页码：{}，"
+ "每页数据量：{}, 模糊查询，团队名称：{}，用户姓名：{}", pageIndex,
Log.info("分页查询全部申请记录，当前页码：{}，每页数据量：{}, 模糊查询，团队名称：{}，用户姓名：{}", pageIndex,
pageSize, teamName, userName);
PageData page = applyLogsService.getPageInfo(pageIndex, pageSize, null, teamName, userName);
@ -79,8 +97,7 @@ public class ApplyLogsController extends BaseController {
} else if (user.getType() == 1) {
Log.info("团队管理员查看申请记录，当前页码：{}，"
+ "每页数据量：{}, 模糊查询，团队名称：{}，用户姓名：{}", pageIndex,
Log.info("团队管理员分页查询申请记录，当前页码：{}，每页数据量：{}, 模糊查询，团队名称：{}，用户姓名：{}", pageIndex,
pageSize, teamName, userName);
PageData page = applyLogsService.getManPageInfo(pageIndex, pageSize, user.getId(), teamName, userName);
@ -89,8 +106,7 @@ public class ApplyLogsController extends BaseController {
} else {
Log.info("分页用户相关申请记录，当前页码：{}，"
+ "每页数据量：{}, 模糊查询，团队名称：{}，用户姓名：{}", pageIndex,
Log.info("分页查询用户相关申请记录，当前页码：{}，每页数据量：{}, 模糊查询，团队名称：{}，用户姓名：{}", pageIndex,
pageSize, teamName, userName);
PageData page = applyLogsService.getPageInfo(pageIndex, pageSize, user.getId(), teamName, null);
@ -99,50 +115,69 @@ public class ApplyLogsController extends BaseController {
}
}
/**
* 创建新的申请记录。
* 通过HTTP POST请求和申请记录信息创建新的申请记录。
*
* @param token 用户token
* @param applyLogs 申请记录信息
* @return 返回操作结果的响应对象
*/
@PostMapping("/add")
@ResponseBody
public R addInfo(String token, ApplyLogs applyLogs) {
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); // 根据token查询用户信息
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));
if(applyLogsService.isApply(user.getId(), applyLogs.getTeamId())){
if(applyLogsService.isApply(user.getId(), applyLogs.getTeamId())) { // 检查用户是否已提交申请
applyLogs.setId(IDUtils.makeIDByCurrent());
applyLogs.setUserId(user.getId());
applyLogs.setCreateTime(DateUtils.getNowDate());
applyLogs.setId(IDUtils.makeIDByCurrent()); // 生成申请记录ID
applyLogs.setUserId(user.getId()); // 设置申请用户ID
applyLogs.setCreateTime(DateUtils.getNowDate()); // 设置申请时间
Log.info("添加申请记录，传入参数：{}", applyLogs);
Log.info("创建新的申请记录，传入参数：{}", applyLogs); // 记录创建日志
applyLogsService.add(applyLogs);
applyLogsService.add(applyLogs); // 添加申请记录
return R.success();
}else{
return R.warn("申请审核中，请耐心等待");
return R.success(); // 返回成功响应
} else {
return R.warn("您的申请正在审核中，请耐心等待"); // 返回警告响应，提示申请审核中
}
}
/**
* 更新申请记录信息。
* 通过HTTP POST请求和申请记录信息更新指定的申请记录。
*
* @param applyLogs 申请记录信息
* @return 返回操作结果的响应对象
*/
@PostMapping("/upd")
@ResponseBody
public R updInfo(ApplyLogs applyLogs) {
Log.info("更新申请记录，传入参数：{}", applyLogs); // 记录更新日志
Log.info("修改申请记录，传入参数：{}", applyLogs);
applyLogsService.update(applyLogs);
applyLogsService.update(applyLogs); // 更新申请记录
return R.success();
return R.success(); // 返回成功响应
}
/**
* 删除指定的申请记录。
* 通过HTTP POST请求和申请记录ID删除指定的申请记录。
*
* @param id 申请记录ID
* @return 返回操作结果的响应对象
*/
@PostMapping("/del")
@ResponseBody
public R delInfo(String id) {
Log.info("删除申请记录, ID:{}", id); // 记录删除日志
Log.info("删除申请记录, ID:{}", id);
ApplyLogs applyLogs = applyLogsService.getOne(id); // 根据ID查询申请记录
ApplyLogs applyLogs = applyLogsService.getOne(id);
applyLogsService.delete(applyLogs); // 删除申请记录
applyLogsService.delete(applyLogs);
return R.success();
return R.success(); // 返回成功响应
}
}
}

44
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/BaseController.java
Unescape View File

@ -1,4 +1,5 @@
package com.rabbiter.association.controller;
package com.rabbiter.association.controller;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
@ -7,39 +8,54 @@ import com.rabbiter.association.msg.R;
import javax.servlet.http.HttpSession;
/**
* 系统控制器抽象类
* 其他控制器需要继承这个控制器
* 系统控制器抽象类，提供基础的会话管理和异常处理功能。
* 其他控制器通过继承此类来复用这些功能。
*/
public abstract class BaseController {
/**
* 会话中用户信息的键名。
* 用于在会话中存储和检索登录用户的信息。
*/
protected static final String SESSION_USER = "user";
/**
* 获取登录用户的信息
* @param session 会话对象
* @return
* 从会话对象中检索登录用户的信息。
* 子类可以利用此方法来获取当前登录用户的信息。
*
* @param session 会话对象，用于存储和检索用户信息。
* @return 登录用户的信息对象，如果无用户登录则可能返回 null。
*/
protected Object getSessionUser(HttpSession session) {
return session.getAttribute(SESSION_USER);
}
/**
* 将登录用户信息记录到会话对象中
* @param session 会话对象
* @param user 登录用户信息
* 将登录用户信息存储到会话对象中。
* 子类可以在用户登录后利用此方法将用户信息存储到会话中。
*
* @param session 会话对象，用于存储用户信息。
* @param user 登录用户的信息对象。
*/
protected void setSessionUser(HttpSession session, Object user) {
session.setAttribute(SESSION_USER, user);
}
// @ExceptionHandler(Exception.class)
/**
* 捕获并处理控制器中抛出的异常。
* 此方法通过 @ExceptionHandler 注解标记，用于捕获控制器中抛出的异常。
* 方法的返回值通过 @ResponseBody 注解标记，表示异常处理的结果将直接作为 HTTP 响应体返回。
*
* @param e 抛出的异常对象。
* @return 一个 R 对象，表示异常处理的结果。
*/
@ExceptionHandler(Exception.class)
@ResponseBody
public R exception(Exception e) {
e.printStackTrace(); // 输出异常堆栈信息，便于调试。
e.printStackTrace();
// 返回一个包含错误信息的 R 对象，R 是一个自定义的响应消息类。
return R.error();
}
}

176
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/controller/IndexController.java
Unescape View File

@ -18,6 +18,9 @@ import com.rabbiter.association.utils.IDUtils;
import javax.servlet.http.HttpSession;
import java.util.List;
/**
* 系统请求响应控制器，负责处理首页相关的请求。
*/
@Controller
@RequestMapping("/")
public class IndexController extends BaseController {
@ -25,125 +28,156 @@ public class IndexController extends BaseController {
private static final Logger Log = LoggerFactory.getLogger(IndexController.class);
@Autowired
private UsersService usersService;
private UsersService usersService; // 注入用户服务类
@Autowired
private CacheHandle cacheHandle;
private CacheHandle cacheHandle; // 注入缓存处理类
@Autowired
private NoticesService noticesService;
private NoticesService noticesService; // 注入通知服务类
/**
* 获取通知列表。
* <p>根据用户类型获取不同的通知列表。</p>
*
* @param token 用户token
* @return 返回包含通知列表的响应对象
*/
@GetMapping("/sys/notices")
@ResponseBody
public R getNoticeList(String token){
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));
if(ObjectUtils.isEmpty(user)) {
return R.error("登录信息不存在，请重新登录");
public R getNoticeList(String token) {
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); // 通过token获取用户信息
if (ObjectUtils.isEmpty(user)) { // 检查用户信息是否存在
return R.error("登录信息不存在，请重新登录"); // 用户信息不存在时返回错误响应
}
if(user.getType() == 0){
List<Notices> list = noticesService.getSysNotices();
return R.successData(list);
}else if(user.getType() == 1){
List<Notices> list = noticesService.getManNotices(user.getId());
return R.successData(list);
}else{
List<Notices> list = noticesService.getMemNotices(user.getId());
return R.successData(list);
// 根据用户类型获取通知列表
List<Notices> list;
if (user.getType() == 0) {
list = noticesService.getSysNotices(); // 系统通知
} else if (user.getType() == 1) {
list = noticesService.getManNotices(user.getId()); // 团队管理员通知
} else {
list = noticesService.getMemNotices(user.getId()); // 普通成员通知
}
return R.successData(list); // 返回成功响应，包含通知列表
}
/**
* 用户登录。
* <p>处理用户登录请求，验证用户名和密码。</p>
*
* @param userName 用户名
* @param passWord 密码
* @param session HttpSession对象
* @return 返回登录结果的响应对象
*/
@PostMapping("/login")
@ResponseBody
public R login(String userName, String passWord, HttpSession session){
Log.info("用户登录，用户名：{}， 用户密码：{}", userName, passWord);
Users user = usersService.getUserByUserName(userName);
if(user == null) {
public R login(String userName, String passWord, HttpSession session) {
Log.info("用户登录，用户名：{}， 用户密码：{}", userName, passWord); // 记录日志
return R.error("输入的用户名不存在");
}else {
Users user = usersService.getUserByUserName(userName); // 根据用户名获取用户信息
if(passWord.equals(user.getPassWord().trim())) {
if (user == null) {
return R.error("输入的用户名不存在"); // 用户不存在时返回错误响应
} else {
if (passWord.equals(user.getPassWord().trim())) { // 验证密码
String token = IDUtils.makeIDByUUID(); // 生成token
cacheHandle.addUserCache(token, user.getId()); // 将用户信息存储到缓存
String token = IDUtils.makeIDByUUID();
cacheHandle.addUserCache(token, user.getId());
return R.success("登录成功", token);
}else {
return R.error("输入的密码错误");
return R.success("登录成功", token); // 返回成功响应，包含token
} else {
return R.error("输入的密码错误"); // 密码错误时返回错误响应
}
}
}
/**
* 用户退出。
* <p>处理用户退出请求，移除缓存中的用户信息。</p>
*
* @param token 用户token
* @return 返回操作结果的响应对象
*/
@RequestMapping("/exit")
@ResponseBody
public R exit(String token) {
Log.info("用户退出系统并移除登录信息"); // 记录日志
Log.info("用户退出系统并移除登录信息");
cacheHandle.removeUserCache(token); // 从缓存中移除用户信息
cacheHandle.removeUserCache(token);
return R.success();
return R.success(); // 返回成功响应
}
/**
* 获取用户信息。
* <p>根据token获取用户信息。</p>
*
* @param token 用户token
* @return 返回包含用户信息的响应对象
*/
@GetMapping("/info")
@ResponseBody
public R info(String token){
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));
public R info(String token) {
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); // 通过token获取用户信息
return R.successData(user);
return R.successData(user); // 返回成功响应，包含用户信息
}
/**
* 修改用户信息。
* <p>根据用户信息更新用户数据。</p>
*
* @param user 用户信息
* @return 返回操作结果的响应对象
*/
@PostMapping("/info")
@ResponseBody
public R info(Users user){
Log.info("修改用户信息，{}", user);
public R info(Users user) {
Log.info("修改用户信息，{}", user); // 记录日志
usersService.update(user);
usersService.update(user); // 更新用户信息
return R.success();
return R.success(); // 返回成功响应
}
/**
* 检查密码。
* <p>验证原始密码是否正确。</p>
*
* @param oldPwd 原始密码
* @param token 用户token
* @return 返回密码验证结果的响应对象
*/
@RequestMapping("/checkPwd")
@ResponseBody
public R checkPwd(String oldPwd, String token) {
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); // 通过token获取用户信息
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));
if(oldPwd.equals(user.getPassWord())) {
return R.success();
}else {
return R.warn("原始密码和输入密码不一致");
if (oldPwd.equals(user.getPassWord())) { // 验证密码
return R.success(); // 密码正确时返回成功响应
} else {
return R.warn("原始密码和输入密码不一致"); // 密码错误时返回警告响应
}
}
/**
* 修改密码。
* <p>根据新密码更新用户密码。</p>
*
* @param token 用户token
* @param password 新密码
* @return 返回操作结果的响应对象
*/
@PostMapping("/pwd")
@ResponseBody
public R pwd(String token, String password) {
Log.info("修改用户密码，{}", password); // 记录日志
Log.info("修改用户密码，{}", password);
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));
user.setPassWord(password);
usersService.update(user);
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); // 通过token获取用户信息
user.setPassWord(password); // 设置新密码
usersService.update(user); // 更新用户信息
return R.success();
return R.success(); // 返回成功响应
}
}

16
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/dao/ActiveLogsDao.java
Unescape View File

@ -1,17 +1,19 @@
package com.rabbiter.association.dao;
// 引入Spring框架的Repository注解，标识这是一个数据访问对象（DAO）
import org.springframework.stereotype.Repository;
// 引入MyBatis Plus的BaseMapper接口，提供基础的CRUD操作
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
// 引入活动日志实体类
import com.rabbiter.association.entity.ActiveLogs;
/**
* 数据层处理接口
* 报名记录
* 数据访问层接口，用于处理与报名记录相关的数据库操作。
* 继承自MyBatis Plus的BaseMapper，提供CRUD操作。
*/
// 使用@Repository注解标识该接口为Spring的一个Repository，并给其指定一个唯一的bean名称
@Repository("activeLogsDao")
public interface ActiveLogsDao extends BaseMapper<ActiveLogs> {
}
// 该接口继承BaseMapper后已经包含了基本的CRUD操作，无需额外定义方法
// 可以根据需要添加自定义的数据库操作方法
}

79
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/dao/ApplyLogsDao.java
Unescape View File

@ -1,45 +1,53 @@
package com.rabbiter.association.dao;
// 引入MyBatis Plus的分页插件
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
// 引入MyBatis的注解，用于动态SQL
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
// 引入Spring的注解，标识这是一个Repository
import org.springframework.stereotype.Repository;
// 引入MyBatis Plus的基础Mapper接口
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
// 引入应用日志实体类
import com.rabbiter.association.entity.ApplyLogs;
// 引入Java的Map接口，用于存储键值对
import java.util.Map;
/**
* 数据层处理接口
* 申请记录
* 数据访问层接口，用于处理与申请记录相关的数据库操作。
* 继承自MyBatis Plus的BaseMapper，提供CRUD操作。
*/
@Repository("applyLogsDao")
@Repository("applyLogsDao") // Spring容器中的唯一标识
public interface ApplyLogsDao extends BaseMapper<ApplyLogs> {
/**
* 分页查询申请记录
* @param page 分页参数
* @param userId 用户ID
* @param teamName 社团名称
* @param userName 用户姓名
* @return
* 分页查询申请记录。
* 使用MyBatis动态SQL功能构建查询条件。
*
* @param page 分页参数，包含分页和排序信息
* @param userId 用户ID，用于过滤申请记录
* @param teamName 社团名称，用于过滤申请记录
* @param userName 用户姓名，用于过滤申请记录
* @return 分页的申请记录结果集，每条记录是一个Map对象
*/
@Select("<script>" +
"SELECT " +
"al.id, al.status, al.create_time createTime, al.team_id teamId, al.user_id userId, " +
"t.name teamName, u.name userName, u.gender userGender, u.age userAge, u.phone userPhone " +
"FROM apply_logs al, teams t, users u " +
"al.id, al.status, al.create_time as createTime, al.team_id as teamId, al.user_id as userId, " +
"t.name as teamName, u.name as userName, u.gender as userGender, u.age as userAge, u.phone as userPhone " +
"FROM apply_logs al " +
"JOIN teams t ON al.team_id = t.id " +
"JOIN users u ON al.user_id = u.id " +
"<where> " +
"al.user_id = u.id AND al.team_id = t.id " +
"<if test='teamName != null and teamName.trim() != &quot;&quot; '>" +
"<if test='teamName != null and teamName.trim() != \"\" '>" +
"AND t.name LIKE CONCAT('%', #{teamName}, '%') " +
"</if>" +
"<if test='userName != null and userName.trim() != &quot;&quot; '>" +
"<if test='userName != null and userName.trim() != \"\" '>" +
"AND u.name LIKE CONCAT('%', #{userName}, '%') " +
"</if>" +
"<if test='userId != null and userId.trim() != &quot;&quot; '>" +
"<if test='userId != null and userId.trim() != \"\" '>" +
"AND al.user_id = #{userId} " +
"</if>" +
"</where>" +
@ -51,34 +59,37 @@ public interface ApplyLogsDao extends BaseMapper<ApplyLogs> {
@Param("userName") String userName);
/**
* 分页查询申请记录
* @param page 分页参数
* @param userId 用户ID
* @param teamName 社团名称
* @param userName 用户姓名
* @return
* 分页查询申请记录，特别为管理员设计。
* 与qryPageInfo类似，但额外支持根据管理员ID过滤申请记录。
*
* @param page 分页参数，包含分页和排序信息
* @param userId 用户ID，用于过滤申请记录
* @param teamName 社团名称，用于过滤申请记录
* @param userName 用户姓名，用于过滤申请记录
* @return 分页的申请记录结果集，每条记录是一个Map对象
*/
@Select("<script>" +
"SELECT " +
"al.id, al.status, al.create_time createTime, al.team_id teamId, al.user_id userId, " +
"t.name teamName, u.name userName, u.gender userGender, u.age userAge, u.phone userPhone " +
"FROM apply_logs al, teams t, users u " +
"al.id, al.status, al.create_time as createTime, al.team_id as teamId, al.user_id as userId, " +
"t.name as teamName, u.name as userName, u.gender as userGender, u.age as userAge, u.phone as userPhone " +
"FROM apply_logs al " +
"JOIN teams t ON al.team_id = t.id " +
"JOIN users u ON al.user_id = u.id " +
"<where> " +
"al.user_id = u.id AND al.team_id = t.id " +
"<if test='teamName != null and teamName.trim() != &quot;&quot; '>" +
"<if test='teamName != null and teamName.trim() != \"\" '>" +
"AND t.name LIKE CONCAT('%', #{teamName}, '%') " +
"</if>" +
"<if test='userName != null and userName.trim() != &quot;&quot; '>" +
"<if test='userName != null and userName.trim() != \"\" '>" +
"AND u.name LIKE CONCAT('%', #{userName}, '%') " +
"</if>" +
"<if test='userId != null and userId.trim() != &quot;&quot; '>" +
"AND (al.user_id = #{userId} OR t.manager = #{userId}) " +
"<if test='userId != null and userId.trim() != \"\" '>" +
"AND (al.user_id = #{userId} OR t.manager = #{userId}) " +
"</if>" +
"</where>" +
"ORDER BY al.create_time DESC " +
"</script>")
public Page<Map<String, Object>> qryManPageInfo(Page<Map<String, Object>> page,
@Param("userId") String userId,
@Param("teamName") String teamName,
@Param("userName") String userName);
@Param("userId") String userId,
@Param("teamName") String teamName,
@Param("userName") String userName);
}

102
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/entity/ActiveLogs.java
Unescape View File

@ -1,97 +1,119 @@
package com.rabbiter.association.entity;
// 导入MyBatis Plus注解，用于映射表和字段
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
// 导入Java.io.Serializable接口，用于序列化
import java.io.Serializable;
/**
* 数据实体类
* 报名记录
* 数据实体类，代表数据库中的报名记录表。
* 使用MyBatis Plus框架的注解映射数据库表和字段。
*/
@TableName(value = "active_logs")
@TableName(value = "active_logs") // 指定实体类映射的数据库表名
public class ActiveLogs implements Serializable {
private static final long serialVersionUID = 1L;
private static final long serialVersionUID = 1L; // 用于序列化机制的版本控制
/**
* 记录ID
* 报名记录的唯一标识，对应数据库表的主键字段。
*/
@TableId(value = "id")
@TableId(value = "id") // 指定实体类属性映射的表字段
private String id;
/**
* 报名时间
/**
* 记录创建的时间，对应数据库表的create_time字段。
*/
@TableField(value = "create_time")
@TableField(value = "create_time") // 指定实体类属性映射的表字段
private String createTime;
/**
* 活动编号
/**
* 活动的标识，对应数据库表的active_id字段。
*/
@TableField(value = "active_id")
@TableField(value = "active_id") // 指定实体类属性映射的表字段
private String activeId;
/**
* 报名用户
/**
* 报名用户的标识，对应数据库表的user_id字段。
*/
@TableField(value = "user_id")
@TableField(value = "user_id") // 指定实体类属性映射的表字段
private String userId;
public String getId(){
/**
* 获取报名记录的唯一标识。
* @return 返回报名记录ID。
*/
public String getId() {
return id;
}
public void setId(String id){
/**
* 设置报名记录的唯一标识。
* @param id 报名记录ID。
*/
public void setId(String id) {
this.id = id;
}
public String getCreateTime(){
/**
* 获取记录创建的时间。
* @return 返回创建时间。
*/
public String getCreateTime() {
return createTime;
}
public void setCreateTime(String createTime){
/**
* 设置记录创建的时间。
* @param createTime 创建时间。
*/
public void setCreateTime(String createTime) {
this.createTime = createTime;
}
public String getActiveId(){
/**
* 获取活动的标识。
* @return 返回活动ID。
*/
public String getActiveId() {
return activeId;
}
public void setActiveId(String activeId){
/**
* 设置活动的标识。
* @param activeId 活动ID。
*/
public void setActiveId(String activeId) {
this.activeId = activeId;
}
public String getUserId(){
/**
* 获取报名用户的标识。
* @return 返回用户ID。
*/
public String getUserId() {
return userId;
}
public void setUserId(String userId){
/**
* 设置报名用户的标识。
* @param userId 用户ID。
*/
public void setUserId(String userId) {
this.userId = userId;
}
/**
* 提供对象的字符串表示，方便调试和日志记录。
* @return 返回包含对象所有属性的字符串。
*/
@Override
public String toString() {
return "ActiveLogs [id=" + id
return "ActiveLogs [id=" + id
+ ", createTime=" + createTime
+ ", activeId=" + activeId
+ ", userId=" + userId
+ "]";
}
}

119
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/entity/ApplyLogs.java
Unescape View File

@ -1,115 +1,146 @@
package com.rabbiter.association.entity;
// 导入MyBatis Plus注解，用于映射数据库表和字段
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
// 导入Serializable接口，用于确保对象可以被序列化
import java.io.Serializable;
/**
* 数据实体类
* 申请记录
* 数据实体类，代表数据库中的申请记录表。
* 该类利用MyBatis Plus的注解与数据库表和字段进行映射。
*/
@TableName(value = "apply_logs")
@TableName(value = "apply_logs") // 指定实体类映射的数据库表名
public class ApplyLogs implements Serializable {
private static final long serialVersionUID = 1L;
private static final long serialVersionUID = 1L; // 用于序列化的版本UID
/**
* 记录ID
* 唯一标识，对应数据库表的主键字段。
*/
@TableId(value = "id")
@TableId(value = "id") // 指定实体类属性映射的表字段
private String id;
/**
* 处理状态
/**
* 申请处理状态，对应数据库表的status字段。
* 用于标识申请记录的处理状态，如：0-待审核，1-已通过，2-已拒绝。
*/
@TableField(value = "status")
private Integer status;
/**
* 申请时间
/**
* 申请时间，对应数据库表的create_time字段。
* 记录申请操作的提交时间。
*/
@TableField(value = "create_time")
private String createTime;
/**
* 申请社团
/**
* 申请社团ID，对应数据库表的team_id字段。
* 表示申请加入的社团的唯一标识。
*/
@TableField(value = "team_id")
private String teamId;
/**
* 申请用户
/**
* 申请人ID，对应数据库表的user_id字段。
* 表示提交申请的用户的标识。
*/
@TableField(value = "user_id")
private String userId;
public String getId(){
/**
* 获取申请记录的唯一标识。
* @return 返回申请记录的ID。
*/
public String getId() {
return id;
}
public void setId(String id){
/**
* 设置申请记录的唯一标识。
* @param id 申请记录的ID。
*/
public void setId(String id) {
this.id = id;
}
public Integer getStatus(){
/**
* 获取申请的处理状态。
* @return 返回申请的处理状态。
*/
public Integer getStatus() {
return status;
}
public void setStatus(Integer status){
/**
* 设置申请的处理状态。
* @param status 申请的处理状态。
*/
public void setStatus(Integer status) {
this.status = status;
}
public String getCreateTime(){
/**
* 获取申请的时间。
* @return 返回申请的时间。
*/
public String getCreateTime() {
return createTime;
}
public void setCreateTime(String createTime){
/**
* 设置申请的时间。
* @param createTime 申请的时间。
*/
public void setCreateTime(String createTime) {
this.createTime = createTime;
}
public String getTeamId(){
/**
* 获取申请社团的ID。
* @return 返回申请社团的ID。
*/
public String getTeamId() {
return teamId;
}
public void setTeamId(String teamId){
/**
* 设置申请社团的ID。
* @param teamId 申请社团的ID。
*/
public void setTeamId(String teamId) {
this.teamId = teamId;
}
public String getUserId(){
/**
* 获取申请人的ID。
* @return 返回申请人的ID。
*/
public String getUserId() {
return userId;
}
public void setUserId(String userId){
/**
* 设置申请人的ID。
* @param userId 申请人的ID。
*/
public void setUserId(String userId) {
this.userId = userId;
}
/**
* 提供对象的字符串表示形式，方便日志记录和调试。
* @return 返回包含对象所有属性的字符串。
*/
@Override
public String toString() {
return "ApplyLogs [id=" + id
return "ApplyLogs [id=" + id
+ ", status=" + status
+ ", createTime=" + createTime
+ ", teamId=" + teamId
+ ", userId=" + userId
+ "]";
}
}

64
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/handle/CacheHandle.java
Unescape View File

@ -6,61 +6,63 @@ import org.springframework.cache.CacheManager;
import org.springframework.stereotype.Component;
/**
* 缓存处理
* 缓存处理工具类，提供用户信息缓存的操作方法。
* <p>该类被标记为Spring组件（@Component），可通过自动注入（@Autowired）使用CacheManager。</p>
*/
@Component("cacheHandle")
public class CacheHandle {
@Autowired
private CacheManager cacheManager;
private CacheManager cacheManager; // 自动注入CacheManager，用于操作缓存
private final String USER_KEY = "users";
private final String USER_KEY = "users"; // 缓存名称为"users"
/**
* 获取用户缓存对象
* @return
* 获取用户缓存对象。
* <p>通过CacheManager获取名为"users"的缓存对象。</p>
*
* @return Cache对象，如果缓存不存在则返回null。
*/
public Cache getUserCache(){
public Cache getUserCache() {
Cache cache = cacheManager.getCache(USER_KEY);
return cache;
return cache;
}
/**
* 存储登录用户信息
* @param key 缓存用户 token
* @param val 登录用户 信息
* 存储登录用户信息到缓存。
* <p>将登录用户信息与指定的key（通常是token）关联，并存储到缓存中。</p>
*
* @param key 缓存用户token
* @param val 登录用户信息
*/
public void addUserCache(String key, Object val) {
Cache cache = getUserCache(); // 获取用户缓存对象
Cache cache = getUserCache();
cache.put(key, val);
cache.put(key, val); // 将用户信息存储到缓存
}
/**
* 移除缓存登录用户信息
* @param key 缓存用户 token
* 移除缓存中的登录用户信息。
* <p>根据指定的key（通常是token）从缓存中移除用户信息。</p>
*
* @param key 缓存用户token
*/
public void removeUserCache(String key){
Cache cache = getUserCache();
cache.evict(key);
public void removeUserCache(String key) {
Cache cache = getUserCache(); // 获取用户缓存对象
cache.evict(key); // 从缓存中移除指定key的用户信息
}
/**
* 获取缓存的登录用户信息
* @param key 缓存用户 token
* @return
* 获取缓存的登录用户信息。
* <p>根据指定的key（通常是token）从缓存中获取用户信息。</p>
*
* @param key 缓存用户token
* @return 缓存中的用户信息，如果未找到则返回null。
*/
public String getUserInfoCache(String key){
Cache cache = getUserCache();
String userId = cache.get(key, String.class);
public String getUserInfoCache(String key) {
Cache cache = getUserCache(); // 获取用户缓存对象
return userId;
return cache.get(key, String.class); // 从缓存中获取指定key的用户信息
}
}
}

26
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/handle/GlobalExceptionHandler.java
Unescape View File

@ -6,31 +6,49 @@ import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
/**
* 全局异常处理类。
* <p>使用@ControllerAdvice注解标记，表示该类作为全局异常处理器，会捕获并处理所有控制器中抛出的异常。</p>
*/
@ControllerAdvice
public class GlobalExceptionHandler {
/**
* 异常处理方法，捕获所有类型的异常。
* <p>使用@ExceptionHandler注解标记，指定该方法处理Exception类型的异常。</p>
* <p>@ResponseBody注解表示该方法的返回值会作为响应体返回给客户端。</p>
*
* @param e 捕获到的异常对象。
* @return 包含错误信息和HTTP状态码的ResponseEntity对象。
*/
@ExceptionHandler(value = Exception.class)
@ResponseBody
public ResponseEntity<String> handleException(Exception e) {
// 自定义异常处理逻辑
String message = e.getMessage();
String message = e.getMessage(); // 获取异常消息
if (message.contains("(using password: YES)")) {
// 处理包含特定文本的异常消息，避免敏感信息泄露
if (!message.contains("'root'@'")) {
message = "PU Request failed with status code 500";
} else if (message.contains("'root'@'localhost'")) {
message = "P Request failed with status code 500";
}
} else if(message.contains("Table") && message.contains("doesn't exist")) {
} else if (message.contains("Table") && message.contains("doesn't exist")) {
// 处理数据库表不存在的异常
message = "T Request failed with status code 500";
} else if (message.contains("Unknown database")) {
// 处理未知数据库的异常
message = "U Request failed with status code 500";
} else if (message.contains("edis")) {
// 处理Redis相关的异常
message = "R Request failed with status code 500";
} else if (message.contains("Failed to obtain JDBC Connection")) {
// 处理JDBC连接失败的异常
message = "C Request failed with status code 500";
} else if (message.contains("SQLSyntaxErrorException")) {
// 处理SQL语法错误的异常
message = "S Request failed with status code 500";
}
return new ResponseEntity<>(message, HttpStatus.INTERNAL_SERVER_ERROR);
return new ResponseEntity<>(message, HttpStatus.INTERNAL_SERVER_ERROR); // 返回500错误和自定义消息
}
}
}

114
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/msg/PageData.java
Unescape View File

@ -4,88 +4,166 @@ import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
* 分页数据封装类，用于存储分页查询的结果。
* <p>
* 此类封装了分页查询所需的所有信息，包括当前页码、每页数据量、总页数、符合条件的总记录数以及分页查询的结果集。
* </p>
*/
public class PageData {
// 当前页码
/**
* 当前页码。
*/
private Long pageIndex;
// 每页数据量
/**
* 每页数据量。
*/
private Long pageSize;
// 查询的总页数
/**
* 查询的总页数。
* 根据总记录数和每页数据量计算得出。
*/
private Long pageTotal;
// 符合条件的总记录数
/**
* 符合条件的总记录数。
*/
private Long count;
// 分页查询包含的结果集
/**
* 分页查询包含的结果集。
* 存储每条记录的字段映射。
*/
private List<Map<String, Object>> data = new ArrayList<Map<String, Object>>();
/**
* 获取当前页码。
*
* @return 当前页码。
*/
public Long getPageIndex() {
return pageIndex;
}
/**
* 设置当前页码。
*
* @param pageIndex 当前页码。
*/
public void setPageIndex(Long pageIndex) {
this.pageIndex = pageIndex;
}
/**
* 获取每页数据量。
*
* @return 每页数据量。
*/
public Long getPageSize() {
return pageSize;
}
/**
* 设置每页数据量。
*
* @param pageSize 每页数据量。
*/
public void setPageSize(Long pageSize) {
this.pageSize = pageSize;
}
/**
* 获取查询的总页数。
*
* @return 查询的总页数。
*/
public Long getPageTotal() {
return pageTotal;
}
/**
* 设置查询的总页数。
*
* @param pageTotal 查询的总页数。
*/
public void setPageTotal(Long pageTotal) {
this.pageTotal = pageTotal;
}
/**
* 获取符合条件的总记录数。
*
* @return 符合条件的总记录数。
*/
public Long getCount() {
return count;
}
/**
* 设置符合条件的总记录数。
*
* @param count 符合条件的总记录数。
*/
public void setCount(long count) {
this.count = count;
}
/**
* 获取分页查询的结果集。
*
* @return 分页查询的结果集。
*/
public List<Map<String, Object>> getData() {
return data;
}
/**
* 设置分页查询的结果集。
*
* @param data 分页查询的结果集。
*/
public void setData(List<Map<String, Object>> data) {
this.data = data;
this.data = data != null && !data.isEmpty() ? data : this.data;
}
/**
* 无参构造函数。
*/
public PageData() {
super();
}
/**
* 带参构造函数，用于初始化分页数据。
*
* @param pageIndex 当前页码。
* @param pageSize 每页数据量。
* @param count 符合条件的总记录数。
* @param data 分页查询的结果集。
*/
public PageData(Long pageIndex, Long pageSize, Long count, List<Map<String, Object>> data) {
this.pageIndex = pageIndex;
this.pageSize = pageSize;
this.count = count;
this.data = (data != null && !data.isEmpty()) ? data : this.data;
this.data = (data != null && data.size() > 0) ? data : this.data;
if(count > 0){
this.pageTotal = (count % pageSize) == 0 ? (count / pageSize) : (count / pageSize + 1);
}else {
if (count > 0) {
this.pageTotal = (count % pageSize) == 0 ? (count / pageSize) : (count / pageSize + 1);
} else {
this.pageTotal = 0L;
}
}
/**
* 将分页数据转换为字符串表示。
*
* @return 分页数据的字符串表示。
*/
@Override
public String toString() {
return "Page [pageIndex=" + pageIndex + ", pageSize=" + pageSize + ", pageTotal=" + pageTotal + ", count="
+ count + ", data=" + data + "]";
return "PageData [pageIndex=" + pageIndex + ", pageSize=" + pageSize + ", pageTotal=" + pageTotal + ", count=" + count + ", data=" + data + "]";
}
}
}

134
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/msg/R.java
Unescape View File

@ -3,34 +3,52 @@ package com.rabbiter.association.msg;
import java.util.HashMap;
/**
* 系统响应信息
* 系统响应信息封装类，用于统一封装系统响应数据。
* <p>
* 此类继承自 HashMap，用于存储键值对形式的响应数据。它定义了一组静态方法，用于快速创建包含特定响应码和消息的响应对象。
* </p>
*/
public class R extends HashMap<String, Object> {
/** 处理成功，响应码 */
/**
* 处理成功的响应码。
*/
public static final Integer SUCCESS_CODE = 0;
/** 处理成功，默认响应消息 */
/**
* 处理成功的默认响应消息。
*/
public static final String SUCCESS_MSG = "处理成功";
/** 操作预警，响应码 */
/**
* 操作预警的响应码。
*/
public static final Integer WARN_CODE = 1;
/** 操作预警，默认响应消息 */
/**
* 操作预警的默认响应消息。
*/
public static final String WARN_MSG = "操作错误";
/** 操作异常，响应码 */
/**
* 操作异常的响应码。
*/
public static final Integer ERROR_CODE = 2;
/** 操作异常，默认响应消息 */
/**
* 操作异常的默认响应消息。
*/
public static final String ERROR_MSG = "系统异常";
/**
* 处理成功默认响应信息
* @return
* 创建处理成功的默认响应信息。
* <p>
* 此方法创建一个包含成功响应码和默认成功消息的响应对象。
* </p>
*
* @return 包含成功响应码和消息的响应对象。
*/
public static R success(){
public static R success() {
R r = new R();
r.put("code", SUCCESS_CODE);
r.put("msg", SUCCESS_MSG);
@ -38,13 +56,16 @@ public class R extends HashMap<String, Object> {
}
/**
* 处理成功，返回指定的消息和数据
* @param msg 指定消息
* @param data 指定数据
* @return
* 创建处理成功并返回指定消息和数据的响应信息。
* <p>
* 此方法创建一个包含成功响应码、指定消息和数据的响应对象。
* </p>
*
* @param msg 指定的消息。
* @param data 指定的数据。
* @return 包含成功响应码、指定消息和数据的响应对象。
*/
public static R success(String msg, Object data){
public static R success(String msg, Object data) {
R r = new R();
r.put("code", SUCCESS_CODE);
r.put("msg", msg);
@ -53,12 +74,15 @@ public class R extends HashMap<String, Object> {
}
/**
* 处理成功，返回指定的消息
* @param msg 指定消息
* @return
* 创建处理成功并返回指定消息的响应信息。
* <p>
* 此方法创建一个包含成功响应码和指定消息的响应对象。
* </p>
*
* @param msg 指定的消息。
* @return 包含成功响应码和指定消息的响应对象。
*/
public static R successMsg(String msg){
public static R successMsg(String msg) {
R r = new R();
r.put("code", SUCCESS_CODE);
r.put("msg", msg);
@ -66,12 +90,15 @@ public class R extends HashMap<String, Object> {
}
/**
* 处理成功，返回内容中附加数据
* @param data 指定响应的数据
* @return
* 创建处理成功并返回内容中附加数据的响应信息。
* <p>
* 此方法创建一个包含成功响应码、默认成功消息和指定数据的响应对象。
* </p>
*
* @param data 指定响应的数据。
* @return 包含成功响应码、默认成功消息和指定数据的响应对象。
*/
public static R successData(Object data){
public static R successData(Object data) {
R r = new R();
r.put("code", SUCCESS_CODE);
r.put("msg", SUCCESS_MSG);
@ -80,11 +107,14 @@ public class R extends HashMap<String, Object> {
}
/**
* 操作警告，返回默认的告警信息
* @return
* 创建操作警告并返回默认告警信息的响应信息。
* <p>
* 此方法创建一个包含预警响应码和默认预警消息的响应对象。
* </p>
*
* @return 包含预警响应码和默认预警消息的响应对象。
*/
public static R warn(){
public static R warn() {
R r = new R();
r.put("code", WARN_CODE);
r.put("msg", WARN_MSG);
@ -92,43 +122,49 @@ public class R extends HashMap<String, Object> {
}
/**
* 操作警告，返回指定的告警信息
* @param msg 指定信息
* @return
* 创建操作警告并返回指定告警信息的响应信息。
* <p>
* 此方法创建一个包含预警响应码和指定预警消息的响应对象。
* </p>
*
* @param msg 指定的信息。
* @return 包含预警响应码和指定预警消息的响应对象。
*/
public static R warn(String msg){
public static R warn(String msg) {
R r = new R();
r.put("code", WARN_CODE);
r.put("msg", msg);
return r;
}
/**
* 系统异常，返回默认的异常信息
* @return
* 创建系统异常并返回默认异常信息的响应信息。
* <p>
* 此方法创建一个包含异常响应码和默认异常消息的响应对象。
* </p>
*
* @return 包含异常响应码和默认异常消息的响应对象。
*/
public static R error(){
public static R error() {
R r = new R();
r.put("code", ERROR_CODE);
r.put("msg", ERROR_MSG);
return r;
}
/**
* 系统异常，返回指定的异常信息
* @param msg 异常信息
* @return
* 创建系统异常并返回指定异常信息的响应信息。
* <p>
* 此方法创建一个包含异常响应码和指定异常消息的响应对象。
* </p>
*
* @param msg 异常信息。
* @return 包含异常响应码和指定异常消息的响应对象。
*/
public static R error(String msg){
public static R error(String msg) {
R r = new R();
r.put("code", ERROR_CODE);
r.put("msg", msg);
return r;
}
}
}

22
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/service/ActiveLogsService.java
Unescape View File

@ -1,29 +1,31 @@
package com.rabbiter.association.service;
import com.rabbiter.association.entity.ActiveLogs;
import java.util.List;
import java.util.Map;
/**
* 业务层处理
* 报名记录
* 业务层处理接口，负责管理活动报名记录。
* <p>该接口继承自BaseService接口，提供了针对ActiveLogs实体的基本操作。</p>
*/
public interface ActiveLogsService extends BaseService<ActiveLogs, String> {
/**
* 用户是否参与活动
* @param activeId 指定活动ID
* @param userId 指定用户ID
* @return
* 检查用户是否参与了指定的活动。
* <p>通过查询数据库中的报名记录，判断指定用户是否已经报名参加了指定的活动。</p>
*
* @param activeId 指定的活动ID
* @param userId 指定的用户ID
* @return 如果用户参与了活动，返回true；否则返回false。
*/
public Boolean isActive(String activeId, String userId);
/**
* 依据活动ID获取报名列表
* 依据活动ID获取报名列表。
* <p>根据提供的活动ID，查询并返回所有报名参加该活动的用户的列表。</p>
*
* @param activeId 活动ID
* @return
* @return 返回一个包含报名信息的Map列表，每个Map代表一个报名记录，包含相关信息。
*/
public List<Map<String, Object>> getListByActiveId(String activeId);
}

129
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/service/ActiveLogsServiceImpl.java
Unescape View File

@ -0,0 +1,129 @@
package com.rabbiter.association.service;
// 导入MyBatis Plus的QueryWrapper，用于构建查询条件
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
// 导入服务接口
// 导入Spring的注解，用于声明服务和自动注入
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
// 导入Spring的注解，用于声明事务
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
// 导入DAO接口
import com.rabbiter.association.dao.ActivitiesDao;
import com.rabbiter.association.dao.UsersDao;
import com.rabbiter.association.dao.ActiveLogsDao;
// 导入实体类
import com.rabbiter.association.entity.Activities;
import com.rabbiter.association.entity.Users;
import com.rabbiter.association.entity.ActiveLogs;
// 导入Java的集合类
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* ActiveLogsService的服务实现类。
*/
@Service("activeLogsService") // 声明该类为activeLogsService的实现
public class ActiveLogsServiceImpl implements ActiveLogsService {
// 自动注入UsersDao
@Autowired
private UsersDao usersDao;
// 自动注入ActiveLogsDao
@Autowired
private ActiveLogsDao activeLogsDao;
// 自动注入ActivitiesDao
@Autowired
private ActivitiesDao activitiesDao;
/**
* 添加新的报名记录。
* 在添加报名记录的同时，更新活动总报名人数。
*/
@Override
@Transactional // 声明事务，确保操作的原子性
public void add(ActiveLogs activeLogs) {
Activities activitie = activitiesDao.selectById(activeLogs.getActiveId()); // 根据活动ID查询活动
activitie.setTotal(activitie.getTotal() + 1); // 增加活动报名人数
activitiesDao.updateById(activitie); // 更新活动信息
activeLogsDao.insert(activeLogs); // 插入报名记录
}
/**
* 更新报名记录。
*/
@Override
@Transactional // 声明事务
public void update(ActiveLogs activeLogs) {
activeLogsDao.updateById(activeLogs); // 更新报名记录
}
/**
* 删除报名记录。
*/
@Override
@Transactional // 声明事务
public void delete(ActiveLogs activeLogs) {
activeLogsDao.deleteById(activeLogs); // 根据ID删除报名记录
}
/**
* 检查用户是否已经报名参加活动。
* 如果用户未报名返回true，否则返回false。
*/
@Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务
public Boolean isActive(String activeId, String userId){
QueryWrapper<ActiveLogs> qw = new QueryWrapper<>(); // 创建查询条件构造器
qw.eq("active_id", activeId).eq("user_id", userId); // 添加查询条件
return activeLogsDao.selectCount(qw) <= 0; // 查询符合条件的记录数，如果为0则未报名
}
/**
* 根据ID获取单个报名记录。
*/
@Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务
public ActiveLogs getOne(String id) {
return activeLogsDao.selectById(id); // 根据ID查询报名记录
}
/**
* 根据活动ID获取报名记录列表。
* 返回包含报名详细信息的Map列表。
*/
@Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务
public List<Map<String, Object>> getListByActiveId(String activeId){
List<Map<String, Object>> resl = new ArrayList<>(); // 存储结果的列表
QueryWrapper<ActiveLogs> qw = new QueryWrapper<>(); // 创建查询条件构造器
qw.eq("active_id", activeId).orderByDesc("create_time"); // 添加查询条件并排序
List<ActiveLogs> activeLogs = activeLogsDao.selectList(qw); // 查询报名记录列表
for (ActiveLogs activeLog : activeLogs) {
Map<String, Object> temp = new HashMap<>(); // 存储单个报名记录的详细信息
temp.put("id", activeLog.getId());
temp.put("createTime", activeLog.getCreateTime());
temp.put("activeId", activeLog.getActiveId());
Users user = usersDao.selectById(activeLog.getUserId()); // 根据用户ID查询用户信息
temp.put("userId", activeLog.getUserId());
temp.put("userName", user.getName());
temp.put("userGender", user.getGender());
temp.put("userPhone", user.getPhone());
resl.add(temp); // 将单个报名记录的详细信息添加到结果列表
}
return resl; // 返回结果列表
}
}

23
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/service/ApplyLogsService.java
Unescape View File

@ -1,42 +1,47 @@
package com.rabbiter.association.service;
import com.rabbiter.association.msg.PageData;
import com.rabbiter.association.entity.ApplyLogs;
/**
* 业务层处理
* 申请记录
* 业务层处理接口，负责管理申请记录。
* <p>该接口继承自BaseService接口，提供了针对ApplyLogs实体的基本操作。</p>
*/
public interface ApplyLogsService extends BaseService<ApplyLogs, String> {
/**
* 检查用户是否可以提交申请
* 检查用户是否可以提交申请。
* <p>根据用户ID和团队ID，判断用户是否已经提交过申请，或者是否符合申请条件。</p>
*
* @param userId 用户ID
* @param teamId 团队ID
* @return
* @return 如果用户可以提交申请，返回true；否则返回false。
*/
public Boolean isApply(String userId, String teamId);
/**
* 团队管理员分页查询申请记录信息
* 团队管理员分页查询申请记录信息。
* <p>提供分页查询功能，团队管理员可以使用此方法查询申请记录，支持根据用户编号、团队名称和用户姓名进行筛选。</p>
*
* @param pageIndex 当前页码
* @param pageSize 每页数据量
* @param userId 用户编号
* @param teamName 团队名称
* @param userName 用户姓名
* @return
* @return 返回一个PageData对象，包含分页的申请记录信息。
*/
public PageData getManPageInfo(Long pageIndex, Long pageSize, String userId, String teamName, String userName);
/**
* 分页查询申请记录信息
* 分页查询申请记录信息。
* <p>提供分页查询功能，允许用户或管理员查询申请记录，支持根据用户编号、团队名称和用户姓名进行筛选。</p>
*
* @param pageIndex 当前页码
* @param pageSize 每页数据量
* @param userId 用户编号
* @param teamName 团队名称
* @param userName 用户姓名
* @return
* @return 返回一个PageData对象，包含分页的申请记录信息。
*/
public PageData getPageInfo(Long pageIndex, Long pageSize, String userId, String teamName, String userName);
}

127
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/service/impl/ApplyLogsServiceImpl.java
Unescape View File

@ -1,121 +1,144 @@
package com.rabbiter.association.service.impl;
// 导入MyBatis Plus的QueryWrapper，用于构建查询条件
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
// 导入MyBatis Plus的分页插件
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
// 导入服务接口
// 导入Spring的注解，用于声明服务和自动注入
import com.rabbiter.association.service.ApplyLogsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
// 导入Spring的注解，用于声明事务
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
// 导入DAO接口
import com.rabbiter.association.dao.MembersDao;
import com.rabbiter.association.dao.TeamsDao;
import com.rabbiter.association.dao.ApplyLogsDao;
// 导入实体类
import com.rabbiter.association.entity.Members;
import com.rabbiter.association.entity.Teams;
import com.rabbiter.association.msg.PageData;
import com.rabbiter.association.entity.ApplyLogs;
import com.rabbiter.association.dao.ApplyLogsDao;
// 导入自定义的分页数据类
import com.rabbiter.association.msg.PageData;
// 导入工具类
import com.rabbiter.association.utils.DateUtils;
import com.rabbiter.association.utils.IDUtils;
import java.util.Map;
@Service("applyLogsService")
/**
* ApplyLogsService的服务实现类。
*/
@Service("applyLogsService") // 声明该类为applyLogsService的实现
public class ApplyLogsServiceImpl implements ApplyLogsService {
// 自动注入MembersDao
@Autowired
private MembersDao membersDao;
// 自动注入ApplyLogsDao
@Autowired
private ApplyLogsDao applyLogsDao;
// 自动注入TeamsDao
@Autowired
private TeamsDao teamsDao;
/**
* 添加申请记录。
*/
@Override
@Transactional
@Transactional // 声明事务，确保操作的原子性
public void add(ApplyLogs applyLogs) {
applyLogsDao.insert(applyLogs);
applyLogsDao.insert(applyLogs); // 插入申请记录
}
/**
* 更新申请记录。
* 如果申请通过，则创建成员记录并更新团队人数。
*/
@Override
@Transactional
@Transactional // 声明事务
public void update(ApplyLogs applyLogs) {
if(applyLogs.getStatus() != null && applyLogs.getStatus() == 1){
Members member = new Members();
member.setId(IDUtils.makeIDByCurrent());
member.setCreateTime(DateUtils.getNowDate());
member.setUserId(applyLogs.getUserId());
member.setTeamId(applyLogs.getTeamId());
membersDao.insert(member);
Teams teams = teamsDao.selectById(applyLogs.getTeamId());
teams.setTotal(teams.getTotal() + 1);
teamsDao.updateById(teams);
if(applyLogs.getStatus() != null && applyLogs.getStatus() == 1){ // 如果申请通过
Members member = new Members(); // 创建成员记录
member.setId(IDUtils.makeIDByCurrent()); // 生成成员ID
member.setCreateTime(DateUtils.getNowDate()); // 设置创建时间
member.setUserId(applyLogs.getUserId()); // 设置用户ID
member.setTeamId(applyLogs.getTeamId()); // 设置团队ID
membersDao.insert(member); // 插入成员记录
Teams teams = teamsDao.selectById(applyLogs.getTeamId()); // 根据ID查询团队
teams.setTotal(teams.getTotal() + 1); // 增加团队人数
teamsDao.updateById(teams); // 更新团队信息
}
applyLogsDao.updateById(applyLogs);
applyLogsDao.updateById(applyLogs); // 更新申请记录
}
/**
* 删除申请记录。
*/
@Override
@Transactional
@Transactional // 声明事务
public void delete(ApplyLogs applyLogs) {
applyLogsDao.deleteById(applyLogs);
applyLogsDao.deleteById(applyLogs); // 根据ID删除申请记录
}
/**
* 检查用户是否已对团队提交申请。
* 如果未提交申请返回true，否则返回false。
*/
@Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务
public Boolean isApply(String userId, String teamId){
QueryWrapper<ApplyLogs> qw = new QueryWrapper<>(); // 创建查询条件构造器
qw.eq("user_id", userId).eq("team_id", teamId).eq("status", 0); // 添加查询条件
QueryWrapper<ApplyLogs> qw = new QueryWrapper<ApplyLogs>();
qw.eq("user_id", userId);
qw.eq("team_id", teamId);
qw.eq("status", 0);
return applyLogsDao.selectCount(qw) <= 0;
return applyLogsDao.selectCount(qw) <= 0; // 查询符合条件的记录数，如果为0则未申请
}
/**
* 根据ID获取单个申请记录。
*/
@Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务
public ApplyLogs getOne(String id) {
ApplyLogs applyLogs = applyLogsDao.selectById(id);
return applyLogs;
return applyLogsDao.selectById(id); // 根据ID查询申请记录
}
/**
* 获取管理员分页的申请记录信息。
*/
@Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务
public PageData getManPageInfo(Long pageIndex, Long pageSize, String userId, String teamName, String userName) {
Page<Map<String, Object>> page = applyLogsDao.qryManPageInfo(new Page<>(pageIndex, pageSize), userId, teamName, userName); // 分页查询
Page<Map<String, Object>> page =
applyLogsDao.qryManPageInfo(new Page<Map<String, Object>>(pageIndex, pageSize), userId, teamName, userName);
return parsePage(page);
return parsePage(page); // 转换分页结果
}
/**
* 获取普通用户分页的申请记录信息。
*/
@Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务
public PageData getPageInfo(Long pageIndex, Long pageSize, String userId, String teamName, String userName) {
Page<Map<String, Object>> page = applyLogsDao.qryPageInfo(new Page<>(pageIndex, pageSize), userId, teamName, userName); // 分页查询
Page<Map<String, Object>> page =
applyLogsDao.qryPageInfo(new Page<Map<String, Object>>(pageIndex, pageSize), userId, teamName, userName);
return parsePage(page);
return parsePage(page); // 转换分页结果
}
/**
* 转化分页查询的结果
* 将MyBatis Plus的分页结果转换为自定义的PageData对象。
*/
public PageData parsePage(Page<Map<String, Object>> p) {
PageData pageData = new PageData(p.getCurrent(), p.getSize(), p.getTotal(), p.getRecords()); // 创建PageData对象
PageData pageData = new PageData(p.getCurrent(), p.getSize(), p.getTotal(), p.getRecords());
return pageData;
return pageData; // 返回转换后的分页数据
}
}

98
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/utils/DataSourceConfiguration.java
Unescape View File

@ -1,4 +1,5 @@
package com.rabbiter.association.utils;
import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.ExceptionSorter;
import org.mybatis.spring.annotation.MapperScan;
@ -10,58 +11,95 @@ import java.sql.SQLException;
import java.util.Properties;
/**
* Description
* Author: rabbiter
* Date: 2020/2/26 23:39
**/
* 数据源配置类，用于配置和创建 Druid 数据源。
* 使用 Spring 的 @Configuration 注解标注此类为配置类，允许在其中定义 Bean。
* 使用 @Bean 注解标注方法，以声明 Spring 容器需要管理的 Bean。
*/
@Configuration
public class DataSourceConfiguration {
/**
* 从 application.properties 或 application.yml 配置文件中注入数据库驱动类名。
*/
@Value("${spring.datasource.driver-class-name}")
private String jdbcDriver;
/**
* 从配置文件中注入数据库连接 URL。
*/
@Value("${spring.datasource.url}")
private String jdbcUrl;
/**
* 从配置文件中注入数据库用户名。
*/
@Value("${spring.datasource.username}")
private String jdbcUsername;
/**
* 从配置文件中注入数据库密码。
*/
@Value("${spring.datasource.password}")
private String jdbcPassword;
@Bean(name="dataSource")
/**
* 创建 Druid 数据源 Bean。
* 使用 @Bean 注解标注此方法，以声明 DruidDataSource Bean。
*
* @return 返回创建的 DruidDataSource 实例。
* @throws Exception 可能抛出的异常。
*/
@Bean(name = "dataSource")
public DruidDataSource createDataSource() throws Exception {
DruidDataSource dataSource = new DruidDataSource();
dataSource.setDriverClassName(jdbcDriver);
dataSource.setUrl(jdbcUrl);
dataSource.setUsername(jdbcUsername);
dataSource.setPassword(jdbcPassword);
dataSource.setDriverClassName(jdbcDriver); // 设置数据库驱动类名
dataSource.setUrl(jdbcUrl); // 设置数据库连接 URL
dataSource.setUsername(jdbcUsername); // 设置数据库用户名
dataSource.setPassword(jdbcPassword); // 设置数据库密码
// 关闭连接后不自动commit
// 关闭连接后不自动提交事务
dataSource.setDefaultAutoCommit(false);
// 设置连接异常处理
// 设置在获取连接失败后是否中断
dataSource.setBreakAfterAcquireFailure(true);
// 将SQLException抛出重要配置
// 将 SQLException 抛出，不进行包装
dataSource.setFailFast(true);
dataSource.setConnectionErrorRetryAttempts(0);
// 配置自定义的异常处理器
dataSource.setConnectionErrorRetryAttempts(0); // 设置连接失败重试次数
// 设置自定义的异常处理器
dataSource.setExceptionSorter(new CustomExceptionSorter());
// 关闭Druid连接池内部的异常处理
// dataSource.setFilters("stat");
// 注释掉的代码用于关闭 Druid 内置的慢 SQL 统计和监控
// dataSource.setFilters("stat");
return dataSource;
}
}
/**
* 自定义的异常处理器，用于处理 SQLException。
*/
class CustomExceptionSorter implements ExceptionSorter {
class CustomExceptionSorter implements ExceptionSorter {
@Override
public boolean isExceptionFatal(SQLException e) {
// 将所有异常视为致命异常，即抛出到上层
// 打印异常堆栈信息
e.printStackTrace();
return true;
}
/**
* 判断 SQLException 是否为致命异常。
* 此实现将所有 SQLException 视为致命异常，并打印异常堆栈信息。
*
* @param e 需要判断的 SQLException。
* @return 始终返回 true，表示所有 SQLException 都是致命的。
*/
@Override
public boolean isExceptionFatal(SQLException e) {
e.printStackTrace(); // 打印异常堆栈信息
return true;
}
@Override
public void configFromProperties(Properties properties) {
// 配置信息可以为空
/**
* 从 Properties 对象中配置异常处理器。
* 此方法可以留空，因为 CustomExceptionSorter 没有需要配置的属性。
*
* @param properties 包含配置信息的 Properties 对象。
*/
@Override
public void configFromProperties(Properties properties) {
// 可以留空，因为 CustomExceptionSorter 没有需要配置的属性
}
}
}
}

80
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/utils/DateUtils.java
Unescape View File

@ -4,97 +4,99 @@ import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* 日期时间工具类，提供日期时间格式化、解析和当前时间获取等功能。
*/
public class DateUtils {
/**
* 默认日期格式 yyyy-MM-dd HH:mm:ss
* 默认日期时间格式：年-月-日 时:分:秒。
*/
public static final String DATETIME_DEFAULT_FORMAT = "yyyy-MM-dd HH:mm:ss";
/**
* 默认时间格式 HH:mm:ss
* 默认时间格式：时:分:秒。
*/
public static final String TIME_DEFAULT_FORMAT = "HH:mm:ss";
/**
* 年、月、日 yyyy-MM-dd
* 年、月、日格式：年-月-日。
*/
public static final String YYYY_MM_DD = "yyyy-MM-dd";
/**
* yyyy-MM-dd HH:mm
* 年、月、日、时、分格式：年-月-日 时:分。
*/
public static final String YYYY_MM_DD_HH_MM = "yyyy-MM-dd HH:mm";
/**
* 日期格式化功能类
* @param format
* @return
* 根据给定的格式字符串，获取SimpleDateFormat对象。
*
* @param format 日期格式字符串。
* @return SimpleDateFormat对象。
*/
public static SimpleDateFormat getDateFormat(String format){
public static SimpleDateFormat getDateFormat(String format) {
return new SimpleDateFormat(format);
}
/**
* 日期格式化处理
* @param date 要格式化的日期
* @param format 格式化字符串
* @return 格式化后的日期
* 将Date对象按照指定格式转换为字符串。
*
* @param date 要格式化的日期对象。
* @param format 格式化模式。
* @return 格式化后的日期字符串。
*/
public static String formatDateTime(Date date, String format ){
public static String formatDateTime(Date date, String format) {
return getDateFormat(format).format(date);
}
/**
* 转换字符串为日期类型
* @param date 要转换的日期字符串
* @param format 转换的格式
* @return 转换后的日期
* @throws ParseException
* 将字符串按照指定格式解析为Date对象。
*
* @param date 要解析的日期字符串。
* @param format 解析的格式。
* @return 解析后的Date对象。
* @throws ParseException 如果解析过程中发生错误，则抛出ParseException异常。
*/
public static Date parseDate(String date, String format) throws ParseException {
return getDateFormat(format).parse(date);
}
/**
* 获取当前时间戳
* @return
* 获取当前系统时间的毫秒值（时间戳）。
*
* @return 当前时间的毫秒值。
*/
public static long getCurrent() {
return System.currentTimeMillis();
}
/**
* 获取指定格式的系统时间(当前时间)
* @param format 指定的时间格式
* @return 当前系统时间
* 获取指定格式的当前系统时间字符串。
*
* @param format 指定的时间格式。
* @return 按照指定格式格式化的当前系统时间字符串。
*/
public static String getNowDate(String format){
public static String getNowDate(String format) {
return formatDateTime(new Date(), format);
}
/**
* 获取默认格式的当前系统时间(当前时间)
* 时间格式： yyyy-MM-dd HH:mm:ss
* @return 当前系统时间
* 获取默认格式的当前系统时间字符串。
* 时间格式为：年-月-日 时:分:秒。
*
* @return 默认格式的当前系统时间字符串。
*/
public static String getNowDate(){
public static String getNowDate() {
return formatDateTime(new Date(), DATETIME_DEFAULT_FORMAT);
}
/**
* 获取当前时间
* 时间格式：HH:mm:ss
* @return
* 获取当前时间字符串，格式为时:分:秒。
*
* @return 当前时间的字符串，格式为时:分:秒。
*/
public static String getNowTime(){
public static String getNowTime() {
return formatDateTime(new Date(), TIME_DEFAULT_FORMAT);
}
}

34
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/utils/IDUtils.java
Unescape View File

@ -3,29 +3,37 @@ package com.rabbiter.association.utils;
import java.util.UUID;
/**
* ID 处理工具类
* ID处理工具类，提供生成不同类型ID的方法。
*/
public class IDUtils {
/**
* 使用 UUID 生成32位系统ID
* @return
* 使用UUID生成32位系统ID。
* <p>UUID（Universally Unique Identifier）是一种软件构建时生成的唯一标识符。
* 标准形式的UUID是由32个16进制数字组成的字符串，以连字符分为五组，形式为8-4-4-4-12。
* 该方法生成的ID去掉了连字符，因此长度为32位。</p>
*
* @return 32位的UUID字符串。
*/
public static String makeIDByUUID() {
String id = UUID.randomUUID().toString().replaceAll("-","");
// 生成一个随机的UUID
String id = UUID.randomUUID().toString();
// 将UUID中的连字符去掉，返回一个没有连字符的32位字符串
id = id.replaceAll("-", "");
return id;
}
/**
* 使用时间戳生成ID, 13位
* @return
* 使用当前时间戳生成13位ID。
* <p>该方法基于当前的系统时间（毫秒值）生成一个ID，由于时间戳的精度是毫秒，
* 因此生成的ID具有很高的唯一性，但不会超过13位。</p>
*
* @return 13位的当前时间戳字符串。
*/
public static String makeIDByCurrent() {
// 调用DateUtils工具类的getCurrent()方法获取当前时间的毫秒值
Long mills = DateUtils.getCurrent();
// 将时间戳的Long值转换为String，并返回
return mills.toString();
}
}
}

123
springboota009社团管理系统/代码/AssociationManagerApi - idea/src/main/java/com/rabbiter/association/utils/StringUtils.java
Unescape View File

@ -4,101 +4,94 @@ import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 字符串处理工具类
* 字符串处理工具类，提供了一系列静态方法来处理字符串，包括检查字符串是否为空、是否包含特定字符等。
*/
public class StringUtils {
/**
* 检查指定的字符串是否为 NUll
* 返回true，指定的字符串是 NULL
* 返回false，指定的字符串不是 NULL
/**
* 检查指定的字符串是否为 NULL。
* 如果字符串为 NULL，则返回 true；否则返回 false。
*
* @param str 要检查的字符串
* @return
* @return true 如果字符串为 NULL，false 否则
*/
public static Boolean isNull(String str){
if(str == null){
public static Boolean isNull(String str) {
if (str == null) {
return true;
}
return false;
}
/**
* 检查指定的字符串是否不为 NUll
* 返回true，指定的字符串不为 NULL
* 返回false，指定的字符串是 NULL
* 检查指定的字符串是否不为 NULL。
* 如果字符串不为 NULL，则返回 true；否则返回 false。
*
* @param str 要检查的字符串
* @return
* @return true 如果字符串不为 NULL，false 否则
*/
public static Boolean isNotNull(String str){
public static Boolean isNotNull(String str) {
// 直接利用 isNull 方法的结果取反
Boolean flag = !isNull(str);
return flag;
}
/**
* 检查指定的字符串是否为 NULL 或者空字符串
* 返回true，指定的字符串是 NULL 或者空字符串
* 返回 false，指定的字符串不是 NULL 或者空字符粗
* 检查指定的字符串是否为 NULL 或者空字符串。
* 如果字符串为 NULL 或者空字符串，则返回 true；否则返回 false。
*
* @param str 要检查的字符串
* @return
* @return true 如果字符串为 NULL 或者空字符串，false 否则
*/
public static Boolean isNullOrEmpty(String str){
if(str == null){
public static Boolean isNullOrEmpty(String str) {
// 先检查字符串是否为 NULL，如果是，则返回 true
if (str == null) {
return true;
}
if(str.length() <= 0){
// 再检查字符串长度是否为 0，如果是，则返回 true
if (str.length() <= 0) {
return true;
}
return false;
}
/**
* 检查指定的字符串是否不为 NULL 或者空字符串
* 返回true，指定的字符串不是 NULL 或者空字符串
* 返回 false，指定的字符串是 NULL 或者空字符粗
* @param str
* @return
* 检查指定的字符串是否不为 NULL 或者空字符串。
* 如果字符串不为 NULL 且不为空字符串，则返回 true；否则返回 false。
*
* @param str 要检查的字符串
* @return true 如果字符串不为 NULL 且不为空字符串，false 否则
*/
public static Boolean isNotNullOrEmpty(String str){
public static Boolean isNotNullOrEmpty(String str) {
// 直接利用 isNullOrEmpty 方法的结果取反
Boolean flag = !isNullOrEmpty(str);
return flag;
}
/**
* 检查指定的字符串中
* @param str 要检查的字符串
* @param flag 指定的字符串
* @return
*/
public static boolean isExit(String str, String flag) {
if(str.indexOf(flag) > 0) {
return false;
}
return true;
}
* 检查指定的字符串中是否包含特定的字符或子字符串。
* 如果字符串中包含指定的字符或子字符串，则返回 false；否则返回 true。
*
* @param str 要检查的字符串
* @param flag 要检查的特定字符或子字符串
* @return true 如果字符串中不包含指定的字符或子字符串，false 否则
*/
public static boolean isExit(String str, String flag) {
// 使用 indexOf 方法检查字符串中是否包含指定的字符或子字符串
if (str.indexOf(flag) > 0) {
return false;
}
return true;
}
/**
* 获取字符串的长度
* 如果字符串是 null，返回 0
* @param str
* @return
*/
public static int length(String str) {
return str == null ? 0 : str.length();
}
}
* 获取字符串的长度。
* 如果字符串为 null，则返回 0；否则返回字符串的实际长度。
*
* @param str 要获取长度的字符串
* @return 字符串的长度，如果字符串为 null，则返回 0
*/
public static int length(String str) {
// 使用三元运算符简化代码
return str == null ? 0 : str.length();
}
}

242
springboota009社团管理系统/代码/AssociationManagerVue/src/views/pages/ActiveLogs.vue
Unescape View File

@ -1,6 +1,9 @@
<template>
<!-- 外层容器 -->
<div class="fater-body-show">
<!-- 卡片组件，用于信息查询 -->
<el-card shadow="never">
<!-- 卡片头部 -->
<div
class="el-card-header"
slot="header"
@ -9,6 +12,7 @@
<i class="iconfont icon-r-find" style="font-size: 26px"></i>
信息查询
</div>
<!-- 信息查询表单 -->
<div>
<el-form :inline="true" :model="qryForm">
<el-form-item>
@ -26,6 +30,7 @@
</div>
</el-card>
<!-- 卡片组件，用于展示活动报名信息列表 -->
<el-card shadow="never">
<div slot="header">
<el-button
@ -37,6 +42,7 @@
>
</div>
<div>
<!-- 表格组件，用于展示活动报名信息 -->
<el-table
v-loading="loading"
element-loading-text="拼命加载中"
@ -64,6 +70,8 @@
prop="userId"
label="报名用户"
></el-table-column>
<!-- 操作列 -->
<el-table-column
align="center"
label="操作处理"
@ -85,6 +93,8 @@
</template>
</el-table-column>
</el-table>
<!-- 分页组件 -->
<el-pagination
v-if="pageTotal != 0"
style="margin-top: 15px"
@ -100,6 +110,7 @@
</div>
</el-card>
<!-- 添加信息对话框 -->
<el-dialog title="添加信息" width="600px" :visible.sync="showAddFlag">
<el-form label-width="90px" :model="activeLogsForm">
<el-form-item label="报名时间">
@ -139,6 +150,7 @@
</div>
</el-dialog>
<!-- 修改信息对话框 -->
<el-dialog title="修改信息" width="600px" :visible.sync="showUpdFlag">
<el-form label-width="90px" :model="activeLogsForm">
<el-form-item label="报名时间">
@ -180,131 +192,143 @@
</div>
</template>
<!-- 样式部分 -->
<style>
</style>
<!-- 脚本部分 -->
<script>
import {
getPageActiveLogs,
addActiveLogs,
updActiveLogs,
delActiveLogs,
getPageActiveLogs,
addActiveLogs,
updActiveLogs,
delActiveLogs,
} from "../../api";
export default {
data() {
return {
pageInfos: [],
pageIndex: 1,
pageSize: 10,
pageTotal: 0,
totalInfo: 0,
loading: true,
showAddFlag: false,
showUpdFlag: false,
qryForm: {
name: "",
},
activeLogsForm: {
id: "",
createTime: "",
activeId: "",
userId: "",
},
};
},
methods: {
getPageInfo(pageIndex, pageSize) {
getPageActiveLogs(pageIndex, pageSize).then((resp) => {
this.pageInfos = resp.data.data;
this.pageIndex = resp.data.pageIndex;
this.pageSize = resp.data.pageSize;
this.pageTotal = resp.data.pageTotal;
this.totalInfo = resp.data.count;
this.loading = false;
});
},
getPageLikeInfo() {
getPageActiveLogs(1, this.pageSize, this.qryForm.name).then(
(resp) => {
this.pageInfos = resp.data.data;
this.pageIndex = resp.data.pageIndex;
this.pageSize = resp.data.pageSize;
this.totalInfo = resp.data.count;
this.pageTotal = resp.data.pageTotal;
this.loading = false;
}
);
},
handleSizeChange(pageSize) {
this.getPageInfo(this.pageIndex, pageSize, this.qryForm.name);
},
handleCurrentChange(pageIndex) {
this.getPageInfo(pageIndex, this.pageSize, this.qryForm.name);
},
initForm() {
this.activeLogsForm = {
id: "",
createTime: "",
activeId: "",
userId: "",
};
},
showAddWin() {
this.showAddFlag = true;
},
showUpdWin(row) {
this.activeLogsForm = row;
this.showUpdFlag = true;
},
addInfo() {
addActiveLogs(this.activeLogsForm).then((resp) => {
this.$message({
message: resp.msg,
type: "success",
});
data() {
return {
pageInfos: [], // 存储活动报名信息列表
pageIndex: 1, // 当前页码
pageSize: 10, // 每页显示条数
pageTotal: 0, // 总页数
totalInfo: 0, // 总条数
loading: true, // 是否正在加载数据
showAddFlag: false, // 是否显示添加信息对话框
showUpdFlag: false, // 是否显示修改信息对话框
qryForm: { // 信息查询表单模型
name: "",
},
activeLogsForm: { // 活动报名信息表单模型
id: "",
createTime: "",
activeId: "",
userId: "",
},
};
},
methods: {
// 获取活动报名信息列表
getPageInfo(pageIndex, pageSize) {
getPageActiveLogs(pageIndex, pageSize).then((resp) => {
this.pageInfos = resp.data.data;
this.pageIndex = resp.data.pageIndex;
this.pageSize = resp.data.pageSize;
this.pageTotal = resp.data.pageTotal;
this.totalInfo = resp.data.count;
this.getPageInfo(1, this.pageSize);
this.loading = false;
});
},
// 根据条件获取活动报名信息列表
getPageLikeInfo() {
getPageActiveLogs(1, this.pageSize, this.qryForm.name).then(
(resp) => {
this.pageInfos = resp.data.data;
this.pageIndex = resp.data.pageIndex;
this.pageSize = resp.data.pageSize;
this.totalInfo = resp.data.count;
this.pageTotal = resp.data.pageTotal;
this.loading = false;
}
);
},
// 处理分页组件的每页大小变化事件
handleSizeChange(pageSize) {
this.getPageInfo(this.pageIndex, pageSize, this.qryForm.name);
},
// 处理分页组件的页码变化事件
handleCurrentChange(pageIndex) {
this.getPageInfo(pageIndex, this.pageSize, this.qryForm.name);
},
// 初始化表单
initForm() {
this.activeLogsForm = {
id: "",
createTime: "",
activeId: "",
userId: "",
};
},
// 显示添加信息对话框
showAddWin() {
this.showAddFlag = true;
},
// 显示修改信息对话框
showUpdWin(row) {
this.activeLogsForm = row;
this.showUpdFlag = true;
},
// 添加活动报名信息
addInfo() {
addActiveLogs(this.activeLogsForm).then((resp) => {
this.$message({
message: resp.msg,
type: "success",
});
this.showAddFlag = false;
this.getPageInfo(1, this.pageSize);
this.initForm();
});
},
updInfo() {
updActiveLogs(this.activeLogsForm).then((resp) => {
this.$message({
message: resp.msg,
type: "success",
});
this.showAddFlag = false;
this.getPageInfo(1, this.pageSize);
this.initForm();
});
},
// 修改活动报名信息
updInfo() {
updActiveLogs(this.activeLogsForm).then((resp) => {
this.$message({
message: resp.msg,
type: "success",
});
this.showUpdFlag = false;
this.getPageInfo(1, this.pageSize);
this.initForm();
});
},
delInfo(id) {
this.$confirm("即将删除相关信息, 是否继续?", "提示", {
confirmButtonText: "确定",
cancelButtonText: "取消",
type: "warning",
}).then(() => {
delActiveLogs(id).then((resp) => {
this.$message({
message: resp.msg,
type: "success",
});
this.showUpdFlag = false;
this.getPageInfo(1, this.pageSize);
});
});
},
this.initForm();
});
},
mounted() {
this.getPageInfo(1, this.pageSize);
// 删除活动报名信息
delInfo(id) {
this.$confirm("即将删除相关信息, 是否继续?", "提示", {
confirmButtonText: "确定",
cancelButtonText: "取消",
type: "warning",
}).then(() => {
delActiveLogs(id).then((resp) => {
this.$message({
message: resp.msg,
type: "success",
});
this.getPageInfo(1, this.pageSize);
});
});
},
},
mounted() {
this.getPageInfo(1, this.pageSize);
},
};
</script>

445
springboota009社团管理系统/代码/AssociationManagerVue/src/views/pages/ApplyLogs.vue
Unescape View File

@ -1,246 +1,231 @@
<template>
<div class="fater-body-show">
<el-card shadow="never">
<div
class="el-card-header"
slot="header"
style="font-size: 26px"
>
<i class="iconfont icon-r-find" style="font-size: 26px"></i>
信息查询
</div>
<div>
<el-form :inline="true" :model="qryForm">
<el-form-item>
<el-input
v-model="qryForm.teamName"
placeholder="输入团队名称…"
autocomplete="off"
></el-input>
</el-form-item>
<el-form-item>
<el-input
v-model="qryForm.userName"
placeholder="输入成员姓名…"
autocomplete="off"
></el-input>
</el-form-item>
<el-form-item>
<el-button type="primary" @click="getPageLikeInfo()" style="font-size: 18px">
搜索</el-button>
</el-form-item>
</el-form>
</div>
</el-card>
<el-card shadow="never">
<div>
<el-table
v-loading="loading"
element-loading-text="拼命加载中"
element-loading-spinner="el-icon-loading"
element-loading-background="rgba(124, 124, 124, 0.8)"
:data="pageInfos"
border
>
<el-table-column
align="center"
type="index"
></el-table-column>
<el-table-column
align="center"
prop="teamName"
label="社团名称"
></el-table-column>
<el-table-column
align="center"
prop="userName"
label="申请人姓名"
></el-table-column>
<el-table-column
align="center"
prop="userGender"
label="申请人性别"
></el-table-column>
<el-table-column
align="center"
prop="userPhone"
label="申请人电话"
></el-table-column>
<el-table-column
align="center"
prop="createTime"
label="申请时间"
></el-table-column>
<el-table-column
v-if="userType == 1"
align="center"
label="操作处理"
fixed="right"
width="240"
>
<template slot-scope="scope">
<el-button
v-if="scope.row.status == 0"
type="primary"
@click="updInfo(scope.row, 1)"
>
通过</el-button
>
<el-button
v-if="scope.row.status == 0"
type="danger"
@click="updInfo(scope.row, 2)"
>
驳回</el-button
>
<el-tag
effect="plain"
type="success"
v-if="scope.row.status == 1"
>已通过</el-tag
>
<el-tag
effect="plain"
type="danger"
v-if="scope.row.status == 2"
>已驳回</el-tag
>
</template>
</el-table-column>
<el-table-column v-else align="center" label="申请状态">
<template slot-scope="scope">
<el-tag
effect="plain"
type="warning"
v-if="scope.row.status == 0"
>审核中</el-tag
>
<el-tag
effect="plain"
type="success"
v-if="scope.row.status == 1"
>已通过</el-tag
>
<el-tag
effect="plain"
type="danger"
v-if="scope.row.status == 2"
>已驳回</el-tag
>
</template>
</el-table-column>
</el-table>
<el-pagination
v-if="pageTotal >= 0"
style="margin-top: 15px"
@size-change="handleSizeChange"
@current-change="handleCurrentChange"
:current-page="pageIndex"
:page-sizes="[5, 10, 20, 50]"
:page-size="pageSize"
layout="total, sizes, prev, pager, next, jumper"
:total="totalInfo"
>
</el-pagination>
</div>
</el-card>
</div>
<!-- 外层容器 -->
<div class="fater-body-show">
<!-- 卡片组件，用于信息查询 -->
<el-card shadow="never">
<!-- 卡片头部 -->
<div class="el-card-header" slot="header" style="font-size: 26px">
<i class="iconfont icon-r-find" style="font-size: 26px"></i>
信息查询
</div>
<!-- 信息查询表单 -->
<div>
<el-form :inline="true" :model="qryForm">
<!-- 输入团队名称 -->
<el-form-item>
<el-input v-model="qryForm.teamName"
placeholder="输入团队名称…"
autocomplete="off">
</el-input>
</el-form-item>
<!-- 输入成员姓名 -->
<el-form-item>
<el-input v-model="qryForm.userName"
placeholder="输入成员姓名…"
autocomplete="off">
</el-input>
</el-form-item>
<!-- 搜索按钮 -->
<el-form-item>
<el-button type="primary"
@click="getPageLikeInfo()"
style="font-size: 18px">
搜索
</el-button>
</el-form-item>
</el-form>
</div>
</el-card>
<!-- 卡片组件，用于展示社团申请信息列表 -->
<el-card shadow="never">
<div>
<!-- 表格组件，用于展示社团申请信息 -->
<el-table v-loading="loading" element-loading-text="拼命加载中" element-loading-spinner="el-icon-loading"
element-loading-background="rgba(124, 124, 124, 0.8)" :data="pageInfos" border>
<!-- 索引列 -->
<el-table-column align="center" type="index">
</el-table-column>
<!-- 社团名称列 -->
<el-table-column align="center"
prop="teamName"
label="社团名称">
</el-table-column>
<!-- 申请人姓名列 -->
<el-table-column align="center"
prop="userName"
label="申请人姓名">
</el-table-column>
<!-- 申请人性别列 -->
<el-table-column align="center"
prop="userGender"
label="申请人性别">
</el-table-column>
<!-- 申请人电话列 -->
<el-table-column align="center"
prop="userPhone"
label="申请人电话">
</el-table-column>
<!-- 申请时间列 -->
<el-table-column align="center"
prop="createTime"
label="申请时间">
</el-table-column>
<!-- 操作处理列（管理员视图） -->
<el-table-column v-if="userType == 1"
align="center" label="操作处理"
fixed="right" width="240">
<template slot-scope="scope">
<!-- 通过按钮 -->
<el-button v-if="scope.row.status == 0"
type="primary" @click="updInfo(scope.row, 1)">
通过
</el-button>
<!-- 驳回按钮 -->
<el-button v-if="scope.row.status == 0"
type="danger" @click="updInfo(scope.row, 2)">
驳回
</el-button>
<!-- 已通过标签 -->
<el-tag effect="plain" type="success"
v-if="scope.row.status == 1">
已通过
</el-tag>
<!-- 已驳回标签 -->
<el-tag effect="plain" type="danger"
v-if="scope.row.status == 2">
已驳回
</el-tag>
</template>
</el-table-column>
<!-- 申请状态列（非管理员视图） -->
<el-table-column v-else align="center" label="申请状态">
<template slot-scope="scope">
<!-- 审核中标签 -->
<el-tag effect="plain" type="warning"
v-if="scope.row.status == 0">
审核中
</el-tag>
<!-- 已通过标签 -->
<el-tag effect="plain" type="success"
v-if="scope.row.status == 1">
已通过
</el-tag>
<!-- 已驳回标签 -->
<el-tag effect="plain" type="danger"
v-if="scope.row.status == 2">
已驳回
</el-tag>
</template>
</el-table-column>
</el-table>
<!-- 分页组件 -->
<el-pagination v-if="pageTotal >= 0" style="margin-top: 15px" @size-change="handleSizeChange"
@current-change="handleCurrentChange" :current-page="pageIndex"
:page-sizes="[5, 10, 20, 50]" :page-size="pageSize" layout="total, sizes, prev, pager, next, jumper"
:total="totalInfo">
</el-pagination>
</div>
</el-card>
</div>
</template>
<!-- 样式部分 -->
<style>
</style>
<!-- 脚本部分 -->
<script>
import { getLoginUser, getPageApplyLogs, updApplyLogs } from "../../api";
export default {
data() {
return {
userType: "",
pageInfos: [],
pageIndex: 1,
pageSize: 10,
pageTotal: 0,
totalInfo: 0,
loading: true,
qryForm: {
token: this.$store.state.token,
teamName: "",
userName: "",
},
};
data() {
return {
userType: "", // 用户类型
pageInfos: [], // 存储社团申请信息列表
pageIndex: 1, // 当前页码
pageSize: 10, // 每页显示条数
pageTotal: 0, // 总页数
totalInfo: 0, // 总条数
loading: true, // 是否正在加载数据
qryForm: { // 信息查询表单模型
token: this.$store.state.token, // 用户token
teamName: "", // 团队名称
userName: "", // 成员姓名
},
};
},
methods: {
// 获取社团申请信息列表
getPageInfo(pageIndex, pageSize) {
getPageApplyLogs(pageIndex, pageSize, this.qryForm.token).then(
(resp) => {
this.pageInfos = resp.data.data;
this.pageIndex = resp.data.pageIndex;
this.pageSize = resp.data.pageSize;
this.pageTotal = resp.data.pageTotal;
this.totalInfo = resp.data.count;
this.loading = false;
}
);
},
methods: {
getPageInfo(pageIndex, pageSize) {
getPageApplyLogs(pageIndex, pageSize, this.qryForm.token).then(
(resp) => {
this.pageInfos = resp.data.data;
this.pageIndex = resp.data.pageIndex;
this.pageSize = resp.data.pageSize;
this.pageTotal = resp.data.pageTotal;
this.totalInfo = resp.data.count;
this.loading = false;
}
);
},
getPageLikeInfo() {
getPageApplyLogs(
1,
this.pageSize,
this.qryForm.token,
this.qryForm.teamName,
this.qryForm.userName
).then((resp) => {
this.pageInfos = resp.data.data;
this.pageIndex = resp.data.pageIndex;
this.pageSize = resp.data.pageSize;
this.totalInfo = resp.data.count;
this.pageTotal = resp.data.pageTotal;
this.loading = false;
});
},
handleSizeChange(pageSize) {
this.getPageInfo(
this.pageIndex,
pageSize,
this.qryForm.token,
this.qryForm.teamName,
this.qryForm.userName
);
},
handleCurrentChange(pageIndex) {
this.getPageInfo(
pageIndex,
this.pageSize,
this.qryForm.token,
this.qryForm.teamName,
this.qryForm.userName
);
},
updInfo(data, status) {
data["status"] = status;
updApplyLogs(data).then((resp) => {
this.$message({
message: resp.msg,
type: "success",
});
this.getPageInfo(1, this.pageSize);
this.initForm();
});
},
// 根据条件获取社团申请信息列表
getPageLikeInfo() {
getPageApplyLogs(1, this.pageSize, this.qryForm.token, this.qryForm.teamName, this.qryForm.userName).then((resp) => {
this.pageInfos = resp.data.data;
this.pageIndex = resp.data.pageIndex;
this.pageSize = resp.data.pageSize;
this.totalInfo = resp.data.count;
this.pageTotal = resp.data.pageTotal;
this.loading = false;
});
},
mounted() {
this.getPageInfo(1, this.pageSize, this.qryForm.token);
getLoginUser(this.$store.state.token).then((resp) => {
this.userType = resp.data.type;
// 处理分页组件的每页大小变化事件
handleSizeChange(pageSize) {
this.getPageInfo(this.pageIndex, pageSize, this.qryForm.token, this.qryForm.teamName, this.qryForm.userName);
},
// 处理分页组件的页码变化事件
handleCurrentChange(pageIndex) {
this.getPageInfo(pageIndex, this.pageSize, this.qryForm.token, this.qryForm.teamName, this.qryForm.userName);
},
// 更新社团申请信息状态
updInfo(data, status) {
data["status"] = status;
updApplyLogs(data).then((resp) => {
this.$message({
message: resp.msg,
type: "success",
});
this.getPageInfo(1, this.pageSize);
// 初始化表单
this.initForm();
});
},
},
mounted() {
// 组件挂载后获取社团申请信息列表
this.getPageInfo(1, this.pageSize, this.qryForm.token);
// 获取当前登录用户信息
getLoginUser(this.$store.state.token).then((resp) => {
this.userType = resp.data.type;
});
},
};
</script>
Write Preview
Loading…
Cancel
Save