p63l5o8xk
/
ClubManagementSystem
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

xiu8

Browse Source
main
YZY 4 months ago
parent 562311e111
commit 4b5792d07b
28 changed files with 823 additions and 706 deletions
Show Stats Download Patch File Download Diff File

2
server/.idea/workspace.xml
Unescape View File

@ -146,7 +146,7 @@
<workItem from="1744197535410" duration="1873000" /> <workItem from="1744197535410" duration="1873000" />
<workItem from="1744199899989" duration="1551000" /> <workItem from="1744199899989" duration="1551000" />
<workItem from="1744202106298" duration="8351000" /> <workItem from="1744202106298" duration="8351000" />
<workItem from="1744270789267" duration="1977000" /> <workItem from="1744270789267" duration="3666000" />
</task> </task>
<servers /> <servers />
</component> </component>

18
server/src/main/java/self/cases/teams/dao/ActiveLogsDao.java
Unescape View File

@ -1,17 +1,15 @@
package self.cases.teams.dao; package self.cases.teams.dao; // 定义包路径，存放与团队案例相关的数据访问层类
import org.springframework.stereotype.Repository; import org.springframework.stereotype.Repository; // 导入 Spring 的 Repository 注解，用于标记数据访问层组件
import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入 MyBatis-Plus 提供的 BaseMapper 基础接口，简化 CRUD 操作
import com.baomidou.mybatisplus.core.mapper.BaseMapper; import self.cases.teams.entity.ActiveLogs; // 引入 ActiveLogs 实体类，表示报名记录的模型
import self.cases.teams.entity.ActiveLogs;
/** /**
* 数据层处理接口 * 数据层处理接口
* 报名记录 * 报名记录
*/ */ // 文档注释，描述该接口的作用是处理报名记录的数据操作
@Repository("activeLogsDao")
public interface ActiveLogsDao extends BaseMapper<ActiveLogs> {
@Repository("activeLogsDao") // 使用 Spring 的 Repository 注解，将该接口注册为 Spring 容器中的 Bean，并命名为 "activeLogsDao"
public interface ActiveLogsDao extends BaseMapper<ActiveLogs> { // 定义 ActiveLogsDao 接口，继承自 MyBatis-Plus 的 BaseMapper，泛型指定为 ActiveLogs 实体类
} } // 接口结束符号

91
server/src/main/java/self/cases/teams/dao/ActivitiesDao.java
Unescape View File

@ -1,49 +1,51 @@
package self.cases.teams.dao; package self.cases.teams.dao; // 定义包路径，存放与团队案例相关的数据访问层类
import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; // 导入 MyBatis-Plus 的分页插件，用于支持分页查询
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param; // 导入 MyBatis 的 Param 注解，用于标注方法参数
import org.apache.ibatis.annotations.Select; import org.apache.ibatis.annotations.Select; // 导入 MyBatis 的 Select 注解，用于标注查询方法
import org.springframework.stereotype.Repository; import org.springframework.stereotype.Repository; // 导入 Spring 的 Repository 注解，用于标记数据访问层组件
import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入 MyBatis-Plus 提供的 BaseMapper 基础接口，简化 CRUD 操作
import self.cases.teams.entity.Activities; import self.cases.teams.entity.Activities; // 引入 Activities 实体类，表示活动信息的模型
import java.util.Map; import java.util.Map; // 导入 Map 集合，用于存储查询结果
/** /**
* 数据层处理接口 * 数据层处理接口
* 活动信息 * 活动信息
*/ */ // 文档注释，描述该接口的作用是处理活动信息的数据操作
@Repository("activitiesDao")
public interface ActivitiesDao extends BaseMapper<Activities> { @Repository("activitiesDao") // 使用 Spring 的 Repository 注解，将该接口注册为 Spring 容器中的 Bean，并命名为 "activitiesDao"
public interface ActivitiesDao extends BaseMapper<Activities> { // 定义 ActivitiesDao 接口，继承自 MyBatis-Plus 的 BaseMapper，泛型指定为 Activities 实体类
/** /**
* 分页查看全部活动信息 * 分页查看全部活动信息
* @param page 分页信息 * @param page 分页信息
* @param activeName 活动名称 * @param activeName 活动名称
* @param teamName 团队名称 * @param teamName 团队名称
* @return * @return 返回分页结果集
*/ */
@Select("<script>" + @Select("" + // 使用 MyBatis 的 SQL 注解，定义查询语句
"SELECT " + "SELECT " +
"a.id, a.name, a.comm, a.detail, a.ask, a.total, " + "a.id, a.name, a.comm, a.detail, a.ask, a.total, " +
"a.active_time activeTime, a.team_id teamId, t.name teamName " + "a.active_time activeTime, a.team_id teamId, t.name teamName " + // 查询字段映射
"FROM activities a, teams t " + "FROM activities a, teams t " + // 表关联
"<where>" + "<where>" + // 动态条件标签
"a.team_id = t.id " + "a.team_id = t.id " + // 固定条件：活动表与团队表通过 team_id 关联
"<if test='teamName != null and teamName.trim() != &quot;&quot; '>" + "<if test='teamName != null and teamName.trim() != &quot;&quot; '>" + // 动态条件：如果团队名称不为空，则添加模糊匹配条件
"AND t.name LIKE CONCAT('%', #{teamName}, '%') " + "AND t.name LIKE CONCAT('%', #{teamName}, '%') " + // 模糊匹配团队名称
"</if>" + "</if>" +
"<if test='activeName != null and activeName.trim() != &quot;&quot; '>" + "<if test='activeName != null and activeName.trim() != &quot;&quot; '>" + // 动态条件：如果活动名称不为空，则添加模糊匹配条件
"AND a.name LIKE CONCAT('%', #{activeName}, '%') " + "AND a.name LIKE CONCAT('%', #{activeName}, '%') " + // 模糊匹配活动名称
"</if>" + "</if>" +
"</where>" + "</where>" + // 结束动态条件
"ORDER BY a.active_time DESC" + "ORDER BY a.active_time DESC" + // 按活动时间倒序排序
"</script>") "")
public Page<Map<String, Object>> qryPageAll(Page<Map<String, Object>> page, public Page<Map<String, Object>> qryPageAll( // 定义分页查询方法
@Param("activeName") String activeName, Page<Map<String, Object>> page, // 分页参数
@Param("teamName") String teamName); @Param("activeName") String activeName, // 活动名称参数
@Param("teamName") String teamName); // 团队名称参数
/** /**
* 分页查询指定成员相关的活动信息 * 分页查询指定成员相关的活动信息
@ -51,26 +53,27 @@ public interface ActivitiesDao extends BaseMapper<Activities> {
* @param memId 成员ID * @param memId 成员ID
* @param activeName 活动名称 * @param activeName 活动名称
* @param teamName 团队名称 * @param teamName 团队名称
* @return * @return 返回分页结果集
*/ */
@Select("<script>" + @Select("" + // 使用 MyBatis 的 SQL 注解，定义查询语句
"SELECT " + "SELECT " +
"a.id, a.name, a.comm, a.detail, a.ask, a.total, " + "a.id, a.name, a.comm, a.detail, a.ask, a.total, " +
"a.active_time activeTime, a.team_id teamId, t.name teamName " + "a.active_time activeTime, a.team_id teamId, t.name teamName " + // 查询字段映射
"FROM activities a, teams t " + "FROM activities a, teams t " + // 表关联
"<where>" + "<where>" + // 动态条件标签
"a.team_id = t.id AND a.team_id IN (SELECT team_id FROM members WHERE user_id = #{memId}) " + "a.team_id = t.id AND a.team_id IN (SELECT team_id FROM members WHERE user_id = #{memId}) " + // 固定条件：活动表与团队表通过 team_id 关联，且团队 ID 在成员表中
"<if test='teamName != null and teamName.trim() != &quot;&quot; '>" + "<if test='teamName != null and teamName.trim() != &quot;&quot; '>" + // 动态条件：如果团队名称不为空，则添加模糊匹配条件
"AND t.name LIKE CONCAT('%', #{teamName}, '%') " + "AND t.name LIKE CONCAT('%', #{teamName}, '%') " + // 模糊匹配团队名称
"</if>" + "</if>" +
"<if test='activeName != null and activeName.trim() != &quot;&quot; '>" + "<if test='activeName != null and activeName.trim() != &quot;&quot; '>" + // 动态条件：如果活动名称不为空，则添加模糊匹配条件
"AND a.name LIKE CONCAT('%', #{activeName}, '%') " + "AND a.name LIKE CONCAT('%', #{activeName}, '%') " + // 模糊匹配活动名称
"</if>" + "</if>" +
"</where>" + "</where>" + // 结束动态条件
"ORDER BY a.active_time DESC" + "ORDER BY a.active_time DESC" + // 按活动时间倒序排序
"</script>") "")
public Page<Map<String, Object>> qryPageByMemId(Page<Map<String, Object>> page, public Page<Map<String, Object>> qryPageByMemId( // 定义分页查询方法
@Param("memId") String memId, Page<Map<String, Object>> page, // 分页参数
@Param("activeName") String activeName, @Param("memId") String memId, // 成员 ID 参数
@Param("teamName") String teamName); @Param("activeName") String activeName, // 活动名称参数
@Param("teamName") String teamName); // 团队名称参数
} }

104
server/src/main/java/self/cases/teams/dao/ApplyLogsDao.java
Unescape View File

@ -1,22 +1,22 @@
package self.cases.teams.dao; package self.cases.teams.dao; // 定义包路径，存放与团队案例相关的数据访问层类
import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; // 导入 MyBatis-Plus 的分页插件，用于支持分页查询
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param; // 导入 MyBatis 的 Param 注解，用于标注方法参数
import org.apache.ibatis.annotations.Select; import org.apache.ibatis.annotations.Select; // 导入 MyBatis 的 Select 注解，用于标注查询方法
import org.springframework.stereotype.Repository; import org.springframework.stereotype.Repository; // 导入 Spring 的 Repository 注解，用于标记数据访问层组件
import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入 MyBatis-Plus 提供的 BaseMapper 基础接口，简化 CRUD 操作
import self.cases.teams.entity.ApplyLogs; import self.cases.teams.entity.ApplyLogs; // 引入 ApplyLogs 实体类，表示申请记录信息的模型
import java.util.Map; import java.util.Map; // 导入 Map 集合，用于存储查询结果
/** /**
* 数据层处理接口 * 数据层处理接口
* 申请记录 * 申请记录
*/ */ // 文档注释，描述该接口的作用是处理申请记录的数据操作
@Repository("applyLogsDao") @Repository("applyLogsDao") // 使用 Spring 的 Repository 注解，将该接口注册为 Spring 容器中的 Bean，并命名为 "applyLogsDao"
public interface ApplyLogsDao extends BaseMapper<ApplyLogs> { public interface ApplyLogsDao extends BaseMapper<ApplyLogs> { // 定义 ApplyLogsDao 接口，继承自 MyBatis-Plus 的 BaseMapper，泛型指定为 ApplyLogs 实体类
/** /**
* 分页查询申请记录 * 分页查询申请记录
@ -24,31 +24,32 @@ public interface ApplyLogsDao extends BaseMapper<ApplyLogs> {
* @param userId 用户ID * @param userId 用户ID
* @param teamName 社团名称 * @param teamName 社团名称
* @param userName 用户姓名 * @param userName 用户姓名
* @return * @return 返回分页结果集
*/ */
@Select("<script>" + @Select("" + // 使用 MyBatis 的 SQL 注解，定义查询语句
"SELECT " + "SELECT " +
"al.id, al.status, al.create_time createTime, al.team_id teamId, al.user_id userId, " + "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 " + "t.name teamName, u.name userName, u.gender userGender, u.age userAge, u.phone userPhone " + // 查询字段映射
"FROM apply_logs al, teams t, users u " + "FROM apply_logs al, teams t, users u " + // 表关联
"<where> " + "<where> " + // 动态条件标签
"al.user_id = u.id AND al.team_id = t.id " + "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() != &quot;&quot; '>" + // 动态条件：如果社团名称不为空，则添加模糊匹配条件
"AND t.name LIKE CONCAT('%', #{teamName}, '%') " + "AND t.name LIKE CONCAT('%', #{teamName}, '%') " + // 模糊匹配社团名称
"</if>" + "</if>" +
"<if test='userName != null and userName.trim() != &quot;&quot; '>" + "<if test='userName != null and userName.trim() != &quot;&quot; '>" + // 动态条件：如果用户姓名不为空，则添加模糊匹配条件
"AND u.name LIKE CONCAT('%', #{userName}, '%') " + "AND u.name LIKE CONCAT('%', #{userName}, '%') " + // 模糊匹配用户姓名
"</if>" + "</if>" +
"<if test='userId != null and userId.trim() != &quot;&quot; '>" + "<if test='userId != null and userId.trim() != &quot;&quot; '>" + // 动态条件：如果用户 ID 不为空，则添加精确匹配条件
"AND al.user_id = #{userId} " + "AND al.user_id = #{userId} " + // 精确匹配用户 ID
"</if>" + "</if>" +
"</where>" + "</where>" + // 结束动态条件
"ORDER BY al.create_time DESC " + "ORDER BY al.create_time DESC " + // 按创建时间倒序排序
"</script>") "")
public Page<Map<String, Object>> qryPageInfo(Page<Map<String, Object>> page, public Page<Map<String, Object>> qryPageInfo( // 定义分页查询方法
@Param("userId") String userId, Page<Map<String, Object>> page, // 分页参数
@Param("teamName") String teamName, @Param("userId") String userId, // 用户 ID 参数
@Param("userName") String userName); @Param("teamName") String teamName, // 社团名称参数
@Param("userName") String userName); // 用户姓名参数
/** /**
* 分页查询申请记录 * 分页查询申请记录
@ -56,29 +57,30 @@ public interface ApplyLogsDao extends BaseMapper<ApplyLogs> {
* @param userId 用户ID * @param userId 用户ID
* @param teamName 社团名称 * @param teamName 社团名称
* @param userName 用户姓名 * @param userName 用户姓名
* @return * @return 返回分页结果集
*/ */
@Select("<script>" + @Select("" + // 使用 MyBatis 的 SQL 注解，定义查询语句
"SELECT " + "SELECT " +
"al.id, al.status, al.create_time createTime, al.team_id teamId, al.user_id userId, " + "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 " + "t.name teamName, u.name userName, u.gender userGender, u.age userAge, u.phone userPhone " + // 查询字段映射
"FROM apply_logs al, teams t, users u " + "FROM apply_logs al, teams t, users u " + // 表关联
"<where> " + "<where> " + // 动态条件标签
"al.user_id = u.id AND al.team_id = t.id " + "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() != &quot;&quot; '>" + // 动态条件：如果社团名称不为空，则添加模糊匹配条件
"AND t.name LIKE CONCAT('%', #{teamName}, '%') " + "AND t.name LIKE CONCAT('%', #{teamName}, '%') " + // 模糊匹配社团名称
"</if>" + "</if>" +
"<if test='userName != null and userName.trim() != &quot;&quot; '>" + "<if test='userName != null and userName.trim() != &quot;&quot; '>" + // 动态条件：如果用户姓名不为空，则添加模糊匹配条件
"AND u.name LIKE CONCAT('%', #{userName}, '%') " + "AND u.name LIKE CONCAT('%', #{userName}, '%') " + // 模糊匹配用户姓名
"</if>" + "</if>" +
"<if test='userId != null and userId.trim() != &quot;&quot; '>" + "<if test='userId != null and userId.trim() != &quot;&quot; '>" + // 动态条件：如果用户 ID 或社团管理员 ID 不为空，则添加匹配条件
"AND (al.user_id = #{userId} OR t.manager = #{userId}) " + "AND (al.user_id = #{userId} OR t.manager = #{userId}) " + // 精确匹配用户 ID 或社团管理员 ID
"</if>" + "</if>" +
"</where>" + "</where>" + // 结束动态条件
"ORDER BY al.create_time DESC " + "ORDER BY al.create_time DESC " + // 按创建时间倒序排序
"</script>") "")
public Page<Map<String, Object>> qryManPageInfo(Page<Map<String, Object>> page, public Page<Map<String, Object>> qryManPageInfo( // 定义分页查询方法
@Param("userId") String userId, Page<Map<String, Object>> page, // 分页参数
@Param("teamName") String teamName, @Param("userId") String userId, // 用户 ID 参数
@Param("userName") String userName); @Param("teamName") String teamName, // 社团名称参数
@Param("userName") String userName); // 用户姓名参数
} }

96
server/src/main/java/self/cases/teams/dao/MembersDao.java
Unescape View File

@ -1,76 +1,78 @@
package self.cases.teams.dao; package self.cases.teams.dao; // 定义包路径，存放与团队案例相关的数据访问层类
import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; // 导入 MyBatis-Plus 的分页插件，用于支持分页查询
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param; // 导入 MyBatis 的 Param 注解，用于标注方法参数
import org.apache.ibatis.annotations.Select; import org.apache.ibatis.annotations.Select; // 导入 MyBatis 的 Select 注解，用于标注查询方法
import org.springframework.stereotype.Repository; import org.springframework.stereotype.Repository; // 导入 Spring 的 Repository 注解，用于标记数据访问层组件
import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入 MyBatis-Plus 提供的 BaseMapper 基础接口，简化 CRUD 操作
import self.cases.teams.entity.Members; import self.cases.teams.entity.Members; // 引入 Members 实体类，表示社团成员信息的模型
import java.util.Map; import java.util.Map; // 导入 Map 集合，用于存储查询结果
/** /**
* 数据层处理接口 * 数据层处理接口
* 成员信息 * 成员信息
*/ */ // 文档注释，描述该接口的作用是处理成员信息的数据操作
@Repository("membersDao") @Repository("membersDao") // 使用 Spring 的 Repository 注解，将该接口注册为 Spring 容器中的 Bean，并命名为 "membersDao"
public interface MembersDao extends BaseMapper<Members> { public interface MembersDao extends BaseMapper<Members> { // 定义 MembersDao 接口，继承自 MyBatis-Plus 的 BaseMapper，泛型指定为 Members 实体类
/** /**
* 分页查看社团成员信息 * 分页查看社团成员信息
* @param page 分页参数 * @param page 分页参数
* @param teamName 社团名称 * @param teamName 社团名称
* @param userName 用户姓名 * @param userName 用户姓名
* @return * @return 返回分页结果集
*/ */
@Select("<script>" + @Select("" + // 使用 MyBatis 的 SQL 注解，定义查询语句
"SELECT " + "SELECT " +
"m.id, m.create_time createTime, m.team_id teamId, m.user_id userId, " + "m.id, m.create_time createTime, m.team_id teamId, m.user_id userId, " + // 查询字段映射
"t.name teamName, t.total, u.name userName, u.gender userGender, u.age userAge, u.phone userPhone " + "t.name teamName, t.total, u.name userName, u.gender userGender, u.age userAge, u.phone userPhone " + // 查询字段映射
"FROM members m, teams t, users u " + "FROM members m, teams t, users u " + // 表关联
"<where> " + "<where> " + // 动态条件标签
"m.user_id = u.id AND m.team_id = t.id " + "m.user_id = u.id AND m.team_id = t.id " + // 固定条件：成员表与用户表、社团表通过外键关联
"<if test='teamName != null and teamName.trim() != &quot;&quot; '>" + "<if test='teamName != null and teamName.trim() != &quot;&quot; '>" + // 动态条件：如果社团名称不为空，则添加模糊匹配条件
"AND t.name LIKE CONCAT('%', #{teamName}, '%') " + "AND t.name LIKE CONCAT('%', #{teamName}, '%') " + // 模糊匹配社团名称
"</if>" + "</if>" +
"<if test='userName != null and userName.trim() != &quot;&quot; '>" + "<if test='userName != null and userName.trim() != &quot;&quot; '>" + // 动态条件：如果用户姓名不为空，则添加模糊匹配条件
"AND u.name LIKE CONCAT('%', #{userName}, '%') " + "AND u.name LIKE CONCAT('%', #{userName}, '%') " + // 模糊匹配用户姓名
"</if>" + "</if>" +
"</where>" + "</where>" + // 结束动态条件
"ORDER BY m.create_time DESC" + "ORDER BY m.create_time DESC" + // 按创建时间倒序排序
"</script>") "")
public Page<Map<String, Object>> qryPageAll(Page<Map<String, Object>> page, public Page<Map<String, Object>> qryPageAll( // 定义分页查询方法
@Param("teamName") String teamName, Page<Map<String, Object>> page, // 分页参数
@Param("userName") String userName); @Param("teamName") String teamName, // 社团名称参数
@Param("userName") String userName); // 用户姓名参数
/** /**
* 依据社团管理员ID获取社团成员信息 * 依据社团管理员ID获取社团成员信息
* @param page 分页参数 * @param page 分页参数
* @param manId 管理员ID * @param manId 管理员ID
* @param teamName 社团名称 * @param teamName 社团名称
* @param userName 用户姓名 * @param userName 用户姓名
* @return * @return 返回分页结果集
*/ */
@Select("<script>" + @Select("" + // 使用 MyBatis 的 SQL 注解，定义查询语句
"SELECT " + "SELECT " +
"m.id, m.create_time createTime, m.team_id teamId, m.user_id userId, " + "m.id, m.create_time createTime, m.team_id teamId, m.user_id userId, " + // 查询字段映射
"t.name teamName, t.total, u.name userName, u.gender userGender, u.age userAge, u.phone userPhone " + "t.name teamName, t.total, u.name userName, u.gender userGender, u.age userAge, u.phone userPhone " + // 查询字段映射
"FROM members m, teams t, users u " + "FROM members m, teams t, users u " + // 表关联
"<where> " + "<where> " + // 动态条件标签
"m.user_id = u.id AND m.team_id = t.id AND t.manager = #{manId} " + "m.user_id = u.id AND m.team_id = t.id AND t.manager = #{manId} " + // 固定条件：成员表与用户表、社团表通过外键关联，并且筛选出指定管理员管理的社团
"<if test='teamName != null and teamName.trim() != &quot;&quot; '>" + "<if test='teamName != null and teamName.trim() != &quot;&quot; '>" + // 动态条件：如果社团名称不为空，则添加模糊匹配条件
"AND t.name LIKE CONCAT('%', #{teamName}, '%') " + "AND t.name LIKE CONCAT('%', #{teamName}, '%') " + // 模糊匹配社团名称
"</if>" + "</if>" +
"<if test='userName != null and userName.trim() != &quot;&quot; '>" + "<if test='userName != null and userName.trim() != &quot;&quot; '>" + // 动态条件：如果用户姓名不为空，则添加模糊匹配条件
"AND u.name LIKE CONCAT('%', #{userName}, '%') " + "AND u.name LIKE CONCAT('%', #{userName}, '%') " + // 模糊匹配用户姓名
"</if>" + "</if>" +
"</where>" + "</where>" + // 结束动态条件
"ORDER BY m.create_time DESC" + "ORDER BY m.create_time DESC" + // 按创建时间倒序排序
"</script>") "")
public Page<Map<String, Object>> qryPageByManId(Page<Map<String, Object>> page, public Page<Map<String, Object>> qryPageByManId( // 定义分页查询方法
@Param("manId") String manId, Page<Map<String, Object>> page, // 分页参数
@Param("teamName") String teamName, @Param("manId") String manId, // 管理员 ID 参数
@Param("userName") String userName); @Param("teamName") String teamName, // 社团名称参数
@Param("userName") String userName); // 用户姓名参数
} }

136
server/src/main/java/self/cases/teams/dao/NoticesDao.java
Unescape View File

@ -1,89 +1,89 @@
package self.cases.teams.dao; package self.cases.teams.dao; // 定义包路径，存放与团队案例相关的数据访问层类
import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; // 导入 MyBatis-Plus 的分页插件，用于支持分页查询
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param; // 导入 MyBatis 的 Param 注解，用于标注方法参数
import org.apache.ibatis.annotations.Select; import org.apache.ibatis.annotations.Select; // 导入 MyBatis 的 Select 注解，用于标注查询方法
import org.springframework.stereotype.Repository; import org.springframework.stereotype.Repository; // 导入 Spring 的 Repository 注解，用于标记数据访问层组件
import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入 MyBatis-Plus 提供的 BaseMapper 基础接口，简化 CRUD 操作
import self.cases.teams.entity.Notices; import self.cases.teams.entity.Notices; // 引入 Notices 实体类，表示通知记录的模型
import java.util.List; import java.util.List; // 导入 List 集合，用于存储查询结果
import java.util.Map; import java.util.Map; // 导入 Map 集合，用于存储查询结果
/** /**
* 数据层处理接口 * 数据层处理接口
* 通知记录 * 通知记录
*/ */ // 文档注释，描述该接口的作用是处理通知记录的数据操作
@Repository("noticesDao") @Repository("noticesDao") // 使用 Spring 的 Repository 注解，将该接口注册为 Spring 容器中的 Bean，并命名为 "noticesDao"
public interface NoticesDao extends BaseMapper<Notices> { public interface NoticesDao extends BaseMapper<Notices> { // 定义 NoticesDao 接口，继承自 MyBatis-Plus 的 BaseMapper，泛型指定为 Notices 实体类
/** /**
* 获取系统通知 * 获取系统通知
* @return * @return 返回所有系统通知列表
*/ */
@Select("<script>" + @Select("" + // 使用 MyBatis 的 SQL 注解，定义查询语句
"SELECT " + "SELECT " +
"id, title, detail, create_time createTime, team_id teamId " + "id, title, detail, create_time createTime, team_id teamId " + // 查询字段映射
"FROM notices " + "FROM notices " + // 指定表名
"WHERE team_id IS NULL " + "WHERE team_id IS NULL " + // 筛选条件：只查询没有绑定社团的通知（系统通知）
"ORDER BY create_time DESC " + "ORDER BY create_time DESC " + // 按创建时间倒序排序
"</script>") "")
public List<Notices> qrySysNotices(); public List<Notices> qrySysNotices(); // 定义获取系统通知的方法
/** /**
* 查询指定社团管理员相关通知信息列表 * 查询指定社团管理员相关通知信息列表
* @param manId 社团管理ID * @param manId 社团管理ID
* @return * @return 返回管理员相关的通知信息列表
*/ */
@Select("<script>" + @Select("" + // 使用 MyBatis 的 SQL 注解，定义查询语句
"SELECT " + "SELECT " +
"id, title, detail, create_time createTime, team_id teamId " + "id, title, detail, create_time createTime, team_id teamId " + // 查询字段映射
"FROM notices " + "FROM notices " + // 指定表名
"WHERE (team_id IS NULL) OR (team_id IN (SELECT team_id FROM members WHERE user_id = #{manId})) " + "WHERE (team_id IS NULL) OR (team_id IN (SELECT team_id FROM members WHERE user_id = #{manId})) " + // 筛选条件：查询没有绑定社团的通知（系统通知），或者属于该管理员管理的社团的通知
"ORDER BY create_time DESC " + "ORDER BY create_time DESC " + // 按创建时间倒序排序
"</script>") "")
public List<Notices> qryManNotices(String manId); public List<Notices> qryManNotices(String manId); // 定义查询管理员相关通知的方法
/** /**
* 查询指定社团成员相关通知信息列表 * 查询指定社团成员相关通知信息列表
* @param memId 社团成员ID * @param memId 社团成员ID
* @return * @return 返回成员相关的通知信息列表
*/ */
@Select("<script>" + @Select("" + // 使用 MyBatis 的 SQL 注解，定义查询语句
"SELECT " + "SELECT " +
"id, title, detail, create_time createTime, team_id teamId " + "id, title, detail, create_time createTime, team_id teamId " + // 查询字段映射
"FROM notices " + "FROM notices " + // 指定表名
"WHERE (team_id IS NULL) OR (team_id IN (SELECT team_id FROM members WHERE user_id = #{memId})) " + "WHERE (team_id IS NULL) OR (team_id IN (SELECT team_id FROM members WHERE user_id = #{memId})) " + // 筛选条件：查询没有绑定社团的通知（系统通知），或者属于该成员所在社团的通知
"ORDER BY create_time DESC " + "ORDER BY create_time DESC " + // 按创建时间倒序排序
"</script>") "")
public List<Notices> qryMemNotices(String memId); public List<Notices> qryMemNotices(String memId); // 定义查询成员相关通知的方法
/** /**
* 分页查找全部通知信息 * 分页查找全部通知信息
* @param page 分页参数 * @param page 分页参数
* @param title 通知标题 * @param title 通知标题
* @param teamName 团队名称 * @param teamName 团队名称
* @return * @return 返回分页后的通知信息集合
*/ */
@Select("<script>" + @Select("" + // 使用 MyBatis 的 SQL 注解，定义查询语句
"SELECT " + "SELECT " +
"n.id, n.title, n.detail, n.create_time createTime, n.team_id teamId, t.name teamName " + "n.id, n.title, n.detail, n.create_time createTime, n.team_id teamId, t.name teamName " + // 查询字段映射
"FROM notices n LEFT JOIN teams t ON n.team_id = t.id " + "FROM notices n LEFT JOIN teams t ON n.team_id = t.id " + // 左连接社团表，以便获取社团名称
"<where>" + "<where>" + // 动态条件标签
"<if test='teamName != null and teamName.trim() != &quot;&quot; '>" + "<if test='teamName != null and teamName.trim() != &quot;&quot; '>" + // 动态条件：如果社团名称不为空，则添加模糊匹配条件
"t.name LIKE CONCAT('%', #{teamName}, '%') " + "t.name LIKE CONCAT('%', #{teamName}, '%') " + // 模糊匹配社团名称
"</if>" + "</if>" +
"<if test='title != null and title.trim() != &quot;&quot; '>" + "<if test='title != null and title.trim() != &quot;&quot; '>" + // 动态条件：如果通知标题不为空，则添加模糊匹配条件
"AND n.title LIKE CONCAT('%', #{title}, '%') " + "AND n.title LIKE CONCAT('%', #{title}, '%') " + // 模糊匹配通知标题
"</if>" + "</if>" +
"</where>" + "</where>" + // 结束动态条件
"ORDER BY n.create_time DESC " + "ORDER BY n.create_time DESC " + // 按创建时间倒序排序
"</script>") "")
public Page<Map<String, Object>> qryPageAll(Page<Map<String, Object>> page, public Page<Map<String, Object>> qryPageAll(Page<Map<String, Object>> page, // 定义分页查询方法
@Param("title") String title, @Param("title") String title, // 通知标题参数
@Param("teamName") String teamName); @Param("teamName") String teamName); // 社团名称参数
/** /**
* 获取指定用户相关的通知信息 * 获取指定用户相关的通知信息
@ -91,25 +91,25 @@ public interface NoticesDao extends BaseMapper<Notices> {
* @param userId 指定用户ID * @param userId 指定用户ID
* @param title 通知标题 * @param title 通知标题
* @param teamName 团队名称 * @param teamName 团队名称
* @return * @return 返回指定用户相关的通知信息集合
*/ */
@Select("<script>" + @Select("" + // 使用 MyBatis 的 SQL 注解，定义查询语句
"SELECT " + "SELECT " +
"n.id, n.title, n.detail, n.create_time createTime, n.team_id teamId, t.name teamName " + "n.id, n.title, n.detail, n.create_time createTime, n.team_id teamId, t.name teamName " + // 查询字段映射
"FROM notices n JOIN teams t ON n.team_id = t.id " + "FROM notices n JOIN teams t ON n.team_id = t.id " + // 内连接社团表，确保社团存在
"<where>" + "<where>" + // 动态条件标签
"team_id IN (SELECT team_id FROM members WHERE user_id = #{userId}) " + "team_id IN (SELECT team_id FROM members WHERE user_id = #{userId}) " + // 固定条件：筛选属于指定用户所属社团的通知
"<if test='teamName != null and teamName.trim() != &quot;&quot; '>" + "<if test='teamName != null and teamName.trim() != &quot;&quot; '>" + // 动态条件：如果社团名称不为空，则添加模糊匹配条件
"AND t.name LIKE CONCAT('%', #{teamName}, '%') " + "AND t.name LIKE CONCAT('%', #{teamName}, '%') " + // 模糊匹配社团名称
"</if>" + "</if>" +
"<if test='title != null and title.trim() != &quot;&quot; '>" + "<if test='title != null and title.trim() != &quot;&quot; '>" + // 动态条件：如果通知标题不为空，则添加模糊匹配条件
"AND n.title LIKE CONCAT('%', #{title}, '%') " + "AND n.title LIKE CONCAT('%', #{title}, '%') " + // 模糊匹配通知标题
"</if>" + "</if>" +
"</where>" + "</where>" + // 结束动态条件
"ORDER BY n.create_time DESC " + "ORDER BY n.create_time DESC " + // 按创建时间倒序排序
"</script>") "")
public Page<Map<String, Object>> qryPageById(Page<Map<String, Object>> page, public Page<Map<String, Object>> qryPageById(Page<Map<String, Object>> page, // 定义分页查询方法
@Param("userId") String userId, @Param("userId") String userId, // 用户ID参数
@Param("title") String title, @Param("title") String title, // 通知标题参数
@Param("teamName") String teamName); @Param("teamName") String teamName); // 社团名称参数
} }

108
server/src/main/java/self/cases/teams/dao/PayLogsDao.java
Unescape View File

@ -1,22 +1,22 @@
package self.cases.teams.dao; package self.cases.teams.dao; // 定义包路径，存放与团队案例相关的数据访问层类
import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; // 导入 MyBatis-Plus 的分页插件，用于支持分页查询
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param; // 导入 MyBatis 的 Param 注解，用于标注方法参数
import org.apache.ibatis.annotations.Select; import org.apache.ibatis.annotations.Select; // 导入 MyBatis 的 Select 注解，用于标注查询方法
import org.springframework.stereotype.Repository; import org.springframework.stereotype.Repository; // 导入 Spring 的 Repository 注解，用于标记数据访问层组件
import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入 MyBatis-Plus 提供的 BaseMapper 基础接口，简化 CRUD 操作
import self.cases.teams.entity.PayLogs; import self.cases.teams.entity.PayLogs; // 引入 PayLogs 实体类，表示缴费记录的模型
import java.util.Map; import java.util.Map; // 导入 Map 集合，用于存储查询结果
/** /**
* 数据层处理接口 * 数据层处理接口
* 缴费记录 * 缴费记录
*/ */ // 文档注释，描述该接口的作用是处理缴费记录的数据操作
@Repository("payLogsDao") @Repository("payLogsDao") // 使用 Spring 的 Repository 注解，将该接口注册为 Spring 容器中的 Bean，并命名为 "payLogsDao"
public interface PayLogsDao extends BaseMapper<PayLogs> { public interface PayLogsDao extends BaseMapper<PayLogs> { // 定义 PayLogsDao 接口，继承自 MyBatis-Plus 的 BaseMapper，泛型指定为 PayLogs 实体类
/** /**
* 分页查询费用记录 * 分页查询费用记录
@ -24,53 +24,61 @@ public interface PayLogsDao extends BaseMapper<PayLogs> {
* @param userId 用户ID * @param userId 用户ID
* @param teamName 社团名称 * @param teamName 社团名称
* @param userName 用户姓名 * @param userName 用户姓名
* @return * @return 返回分页后的缴费记录集合
*/ */
@Select("<script>" + @Select("" + // 使用 MyBatis 的 SQL 注解，定义查询语句
"SELECT " + "SELECT " +
"pl.id, pl.create_time createTime, pl.total, pl.team_id teamId, pl.user_id userId, " + "pl.id, pl.create_time createTime, pl.total, pl.team_id teamId, pl.user_id userId, " + // 查询字段映射
"t.name teamName, u.name userName, u.gender userGender, u.age userAge, u.phone userPhone " + "t.name teamName, u.name userName, u.gender userGender, u.age userAge, u.phone userPhone " + // 查询字段映射
"FROM pay_logs pl, teams t, users u " + "FROM pay_logs pl, teams t, users u " + // 表关联：缴费记录表与社团表、用户表
"<where> " + "<where> " + // 动态条件标签
"pl.user_id = u.id AND pl.team_id = t.id " + "pl.user_id = u.id AND pl.team_id = t.id " + // 固定条件：确保缴费记录表与用户表、社团表关联
"<if test='teamName != null and teamName.trim() != &quot;&quot; '>" + "<if test='teamName != null and teamName.trim() != &quot;&quot; '>" + // 动态条件：如果社团名称不为空，则添加模糊匹配条件
"AND t.name LIKE CONCAT('%', #{teamName}, '%') " + "AND t.name LIKE CONCAT('%', #{teamName}, '%') " + // 模糊匹配社团名称
"</if>" + "</if>" +
"<if test='userName != null and userName.trim() != &quot;&quot; '>" + "<if test='userName != null and userName.trim() != &quot;&quot; '>" + // 动态条件：如果用户姓名不为空，则添加模糊匹配条件
"AND u.name LIKE CONCAT('%', #{userName}, '%') " + "AND u.name LIKE CONCAT('%', #{userName}, '%') " + // 模糊匹配用户姓名
"</if>" + "</if>" +
"<if test='userId != null and userId.trim() != &quot;&quot; '>" + "<if test='userId != null and userId.trim() != &quot;&quot; '>" + // 动态条件：如果用户ID不为空，则添加精确匹配条件
"AND pl.user_id = #{userId} " + "AND pl.user_id = #{userId} " + // 精确匹配用户ID
"</if>" + "</if>" +
"</where>" + "</where>" + // 结束动态条件
"ORDER BY pl.create_time DESC " + "ORDER BY pl.create_time DESC " + // 按创建时间倒序排序
"</script>") "")
public Page<Map<String, Object>> qryPageInfo(Page<Map<String, Object>> page, public Page<Map<String, Object>> qryPageInfo(Page<Map<String, Object>> page, // 定义分页查询方法
@Param("userId") String userId, @Param("userId") String userId, // 用户ID参数
@Param("teamName") String teamName, @Param("teamName") String teamName, // 社团名称参数
@Param("userName") String userName); @Param("userName") String userName); // 用户姓名参数
@Select("<script>" + /**
* 查询指定用户或管理员相关的缴费记录
* @param page 分页参数
* @param userId 用户ID或管理员ID
* @param teamName 社团名称
* @param userName 用户姓名
* @return 返回分页后的缴费记录集合
*/
@Select("" + // 使用 MyBatis 的 SQL 注解，定义查询语句
"SELECT " + "SELECT " +
"pl.id, pl.create_time createTime, pl.total, pl.team_id teamId, pl.user_id userId, " + "pl.id, pl.create_time createTime, pl.total, pl.team_id teamId, pl.user_id userId, " + // 查询字段映射
"t.name teamName, u.name userName, u.gender userGender, u.age userAge, u.phone userPhone " + "t.name teamName, u.name userName, u.gender userGender, u.age userAge, u.phone userPhone " + // 查询字段映射
"FROM pay_logs pl, teams t, users u " + "FROM pay_logs pl, teams t, users u " + // 表关联：缴费记录表与社团表、用户表
"<where> " + "<where> " + // 动态条件标签
"pl.user_id = u.id AND pl.team_id = t.id " + "pl.user_id = u.id AND pl.team_id = t.id " + // 固定条件：确保缴费记录表与用户表、社团表关联
"<if test='teamName != null and teamName.trim() != &quot;&quot; '>" + "<if test='teamName != null and teamName.trim() != &quot;&quot; '>" + // 动态条件：如果社团名称不为空，则添加模糊匹配条件
"AND t.name LIKE CONCAT('%', #{teamName}, '%') " + "AND t.name LIKE CONCAT('%', #{teamName}, '%') " + // 模糊匹配社团名称
"</if>" + "</if>" +
"<if test='userName != null and userName.trim() != &quot;&quot; '>" + "<if test='userName != null and userName.trim() != &quot;&quot; '>" + // 动态条件：如果用户姓名不为空，则添加模糊匹配条件
"AND u.name LIKE CONCAT('%', #{userName}, '%') " + "AND u.name LIKE CONCAT('%', #{userName}, '%') " + // 模糊匹配用户姓名
"</if>" + "</if>" +
"<if test='userId != null and userId.trim() != &quot;&quot; '>" + "<if test='userId != null and userId.trim() != &quot;&quot; '>" + // 动态条件：如果用户ID或管理员ID不为空，则添加匹配条件
"AND (pl.user_id = #{userId} OR t.manager = #{userId}) " + "AND (pl.user_id = #{userId} OR t.manager = #{userId}) " + // 匹配用户ID或管理员ID
"</if>" + "</if>" +
"</where>" + "</where>" + // 结束动态条件
"ORDER BY pl.create_time DESC " + "ORDER BY pl.create_time DESC " + // 按创建时间倒序排序
"</script>") "")
public Page<Map<String, Object>> qryManPageInfo(Page<Map<String, Object>> page, public Page<Map<String, Object>> qryManPageInfo(Page<Map<String, Object>> page, // 定义分页查询方法
@Param("userId") String userId, @Param("userId") String userId, // 用户ID或管理员ID参数
@Param("teamName") String teamName, @Param("teamName") String teamName, // 社团名称参数
@Param("userName") String userName); @Param("userName") String userName); // 用户姓名参数
} }

17
server/src/main/java/self/cases/teams/dao/TeamTypesDao.java
Unescape View File

@ -1,17 +1,16 @@
package self.cases.teams.dao; package self.cases.teams.dao; // 定义包路径，存放与团队案例相关的数据访问层类
import org.springframework.stereotype.Repository; import org.springframework.stereotype.Repository; // 导入 Spring 的 Repository 注解，用于标记数据访问层组件
import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入 MyBatis-Plus 提供的 BaseMapper 基础接口，简化 CRUD 操作
import self.cases.teams.entity.TeamTypes; import self.cases.teams.entity.TeamTypes; // 引入 TeamTypes 实体类，表示社团类型的模型
/** /**
* 数据层处理接口 * 数据层处理接口
* 社团类型 * 社团类型
*/ */ // 文档注释，描述该接口的作用是处理社团类型的数据操作
@Repository("teamTypesDao") @Repository("teamTypesDao") // 使用 Spring 的 Repository 注解，将该接口注册为 Spring 容器中的 Bean，并命名为 "teamTypesDao"
public interface TeamTypesDao extends BaseMapper<TeamTypes> { public interface TeamTypesDao extends BaseMapper<TeamTypes> { // 定义 TeamTypesDao 接口，继承自 MyBatis-Plus 的 BaseMapper，泛型指定为 TeamTypes 实体类
} // 结束接口定义
}

17
server/src/main/java/self/cases/teams/dao/TeamsDao.java
Unescape View File

@ -1,17 +1,16 @@
package self.cases.teams.dao; package self.cases.teams.dao; // 定义包路径，存放与团队案例相关的数据访问层类
import org.springframework.stereotype.Repository; import org.springframework.stereotype.Repository; // 导入 Spring 的 Repository 注解，用于标记数据访问层组件
import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入 MyBatis-Plus 提供的 BaseMapper 基础接口，简化 CRUD 操作
import self.cases.teams.entity.Teams; import self.cases.teams.entity.Teams; // 引入 Teams 实体类，表示社团信息的模型
/** /**
* 数据层处理接口 * 数据层处理接口
* 社团信息 * 社团信息
*/ */ // 文档注释，描述该接口的作用是处理社团信息的数据操作
@Repository("teamsDao") @Repository("teamsDao") // 使用 Spring 的 Repository 注解，将该接口注册为 Spring 容器中的 Bean，并命名为 "teamsDao"
public interface TeamsDao extends BaseMapper<Teams> { public interface TeamsDao extends BaseMapper<Teams> { // 定义 TeamsDao 接口，继承自 MyBatis-Plus 的 BaseMapper，泛型指定为 Teams 实体类
} // 结束接口定义
}

17
server/src/main/java/self/cases/teams/dao/UsersDao.java
Unescape View File

@ -1,17 +1,16 @@
package self.cases.teams.dao; package self.cases.teams.dao; // 定义包路径，存放与团队案例相关的数据访问层类
import org.springframework.stereotype.Repository; import org.springframework.stereotype.Repository; // 导入 Spring 的 Repository 注解，用于标记数据访问层组件
import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入 MyBatis-Plus 提供的 BaseMapper 基础接口，简化 CRUD 操作
import self.cases.teams.entity.Users; import self.cases.teams.entity.Users; // 引入 Users 实体类，表示系统用户的模型
/** /**
* 数据层处理接口 * 数据层处理接口
* 系统用户 * 系统用户
*/ */ // 文档注释，描述该接口的作用是处理系统用户的数据操作
@Repository("usersDao") @Repository("usersDao") // 使用 Spring 的 Repository 注解，将该接口注册为 Spring 容器中的 Bean，并命名为 "usersDao"
public interface UsersDao extends BaseMapper<Users> { public interface UsersDao extends BaseMapper<Users> { // 定义 UsersDao 接口，继承自 MyBatis-Plus 的 BaseMapper，泛型指定为 Users 实体类
} // 结束接口定义
}

66
server/src/main/java/self/cases/teams/msg/PageData.java
Unescape View File

@ -1,10 +1,10 @@
package self.cases.teams.msg; package self.cases.teams.msg; // 定义包名
import java.util.ArrayList; import java.util.ArrayList; // 导入 ArrayList 类
import java.util.List; import java.util.List; // 导入 List 接口
import java.util.Map; import java.util.Map; // 导入 Map 接口
public class PageData { public class PageData { // 定义分页数据封装类
// 当前页码 // 当前页码
private Long pageIndex; private Long pageIndex;
@ -19,73 +19,89 @@ public class PageData {
private Long count; private Long count;
// 分页查询包含的结果集 // 分页查询包含的结果集
private List<Map<String, Object>> data = new ArrayList<Map<String, Object>>(); private List<Map<String, Object>> data = new ArrayList<Map<String, Object>>(); // 初始化为一个空的 ArrayList
// 获取当前页码
public Long getPageIndex() { public Long getPageIndex() {
return pageIndex; return pageIndex;
} }
// 设置当前页码
public void setPageIndex(Long pageIndex) { public void setPageIndex(Long pageIndex) {
this.pageIndex = pageIndex; this.pageIndex = pageIndex; // 更新页码
} }
// 获取每页数据量
public Long getPageSize() { public Long getPageSize() {
return pageSize; return pageSize;
} }
// 设置每页数据量
public void setPageSize(Long pageSize) { public void setPageSize(Long pageSize) {
this.pageSize = pageSize; this.pageSize = pageSize; // 更新每页数据量
} }
// 获取总页数
public Long getPageTotal() { public Long getPageTotal() {
return pageTotal; return pageTotal;
} }
// 设置总页数
public void setPageTotal(Long pageTotal) { public void setPageTotal(Long pageTotal) {
this.pageTotal = pageTotal; this.pageTotal = pageTotal; // 更新总页数
} }
// 获取符合条件的总记录数
public Long getCount() { public Long getCount() {
return count; return count;
} }
// 设置符合条件的总记录数
public void setCount(long count) { public void setCount(long count) {
this.count = count; this.count = count; // 更新总记录数
} }
// 获取分页查询包含的结果集
public List<Map<String, Object>> getData() { public List<Map<String, Object>> getData() {
return data; return data;
} }
// 设置分页查询包含的结果集
public void setData(List<Map<String, Object>> data) { public void setData(List<Map<String, Object>> data) {
this.data = data; this.data = data; // 更新结果集
} }
// 无参构造函数
public PageData() { public PageData() {
super(); // 调用父类构造函数
super();
} }
// 带参构造函数
public PageData(Long pageIndex, Long pageSize, Long count, List<Map<String, Object>> data) { public PageData(Long pageIndex, Long pageSize, Long count, List<Map<String, Object>> data) {
this.pageIndex = pageIndex; // 初始化当前页码
this.pageSize = pageSize; // 初始化每页数据量
this.count = count; // 初始化总记录数
this.pageIndex = pageIndex; // 如果传入的数据不为空且不为空列表，则赋值；否则保留默认值
this.pageSize = pageSize;
this.count = count;
this.data = (data != null && data.size() > 0) ? data : this.data; this.data = (data != null && data.size() > 0) ? data : this.data;
if(count > 0){ // 如果总记录数大于 0，则计算总页数
if (count > 0) {
this.pageTotal = (count % pageSize) == 0 ? (count / pageSize) : (count / pageSize + 1); this.pageTotal = (count % pageSize == 0) ? (count / pageSize) : (count / pageSize + 1);
}else { } else {
this.pageTotal = 0L; // 如果总记录数为 0，则总页数为 0
this.pageTotal = 0L;
} }
} }
// 重写 toString 方法，便于调试和日志打印
@Override @Override
public String toString() { public String toString() {
return "Page [pageIndex=" + pageIndex + ", pageSize=" + pageSize + ", pageTotal=" + pageTotal + ", count=" return "PageData{" +
+ count + ", data=" + data + "]"; "pageIndex=" + pageIndex + // 当前页码
", pageSize=" + pageSize + // 每页数据量
", pageTotal=" + pageTotal + // 总页数
", count=" + count + // 总记录数
", data=" + data + // 结果集
'}';
} }
} }

131
server/src/main/java/self/cases/teams/msg/R.java
Unescape View File

@ -1,136 +1,123 @@
package self.cases.teams.msg; package self.cases.teams.msg; // 定义包名
import java.util.HashMap; import java.util.HashMap; // 导入 HashMap 类，用于存储键值对
/** /**
* 系统响应信息 * 系统响应信息
*/ */
public class R extends HashMap<String, Object> { public class R extends HashMap<String, Object> { // 继承自 HashMap，用于存储响应信息
/** 处理成功，响应码 */ /** 处理成功，响应码 */
public static final Integer SUCCESS_CODE = 0; public static final Integer SUCCESS_CODE = 0; // 定义成功状态码
/** 处理成功，默认响应消息 */ /** 处理成功，默认响应消息 */
public static final String SUCCESS_MSG = "处理成功"; public static final String SUCCESS_MSG = "处理成功"; // 定义成功状态消息
/** 操作预警，响应码 */ /** 操作预警，响应码 */
public static final Integer WARN_CODE = 1; public static final Integer WARN_CODE = 1; // 定义警告状态码
/** 操作预警，默认响应消息 */ /** 操作预警，默认响应消息 */
public static final String WARN_MSG = "操作错误"; public static final String WARN_MSG = "操作错误"; // 定义警告状态消息
/** 操作异常，响应码 */ /** 操作异常，响应码 */
public static final Integer ERROR_CODE = 2; public static final Integer ERROR_CODE = 2; // 定义异常状态码
/** 操作异常，默认响应消息 */ /** 操作异常，默认响应消息 */
public static final String ERROR_MSG = "系统异常"; public static final String ERROR_MSG = "系统异常"; // 定义异常状态消息
/** /**
* 处理成功默认响应信息 * 处理成功默认响应信息
* @return * @return 返回成功的响应对象
*/ */
public static R success(){ public static R success() { // 定义成功响应方法
R r = new R(); // 创建一个新的 R 对象
R r = new R(); r.put("code", SUCCESS_CODE); // 添加成功状态码
r.put("code", SUCCESS_CODE); r.put("msg", SUCCESS_MSG); // 添加成功状态消息
r.put("msg", SUCCESS_MSG); return r; // 返回响应对象
return r;
} }
/** /**
* 处理成功，返回指定的消息和数据 * 处理成功，返回指定的消息和数据
* @param msg 指定消息 * @param msg 指定消息
* @param data 指定数据 * @param data 指定数据
* @return * @return 返回成功的响应对象
*/ */
public static R success(String msg, Object data){ public static R success(String msg, Object data) { // 定义成功响应方法，支持自定义消息和数据
R r = new R(); // 创建一个新的 R 对象
R r = new R(); r.put("code", SUCCESS_CODE); // 添加成功状态码
r.put("code", SUCCESS_CODE); r.put("msg", msg); // 添加自定义消息
r.put("msg", msg); r.put("data", data); // 添加自定义数据
r.put("data", data); return r; // 返回响应对象
return r;
} }
/** /**
* 处理成功，返回指定的消息 * 处理成功，返回指定的消息
* @param msg 指定消息 * @param msg 指定消息
* @return * @return 返回成功的响应对象
*/ */
public static R successMsg(String msg){ public static R successMsg(String msg) { // 定义成功响应方法，支持自定义消息
R r = new R(); // 创建一个新的 R 对象
R r = new R(); r.put("code", SUCCESS_CODE); // 添加成功状态码
r.put("code", SUCCESS_CODE); r.put("msg", msg); // 添加自定义消息
r.put("msg", msg); return r; // 返回响应对象
return r;
} }
/** /**
* 处理成功，返回内容中附加数据 * 处理成功，返回内容中附加数据
* @param data 指定响应的数据 * @param data 指定响应的数据
* @return * @return 返回成功的响应对象
*/ */
public static R successData(Object data){ public static R successData(Object data) { // 定义成功响应方法，支持附加数据
R r = new R(); // 创建一个新的 R 对象
R r = new R(); r.put("code", SUCCESS_CODE); // 添加成功状态码
r.put("code", SUCCESS_CODE); r.put("msg", SUCCESS_MSG); // 添加成功状态消息
r.put("msg", SUCCESS_MSG); r.put("data", data); // 添加自定义数据
r.put("data", data); return r; // 返回响应对象
return r;
} }
/** /**
* 操作警告，返回默认的告警信息 * 操作警告，返回默认的告警信息
* @return * @return 返回警告响应对象
*/ */
public static R warn(){ public static R warn() { // 定义警告响应方法
R r = new R(); // 创建一个新的 R 对象
R r = new R(); r.put("code", WARN_CODE); // 添加警告状态码
r.put("code", WARN_CODE); r.put("msg", WARN_MSG); // 添加警告状态消息
r.put("msg", WARN_MSG); return r; // 返回响应对象
return r;
} }
/** /**
* 操作警告，返回指定的告警信息 * 操作警告，返回指定的告警信息
* @param msg 指定信息 * @param msg 指定信息
* @return * @return 返回警告响应对象
*/ */
public static R warn(String msg){ public static R warn(String msg) { // 定义警告响应方法，支持自定义消息
R r = new R(); // 创建一个新的 R 对象
R r = new R(); r.put("code", WARN_CODE); // 添加警告状态码
r.put("code", WARN_CODE); r.put("msg", msg); // 添加自定义消息
r.put("msg", msg); return r; // 返回响应对象
return r;
} }
/** /**
* 系统异常，返回默认的异常信息 * 系统异常，返回默认的异常信息
* @return * @return 返回异常响应对象
*/ */
public static R error(){ public static R error() { // 定义异常响应方法
R r = new R(); // 创建一个新的 R 对象
R r = new R(); r.put("code", ERROR_CODE); // 添加异常状态码
r.put("code", ERROR_CODE); r.put("msg", ERROR_MSG); // 添加异常状态消息
r.put("msg", ERROR_MSG); return r; // 返回响应对象
return r;
} }
/** /**
* 系统异常，返回指定的异常信息 * 系统异常，返回指定的异常信息
* @param msg 异常信息 * @param msg 异常信息
* @return * @return 返回异常响应对象
*/ */
public static R error(String msg){ public static R error(String msg) { // 定义异常响应方法，支持自定义消息
R r = new R(); // 创建一个新的 R 对象
R r = new R(); r.put("code", ERROR_CODE); // 添加异常状态码
r.put("code", ERROR_CODE); r.put("msg", msg); // 添加自定义异常消息
r.put("msg", msg); return r; // 返回响应对象
return r;
} }
} }

80
server/src/main/java/self/cases/teams/service/impl/ActiveLogsServiceImpl.java
Unescape View File

@ -21,91 +21,91 @@ import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
@Service("activeLogsService") @Service("activeLogsService") // 将类注册为 Spring 的 Bean，名称为 "activeLogsService"
public class ActiveLogsServiceImpl implements ActiveLogsService { public class ActiveLogsServiceImpl implements ActiveLogsService { // 实现 ActiveLogsService 接口
@Autowired @Autowired // 自动注入 UsersDao，用于操作用户表
private UsersDao usersDao; private UsersDao usersDao;
@Autowired @Autowired // 自动注入 ActiveLogsDao，用于操作活动日志表
private ActiveLogsDao activeLogsDao; private ActiveLogsDao activeLogsDao;
@Autowired @Autowired // 自动注入 ActivitiesDao，用于操作活动表
private ActivitiesDao activitiesDao; private ActivitiesDao activitiesDao;
@Override @Override
@Transactional @Transactional // 声明事务管理，确保添加操作的原子性
public void add(ActiveLogs activeLogs) { public void add(ActiveLogs activeLogs) {
Activities activitie = activitiesDao.selectById(activeLogs.getActiveId()); Activities activitie = activitiesDao.selectById(activeLogs.getActiveId()); // 查询活动记录
activitie.setTotal(activitie.getTotal() + 1); activitie.setTotal(activitie.getTotal() + 1); // 更新活动参与总数
activitiesDao.updateById(activitie); activitiesDao.updateById(activitie); // 更新活动记录
activeLogsDao.insert(activeLogs); activeLogsDao.insert(activeLogs); // 插入新的活动日志记录
} }
@Override @Override
@Transactional @Transactional // 声明事务管理，确保更新操作的原子性
public void update(ActiveLogs activeLogs) { public void update(ActiveLogs activeLogs) {
activeLogsDao.updateById(activeLogs); activeLogsDao.updateById(activeLogs); // 根据主键更新活动日志记录
} }
@Override @Override
@Transactional @Transactional // 声明事务管理，确保删除操作的原子性
public void delete(ActiveLogs activeLogs) { public void delete(ActiveLogs activeLogs) {
activeLogsDao.deleteById(activeLogs); activeLogsDao.deleteById(activeLogs); // 根据主键删除活动日志记录
} }
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务，提高性能
public Boolean isActive(String activeId, String userId){ public Boolean isActive(String activeId, String userId){
QueryWrapper<ActiveLogs> qw = new QueryWrapper<ActiveLogs>(); QueryWrapper<ActiveLogs> qw = new QueryWrapper<ActiveLogs>(); // 创建查询条件构造器
qw.eq("active_id", activeId); qw.eq("active_id", activeId); // 设置活动 ID 条件
qw.eq("user_id", userId); qw.eq("user_id", userId); // 设置用户 ID 条件
return activeLogsDao.selectCount(qw) <= 0; return activeLogsDao.selectCount(qw) <= 0; // 判断用户是否未参加过该活动
} }
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务，提高性能
public ActiveLogs getOne(String id) { public ActiveLogs getOne(String id) {
ActiveLogs activeLogs = activeLogsDao.selectById(id); ActiveLogs activeLogs = activeLogsDao.selectById(id); // 根据主键查询活动日志记录
return activeLogs; return activeLogs; // 返回查询到的活动日志记录
} }
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务，提高性能
public List<Map<String, Object>> getListByActiveId(String activeId){ public List<Map<String, Object>> getListByActiveId(String activeId){
List<Map<String, Object>> resl = new ArrayList<Map<String, Object>>(); List<Map<String, Object>> resl = new ArrayList<Map<String, Object>>(); // 初始化结果列表
QueryWrapper<ActiveLogs> qw = new QueryWrapper<ActiveLogs>(); QueryWrapper<ActiveLogs> qw = new QueryWrapper<ActiveLogs>(); // 创建查询条件构造器
qw.eq("active_id", activeId); qw.eq("active_id", activeId); // 设置活动 ID 条件
qw.orderByDesc("create_time"); qw.orderByDesc("create_time"); // 按创建时间倒序排序
List<ActiveLogs> activeLogs = activeLogsDao.selectList(qw); List<ActiveLogs> activeLogs = activeLogsDao.selectList(qw); // 查询符合条件的活动日志记录
for (ActiveLogs activeLog : activeLogs) { for (ActiveLogs activeLog : activeLogs) { // 遍历活动日志记录
Map<String, Object> temp = new HashMap<String, Object>(); Map<String, Object> temp = new HashMap<String, Object>(); // 初始化临时映射
temp.put("id", activeLog.getId()); temp.put("id", activeLog.getId()); // 添加日志 ID
temp.put("createTime", activeLog.getCreateTime()); temp.put("createTime", activeLog.getCreateTime()); // 添加创建时间
temp.put("activeId", activeLog.getActiveId()); temp.put("activeId", activeLog.getActiveId()); // 添加活动 ID
Users user = usersDao.selectById(activeLog.getUserId()); Users user = usersDao.selectById(activeLog.getUserId()); // 查询用户信息
temp.put("userId", activeLog.getUserId()); temp.put("userId", activeLog.getUserId()); // 添加用户 ID
temp.put("userName", user.getName()); temp.put("userName", user.getName()); // 添加用户名
temp.put("userGender", user.getGender()); temp.put("userGender", user.getGender()); // 添加用户性别
temp.put("userPhone", user.getPhone()); temp.put("userPhone", user.getPhone()); // 添加用户电话
resl.add(temp); resl.add(temp); // 将临时映射加入结果列表
} }
return resl; return resl; // 返回最终结果列表
} }
} }

64
server/src/main/java/self/cases/teams/service/impl/ActivitiesServiceImpl.java
Unescape View File

@ -23,79 +23,79 @@ import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
@Service("activitiesService") @Service("activitiesService") // 将类注册为 Spring 的 Bean，名称为 "activitiesService"
public class ActivitiesServiceImpl implements ActivitiesService { public class ActivitiesServiceImpl implements ActivitiesService { // 实现 ActivitiesService 接口
@Autowired @Autowired // 自动注入 TeamsDao，用于操作团队表
private TeamsDao teamsDao; private TeamsDao teamsDao;
@Autowired @Autowired // 自动注入 ActiveLogsDao，用于操作活动日志表
private ActiveLogsDao activeLogsDao; private ActiveLogsDao activeLogsDao;
@Autowired @Autowired // 自动注入 ActivitiesDao，用于操作活动表
private ActivitiesDao activitiesDao; private ActivitiesDao activitiesDao;
@Override @Override
@Transactional @Transactional // 声明事务管理，确保添加操作的原子性
public void add(Activities activities) { public void add(Activities activities) {
activitiesDao.insert(activities); activitiesDao.insert(activities); // 插入新的活动记录
Teams teams = teamsDao.selectById(activities.getTeamId()); Teams teams = teamsDao.selectById(activities.getTeamId()); // 查询对应的团队信息
ActiveLogs activeLog = new ActiveLogs(); ActiveLogs activeLog = new ActiveLogs(); // 创建新的活动日志对象
activeLog.setId(IDUtils.makeIDByCurrent()); activeLog.setId(IDUtils.makeIDByCurrent()); // 生成日志唯一 ID
activeLog.setActiveId(activities.getId()); activeLog.setActiveId(activities.getId()); // 设置活动 ID
activeLog.setUserId(teams.getManager()); activeLog.setUserId(teams.getManager()); // 设置管理员用户 ID
activeLog.setCreateTime(DateUtils.getNowDate()); activeLog.setCreateTime(DateUtils.getNowDate()); // 设置当前创建时间
activeLogsDao.insert(activeLog); activeLogsDao.insert(activeLog); // 插入新的活动日志记录
} }
@Override @Override
@Transactional @Transactional // 声明事务管理，确保更新操作的原子性
public void update(Activities activities) { public void update(Activities activities) {
activitiesDao.updateById(activities); activitiesDao.updateById(activities); // 根据主键更新活动记录
} }
@Override @Override
@Transactional @Transactional // 声明事务管理，确保删除操作的原子性
public void delete(Activities activities) { public void delete(Activities activities) {
QueryWrapper<ActiveLogs> qw = new QueryWrapper<ActiveLogs>(); QueryWrapper<ActiveLogs> qw = new QueryWrapper<ActiveLogs>(); // 创建查询条件构造器
qw.eq("active_id", activities.getId()); qw.eq("active_id", activities.getId()); // 设置活动 ID 条件
activeLogsDao.delete(qw); activeLogsDao.delete(qw); // 删除与该活动相关的活动日志记录
activitiesDao.deleteById(activities); activitiesDao.deleteById(activities); // 删除活动记录
} }
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务，提高性能
public Activities getOne(String id) { public Activities getOne(String id) {
Activities activities = activitiesDao.selectById(id); Activities activities = activitiesDao.selectById(id); // 根据主键查询活动记录
return activities; return activities; // 返回查询到的活动记录
} }
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务，提高性能
public PageData getPageAll(Long pageIndex, Long pageSize, String activeName, String teamName) { public PageData getPageAll(Long pageIndex, Long pageSize, String activeName, String teamName) {
Page<Map<String, Object>> page = Page<Map<String, Object>> page =
activitiesDao.qryPageAll(new Page<Map<String, Object>>(pageIndex, pageSize), activeName, teamName); activitiesDao.qryPageAll(new Page<Map<String, Object>>(pageIndex, pageSize), activeName, teamName); // 分页查询所有活动记录
return parsePage(page); return parsePage(page); // 转换分页结果并返回
} }
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务，提高性能
public PageData getPageByUserId(Long pageIndex, Long pageSize, String userId, String activeName, String teamName) { public PageData getPageByUserId(Long pageIndex, Long pageSize, String userId, String activeName, String teamName) {
Page<Map<String, Object>> page = Page<Map<String, Object>> page =
activitiesDao.qryPageByMemId(new Page<Map<String, Object>>(pageIndex, pageSize), userId, activeName, teamName); activitiesDao.qryPageByMemId(new Page<Map<String, Object>>(pageIndex, pageSize), userId, activeName, teamName); // 分页查询指定用户的活动记录
return parsePage(page); return parsePage(page); // 转换分页结果并返回
} }
/** /**
@ -103,8 +103,8 @@ public class ActivitiesServiceImpl implements ActivitiesService {
*/ */
public PageData parsePage(Page<Map<String, Object>> p) { public PageData parsePage(Page<Map<String, Object>> p) {
PageData pageData = new PageData(p.getCurrent(), p.getSize(), p.getTotal(), p.getRecords()); PageData pageData = new PageData(p.getCurrent(), p.getSize(), p.getTotal(), p.getRecords()); // 初始化分页数据对象
return pageData; return pageData; // 返回分页数据对象
} }
} }

78
server/src/main/java/self/cases/teams/service/impl/ApplyLogsServiceImpl.java
Unescape View File

@ -23,93 +23,93 @@ import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
@Service("applyLogsService") @Service("applyLogsService") // 将类注册为 Spring 的 Bean，名称为 "applyLogsService"
public class ApplyLogsServiceImpl implements ApplyLogsService { public class ApplyLogsServiceImpl implements ApplyLogsService { // 实现 ApplyLogsService 接口
@Autowired @Autowired // 自动注入 MembersDao，用于操作成员表
private MembersDao membersDao; private MembersDao membersDao;
@Autowired @Autowired // 自动注入 ApplyLogsDao，用于操作申请日志表
private ApplyLogsDao applyLogsDao; private ApplyLogsDao applyLogsDao;
@Autowired @Autowired // 自动注入 TeamsDao，用于操作团队表
private TeamsDao teamsDao; private TeamsDao teamsDao;
@Override @Override
@Transactional @Transactional // 声明事务管理，确保添加操作的原子性
public void add(ApplyLogs applyLogs) { public void add(ApplyLogs applyLogs) {
applyLogsDao.insert(applyLogs); applyLogsDao.insert(applyLogs); // 插入新的申请日志记录
} }
@Override @Override
@Transactional @Transactional // 声明事务管理，确保更新操作的原子性
public void update(ApplyLogs applyLogs) { public void update(ApplyLogs applyLogs) {
if(applyLogs.getStatus() != null && applyLogs.getStatus() == 1){ if(applyLogs.getStatus() != null && applyLogs.getStatus() == 1){ // 如果状态为已批准
Members member = new Members(); Members member = new Members(); // 创建新的成员对象
member.setId(IDUtils.makeIDByCurrent()); member.setId(IDUtils.makeIDByCurrent()); // 生成成员唯一 ID
member.setCreateTime(DateUtils.getNowDate()); member.setCreateTime(DateUtils.getNowDate()); // 设置创建时间
member.setUserId(applyLogs.getUserId()); member.setUserId(applyLogs.getUserId()); // 设置用户 ID
member.setTeamId(applyLogs.getTeamId()); member.setTeamId(applyLogs.getTeamId()); // 设置团队 ID
membersDao.insert(member); membersDao.insert(member); // 插入新成员记录
Teams teams = teamsDao.selectById(applyLogs.getTeamId()); Teams teams = teamsDao.selectById(applyLogs.getTeamId()); // 查询对应团队信息
teams.setTotal(teams.getTotal() + 1); teams.setTotal(teams.getTotal() + 1); // 增加团队总人数
teamsDao.updateById(teams); teamsDao.updateById(teams); // 更新团队总人数
} }
applyLogsDao.updateById(applyLogs); applyLogsDao.updateById(applyLogs); // 更新申请日志记录
} }
@Override @Override
@Transactional @Transactional // 声明事务管理，确保删除操作的原子性
public void delete(ApplyLogs applyLogs) { public void delete(ApplyLogs applyLogs) {
applyLogsDao.deleteById(applyLogs); applyLogsDao.deleteById(applyLogs); // 根据主键删除申请日志记录
} }
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务，提高性能
public Boolean isApply(String userId, String teamId){ public Boolean isApply(String userId, String teamId) {
QueryWrapper<ApplyLogs> qw = new QueryWrapper<ApplyLogs>(); QueryWrapper<ApplyLogs> qw = new QueryWrapper<ApplyLogs>(); // 创建查询条件构造器
qw.eq("user_id", userId); qw.eq("user_id", userId); // 设置用户 ID 条件
qw.eq("team_id", teamId); qw.eq("team_id", teamId); // 设置团队 ID 条件
qw.eq("status", 0); qw.eq("status", 0); // 设置未处理状态条件
return applyLogsDao.selectCount(qw) <= 0; return applyLogsDao.selectCount(qw) <= 0; // 判断是否已有未处理的申请
} }
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务，提高性能
public ApplyLogs getOne(String id) { public ApplyLogs getOne(String id) {
ApplyLogs applyLogs = applyLogsDao.selectById(id); ApplyLogs applyLogs = applyLogsDao.selectById(id); // 根据主键查询申请日志记录
return applyLogs; return applyLogs; // 返回查询到的申请日志记录
} }
@Override @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) { public PageData getManPageInfo(Long pageIndex, Long pageSize, String userId, String teamName, String userName) {
Page<Map<String, Object>> page = Page<Map<String, Object>> page =
applyLogsDao.qryManPageInfo(new Page<Map<String, Object>>(pageIndex, pageSize), userId, teamName, userName); applyLogsDao.qryManPageInfo(new Page<Map<String, Object>>(pageIndex, pageSize), userId, teamName, userName); // 分页查询管理员视角的申请日志
return parsePage(page); return parsePage(page); // 转换分页结果并返回
} }
@Override @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) { public PageData getPageInfo(Long pageIndex, Long pageSize, String userId, String teamName, String userName) {
Page<Map<String, Object>> page = Page<Map<String, Object>> page =
applyLogsDao.qryPageInfo(new Page<Map<String, Object>>(pageIndex, pageSize), userId, teamName, userName); applyLogsDao.qryPageInfo(new Page<Map<String, Object>>(pageIndex, pageSize), userId, teamName, userName); // 分页查询普通用户的申请日志
return parsePage(page); return parsePage(page); // 转换分页结果并返回
} }
/** /**
@ -117,8 +117,8 @@ public class ApplyLogsServiceImpl implements ApplyLogsService {
*/ */
public PageData parsePage(Page<Map<String, Object>> p) { public PageData parsePage(Page<Map<String, Object>> p) {
PageData pageData = new PageData(p.getCurrent(), p.getSize(), p.getTotal(), p.getRecords()); PageData pageData = new PageData(p.getCurrent(), p.getSize(), p.getTotal(), p.getRecords()); // 初始化分页数据对象
return pageData; return pageData; // 返回分页数据对象
} }
} }

84
server/src/main/java/self/cases/teams/service/impl/MembersServiceImpl.java
Unescape View File

@ -17,99 +17,99 @@ import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
@Service("membersService") @Service("membersService") // 将类注册为 Spring 的 Bean，名称为 "membersService"
public class MembersServiceImpl implements MembersService { public class MembersServiceImpl implements MembersService { // 实现 MembersService 接口
@Autowired @Autowired // 自动注入 TeamsDao，用于操作团队表
private TeamsDao teamsDao; private TeamsDao teamsDao;
@Autowired @Autowired // 自动注入 MembersDao，用于操作成员表
private MembersDao membersDao; private MembersDao membersDao;
@Autowired @Autowired // 自动注入 PayLogsDao，用于操作支付日志表
private PayLogsDao payLogsDao; private PayLogsDao payLogsDao;
@Autowired @Autowired // 自动注入 ActiveLogsDao，用于操作活跃日志表
private ActiveLogsDao activeLogsDao; private ActiveLogsDao activeLogsDao;
@Autowired @Autowired // 自动注入 ApplyLogsDao，用于操作申请日志表
private ApplyLogsDao applyLogsDao; private ApplyLogsDao applyLogsDao;
@Override @Override
@Transactional @Transactional // 声明事务管理，确保添加操作的原子性
public void add(Members members) { public void add(Members members) {
membersDao.insert(members); membersDao.insert(members); // 插入新的成员记录
} }
@Override @Override
@Transactional @Transactional // 声明事务管理，确保更新操作的原子性
public void update(Members members) { public void update(Members members) {
membersDao.updateById(members); membersDao.updateById(members); // 根据主键更新成员记录
} }
@Override @Override
@Transactional @Transactional // 声明事务管理，确保删除操作的原子性
public void delete(Members members) { public void delete(Members members) {
QueryWrapper<PayLogs> qw_pay = new QueryWrapper<PayLogs>(); QueryWrapper<PayLogs> qw_pay = new QueryWrapper<PayLogs>(); // 创建支付日志查询条件
qw_pay.eq("user_id", members.getUserId()); qw_pay.eq("user_id", members.getUserId()); // 设置用户 ID 条件
payLogsDao.delete(qw_pay); payLogsDao.delete(qw_pay); // 删除与该用户相关的支付日志
QueryWrapper<ActiveLogs> qw_active = new QueryWrapper<ActiveLogs>(); QueryWrapper<ActiveLogs> qw_active = new QueryWrapper<ActiveLogs>(); // 创建活跃日志查询条件
qw_active.eq("user_id", members.getUserId()); qw_active.eq("user_id", members.getUserId()); // 设置用户 ID 条件
activeLogsDao.delete(qw_active); activeLogsDao.delete(qw_active); // 删除与该用户相关的活跃日志
QueryWrapper<ApplyLogs> qw_apply = new QueryWrapper<ApplyLogs>(); QueryWrapper<ApplyLogs> qw_apply = new QueryWrapper<ApplyLogs>(); // 创建申请日志查询条件
qw_apply.eq("user_id", members.getUserId()); qw_apply.eq("user_id", members.getUserId()); // 设置用户 ID 条件
applyLogsDao.delete(qw_apply); applyLogsDao.delete(qw_apply); // 删除与该用户相关的申请日志
membersDao.deleteById(members); membersDao.deleteById(members); // 根据主键删除成员记录
Teams team = teamsDao.selectById(members.getTeamId()); Teams team = teamsDao.selectById(members.getTeamId()); // 查询对应的团队信息
team.setTotal(team.getTotal() - 1); team.setTotal(team.getTotal() - 1); // 减少团队总人数
teamsDao.updateById(team); teamsDao.updateById(team); // 更新团队总人数
} }
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务，提高性能
public Members getOne(String id) { public Members getOne(String id) {
Members members = membersDao.selectById(id); Members members = membersDao.selectById(id); // 根据主键查询成员记录
return members; return members; // 返回查询到的成员记录
} }
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务，提高性能
public Boolean isManager(String teamId, String userId){ public Boolean isManager(String teamId, String userId) {
QueryWrapper<Teams> qw = new QueryWrapper<Teams>(); QueryWrapper<Teams> qw = new QueryWrapper<Teams>(); // 创建团队查询条件
qw.eq("manager", userId); qw.eq("manager", userId); // 设置经理 ID 条件
qw.eq("id", teamId); qw.eq("id", teamId); // 设置团队 ID 条件
return teamsDao.selectCount(qw) > 0; return teamsDao.selectCount(qw) > 0; // 判断用户是否为该团队的经理
} }
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务，提高性能
public PageData getPageAll(Long pageIndex, Long pageSize, String teamName, String userName) { public PageData getPageAll(Long pageIndex, Long pageSize, String teamName, String userName) {
Page<Map<String, Object>> page = Page<Map<String, Object>> page =
membersDao.qryPageAll(new Page<Map<String, Object>>(pageIndex, pageSize), teamName, userName); membersDao.qryPageAll(new Page<Map<String, Object>>(pageIndex, pageSize), teamName, userName); // 分页查询所有成员信息
return parsePage(page); return parsePage(page); // 转换分页结果并返回
} }
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务，提高性能
public PageData getPageByManId(Long pageIndex, Long pageSize, String manId, String teamName, String userName) { public PageData getPageByManId(Long pageIndex, Long pageSize, String manId, String teamName, String userName) {
Page<Map<String, Object>> page = Page<Map<String, Object>> page =
membersDao.qryPageByManId(new Page<Map<String, Object>>(pageIndex, pageSize), manId, teamName, userName); membersDao.qryPageByManId(new Page<Map<String, Object>>(pageIndex, pageSize), manId, teamName, userName); // 分页查询指定经理的成员信息
return parsePage(page); return parsePage(page); // 转换分页结果并返回
} }
/** /**
@ -117,8 +117,8 @@ public class MembersServiceImpl implements MembersService {
*/ */
public PageData parsePage(Page<Map<String, Object>> p) { public PageData parsePage(Page<Map<String, Object>> p) {
PageData pageData = new PageData(p.getCurrent(), p.getSize(), p.getTotal(), p.getRecords()); PageData pageData = new PageData(p.getCurrent(), p.getSize(), p.getTotal(), p.getRecords()); // 初始化分页数据对象
return pageData; return pageData; // 返回分页数据对象
} }
} }

110
server/src/main/java/self/cases/teams/service/impl/NoticesServiceImpl.java
Unescape View File

@ -20,90 +20,90 @@ import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
@Service("noticesService") @Service("noticesService") // 将类注册为 Spring 的 Bean，名称为 "noticesService"
public class NoticesServiceImpl implements NoticesService { public class NoticesServiceImpl implements NoticesService { // 实现 NoticesService 接口
@Autowired @Autowired // 自动注入 NoticesDao，用于操作公告表
private NoticesDao noticesDao; private NoticesDao noticesDao;
@Autowired @Autowired // 自动注入 TeamsDao，用于操作团队表
private TeamsDao teamsDao; private TeamsDao teamsDao;
@Override @Override
@Transactional @Transactional // 声明事务管理，确保添加操作的原子性
public void add(Notices notices) { public void add(Notices notices) {
noticesDao.insert(notices); noticesDao.insert(notices); // 插入新的公告记录
} }
@Override @Override
@Transactional @Transactional // 声明事务管理，确保更新操作的原子性
public void update(Notices notices) { public void update(Notices notices) {
noticesDao.updateById(notices); noticesDao.updateById(notices); // 根据主键更新公告记录
} }
@Override @Override
@Transactional @Transactional // 声明事务管理，确保删除操作的原子性
public void delete(Notices notices) { public void delete(Notices notices) {
noticesDao.deleteById(notices); noticesDao.deleteById(notices); // 根据主键删除公告记录
} }
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务，提高性能
public Notices getOne(String id) { public Notices getOne(String id) {
Notices notices = noticesDao.selectById(id); Notices notices = noticesDao.selectById(id); // 根据主键查询公告记录
return notices; return notices; // 返回查询到的公告记录
} }
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务，提高性能
public List<Notices> getSysNotices(){ public List<Notices> getSysNotices() {
List<Notices> list = noticesDao.qrySysNotices(); List<Notices> list = noticesDao.qrySysNotices(); // 查询系统公告列表
return list; return list; // 返回系统公告列表
} }
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务，提高性能
public List<Notices> getManNotices(String manId){ public List<Notices> getManNotices(String manId) {
List<Notices> list = noticesDao.qryManNotices(manId); List<Notices> list = noticesDao.qryManNotices(manId); // 查询指定经理的公告列表
return list; return list; // 返回指定经理的公告列表
} }
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务，提高性能
public List<Notices> getMemNotices(String memId){ public List<Notices> getMemNotices(String memId) {
List<Notices> list = noticesDao.qryMemNotices(memId); List<Notices> list = noticesDao.qryMemNotices(memId); // 查询指定成员的公告列表
return list; return list; // 返回指定成员的公告列表
} }
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务，提高性能
public PageData getPageAll(Long pageIndex, Long pageSize, String title, String teamName){ public PageData getPageAll(Long pageIndex, Long pageSize, String title, String teamName) {
Page<Map<String, Object>> page = Page<Map<String, Object>> page =
noticesDao.qryPageAll(new Page<Map<String, Object>>(pageIndex, pageSize), title, teamName); noticesDao.qryPageAll(new Page<Map<String, Object>>(pageIndex, pageSize), title, teamName); // 分页查询所有公告
return parsePage(page); return parsePage(page); // 转换分页结果并返回
} }
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务，提高性能
public PageData getPageById(Long pageIndex, Long pageSize, String userId, String title, String teamName){ public PageData getPageById(Long pageIndex, Long pageSize, String userId, String title, String teamName) {
Page<Map<String, Object>> page = Page<Map<String, Object>> page =
noticesDao.qryPageById(new Page<Map<String, Object>>(pageIndex, pageSize), userId, title, teamName); noticesDao.qryPageById(new Page<Map<String, Object>>(pageIndex, pageSize), userId, title, teamName); // 分页查询指定用户的公告
return parsePage(page); return parsePage(page); // 转换分页结果并返回
} }
/** /**
@ -111,33 +111,33 @@ public class NoticesServiceImpl implements NoticesService {
* @param notices * @param notices
* @return * @return
*/ */
public List<Map<String, Object>> parseList(List<Notices> notices){ public List<Map<String, Object>> parseList(List<Notices> notices) {
List<Map<String, Object>> resl = new ArrayList<Map<String, Object>>(); List<Map<String, Object>> resl = new ArrayList<Map<String, Object>>(); // 初始化结果列表
for (Notices notice : notices) { for (Notices notice : notices) { // 遍历公告列表
Map<String, Object> temp = new HashMap<String, Object>(); Map<String, Object> temp = new HashMap<String, Object>(); // 初始化临时 Map
temp.put("id", notice.getId()); temp.put("id", notice.getId()); // 添加公告 ID
temp.put("title", notice.getTitle()); temp.put("title", notice.getTitle()); // 添加公告标题
temp.put("detail", notice.getDetail()); temp.put("detail", notice.getDetail()); // 添加公告详情
temp.put("createTime", notice.getCreateTime()); temp.put("createTime", notice.getCreateTime()); // 添加创建时间
if(StringUtils.isNotNullOrEmpty(notice.getTeamId())){ if (StringUtils.isNotNullOrEmpty(notice.getTeamId())) { // 如果公告关联团队
Teams teams = teamsDao.selectById(notice.getTeamId()); Teams teams = teamsDao.selectById(notice.getTeamId()); // 查询对应团队信息
temp.put("teamId", notice.getTeamId()); temp.put("teamId", notice.getTeamId()); // 添加团队 ID
temp.put("teamName", teams.getName()); temp.put("teamName", teams.getName()); // 添加团队名称
temp.put("isTeam", true); temp.put("isTeam", true); // 标记为团队公告
}else{ } else {
temp.put("isTeam", false); temp.put("isTeam", false); // 标记为非团队公告
} }
resl.add(temp); resl.add(temp); // 将临时 Map 添加到结果列表中
} }
return resl; return resl; // 返回转换后的结果列表
} }
/** /**
@ -145,8 +145,8 @@ public class NoticesServiceImpl implements NoticesService {
*/ */
public PageData parsePage(Page<Map<String, Object>> p) { public PageData parsePage(Page<Map<String, Object>> p) {
PageData pageData = new PageData(p.getCurrent(), p.getSize(), p.getTotal(), p.getRecords()); PageData pageData = new PageData(p.getCurrent(), p.getSize(), p.getTotal(), p.getRecords()); // 初始化分页数据对象
return pageData; return pageData; // 返回分页数据对象
} }
} }

44
server/src/main/java/self/cases/teams/service/impl/PayLogsServiceImpl.java
Unescape View File

@ -22,66 +22,66 @@ import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
@Service("payLogsService") @Service("payLogsService") // 将类注册为 Spring 的 Bean，名称为 "payLogsService"
public class PayLogsServiceImpl implements PayLogsService { public class PayLogsServiceImpl implements PayLogsService { // 实现 PayLogsService 接口
@Autowired @Autowired // 自动注入 PayLogsDao，用于操作支付日志表
private PayLogsDao payLogsDao; private PayLogsDao payLogsDao;
@Autowired @Autowired // 自动注入 TeamsDao，用于操作团队表
private TeamsDao teamsDao; private TeamsDao teamsDao;
@Autowired @Autowired // 自动注入 UsersDao，用于操作用户表
private UsersDao usersDao; private UsersDao usersDao;
@Override @Override
@Transactional @Transactional // 声明事务管理，确保添加操作的原子性
public void add(PayLogs payLogs) { public void add(PayLogs payLogs) {
payLogsDao.insert(payLogs); payLogsDao.insert(payLogs); // 插入新的支付日志记录
} }
@Override @Override
@Transactional @Transactional // 声明事务管理，确保更新操作的原子性
public void update(PayLogs payLogs) { public void update(PayLogs payLogs) {
payLogsDao.updateById(payLogs); payLogsDao.updateById(payLogs); // 根据主键更新支付日志记录
} }
@Override @Override
@Transactional @Transactional // 声明事务管理，确保删除操作的原子性
public void delete(PayLogs payLogs) { public void delete(PayLogs payLogs) {
payLogsDao.deleteById(payLogs); payLogsDao.deleteById(payLogs); // 根据主键删除支付日志记录
} }
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS) // 声明只读事务，提高性能
public PayLogs getOne(String id) { public PayLogs getOne(String id) {
PayLogs payLogs = payLogsDao.selectById(id); PayLogs payLogs = payLogsDao.selectById(id); // 根据主键查询支付日志记录
return payLogs; return payLogs; // 返回查询到的支付日志记录
} }
@Override @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) { public PageData getManPageInfo(Long pageIndex, Long pageSize, String userId, String teamName, String userName) {
Page<Map<String, Object>> page = Page<Map<String, Object>> page =
payLogsDao.qryManPageInfo(new Page<Map<String, Object>>(pageIndex, pageSize), userId, teamName, userName); payLogsDao.qryManPageInfo(new Page<Map<String, Object>>(pageIndex, pageSize), userId, teamName, userName); // 分页查询经理相关的支付日志
return parsePage(page); return parsePage(page); // 转换分页结果并返回
} }
@Override @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) { public PageData getPageInfo(Long pageIndex, Long pageSize, String userId, String teamName, String userName) {
Page<Map<String, Object>> page = Page<Map<String, Object>> page =
payLogsDao.qryPageInfo(new Page<Map<String, Object>>(pageIndex, pageSize), userId, teamName, userName); payLogsDao.qryPageInfo(new Page<Map<String, Object>>(pageIndex, pageSize), userId, teamName, userName); // 分页查询支付日志
return parsePage(page); return parsePage(page); // 转换分页结果并返回
} }
/** /**
@ -89,8 +89,8 @@ public class PayLogsServiceImpl implements PayLogsService {
*/ */
public PageData parsePage(Page<Map<String, Object>> p) { public PageData parsePage(Page<Map<String, Object>> p) {
PageData pageData = new PageData(p.getCurrent(), p.getSize(), p.getTotal(), p.getRecords()); PageData pageData = new PageData(p.getCurrent(), p.getSize(), p.getTotal(), p.getRecords()); // 初始化分页数据对象
return pageData; return pageData; // 返回分页数据对象
} }
} }

47
server/src/main/java/self/cases/teams/service/impl/TeamTypesServiceImpl.java
Unescape View File

@ -20,84 +20,105 @@ import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
// 将类注册为 Spring 的 Bean，名称为 "teamTypesService"
@Service("teamTypesService") @Service("teamTypesService")
public class TeamTypesServiceImpl implements TeamTypesService { public class TeamTypesServiceImpl implements TeamTypesService {
// 自动注入 TeamTypesDao，用于操作团队类型表
@Autowired @Autowired
private TeamTypesDao teamTypesDao; private TeamTypesDao teamTypesDao;
// 自动注入 TeamsDao，用于操作团队表
@Autowired @Autowired
private TeamsDao teamsDao; private TeamsDao teamsDao;
// 添加团队类型方法，声明事务管理，确保添加操作的原子性
@Override @Override
@Transactional @Transactional
public void add(TeamTypes teamTypes) { public void add(TeamTypes teamTypes) {
// 插入新的团队类型记录
teamTypesDao.insert(teamTypes); teamTypesDao.insert(teamTypes);
} }
// 更新团队类型方法，声明事务管理，确保更新操作的原子性
@Override @Override
@Transactional @Transactional
public void update(TeamTypes teamTypes) { public void update(TeamTypes teamTypes) {
// 根据主键更新团队类型记录
teamTypesDao.updateById(teamTypes); teamTypesDao.updateById(teamTypes);
} }
// 删除团队类型方法，声明事务管理，确保删除操作的原子性
@Override @Override
@Transactional @Transactional
public void delete(TeamTypes teamTypes) { public void delete(TeamTypes teamTypes) {
// 根据主键删除团队类型记录
teamTypesDao.deleteById(teamTypes); teamTypesDao.deleteById(teamTypes);
} }
// 判断团队类型是否可以被删除的方法，声明只读事务，提高性能
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
public Boolean isRemove(String typeId){ public Boolean isRemove(String typeId) {
// 构造查询条件，检查是否有团队使用该类型
QueryWrapper<Teams> qw = new QueryWrapper<Teams>(); QueryWrapper<Teams> qw = new QueryWrapper<Teams>();
qw.eq("type_id", typeId); qw.eq("type_id", typeId);
// 查询使用该类型的团队数量，如果数量为 0，则可以删除
return teamsDao.selectCount(qw) <= 0; return teamsDao.selectCount(qw) <= 0;
} }
// 获取单个团队类型方法，声明只读事务，提高性能
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
public TeamTypes getOne(String id) { public TeamTypes getOne(String id) {
// 构造查询条件，按创建时间降序排序
QueryWrapper<TeamTypes> qw = new QueryWrapper<TeamTypes>(); QueryWrapper<TeamTypes> qw = new QueryWrapper<TeamTypes>();
qw.orderByDesc("create_time"); qw.orderByDesc("create_time");
// 根据主键查询团队类型记录
TeamTypes teamTypes = teamTypesDao.selectById(id); TeamTypes teamTypes = teamTypesDao.selectById(id);
return teamTypes; return teamTypes; // 返回查询到的团队类型记录
} }
// 获取所有团队类型方法，声明只读事务，提高性能
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
public List<TeamTypes> getAll() { public List<TeamTypes> getAll() {
// 查询所有团队类型记录
List<TeamTypes> list = teamTypesDao.selectList(null); List<TeamTypes> list = teamTypesDao.selectList(null);
return list; return list; // 返回所有团队类型记录
} }
// 获取分页团队类型信息方法，声明只读事务，提高性能
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
public PageData getPageInfo(Long pageIndex, Long pageSize, TeamTypes teamTypes) { public PageData getPageInfo(Long pageIndex, Long pageSize, TeamTypes teamTypes) {
// 构造查询条件
QueryWrapper<TeamTypes> qw = new QueryWrapper<TeamTypes>(); QueryWrapper<TeamTypes> qw = new QueryWrapper<TeamTypes>();
// 如果团队类型名称不为空，进行模糊匹配
if (StringUtils.isNotNullOrEmpty(teamTypes.getName())) { if (StringUtils.isNotNullOrEmpty(teamTypes.getName())) {
qw.like("name", teamTypes.getName()); qw.like("name", teamTypes.getName());
} }
// 按创建时间降序排序
qw.orderByDesc("create_time"); qw.orderByDesc("create_time");
// 分页查询团队类型记录
Page<TeamTypes> page = Page<TeamTypes> page =
teamTypesDao.selectPage(new Page<TeamTypes>(pageIndex, pageSize), qw); teamTypesDao.selectPage(new Page<TeamTypes>(pageIndex, pageSize), qw);
return parsePage(page); return parsePage(page); // 转换分页结果并返回
} }
/** /**
@ -105,19 +126,27 @@ public class TeamTypesServiceImpl implements TeamTypesService {
*/ */
public PageData parsePage(Page<TeamTypes> p) { public PageData parsePage(Page<TeamTypes> p) {
// 初始化结果列表
List<Map<String, Object>> resl = new ArrayList<Map<String, Object>>(); List<Map<String, Object>> resl = new ArrayList<Map<String, Object>>();
// 遍历分页结果中的团队类型记录
for (TeamTypes teamTypes : p.getRecords()) { for (TeamTypes teamTypes : p.getRecords()) {
// 初始化临时映射
Map<String, Object> temp = new HashMap<String, Object>(); Map<String, Object> temp = new HashMap<String, Object>();
temp.put("id", teamTypes.getId());
temp.put("name", teamTypes.getName()); // 添加团队类型基本信息
temp.put("createTime", teamTypes.getCreateTime()); temp.put("id", teamTypes.getId()); // 添加团队类型 ID
temp.put("name", teamTypes.getName()); // 添加团队类型名称
temp.put("createTime", teamTypes.getCreateTime()); // 添加创建时间
// 将临时映射添加到结果列表
resl.add(temp); resl.add(temp);
} }
// 初始化分页数据对象
PageData pageData = new PageData(p.getCurrent(), p.getSize(), p.getTotal(), resl); PageData pageData = new PageData(p.getCurrent(), p.getSize(), p.getTotal(), resl);
return pageData; return pageData; // 返回分页数据对象
} }
} }

116
server/src/main/java/self/cases/teams/service/impl/TeamsServiceImpl.java
Unescape View File

@ -20,166 +20,202 @@ import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
// 将类注册为 Spring 的 Bean，名称为 "teamsService"
@Service("teamsService") @Service("teamsService")
public class TeamsServiceImpl implements TeamsService { public class TeamsServiceImpl implements TeamsService {
// 自动注入 UsersDao，用于操作用户表
@Autowired @Autowired
private UsersDao usersDao; private UsersDao usersDao;
// 自动注入 TeamTypesDao，用于操作团队类型表
@Autowired @Autowired
private TeamTypesDao teamTypesDao; private TeamTypesDao teamTypesDao;
// 自动注入 TeamsDao，用于操作团队表
@Autowired @Autowired
private TeamsDao teamsDao; private TeamsDao teamsDao;
// 自动注入 MembersDao，用于操作成员表
@Autowired @Autowired
private MembersDao membersDao; private MembersDao membersDao;
// 自动注入 NoticesDao，用于操作通知表
@Autowired @Autowired
private NoticesDao noticesDao; private NoticesDao noticesDao;
// 自动注入 ActivitiesDao，用于操作活动表
@Autowired @Autowired
private ActivitiesDao activitiesDao; private ActivitiesDao activitiesDao;
// 自动注入 ActiveLogsDao，用于操作活动日志表
@Autowired @Autowired
private ActiveLogsDao activeLogsDao; private ActiveLogsDao activeLogsDao;
// 自动注入 ApplyLogsDao，用于操作申请日志表
@Autowired @Autowired
private ApplyLogsDao applyLogsDao; private ApplyLogsDao applyLogsDao;
// 自动注入 PayLogsDao，用于操作支付日志表
@Autowired @Autowired
private PayLogsDao payLogsDao; private PayLogsDao payLogsDao;
// 添加团队方法，声明事务管理，确保添加操作的原子性
@Override @Override
@Transactional @Transactional
public void add(Teams teams) { public void add(Teams teams) {
// 插入新的团队记录
teamsDao.insert(teams); teamsDao.insert(teams);
// 创建新的成员记录
Members member = new Members(); Members member = new Members();
member.setId(IDUtils.makeIDByCurrent()); member.setId(IDUtils.makeIDByCurrent()); // 设置成员 ID
member.setUserId(teams.getManager()); member.setUserId(teams.getManager()); // 设置负责人 ID
member.setTeamId(teams.getId()); member.setTeamId(teams.getId()); // 设置团队 ID
member.setCreateTime(DateUtils.getNowDate()); member.setCreateTime(DateUtils.getNowDate()); // 设置创建时间
membersDao.insert(member); membersDao.insert(member); // 插入新成员记录
// 查询负责人信息并更新其用户类型为 1（团队负责人）
Users user = usersDao.selectById(teams.getManager()); Users user = usersDao.selectById(teams.getManager());
user.setType(1); user.setType(1);
usersDao.updateById(user); usersDao.updateById(user);
} }
// 更新团队方法，声明事务管理，确保更新操作的原子性
@Override @Override
@Transactional @Transactional
public void update(Teams teams) { public void update(Teams teams) {
// 根据主键更新团队记录
teamsDao.updateById(teams); teamsDao.updateById(teams);
} }
// 删除团队方法，声明事务管理，确保删除操作的原子性
@Override @Override
@Transactional @Transactional
public void delete(Teams teams) { public void delete(Teams teams) {
// 构造查询条件，删除通知表中与团队相关的记录
QueryWrapper<Notices> qw_notice = new QueryWrapper<Notices>(); QueryWrapper<Notices> qw_notice = new QueryWrapper<Notices>();
qw_notice.eq("team_id", teams.getId()); qw_notice.eq("team_id", teams.getId());
noticesDao.delete(qw_notice); noticesDao.delete(qw_notice);
// 构造查询条件，删除支付日志表中与团队相关的记录
QueryWrapper<PayLogs> qw_pay = new QueryWrapper<PayLogs>(); QueryWrapper<PayLogs> qw_pay = new QueryWrapper<PayLogs>();
qw_pay.eq("team_id", teams.getId()); qw_pay.eq("team_id", teams.getId());
payLogsDao.delete(qw_pay); payLogsDao.delete(qw_pay);
// 构造查询条件，删除申请日志表中与团队相关的记录
QueryWrapper<ApplyLogs> qw_apply = new QueryWrapper<ApplyLogs>(); QueryWrapper<ApplyLogs> qw_apply = new QueryWrapper<ApplyLogs>();
qw_apply.eq("team_id", teams.getId()); qw_apply.eq("team_id", teams.getId());
applyLogsDao.delete(qw_apply); applyLogsDao.delete(qw_apply);
// 构造查询条件，删除成员表中与团队相关的记录
QueryWrapper<Members> qw_members = new QueryWrapper<Members>(); QueryWrapper<Members> qw_members = new QueryWrapper<Members>();
qw_members.eq("team_id", teams.getId()); qw_members.eq("team_id", teams.getId());
membersDao.delete(qw_members); membersDao.delete(qw_members);
// 构造查询条件，删除活动表中与团队相关的记录
QueryWrapper<Activities> qw_active = new QueryWrapper<Activities>(); QueryWrapper<Activities> qw_active = new QueryWrapper<Activities>();
qw_active.eq("team_id", teams.getId()); qw_active.eq("team_id", teams.getId());
for(Activities activitie : activitiesDao.selectList(qw_active)){ for (Activities activitie : activitiesDao.selectList(qw_active)) {
// 构造查询条件，删除活动日志表中与活动相关的记录
QueryWrapper<ActiveLogs> qw_active_log = new QueryWrapper<ActiveLogs>(); QueryWrapper<ActiveLogs> qw_active_log = new QueryWrapper<ActiveLogs>();
qw_active_log.eq("active_id", activitie.getId()); qw_active_log.eq("active_id", activitie.getId());
activeLogsDao.delete(qw_active_log); activeLogsDao.delete(qw_active_log);
} }
activitiesDao.delete(qw_active); activitiesDao.delete(qw_active);
// 根据主键删除团队记录
teamsDao.deleteById(teams); teamsDao.deleteById(teams);
// 构造查询条件，检查负责人是否不再管理任何团队
QueryWrapper<Teams> qw_team = new QueryWrapper<Teams>(); QueryWrapper<Teams> qw_team = new QueryWrapper<Teams>();
qw_team.eq("manager", teams.getManager()); qw_team.eq("manager", teams.getManager());
if(teamsDao.selectCount(qw_team) <= 0){ if (teamsDao.selectCount(qw_team) <= 0) {
// 查询负责人信息并更新其用户类型为 2（普通用户）
Users user = usersDao.selectById(teams.getManager()); Users user = usersDao.selectById(teams.getManager());
user.setType(2); user.setType(2);
usersDao.updateById(user); usersDao.updateById(user);
} }
} }
// 获取单个团队方法，声明只读事务，提高性能
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
public Teams getOne(String id) { public Teams getOne(String id) {
// 根据主键查询团队记录
Teams teams = teamsDao.selectById(id); Teams teams = teamsDao.selectById(id);
return teams; return teams; // 返回查询到的团队记录
} }
// 获取所有团队方法，声明只读事务，提高性能
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
public List<Teams> getAll(){ public List<Teams> getAll() {
// 构造查询条件
QueryWrapper<Teams> qw = new QueryWrapper<Teams>(); QueryWrapper<Teams> qw = new QueryWrapper<Teams>();
// 按创建时间降序排序
qw.orderByDesc("create_time"); qw.orderByDesc("create_time");
// 查询所有团队记录
List<Teams> list = teamsDao.selectList(qw); List<Teams> list = teamsDao.selectList(qw);
return list; return list; // 返回所有团队记录
} }
// 根据负责人 ID 获取团队列表方法，声明只读事务，提高性能
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
public List<Teams> getListByManId(String manId){ public List<Teams> getListByManId(String manId) {
// 构造查询条件
QueryWrapper<Teams> qw = new QueryWrapper<Teams>(); QueryWrapper<Teams> qw = new QueryWrapper<Teams>();
qw.eq("manager", manId); qw.eq("manager", manId); // 查询指定负责人的团队记录
qw.orderByDesc("create_time"); qw.orderByDesc("create_time"); // 按创建时间降序排序
// 查询指定负责人的团队记录
List<Teams> list = teamsDao.selectList(qw); List<Teams> list = teamsDao.selectList(qw);
return list; return list; // 返回指定负责人的团队记录
} }
// 获取分页团队信息方法，声明只读事务，提高性能
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
public PageData getPageInfo(Long pageIndex, Long pageSize, Teams teams) { public PageData getPageInfo(Long pageIndex, Long pageSize, Teams teams) {
// 构造查询条件
QueryWrapper<Teams> qw = new QueryWrapper<Teams>(); QueryWrapper<Teams> qw = new QueryWrapper<Teams>();
if(StringUtils.isNotNullOrEmpty(teams.getName())){ // 如果团队名称不为空，进行模糊匹配
if (StringUtils.isNotNullOrEmpty(teams.getName())) {
qw.like("name", teams.getName()); qw.like("name", teams.getName());
} }
if(StringUtils.isNotNullOrEmpty(teams.getTypeId())){ // 如果团队类型 ID 不为空，进行精确匹配
if (StringUtils.isNotNullOrEmpty(teams.getTypeId())) {
qw.eq("type_id", teams.getTypeId()); qw.eq("type_id", teams.getTypeId());
} }
if(StringUtils.isNotNullOrEmpty(teams.getManager())){ // 如果负责人 ID 不为空，进行精确匹配
if (StringUtils.isNotNullOrEmpty(teams.getManager())) {
qw.eq("manager", teams.getManager()); qw.eq("manager", teams.getManager());
} }
// 按创建时间降序排序
qw.orderByDesc("create_time"); qw.orderByDesc("create_time");
// 分页查询团队记录
Page<Teams> page = Page<Teams> page =
teamsDao.selectPage(new Page<Teams>(pageIndex, pageSize), qw); teamsDao.selectPage(new Page<Teams>(pageIndex, pageSize), qw);
return parsePage(page); return parsePage(page); // 转换分页结果并返回
} }
/** /**
@ -187,30 +223,40 @@ public class TeamsServiceImpl implements TeamsService {
*/ */
public PageData parsePage(Page<Teams> p) { public PageData parsePage(Page<Teams> p) {
// 初始化结果列表
List<Map<String, Object>> resl = new ArrayList<Map<String, Object>>(); List<Map<String, Object>> resl = new ArrayList<Map<String, Object>>();
// 遍历分页结果中的团队记录
for (Teams teams : p.getRecords()) { for (Teams teams : p.getRecords()) {
// 初始化临时映射
Map<String, Object> temp = new HashMap<String, Object>(); Map<String, Object> temp = new HashMap<String, Object>();
temp.put("id", teams.getId());
temp.put("name", teams.getName());
temp.put("createTime", teams.getCreateTime());
temp.put("total", teams.getTotal());
// 添加团队基本信息
temp.put("id", teams.getId()); // 添加团队 ID
temp.put("name", teams.getName()); // 添加团队名称
temp.put("createTime", teams.getCreateTime()); // 添加创建时间
temp.put("total", teams.getTotal()); // 添加团队总人数
// 查询负责人信息
Users user = usersDao.selectById(teams.getManager()); Users user = usersDao.selectById(teams.getManager());
temp.put("manager", teams.getManager()); temp.put("manager", teams.getManager()); // 添加负责人 ID
temp.put("managerName", user.getName()); temp.put("managerName", user.getName()); // 添加负责人姓名
temp.put("managerPhone", user.getPhone()); temp.put("managerPhone", user.getPhone()); // 添加负责人电话
temp.put("managerAddress", user.getAddress()); temp.put("managerAddress", user.getAddress()); // 添加负责人地址
// 查询团队类型信息
TeamTypes teamType = teamTypesDao.selectById(teams.getTypeId()); TeamTypes teamType = teamTypesDao.selectById(teams.getTypeId());
temp.put("typeId", teams.getTypeId()); temp.put("typeId", teams.getTypeId()); // 添加团队类型 ID
temp.put("typeName", teamType.getName()); temp.put("typeName", teamType.getName()); // 添加团队类型名称
// 将临时映射添加到结果列表
resl.add(temp); resl.add(temp);
} }
// 初始化分页数据对象
PageData pageData = new PageData(p.getCurrent(), p.getSize(), p.getTotal(), resl); PageData pageData = new PageData(p.getCurrent(), p.getSize(), p.getTotal(), resl);
return pageData; return pageData; // 返回分页数据对象
} }
} }

73
server/src/main/java/self/cases/teams/service/impl/UsersServiceImpl.java
Unescape View File

@ -8,11 +8,10 @@ import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
import self.cases.teams.dao.MembersDao; import self.cases.teams.dao.MembersDao;
import self.cases.teams.dao.TeamsDao; import self.cases.teams.dao.UsersDao;
import self.cases.teams.entity.Members; import self.cases.teams.entity.Members;
import self.cases.teams.entity.Teams;
import self.cases.teams.msg.PageData;
import self.cases.teams.entity.Users; import self.cases.teams.entity.Users;
import self.cases.teams.msg.PageData;
import self.cases.teams.dao.UsersDao; import self.cases.teams.dao.UsersDao;
import self.cases.teams.service.UsersService; import self.cases.teams.service.UsersService;
import self.cases.teams.utils.StringUtils; import self.cases.teams.utils.StringUtils;
@ -22,96 +21,118 @@ import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
// 将类注册为 Spring 的 Bean，名称为 "usersService"
@Service("usersService") @Service("usersService")
public class UsersServiceImpl implements UsersService { public class UsersServiceImpl implements UsersService {
// 自动注入 MembersDao，用于操作成员表
@Autowired @Autowired
private MembersDao membersDao; private MembersDao membersDao;
// 自动注入 UsersDao，用于操作用户表
@Autowired @Autowired
private UsersDao usersDao; private UsersDao usersDao;
// 添加用户方法，声明事务管理，确保添加操作的原子性
@Override @Override
@Transactional @Transactional
public void add(Users users) { public void add(Users users) {
// 插入新的用户记录
usersDao.insert(users); usersDao.insert(users);
} }
// 更新用户方法，声明事务管理，确保更新操作的原子性
@Override @Override
@Transactional @Transactional
public void update(Users users) { public void update(Users users) {
// 根据主键更新用户记录
usersDao.updateById(users); usersDao.updateById(users);
} }
// 删除用户方法，声明事务管理，确保删除操作的原子性
@Override @Override
@Transactional @Transactional
public void delete(Users users) { public void delete(Users users) {
// 根据主键删除用户记录
usersDao.deleteById(users); usersDao.deleteById(users);
} }
// 判断用户是否可以被删除的方法，声明只读事务，提高性能
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
public Boolean isRemove(String userId){ public Boolean isRemove(String userId) {
// 构造查询条件，检查是否有成员关联该用户
QueryWrapper<Members> qw = new QueryWrapper<Members>(); QueryWrapper<Members> qw = new QueryWrapper<Members>();
qw.eq("user_id", userId); qw.eq("user_id", userId);
// 查询关联该用户的成员数量
Integer total = membersDao.selectCount(qw); Integer total = membersDao.selectCount(qw);
// 如果关联数量为 0，则可以删除
return total <= 0; return total <= 0;
} }
// 获取单个用户方法，声明只读事务，提高性能
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
public Users getOne(String id) { public Users getOne(String id) {
// 根据主键查询用户记录
Users users = usersDao.selectById(id); Users users = usersDao.selectById(id);
return users; return users; // 返回查询到的用户记录
} }
// 根据用户名获取用户方法，声明只读事务，提高性能
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
public Users getUserByUserName(String userName) { public Users getUserByUserName(String userName) {
// 构造查询条件，根据用户名查询用户记录
QueryWrapper<Users> qw = new QueryWrapper<Users>(); QueryWrapper<Users> qw = new QueryWrapper<Users>();
qw.eq("user_name", userName); qw.eq("user_name", userName);
// 查询单个符合条件的用户记录
Users user = usersDao.selectOne(qw); Users user = usersDao.selectOne(qw);
return user; return user; // 返回查询到的用户记录
} }
// 获取分页用户信息方法，声明只读事务，提高性能
@Override @Override
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS) @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
public PageData getPageInfo(Long pageIndex, Long pageSize, Users users) { public PageData getPageInfo(Long pageIndex, Long pageSize, Users users) {
// 构造查询条件
QueryWrapper<Users> qw = new QueryWrapper<Users>(); QueryWrapper<Users> qw = new QueryWrapper<Users>();
// 如果用户名不为空，进行模糊匹配
if (StringUtils.isNotNullOrEmpty(users.getUserName())) { if (StringUtils.isNotNullOrEmpty(users.getUserName())) {
qw.like("user_name", users.getUserName()); qw.like("user_name", users.getUserName());
} }
// 如果姓名不为空，进行模糊匹配
if (StringUtils.isNotNullOrEmpty(users.getName())) { if (StringUtils.isNotNullOrEmpty(users.getName())) {
qw.like("name", users.getName()); qw.like("name", users.getName());
} }
// 如果电话不为空，进行模糊匹配
if (StringUtils.isNotNullOrEmpty(users.getPhone())) { if (StringUtils.isNotNullOrEmpty(users.getPhone())) {
qw.like("phone", users.getPhone()); qw.like("phone", users.getPhone());
} }
// 按创建时间降序排序
qw.orderByDesc("create_time"); qw.orderByDesc("create_time");
// 分页查询用户记录
Page<Users> page = Page<Users> page =
usersDao.selectPage(new Page<Users>(pageIndex, pageSize), qw); usersDao.selectPage(new Page<Users>(pageIndex, pageSize), qw);
return parsePage(page); return parsePage(page); // 转换分页结果并返回
} }
/** /**
@ -119,27 +140,35 @@ public class UsersServiceImpl implements UsersService {
*/ */
public PageData parsePage(Page<Users> p) { public PageData parsePage(Page<Users> p) {
// 初始化结果列表
List<Map<String, Object>> resl = new ArrayList<Map<String, Object>>(); List<Map<String, Object>> resl = new ArrayList<Map<String, Object>>();
// 遍历分页结果中的用户记录
for (Users users : p.getRecords()) { for (Users users : p.getRecords()) {
// 初始化临时映射
Map<String, Object> temp = new HashMap<String, Object>(); Map<String, Object> temp = new HashMap<String, Object>();
temp.put("id", users.getId());
temp.put("userName", users.getUserName()); // 添加用户基本信息
temp.put("passWord", users.getPassWord()); temp.put("id", users.getId()); // 添加用户 ID
temp.put("name", users.getName()); temp.put("userName", users.getUserName()); // 添加用户名
temp.put("gender", users.getGender()); temp.put("passWord", users.getPassWord()); // 添加密码
temp.put("age", users.getAge()); temp.put("name", users.getName()); // 添加姓名
temp.put("phone", users.getPhone()); temp.put("gender", users.getGender()); // 添加性别
temp.put("address", users.getAddress()); temp.put("age", users.getAge()); // 添加年龄
temp.put("status", users.getStatus()); temp.put("phone", users.getPhone()); // 添加电话
temp.put("createTime", users.getCreateTime()); temp.put("address", users.getAddress()); // 添加地址
temp.put("type", users.getType()); temp.put("status", users.getStatus()); // 添加状态
temp.put("createTime", users.getCreateTime()); // 添加创建时间
temp.put("type", users.getType()); // 添加用户类型
// 将临时映射添加到结果列表
resl.add(temp); resl.add(temp);
} }
// 初始化分页数据对象
PageData pageData = new PageData(p.getCurrent(), p.getSize(), p.getTotal(), resl); PageData pageData = new PageData(p.getCurrent(), p.getSize(), p.getTotal(), resl);
return pageData; return pageData; // 返回分页数据对象
} }
} }

BIN
server/target/classes/self/cases/teams/dao/ActivitiesDao.class
View File

Binary file not shown.

BIN
server/target/classes/self/cases/teams/dao/ApplyLogsDao.class
View File

Binary file not shown.

BIN
server/target/classes/self/cases/teams/dao/MembersDao.class
View File

Binary file not shown.

BIN
server/target/classes/self/cases/teams/dao/NoticesDao.class
View File

Binary file not shown.

BIN
server/target/classes/self/cases/teams/dao/PayLogsDao.class
View File

Binary file not shown.

BIN
server/target/classes/self/cases/teams/msg/PageData.class
View File

Binary file not shown.

BIN
server/target/classes/self/cases/teams/msg/R.class
View File

Binary file not shown.
Write Preview
Loading…
Cancel
Save