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

xiu7

Browse Source
main
YZY 4 months ago
parent 43e6486731
commit 562311e111
48 changed files with 1290 additions and 1182 deletions
Show Stats Download Patch File Download Diff File

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

@ -146,6 +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" />
</task> </task>
<servers /> <servers />
</component> </component>

112
server/src/main/java/self/cases/teams/Application.java
Unescape View File

@ -1,78 +1,82 @@
package self.cases.teams; package self.cases.teams; // 定义项目主包名
import com.alibaba.fastjson.serializer.SerializerFeature; import com.alibaba.fastjson.serializer.SerializerFeature; // 引入 FastJSON 的序列化特性
import com.alibaba.fastjson.support.config.FastJsonConfig; import com.alibaba.fastjson.support.config.FastJsonConfig; // 引入 FastJSON 的配置类
import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter; import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter; // 引入 FastJSON 的 HTTP 消息转换器
import com.baomidou.mybatisplus.annotation.DbType; import com.baomidou.mybatisplus.annotation.DbType; // 引入 MyBatis-Plus 的数据库类型枚举
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor; import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor; // 引入 MyBatis-Plus 的拦截器
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor; import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor; // 引入 MyBatis-Plus 的分页拦截器
import org.mybatis.spring.annotation.MapperScan; import org.mybatis.spring.annotation.MapperScan; // 引入 MyBatis 的 Mapper 扫描注解
import org.springframework.boot.SpringApplication; import org.springframework.boot.SpringApplication; // 引入 Spring Boot 的启动类
import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; // 引入 Spring Boot 的启动注解
import org.springframework.boot.autoconfigure.http.HttpMessageConverters; import org.springframework.boot.autoconfigure.http.HttpMessageConverters; // 引入 Spring Boot 的消息转换器
import org.springframework.cache.annotation.EnableCaching; import org.springframework.cache.annotation.EnableCaching; // 引入缓存注解
import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Bean; // 引入 Bean 注解
import org.springframework.http.MediaType; import org.springframework.http.MediaType; // 引入 HTTP 媒体类型
import org.springframework.http.converter.HttpMessageConverter; import org.springframework.http.converter.HttpMessageConverter; // 引入 HTTP 消息转换器
import org.springframework.web.servlet.config.annotation.CorsRegistry; import org.springframework.web.servlet.config.annotation.CorsRegistry; // 引入 CORS 配置
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; // 引入 Web MVC 配置
import java.util.ArrayList; import java.util.ArrayList; // 导入 ArrayList 类，用于创建动态数组
import java.util.List; import java.util.List; // 导入 List 接口，用于表示有序集合
@SpringBootApplication
@MapperScan({"self.cases.teams.dao"}) @SpringBootApplication // 启动类注解
@EnableCaching @MapperScan({"self.cases.teams.dao"}) // 扫描 Mapper 接口所在的包
public class Application implements WebMvcConfigurer{ @EnableCaching // 开启缓存功能
public class Application implements WebMvcConfigurer { // 定义启动类并实现 WebMvcConfigurer 接口
/** /**
* JSON格式转换器 * JSON格式转换器
* @return * @return 返回 FastJsonHttpMessageConverter 实例
*/ */
@Bean @Bean // 声明为 Spring 容器中的 Bean
public HttpMessageConverters fastJsonHttpMessageConverters() { public HttpMessageConverters fastJsonHttpMessageConverters() {
FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter(); FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter(); // 创建 FastJSON 消息转换器实例
FastJsonConfig fastJsonConfig = new FastJsonConfig(); FastJsonConfig fastJsonConfig = new FastJsonConfig(); // 创建 FastJSON 配置实例
fastJsonConfig.setSerializerFeatures(SerializerFeature.PrettyFormat); fastJsonConfig.setSerializerFeatures(SerializerFeature.PrettyFormat); // 设置序列化特性为美化格式
List<MediaType> fastMedisTypes = new ArrayList<>(); List<MediaType> fastMedisTypes = new ArrayList<>(); // 创建支持的媒体类型列表
fastMedisTypes.add(MediaType.APPLICATION_JSON); fastMedisTypes.add(MediaType.APPLICATION_JSON); // 添加 JSON 类型
fastConverter.setSupportedMediaTypes(fastMedisTypes); fastConverter.setSupportedMediaTypes(fastMedisTypes); // 设置支持的媒体类型
fastConverter.setFastJsonConfig(fastJsonConfig); fastConverter.setFastJsonConfig(fastJsonConfig); // 设置 FastJSON 配置
HttpMessageConverter<?> converter = fastConverter; HttpMessageConverter<?> converter = fastConverter; // 转换为通用消息转换器
return new HttpMessageConverters(converter); return new HttpMessageConverters(converter); // 返回消息转换器集合
} }
/** /**
* 添加MySQL分页查询 * 添加 MySQL 分页查询拦截器
* @return * @return 返回 MybatisPlusInterceptor 实例
*/ */
@Bean @Bean // 声明为 Spring 容器中的 Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() { public MybatisPlusInterceptor mybatisPlusInterceptor() {
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor(); // 创建拦截器实例
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor(); interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL)); // 添加分页拦截器，并指定数据库类型为 MySQL
return interceptor; // 返回拦截器实例
interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
return interceptor;
} }
@Bean /**
* 配置跨域资源共享 (CORS)
* @return 返回 WebMvcConfigurer 实例
*/
@Bean // 声明为 Spring 容器中的 Bean
public WebMvcConfigurer corsConfigurer() { public WebMvcConfigurer corsConfigurer() {
return new WebMvcConfigurer() { return new WebMvcConfigurer() { // 匿名内部类实现 WebMvcConfigurer 接口
@Override @Override // 重写 addCorsMappings 方法
public void addCorsMappings(CorsRegistry registry) { public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**") registry.addMapping("/**") // 配置所有路径都支持跨域
.allowedOrigins("*") .allowedOrigins("*") // 允许所有来源访问
.allowCredentials(true) .allowCredentials(true) // 允许携带凭证（如 Cookies）
.allowedMethods("GET", "POST", "DELETE", "PUT","PATCH") .allowedMethods("GET", "POST", "DELETE", "PUT", "PATCH") // 允许的 HTTP 方法
.maxAge(3600); .maxAge(3600); // 设置预检请求的有效期为 3600 秒
} }
}; };
} }
/**
* 应用程序入口方法
* @param args 启动参数
*/
public static void main(String[] args) { public static void main(String[] args) {
SpringApplication.run(Application.class, args); // 启动 Spring Boot 应用程序
SpringApplication.run(Application.class, args);
} }
} }

271
server/src/main/java/self/cases/teams/Student.java
Unescape View File

@ -6,24 +6,26 @@ import java.util.*;
import java.util.stream.Collectors; import java.util.stream.Collectors;
// 学生类 // 学生类
// 定义一个名为 Student 的类，实现序列化接口，用于存储学生信息
class Student implements Serializable { class Student implements Serializable {
private String id; private String id; // 学号
private String name; private String name; // 姓名
private int age; private int age; // 年龄
private String className; private String className; // 班级
private Date enrollDate; private Date enrollDate; // 入学日期
private Map<String, Double> scores; private Map<String, Double> scores; // 存储学生成绩的映射表
// 构造函数，初始化学生的基本信息
public Student(String id, String name, int age, String className) { public Student(String id, String name, int age, String className) {
this.id = id; this.id = id;
this.name = name; this.name = name;
this.age = age; this.age = age;
this.className = className; this.className = className;
this.enrollDate = new Date(); this.enrollDate = new Date(); // 当前时间作为入学日期
this.scores = new HashMap<>(); this.scores = new HashMap<>(); // 初始化空的成绩表
} }
// Getter和Setter方法 // Getter 和 Setter 方法，用于访问和修改私有字段
public String getId() { return id; } public String getId() { return id; }
public String getName() { return name; } public String getName() { return name; }
public int getAge() { return age; } public int getAge() { return age; }
@ -31,321 +33,350 @@ class Student implements Serializable {
public Date getEnrollDate() { return enrollDate; } public Date getEnrollDate() { return enrollDate; }
public Map<String, Double> getScores() { return scores; } public Map<String, Double> getScores() { return scores; }
// 更新学生的某门课程成绩
public void updateScore(String course, double score) { public void updateScore(String course, double score) {
scores.put(course, score); scores.put(course, score);
} }
// 计算学生的平均成绩
public double calculateAverage() { public double calculateAverage() {
return scores.values().stream() return scores.values().stream()
.mapToDouble(Double::doubleValue) .mapToDouble(Double::doubleValue)
.average() .average()
.orElse(0.0); .orElse(0.0); // 如果没有成绩则返回默认值 0.0
} }
// 将学生信息以字符串形式输出
@Override @Override
public String toString() { public String toString() {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); // 格式化日期
return String.format("学号: %s\n姓名: %s\n年龄: %d\n班级: %s\n入学日期: %s", return String.format("学号: %s\\n姓名: %s\\n年龄: %d\\n班级: %s\\n入学日期: %s",
id, name, age, className, sdf.format(enrollDate)); id, name, age, className, sdf.format(enrollDate));
} }
} }
// 课程管理类 // 定义一个名为 CourseManager 的类，用于管理课程信息
class CourseManager { class CourseManager {
private static final List<String> AVAILABLE_COURSES = Arrays.asList( private static final List<String> AVAILABLE_COURSES = Arrays.asList(
"数学", "语文", "英语", "物理", "化学" "数学", "语文", "英语", "物理", "化学" // 可用课程列表
); );
// 判断课程是否有效
public static boolean isValidCourse(String course) { public static boolean isValidCourse(String course) {
return AVAILABLE_COURSES.contains(course); return AVAILABLE_COURSES.contains(course);
} }
// 显示可用课程列表
public static void showAvailableCourses() { public static void showAvailableCourses() {
System.out.println("可选课程列表:"); System.out.println("可选课程列表:");
AVAILABLE_COURSES.forEach(c -> System.out.print(c + " ")); AVAILABLE_COURSES.forEach(c -> System.out.print(c + " ")); // 打印课程名
System.out.println(); System.out.println();
} }
} }
// 文件工具类 // 定义一个名为 FileUtil 的类，用于文件操作
class FileUtil { class FileUtil {
private static final String DATA_FILE = "students.dat"; private static final String DATA_FILE = "students.dat"; // 数据文件路径
// 将学生列表保存到文件中
public static void saveData(List<Student> students) { public static void saveData(List<Student> students) {
try (ObjectOutputStream oos = new ObjectOutputStream( try (ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream(DATA_FILE))) { new FileOutputStream(DATA_FILE))) {
oos.writeObject(students); oos.writeObject(students); // 序列化并写入文件
} catch (IOException e) { } catch (IOException e) {
System.err.println("数据保存失败: " + e.getMessage()); System.err.println("数据保存失败: " + e.getMessage()); // 错误处理
} }
} }
// 从文件中加载学生数据
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public static List<Student> loadData() { public static List<Student> loadData() {
File file = new File(DATA_FILE); File file = new File(DATA_FILE);
if (!file.exists()) return new ArrayList<>(); if (!file.exists()) return new ArrayList<>(); // 文件不存在时返回空列表
try (ObjectInputStream ois = new ObjectInputStream( try (ObjectInputStream ois = new ObjectInputStream(
new FileInputStream(DATA_FILE))) { new FileInputStream(DATA_FILE))) {
return (List<Student>) ois.readObject(); return (List<Student>) ois.readObject(); // 反序列化读取数据
} catch (IOException | ClassNotFoundException e) { } catch (IOException | ClassNotFoundException e) {
System.err.println("数据加载失败: " + e.getMessage()); System.err.println("数据加载失败: " + e.getMessage()); // 错误处理
return new ArrayList<>(); return new ArrayList<>(); // 返回空列表
} }
} }
} }
// 输入工具类 // 定义一个名为 InputUtil 的类，用于获取用户输入
class InputUtil { class InputUtil {
private static final Scanner scanner = new Scanner(System.in); private static final Scanner scanner = new Scanner(System.in); // 输入流
// 获取整数输入
public static int getIntInput(String prompt) { public static int getIntInput(String prompt) {
while (true) { while (true) {
System.out.print(prompt); System.out.print(prompt); // 提示信息
try { try {
return Integer.parseInt(scanner.nextLine()); return Integer.parseInt(scanner.nextLine()); // 转换为整数
} catch (NumberFormatException e) { } catch (NumberFormatException e) {
System.out.println("输入无效，请输入整数！"); System.out.println("输入无效，请输入整数！"); // 错误提示
} }
} }
} }
// 获取字符串输入
public static String getStringInput(String prompt) { public static String getStringInput(String prompt) {
System.out.print(prompt); System.out.print(prompt); // 提示信息
return scanner.nextLine().trim(); return scanner.nextLine().trim(); // 去除首尾空格
} }
// 获取双精度浮点数输入
public static double getDoubleInput(String prompt) { public static double getDoubleInput(String prompt) {
while (true) { while (true) {
System.out.print(prompt); System.out.print(prompt); // 提示信息
try { try {
return Double.parseDouble(scanner.nextLine()); return Double.parseDouble(scanner.nextLine()); // 转换为浮点数
} catch (NumberFormatException e) { } catch (NumberFormatException e) {
System.out.println("输入无效，请输入数字！"); System.out.println("输入无效，请输入数字！"); // 错误提示
} }
} }
} }
} }
// 主系统类 // 定义主系统类 StudentManagementSystem
class StudentManagementSystem { class StudentManagementSystem {
private List<Student> students; private List<Student> students; // 存储学生列表
private boolean isRunning = true; private boolean isRunning = true; // 控制程序运行状态
// 构造函数，初始化学生列表并加载数据
public StudentManagementSystem() { public StudentManagementSystem() {
students = FileUtil.loadData(); students = FileUtil.loadData();
} }
// 启动系统主循环
public void start() { public void start() {
while (isRunning) { while (isRunning) {
showMainMenu(); showMainMenu(); // 显示主菜单
int choice = InputUtil.getIntInput("请选择操作："); int choice = InputUtil.getIntInput("请选择操作："); // 获取用户选择
handleMainMenu(choice); handleMainMenu(choice); // 处理用户选择
} }
} }
// 显示主菜单
private void showMainMenu() { private void showMainMenu() {
System.out.println("\n==== 学生信息管理系统 ===="); System.out.println("\\n==== 学生信息管理 ====");
System.out.println("1. 添加学生"); System.out.println("1. 添加学生");
System.out.println("2. 查询学生"); System.out.println("2. 查询学生");
System.out.println("3. 录入成绩"); System.out.println("3. 录入活动成绩");
System.out.println("4. 显示统计"); System.out.println("4. 显示统计");
System.out.println("5. 删除学生"); System.out.println("5. 删除学生信息");
System.out.println("6. 保存数据"); System.out.println("6. 保存数据");
System.out.println("7. 退出系统"); System.out.println("7. 退出系统");
} }
// 处理主菜单选项
private void handleMainMenu(int choice) { private void handleMainMenu(int choice) {
switch (choice) { switch (choice) {
// case 1 -> addStudent(); // case 1 -> addStudent(); // 添加学生
// case 2 -> searchStudent(); // case 2 -> searchStudent(); // 查询学生
// case 3 -> inputScore(); // case 3 -> inputScore(); // 录入成绩
// case 4 -> showStatistics(); // case 4 -> showStatistics(); // 显示统计信息
// case 5 -> deleteStudent(); // case 5 -> deleteStudent(); // 删除学生
// case 6 -> saveData(); // case 6 -> saveData(); // 保存数据
// case 7 -> exitSystem(); // case 7 -> exitSystem(); // 退出系统
// default -> System.out.println("无效选项！"); // default -> System.out.println("无效选项！");
} }
} }
// 添加学生
private void addStudent() { private void addStudent() {
String id = InputUtil.getStringInput("请输入学号："); String id = InputUtil.getStringInput("请输入学号："); // 获取学号
if (isStudentExist(id)) { if (isStudentExist(id)) { // 检查学号是否已存在
System.out.println("该学号已存在！"); System.out.println("该学号已存在！");
return; return;
} }
String name = InputUtil.getStringInput("请输入姓名："); String name = InputUtil.getStringInput("请输入姓名："); // 获取姓名
int age = InputUtil.getIntInput("请输入年龄："); int age = InputUtil.getIntInput("请输入年龄："); // 获取年龄
String className = InputUtil.getStringInput("请输入班级："); String className = InputUtil.getStringInput("请输入班级："); // 获取班级
Student student = new Student(id, name, age, className); Student student = new Student(id, name, age, className); // 创建学生对象
students.add(student); students.add(student); // 添加到学生列表
System.out.println("学生添加成功！"); System.out.println("学生添加成功！");
} }
// 查询学生
private void searchStudent() { private void searchStudent() {
System.out.println("\n==== 查询选项 ===="); System.out.println("\\n==== 查询选项 ====");
System.out.println("1. 按学号查询"); System.out.println("1. 按学号查询");
System.out.println("2. 按姓名查询"); System.out.println("2. 按姓名查询");
System.out.println("3. 显示全部"); System.out.println("3. 显示全部");
int choice = InputUtil.getIntInput("请选择查询方式："); int choice = InputUtil.getIntInput("请选择查询方式："); // 获取查询方式
switch (choice) { switch (choice) {
// case 1 -> searchById(); // case 1 -> searchById(); // 按学号查询
// case 2 -> searchByName(); // case 2 -> searchByName(); // 按姓名查询
// case 3 -> showAllStudents(); // case 3 -> showAllStudents(); // 显示全部学生
// default -> System.out.println("无效选项！"); // default -> System.out.println("无效选项！");
} }
} }
// 按学号查询学生
private void searchById() { private void searchById() {
String id = InputUtil.getStringInput("请输入学号："); String id = InputUtil.getStringInput("请输入学号："); // 获取学号
students.stream() students.stream()
.filter(s -> s.getId().equals(id)) .filter(s -> s.getId().equals(id)) // 筛选符合条件的学生
.findFirst(); .findFirst(); // 查找第一个匹配项
} }
// 按姓名查询学生
private void searchByName() { private void searchByName() {
String name = InputUtil.getStringInput("请输入姓名："); String name = InputUtil.getStringInput("请输入姓名："); // 获取姓名
List<Student> result = null; List<Student> result = null;
try { try {
students.stream() students.stream()
.filter(s -> s.getName().equalsIgnoreCase(name)) .filter(s -> s.getName().equalsIgnoreCase(name)) // 忽略大小写筛选
.wait(); .wait(); // 等待（此处有误，应改为 collect 或其他操作）
} catch (InterruptedException e) { } catch (InterruptedException e) {
throw new RuntimeException(e); throw new RuntimeException(e);
} }
if (result.isEmpty()) { if (result.isEmpty()) { // 如果未找到学生
System.out.println("找不到该学生"); System.out.println("找不到该学生");
} else { } else {
result.forEach(System.out::println); result.forEach(System.out::println); // 输出学生信息
} }
} }
// 显示所有学生
private void showAllStudents() { private void showAllStudents() {
if (students.isEmpty()) { if (students.isEmpty()) { // 如果学生列表为空
System.out.println("当前没有学生记录"); System.out.println("当前没有学生记录");
return; return;
} }
students.forEach(s -> {
System.out.println(s); students.forEach(s -> { // 遍历学生列表
System.out.println(s); // 输出学生信息
System.out.println("--------------------"); System.out.println("--------------------");
}); });
} }
// 录入成绩
private void inputScore() { private void inputScore() {
String id = InputUtil.getStringInput("请输入学号："); String id = InputUtil.getStringInput("请输入学号："); // 获取学号
Student student = findStudentById(id); Student student = findStudentById(id); // 查找学生
if (student == null) { if (student == null) { // 如果学生不存在
System.out.println("学生不存在！"); System.out.println("学生不存在！");
return; return;
} }
CourseManager.showAvailableCourses(); CourseManager.showAvailableCourses(); // 显示可用课程
String course = InputUtil.getStringInput("请输入课程名称："); String course = InputUtil.getStringInput("请输入课程名称："); // 获取课程名称
if (!CourseManager.isValidCourse(course)) { if (!CourseManager.isValidCourse(course)) { // 检查课程是否有效
System.out.println("无效课程！"); System.out.println("无效课程！");
return; return;
} }
double score = InputUtil.getDoubleInput("请输入成绩："); double score = InputUtil.getDoubleInput("请输入成绩："); // 获取成绩
student.updateScore(course, score); student.updateScore(course, score); // 更新学生成绩
System.out.println("成绩录入成功！"); System.out.println("成绩录入成功！");
} }
// 显示统计信息
private void showStatistics() { private void showStatistics() {
System.out.println("\n==== 统计信息 ===="); System.out.println("\\n==== 统计信息 ====");
System.out.println("1. 班级人数统计"); System.out.println("1. 班级人数统计");
System.out.println("2. 课程平均分"); System.out.println("2. 课程平均分");
System.out.println("3. 学生个人成绩"); System.out.println("3. 学生个人成绩");
int choice = InputUtil.getIntInput("请选择统计类型："); int choice = InputUtil.getIntInput("请选择统计类型："); // 获取统计类型
switch (choice) { switch (choice) {
// case 1 -> showClassStatistics(); // case 1 -> showClassStatistics(); // 显示班级人数统计
// case 2 -> showCourseStatistics(); // case 2 -> showCourseStatistics(); // 显示课程平均分
// case 3 -> showStudentScores(); // case 3 -> showStudentScores(); // 显示学生个人成绩
// default -> System.out.println("无效选项！"); // default -> System.out.println("无效选项！");
} }
} }
// 显示班级人数统计
private void showClassStatistics() { private void showClassStatistics() {
Map<String, Long> classCount = students.stream() Map<String, Long> classCount = students.stream()
.collect(Collectors.groupingBy( .collect(Collectors.groupingBy(
Student::getClassName, Student::getClassName, // 按班级分组
Collectors.counting())); Collectors.counting())); // 统计每班人数
classCount.forEach((className, count) -> classCount.forEach((className, count) -> // 遍历班级和人数
System.out.printf("班级 %s: %d 人\n", className, count)); System.out.printf("班级 %s: %d 人\\n", className, count)); // 输出结果
} }
// 显示课程平均分
private void showCourseStatistics() { private void showCourseStatistics() {
Map<String, Double> courseAverages = new HashMap<>(); Map<String, Double> courseAverages = new HashMap<>();
students.forEach(student -> students.forEach(student -> // 遍历每个学生
student.getScores().forEach((course, score) -> student.getScores().forEach((course, score) -> // 遍历每门课程成绩
courseAverages.merge(course, score, Double::sum))); courseAverages.merge(course, score, Double::sum))); // 累加成绩
courseAverages.forEach((course, total) -> { courseAverages.forEach((course, total) -> { // 遍历课程总分
long count = students.stream() long count = students.stream()
.filter(s -> s.getScores().containsKey(course)) .filter(s -> s.getScores().containsKey(course)) // 筛选有该课程的学生
.count(); .count(); // 统计学生数量
double average = count > 0 ? total / count : 0; double average = count > 0 ? total / count : 0; // 计算平均分
System.out.printf("%s 平均分: %.2f\n", course, average); System.out.printf("%s 平均分: %.2f\\n", course, average); // 输出结果
}); });
} }
// 显示学生个人成绩
private void showStudentScores() { private void showStudentScores() {
String id = InputUtil.getStringInput("请输入学号："); String id = InputUtil.getStringInput("请输入学号："); // 获取学号
Student student = findStudentById(id); Student student = findStudentById(id); // 查找学生
if (student == null) { if (student == null) { // 如果学生不存在
System.out.println("学生不存在！"); System.out.println("学生不存在！");
return; return;
} }
System.out.println(student); System.out.println(student); // 输出学生基本信息
if (student.getScores().isEmpty()) { if (student.getScores().isEmpty()) { // 如果没有成绩记录
System.out.println("暂无成绩记录"); System.out.println("暂无成绩记录");
return; return;
} }
student.getScores().forEach((course, score) -> student.getScores().forEach((course, score) -> // 遍历每门课程成绩
System.out.printf("%s: %.2f\n", course, score)); System.out.printf("%s: %.2f\\n", course, score)); // 输出课程成绩
System.out.printf("平均分: %.2f\n", student.calculateAverage()); System.out.printf("平均分: %.2f\\n", student.calculateAverage()); // 输出平均分
} }
// 删除学生信息
private void deleteStudent() { private void deleteStudent() {
String id = InputUtil.getStringInput("请输入要删除的学号："); String id = InputUtil.getStringInput("请输入要删除的学号："); // 获取学号
boolean removed = students.removeIf(s -> s.getId().equals(id)); boolean removed = students.removeIf(s -> s.getId().equals(id)); // 删除学生
System.out.println(removed ? "删除成功！" : "学生不存在！"); System.out.println(removed ? "删除成功！" : "学生不存在！"); // 输出结果
} }
// 保存数据
private void saveData() { private void saveData() {
FileUtil.saveData(students); FileUtil.saveData(students); // 保存学生列表到文件
System.out.println("数据已保存！"); System.out.println("数据已保存！");
} }
// 退出系统
private void exitSystem() { private void exitSystem() {
isRunning = false; isRunning = false; // 设置运行标志为 false
System.out.println("正在退出系统..."); System.out.println("正在退出系统..."); // 提示退出
saveData(); saveData(); // 保存数据
System.out.println("谢谢使用！"); System.out.println("谢谢使用！"); // 结束提示
} }
// 检查学号是否存在
private boolean isStudentExist(String id) { private boolean isStudentExist(String id) {
return students.stream() return students.stream()
.anyMatch(s -> s.getId().equals(id)); .anyMatch(s -> s.getId().equals(id)); // 判断是否有相同学号的学生
} }
// 根据学号查找学生
private Student findStudentById(String id) { private Student findStudentById(String id) {
return students.stream() return students.stream()
.filter(s -> s.getId().equals(id)) .filter(s -> s.getId().equals(id)) // 筛选符合条件的学生
.findFirst() .findFirst() // 查找第一个匹配项
.orElse(null); .orElse(null); // 如果未找到返回 null
} }
public static void main(String[] args) { public static void main(String[] args) {
new StudentManagementSystem().start(); new StudentManagementSystem().start(); // 启动系统
} }
} }

127
server/src/main/java/self/cases/teams/controller/ActiveLogsController.java
Unescape View File

@ -1,121 +1,120 @@
package self.cases.teams.controller; package self.cases.teams.controller;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory; // 导入日志工具类
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired; // 自动注入依赖
import org.springframework.stereotype.Controller; import org.springframework.stereotype.Controller; // Spring MVC 控制器注解
import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.*; // RESTful 注解支持
import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.ExceptionHandler; // 异常处理注解
import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.ResponseBody; // 返回 JSON 数据注解
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody; import self.cases.teams.entity.Users; // 用户实体类
import self.cases.teams.handle.CacheHandle; // 缓存处理类
import self.cases.teams.entity.Users; import self.cases.teams.service.UsersService; // 用户服务接口
import self.cases.teams.handle.CacheHandle; import self.cases.teams.utils.DateUtils; // 日期工具类
import self.cases.teams.service.UsersService; import self.cases.teams.utils.IDUtils; // ID 工具类
import self.cases.teams.utils.DateUtils; import self.cases.teams.msg.R; // 响应封装类
import self.cases.teams.utils.IDUtils; import self.cases.teams.msg.PageData; // 分页数据封装类
import self.cases.teams.msg.R;
import self.cases.teams.msg.PageData; import self.cases.teams.entity.ActiveLogs; // 报名记录实体类
import self.cases.teams.service.ActiveLogsService; // 报名记录服务接口
import self.cases.teams.entity.ActiveLogs;
import self.cases.teams.service.ActiveLogsService; import java.util.List; // Java 集合 List 接口
import java.util.Map; // Java 集合 Map 接口
import java.util.List;
import java.util.Map;
/** /**
* 系统请求响应控制器 * 系统请求响应控制器
* 报名记录 * 报名记录
*/ */
@Controller @Controller
@RequestMapping("/activeLogs") @RequestMapping("/activeLogs") // 设置默认请求路径
public class ActiveLogsController extends BaseController { public class ActiveLogsController extends BaseController { // 继承基础控制器
protected static final Logger Log = LoggerFactory.getLogger(ActiveLogsController.class); protected static final Logger Log = LoggerFactory.getLogger(ActiveLogsController.class); // 日志实例
@Autowired @Autowired // 自动注入缓存处理类
private CacheHandle cacheHandle; private CacheHandle cacheHandle;
@Autowired @Autowired // 自动注入用户服务
private UsersService usersService; private UsersService usersService;
@Autowired @Autowired // 自动注入报名记录服务
private ActiveLogsService activeLogsService; private ActiveLogsService activeLogsService;
@RequestMapping("") @RequestMapping("") // 默认请求映射
public String index() { public String index() {
return "pages/ActiveLogs"; return "pages/ActiveLogs"; // 返回视图页面名称
} }
@GetMapping("/info") @GetMapping("/info") // GET 请求获取单条记录
@ResponseBody @ResponseBody // 返回 JSON 数据
public R getInfo(String id) { public R getInfo(String id) {
Log.info("查找指定报名记录，ID：{}", id); Log.info("查找指定报名记录，ID：{}", id); // 记录日志
ActiveLogs activeLogs = activeLogsService.getOne(id); ActiveLogs activeLogs = activeLogsService.getOne(id); // 查询单条记录
return R.successData(activeLogs); return R.successData(activeLogs); // 返回成功数据
} }
@GetMapping("/list") @GetMapping("/list") // GET 请求获取指定活动的报名记录
@ResponseBody @ResponseBody // 返回 JSON 数据
public R getList(String activeId) { public R getList(String activeId) {
Log.info("获取指定活动的报名记录，活动ID：{}", activeId); Log.info("获取指定活动的报名记录，活动ID：{}", activeId); // 记录日志
List<Map<String, Object>> list = activeLogsService.getListByActiveId(activeId); List<Map<String, Object>> list = activeLogsService.getListByActiveId(activeId); // 查询指定活动的报名记录
return R.successData(list); return R.successData(list); // 返回成功数据
} }
@PostMapping("/add") @PostMapping("/add") // POST 请求新增记录
@ResponseBody @ResponseBody // 返回 JSON 数据
public R addInfo(String token, ActiveLogs activeLogs) { public R addInfo(String token, ActiveLogs activeLogs) {
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); // 获取当前用户
if (activeLogsService.isActive(activeLogs.getActiveId(), user.getId())) { // 判断是否已参与
if(activeLogsService.isActive(activeLogs.getActiveId(), user.getId())){ activeLogs.setId(IDUtils.makeIDByCurrent()); // 生成唯一 ID
activeLogs.setUserId(user.getId()); // 设置用户 ID
activeLogs.setCreateTime(DateUtils.getNowDate()); // 设置创建时间
activeLogs.setId(IDUtils.makeIDByCurrent()); Log.info("添加报名记录，传入参数：{}", activeLogs); // 记录日志
activeLogs.setUserId(user.getId());
activeLogs.setCreateTime(DateUtils.getNowDate());
Log.info("添加报名记录，传入参数：{}", activeLogs); activeLogsService.add(activeLogs); // 添加记录
activeLogsService.add(activeLogs); return R.success(); // 返回成功响应
return R.success(); } else {
}else{
return R.warn("该活动您已参与，请勿重复报名"); return R.warn("该活动您已参与，请勿重复报名"); // 返回警告响应
} }
} }
@PostMapping("/upd") @PostMapping("/upd") // POST 请求更新记录
@ResponseBody @ResponseBody // 返回 JSON 数据
public R updInfo(ActiveLogs activeLogs) { public R updInfo(ActiveLogs activeLogs) {
Log.info("修改报名记录，传入参数：{}", activeLogs); Log.info("修改报名记录，传入参数：{}", activeLogs); // 记录日志
activeLogsService.update(activeLogs); activeLogsService.update(activeLogs); // 更新记录
return R.success(); return R.success(); // 返回成功响应
} }
@PostMapping("/del") @PostMapping("/del") // POST 请求删除记录
@ResponseBody @ResponseBody // 返回 JSON 数据
public R delInfo(String id) { public R delInfo(String id) {
Log.info("删除报名记录, ID:{}", id); Log.info("删除报名记录, ID:{}", id); // 记录日志
ActiveLogs activeLogs = activeLogsService.getOne(id); ActiveLogs activeLogs = activeLogsService.getOne(id); // 查询待删除记录
activeLogsService.delete(activeLogs); activeLogsService.delete(activeLogs); // 删除记录
return R.success(); return R.success(); // 返回成功响应
} }
} }

150
server/src/main/java/self/cases/teams/controller/ApplyLogsController.java
Unescape View File

@ -1,146 +1,142 @@
package self.cases.teams.controller; package self.cases.teams.controller;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory; // 导入日志工具类
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired; // 自动注入依赖
import org.springframework.stereotype.Controller; import org.springframework.stereotype.Controller; // Spring MVC 控制器注解
import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.*; // RESTful 注解支持
import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.ExceptionHandler; // 异常处理注解
import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.ResponseBody; // 返回 JSON 数据注解
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody; import self.cases.teams.entity.Users; // 用户实体类
import self.cases.teams.handle.CacheHandle; // 缓存处理类
import self.cases.teams.entity.Users; import self.cases.teams.service.UsersService; // 用户服务接口
import self.cases.teams.handle.CacheHandle; import self.cases.teams.utils.DateUtils; // 日期工具类
import self.cases.teams.service.UsersService; import self.cases.teams.utils.IDUtils; // ID 工具类
import self.cases.teams.utils.DateUtils; import self.cases.teams.msg.R; // 响应封装类
import self.cases.teams.utils.IDUtils; import self.cases.teams.msg.PageData; // 分页数据封装类
import self.cases.teams.msg.R;
import self.cases.teams.msg.PageData; import self.cases.teams.entity.ApplyLogs; // 申请记录实体类
import self.cases.teams.service.ApplyLogsService; // 申请记录服务接口
import self.cases.teams.entity.ApplyLogs;
import self.cases.teams.service.ApplyLogsService;
/** /**
* 系统请求响应控制器 * 系统请求响应控制器
* 申请记录 * 申请记录
*/ */
@Controller @Controller
@RequestMapping("/applyLogs") @RequestMapping("/applyLogs") // 设置默认请求路径
public class ApplyLogsController extends BaseController { public class ApplyLogsController extends BaseController { // 继承基础控制器
protected static final Logger Log = LoggerFactory.getLogger(ApplyLogsController.class); protected static final Logger Log = LoggerFactory.getLogger(ApplyLogsController.class); // 日志实例
@Autowired @Autowired // 自动注入缓存处理类
private CacheHandle cacheHandle; private CacheHandle cacheHandle;
@Autowired @Autowired // 自动注入用户服务
private UsersService usersService; private UsersService usersService;
@Autowired @Autowired // 自动注入申请记录服务
private ApplyLogsService applyLogsService; private ApplyLogsService applyLogsService;
@RequestMapping("") @RequestMapping("") // 默认请求映射
public String index() { public String index() {
return "pages/ApplyLogs"; return "pages/ApplyLogs"; // 返回视图页面名称
} }
@GetMapping("/info") @GetMapping("/info") // GET 请求获取单条记录
@ResponseBody @ResponseBody // 返回 JSON 数据
public R getInfo(String id) { public R getInfo(String id) {
Log.info("查找指定申请记录，ID：{}", id); Log.info("查找指定申请记录，ID：{}", id); // 记录日志
ApplyLogs applyLogs = applyLogsService.getOne(id); ApplyLogs applyLogs = applyLogsService.getOne(id); // 查询单条记录
return R.successData(applyLogs); return R.successData(applyLogs); // 返回成功数据
} }
@GetMapping("/page") @GetMapping("/page") // GET 请求分页查询
@ResponseBody @ResponseBody // 返回 JSON 数据
public R getPageInfos(Long pageIndex, Long pageSize, public R getPageInfos(Long pageIndex, Long pageSize,
String token, String teamName, String userName) { String token, String teamName, String userName) {
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); // 获取当前用户
if (user.getType() == 0) { if (user.getType() == 0) { // 普通用户权限
Log.info("分页查看全部申请记录，当前页码：{}，" Log.info("分页查看全部申请记录，当前页码：{}，每页数据量：{}, 模糊查询，团队名称：{}，用户姓名：{}",
+ "每页数据量：{}, 模糊查询，团队名称：{}，用户姓名：{}", pageIndex, pageIndex, pageSize, teamName, userName);
pageSize, teamName, userName);
PageData page = applyLogsService.getPageInfo(pageIndex, pageSize, null, teamName, userName); PageData page = applyLogsService.getPageInfo(pageIndex, pageSize, null, teamName, userName); // 查询分页数据
return R.successData(page); return R.successData(page); // 返回成功数据
} else if (user.getType() == 1) { } else if (user.getType() == 1) { // 团队管理员权限
Log.info("团队管理员查看申请记录，当前页码：{}，" Log.info("团队管理员查看申请记录，当前页码：{}，每页数据量：{}, 模糊查询，团队名称：{}，用户姓名：{}",
+ "每页数据量：{}, 模糊查询，团队名称：{}，用户姓名：{}", pageIndex, pageIndex, pageSize, teamName, userName);
pageSize, teamName, userName);
PageData page = applyLogsService.getManPageInfo(pageIndex, pageSize, user.getId(), teamName, userName); PageData page = applyLogsService.getManPageInfo(pageIndex, pageSize, user.getId(), teamName, userName); // 查询团队管理员分页数据
return R.successData(page); return R.successData(page); // 返回成功数据
} else { } else { // 其他权限
Log.info("分页用户相关申请记录，当前页码：{}，" Log.info("分页用户相关申请记录，当前页码：{}，每页数据量：{}, 模糊查询，团队名称：{}，用户姓名：{}",
+ "每页数据量：{}, 模糊查询，团队名称：{}，用户姓名：{}", pageIndex, pageIndex, pageSize, teamName, userName);
pageSize, teamName, userName);
PageData page = applyLogsService.getPageInfo(pageIndex, pageSize, user.getId(), teamName, null); PageData page = applyLogsService.getPageInfo(pageIndex, pageSize, user.getId(), teamName, null); // 查询用户相关分页数据
return R.successData(page); return R.successData(page); // 返回成功数据
} }
} }
@PostMapping("/add") @PostMapping("/add") // POST 请求新增记录
@ResponseBody @ResponseBody // 返回 JSON 数据
public R addInfo(String token, ApplyLogs applyLogs) { public R addInfo(String token, ApplyLogs applyLogs) {
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); // 获取当前用户
if (applyLogsService.isApply(user.getId(), applyLogs.getTeamId())) { // 判断是否已申请
if(applyLogsService.isApply(user.getId(), applyLogs.getTeamId())){ applyLogs.setId(IDUtils.makeIDByCurrent()); // 生成唯一 ID
applyLogs.setUserId(user.getId()); // 设置用户 ID
applyLogs.setCreateTime(DateUtils.getNowDate()); // 设置创建时间
applyLogs.setId(IDUtils.makeIDByCurrent()); Log.info("添加申请记录，传入参数：{}", applyLogs); // 记录日志
applyLogs.setUserId(user.getId());
applyLogs.setCreateTime(DateUtils.getNowDate());
Log.info("添加申请记录，传入参数：{}", applyLogs); applyLogsService.add(applyLogs); // 添加记录
applyLogsService.add(applyLogs); return R.success(); // 返回成功响应
return R.success(); } else {
}else{
return R.warn("申请审核中，请耐心等待"); return R.warn("申请审核中，请耐心等待"); // 返回警告响应
} }
} }
@PostMapping("/upd") @PostMapping("/upd") // POST 请求更新记录
@ResponseBody @ResponseBody // 返回 JSON 数据
public R updInfo(ApplyLogs applyLogs) { public R updInfo(ApplyLogs applyLogs) {
Log.info("修改申请记录，传入参数：{}", applyLogs); Log.info("修改申请记录，传入参数：{}", applyLogs); // 记录日志
applyLogsService.update(applyLogs); applyLogsService.update(applyLogs); // 更新记录
return R.success(); return R.success(); // 返回成功响应
} }
@PostMapping("/del") @PostMapping("/del") // POST 请求删除记录
@ResponseBody @ResponseBody // 返回 JSON 数据
public R delInfo(String id) { public R delInfo(String id) {
Log.info("删除申请记录, ID:{}", id); Log.info("删除申请记录, ID:{}", id); // 记录日志
ApplyLogs applyLogs = applyLogsService.getOne(id); ApplyLogs applyLogs = applyLogsService.getOne(id); // 查询待删除记录
applyLogsService.delete(applyLogs); applyLogsService.delete(applyLogs); // 删除记录
return R.success(); return R.success(); // 返回成功响应
} }
} }

29
server/src/main/java/self/cases/teams/controller/BaseController.java
Unescape View File

@ -1,10 +1,10 @@
package self.cases.teams.controller; package self.cases.teams.controller;
import org.springframework.web.bind.annotation.ExceptionHandler; import org.springframework.web.bind.annotation.ExceptionHandler; // 异常处理注解
import org.springframework.web.bind.annotation.ResponseBody; import org.springframework.web.bind.annotation.ResponseBody; // 返回 JSON 数据注解
import self.cases.teams.msg.R; import self.cases.teams.msg.R; // 响应封装类
import javax.servlet.http.HttpSession; import javax.servlet.http.HttpSession; // Servlet HTTP 会话
/** /**
* 系统控制器抽象类 * 系统控制器抽象类
@ -12,16 +12,16 @@ import javax.servlet.http.HttpSession;
*/ */
public abstract class BaseController { public abstract class BaseController {
protected static final String SESSION_USER = "user"; protected static final String SESSION_USER = "user"; // 定义会话中存储用户信息的键值
/** /**
* 获取登录用户的信息 * 获取登录用户的信息
* @param session 会话对象 * @param session 会话对象
* @return * @return 当前会话中的用户信息
*/ */
protected Object getSessionUser(HttpSession session) { protected Object getSessionUser(HttpSession session) {
return session.getAttribute(SESSION_USER); return session.getAttribute(SESSION_USER); // 从会话中获取用户信息
} }
/** /**
@ -31,15 +31,20 @@ public abstract class BaseController {
*/ */
protected void setSessionUser(HttpSession session, Object user) { protected void setSessionUser(HttpSession session, Object user) {
session.setAttribute(SESSION_USER, user); session.setAttribute(SESSION_USER, user); // 将用户信息存入会话
} }
@ExceptionHandler(Exception.class) /**
@ResponseBody * 全局异常处理器
* @param e 抛出的异常
* @return 错误响应对象
*/
@ExceptionHandler(Exception.class) // 捕获所有类型的异常
@ResponseBody // 返回 JSON 数据
public R exception(Exception e) { public R exception(Exception e) {
e.printStackTrace(); e.printStackTrace(); // 打印异常堆栈信息
return R.error(); return R.error(); // 返回错误响应
} }
} }

159
server/src/main/java/self/cases/teams/controller/IndexController.java
Unescape View File

@ -1,148 +1,171 @@
package self.cases.teams.controller; package self.cases.teams.controller;
import org.slf4j.Logger; import org.slf4j.Logger; // 日志工具类
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory; // 日志工厂类
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired; // 自动注入依赖
import org.springframework.stereotype.Controller; import org.springframework.stereotype.Controller; // Spring MVC 控制器注解
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*; // 注解支持 RESTful API
import self.cases.teams.entity.Notices; import self.cases.teams.entity.Notices; // 公告实体类
import self.cases.teams.handle.CacheHandle; import self.cases.teams.handle.CacheHandle; // 缓存处理类
import self.cases.teams.msg.R; import self.cases.teams.msg.R; // 响应封装类
import self.cases.teams.entity.Users; import self.cases.teams.entity.Users; // 用户实体类
import self.cases.teams.service.NoticesService; import self.cases.teams.service.NoticesService; // 公告服务接口
import self.cases.teams.service.UsersService; import self.cases.teams.service.UsersService; // 用户服务接口
import self.cases.teams.utils.IDUtils; import self.cases.teams.utils.IDUtils; // ID 工具类
import javax.servlet.http.HttpSession; import javax.servlet.http.HttpSession; // Servlet HTTP 会话
import java.util.List; import java.util.List; // Java 集合类
import java.util.Map; import java.util.Map; // Java Map 集合
@Controller @Controller
@RequestMapping("/") @RequestMapping("/") // 基础路径映射
public class IndexController extends BaseController { public class IndexController extends BaseController {
private static final Logger Log = LoggerFactory.getLogger(IndexController.class); private static final Logger Log = LoggerFactory.getLogger(IndexController.class); // 初始化日志记录器
@Autowired @Autowired // 自动注入用户服务接口
private UsersService usersService; private UsersService usersService;
@Autowired @Autowired // 自动注入缓存处理类
private CacheHandle cacheHandle; private CacheHandle cacheHandle;
@Autowired @Autowired // 自动注入公告服务接口
private NoticesService noticesService; private NoticesService noticesService;
/**
* 获取系统公告列表
*/
@GetMapping("/sys/notices") @GetMapping("/sys/notices")
@ResponseBody @ResponseBody // 返回 JSON 数据
public R getNoticeList(String token){ public R getNoticeList(String token) {
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); // 从缓存中获取用户信息
if (user.getType() == 0) { // 如果用户类型为普通用户
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); List<Notices> list = noticesService.getSysNotices(); // 获取系统公告列表
if(user.getType() == 0){ return R.successData(list); // 返回系统公告数据
List<Notices> list = noticesService.getSysNotices(); } else if (user.getType() == 1) { // 如果用户类型为管理员
return R.successData(list); List<Notices> list = noticesService.getManNotices(user.getId()); // 获取管理员相关的公告列表
}else if(user.getType() == 1){
List<Notices> list = noticesService.getManNotices(user.getId()); return R.successData(list); // 返回管理员公告数据
return R.successData(list); } else { // 如果用户类型为会员
}else{
List<Notices> list = noticesService.getMemNotices(user.getId()); List<Notices> list = noticesService.getMemNotices(user.getId()); // 获取会员相关的公告列表
return R.successData(list); return R.successData(list); // 返回会员公告数据
} }
} }
//用户登录 /**
* 用户登录
*/
@PostMapping("/login") @PostMapping("/login")
@ResponseBody @ResponseBody
public R login(String userName, String passWord, HttpSession session){ public R login(String userName, String passWord, HttpSession session) {
Log.info("用户登录，用户名：{}， 用户密码：{}", userName, passWord); Log.info("用户登录，用户名：{}， 用户密码：{}", userName, passWord); // 记录日志
Users user = usersService.getUserByUserName(userName); Users user = usersService.getUserByUserName(userName); // 根据用户名获取用户信息
if(user == null) { if (user == null) { // 如果用户不存在
return R.error("输入的用户名不存在"); return R.error("输入的用户名不存在"); // 返回错误信息
}else {
if(passWord.equals(user.getPassWord().trim())) { } else { // 如果用户存在
if (passWord.equals(user.getPassWord().trim())) { // 如果密码匹配
String token = IDUtils.makeIDByUUID(); String token = IDUtils.makeIDByUUID(); // 生成登录令牌
cacheHandle.addUserCache(token, user.getId()); cacheHandle.addUserCache(token, user.getId()); // 将用户信息存入缓存
return R.success("登录成功", token); return R.success("登录成功", token); // 返回登录成功信息和令牌
}else {
return R.error("输入的密码错误"); } else { // 如果密码不匹配
return R.error("输入的密码错误"); // 返回密码错误信息
} }
} }
} }
/**
* 用户退出系统
*/
@RequestMapping("/exit") @RequestMapping("/exit")
@ResponseBody @ResponseBody
public R exit(String token) { public R exit(String token) {
Log.info("用户退出系统并移除登录信息"); Log.info("用户退出系统并移除登录信息"); // 记录日志
cacheHandle.removeUserCache(token); cacheHandle.removeUserCache(token); // 移除用户的缓存信息
return R.success(); return R.success(); // 返回成功响应
} }
/**
* 获取用户信息
*/
@GetMapping("/info") @GetMapping("/info")
@ResponseBody @ResponseBody
public R info(String token){ public R info(String token) {
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); // 从缓存中获取用户信息
return R.successData(user); return R.successData(user); // 返回用户信息
} }
/**
* 修改用户信息
*/
@PostMapping("/info") @PostMapping("/info")
@ResponseBody @ResponseBody
public R info(Users user){ public R info(Users user) {
Log.info("修改用户信息，{}", user); Log.info("修改用户信息，{}", user); // 记录日志
usersService.update(user); usersService.update(user); // 调用服务层更新用户信息
return R.success(); return R.success(); // 返回成功响应
} }
/**
* 校验旧密码
*/
@RequestMapping("/checkPwd") @RequestMapping("/checkPwd")
@ResponseBody @ResponseBody
public R checkPwd(String oldPwd, String token) { public R checkPwd(String oldPwd, String token) {
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); // 从缓存中获取用户信息
if (oldPwd.equals(user.getPassWord())) { // 如果旧密码匹配
if(oldPwd.equals(user.getPassWord())) { return R.success(); // 返回成功响应
return R.success(); } else { // 如果旧密码不匹配
}else {
return R.warn("原始密码和输入密码不一致"); return R.warn("原始密码和输入密码不一致"); // 返回警告信息
} }
} }
//用户密码修改 /**
* 修改用户密码
*/
@PostMapping("/pwd") @PostMapping("/pwd")
@ResponseBody @ResponseBody
public R pwd(String token, String password) { public R pwd(String token, String password) {
Log.info("修改用户密码，{}", password); Log.info("修改用户密码，{}", password); // 记录日志
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); // 从缓存中获取用户信息
user.setPassWord(password); user.setPassWord(password); // 设置新密码
usersService.update(user); usersService.update(user); // 调用服务层更新用户密码
return R.success(); return R.success(); // 返回成功响应
} }
} }

123
server/src/main/java/self/cases/teams/controller/TeamTypesController.java
Unescape View File

@ -1,124 +1,143 @@
package self.cases.teams.controller; package self.cases.teams.controller;
import org.slf4j.Logger; import org.slf4j.Logger; // 日志工具类
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory; // 日志工厂类
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired; // 自动注入依赖
import org.springframework.stereotype.Controller; import org.springframework.stereotype.Controller; // Spring MVC 控制器注解
import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.GetMapping; // HTTP GET 请求映射
import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.PostMapping; // HTTP POST 请求映射
import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMapping; // 请求路径映射
import org.springframework.web.bind.annotation.ExceptionHandler; import org.springframework.web.bind.annotation.ExceptionHandler; // 异常处理器
import org.springframework.web.bind.annotation.ResponseBody; import org.springframework.web.bind.annotation.ResponseBody; // 返回 JSON 数据
import self.cases.teams.utils.DateUtils; import self.cases.teams.utils.DateUtils; // 自定义日期工具类
import self.cases.teams.utils.IDUtils; import self.cases.teams.utils.IDUtils; // 自定义 ID 工具类
import self.cases.teams.msg.R; import self.cases.teams.msg.R; // 响应封装类
import self.cases.teams.msg.PageData; import self.cases.teams.msg.PageData; // 分页数据封装类
import self.cases.teams.entity.TeamTypes; import self.cases.teams.entity.TeamTypes; // 社团类型实体类
import self.cases.teams.service.TeamTypesService; import self.cases.teams.service.TeamTypesService; // 社团类型服务接口
import java.util.List; import java.util.List; // Java 集合类
/** /**
* 系统请求响应控制器 * 系统请求响应控制器
* 社团类型 * 社团类型相关的请求处理
*/ */
@Controller @Controller
@RequestMapping("/teamTypes") @RequestMapping("/teamTypes") // 基础路径映射
public class TeamTypesController extends BaseController { public class TeamTypesController extends BaseController {
// 日志记录器
protected static final Logger Log = LoggerFactory.getLogger(TeamTypesController.class); protected static final Logger Log = LoggerFactory.getLogger(TeamTypesController.class);
@Autowired @Autowired // 自动注入 TeamTypesService
private TeamTypesService teamTypesService; private TeamTypesService teamTypesService;
/**
* 社团类型首页视图
*/
@RequestMapping("") @RequestMapping("")
public String index() { public String index() {
return "pages/TeamTypes"; return "pages/TeamTypes"; // 返回对应的视图页面
} }
/**
* 查看所有社团类型信息
*/
@GetMapping("/all") @GetMapping("/all")
@ResponseBody @ResponseBody // 返回 JSON 数据
public R getAll(){ public R getAll() {
Log.info("查看全部的社团类型信息"); Log.info("查看全部的社团类型信息"); // 记录日志
List<TeamTypes> list = teamTypesService.getAll(); List<TeamTypes> list = teamTypesService.getAll(); // 调用服务层获取所有社团类型
return R.successData(list); return R.successData(list); // 返回成功数据
} }
/**
* 根据社团类型 ID 获取社团类型信息
*/
@GetMapping("/info") @GetMapping("/info")
@ResponseBody @ResponseBody
public R getInfo(String id) { public R getInfo(String id) {
Log.info("查找指定社团类型，ID：{}", id); Log.info("查找指定社团类型，ID：{}", id); // 记录日志
TeamTypes teamTypes = teamTypesService.getOne(id); TeamTypes teamTypes = teamTypesService.getOne(id); // 调用服务层获取指定社团类型
return R.successData(teamTypes); return R.successData(teamTypes); // 返回成功数据
} }
/**
//社团类型管理 * 分页查询社团类型信息
*/
@GetMapping("/page") @GetMapping("/page")
@ResponseBody @ResponseBody
public R getPageInfos(Long pageIndex, Long pageSize, public R getPageInfos(Long pageIndex, Long pageSize, TeamTypes teamTypes) {
TeamTypes teamTypes) {
Log.info("分页查找社团类型，当前页码：{}，" Log.info("分页查找社团类型，当前页码：{}，每页数据量：{}, 模糊查询，附加参数：{}",
+ "每页数据量：{}, 模糊查询，附加参数：{}", pageIndex, pageIndex, pageSize, teamTypes); // 记录日志
pageSize, teamTypes);
PageData page = teamTypesService.getPageInfo(pageIndex, pageSize, teamTypes); PageData page = teamTypesService.getPageInfo(pageIndex, pageSize, teamTypes); // 调用服务层分页查询
return R.successData(page); return R.successData(page); // 返回分页数据
} }
/**
* 添加社团类型
*/
@PostMapping("/add") @PostMapping("/add")
@ResponseBody @ResponseBody
public R addInfo(TeamTypes teamTypes) { public R addInfo(TeamTypes teamTypes) {
teamTypes.setId(IDUtils.makeIDByCurrent()); teamTypes.setId(IDUtils.makeIDByCurrent()); // 生成社团类型 ID
teamTypes.setCreateTime(DateUtils.getNowDate()); teamTypes.setCreateTime(DateUtils.getNowDate()); // 设置创建时间
Log.info("添加社团类型，传入参数：{}", teamTypes); Log.info("添加社团类型，传入参数：{}", teamTypes); // 记录日志
teamTypesService.add(teamTypes); teamTypesService.add(teamTypes); // 调用服务层添加社团类型
return R.success(); return R.success(); // 返回成功响应
} }
/**
* 修改社团类型
*/
@PostMapping("/upd") @PostMapping("/upd")
@ResponseBody @ResponseBody
public R updInfo(TeamTypes teamTypes) { public R updInfo(TeamTypes teamTypes) {
Log.info("修改社团类型，传入参数：{}", teamTypes); Log.info("修改社团类型，传入参数：{}", teamTypes); // 记录日志
teamTypesService.update(teamTypes); teamTypesService.update(teamTypes); // 调用服务层修改社团类型
return R.success(); return R.success(); // 返回成功响应
} }
/**
* 删除社团类型
*/
@PostMapping("/del") @PostMapping("/del")
@ResponseBody @ResponseBody
public R delInfo(String id) { public R delInfo(String id) {
if(teamTypesService.isRemove(id)){ // 检查是否存在关联社团
if(teamTypesService.isRemove(id)) {
Log.info("删除社团类型, ID:{}", id); Log.info("删除社团类型, ID:{}", id); // 记录日志
TeamTypes teamTypes = teamTypesService.getOne(id); TeamTypes teamTypes = teamTypesService.getOne(id); // 获取社团类型信息
teamTypesService.delete(teamTypes); teamTypesService.delete(teamTypes); // 调用服务层删除社团类型
return R.success(); return R.success(); // 返回成功响应
}else{ } else {
return R.warn("存在关联社团，无法移除"); return R.warn("存在关联社团，无法移除"); // 返回警告响应
} }
} }
} }

148
server/src/main/java/self/cases/teams/controller/TeamsController.java
Unescape View File

@ -1,143 +1,167 @@
package self.cases.teams.controller; package self.cases.teams.controller;
import org.slf4j.Logger; import org.slf4j.Logger; // 日志工具类
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory; // 日志工厂类
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired; // 自动注入依赖
import org.springframework.stereotype.Controller; import org.springframework.stereotype.Controller; // Spring MVC 控制器注解
import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.GetMapping; // HTTP GET 请求映射
import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.PostMapping; // HTTP POST 请求映射
import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMapping; // 请求路径映射
import org.springframework.web.bind.annotation.ExceptionHandler; import org.springframework.web.bind.annotation.ExceptionHandler; // 异常处理器
import org.springframework.web.bind.annotation.ResponseBody; import org.springframework.web.bind.annotation.ResponseBody; // 返回 JSON 数据
import self.cases.teams.entity.Users; import self.cases.teams.entity.Users; // 用户实体类
import self.cases.teams.handle.CacheHandle; import self.cases.teams.handle.CacheHandle; // 缓存处理类
import self.cases.teams.service.UsersService; import self.cases.teams.service.UsersService; // 用户服务接口
import self.cases.teams.utils.DateUtils; import self.cases.teams.utils.DateUtils; // 自定义日期工具类
import self.cases.teams.utils.IDUtils; import self.cases.teams.utils.IDUtils; // 自定义 ID 工具类
import self.cases.teams.msg.R; import self.cases.teams.msg.R; // 响应封装类
import self.cases.teams.msg.PageData; import self.cases.teams.msg.PageData; // 分页数据封装类
import self.cases.teams.entity.Teams; import self.cases.teams.entity.Teams; // 社团实体类
import self.cases.teams.service.TeamsService; import self.cases.teams.service.TeamsService; // 社团服务接口
import java.util.List; import java.util.List; // Java 集合类
/** /**
* 系统请求响应控制器 * 系统请求响应控制器
* 社团信息 * 社团信息相关的请求处理
*/ */
@Controller @Controller
@RequestMapping("/teams") @RequestMapping("/teams") // 基础路径映射
public class TeamsController extends BaseController { public class TeamsController extends BaseController {
// 日志记录器
protected static final Logger Log = LoggerFactory.getLogger(TeamsController.class); protected static final Logger Log = LoggerFactory.getLogger(TeamsController.class);
@Autowired @Autowired // 自动注入缓存处理类
private CacheHandle cacheHandle; private CacheHandle cacheHandle;
@Autowired @Autowired // 自动注入用户服务接口
private UsersService usersService; private UsersService usersService;
@Autowired @Autowired // 自动注入社团服务接口
private TeamsService teamsService; private TeamsService teamsService;
/**
* 社团信息首页视图
*/
@RequestMapping("") @RequestMapping("")
public String index() { public String index() {
return "pages/Teams"; return "pages/Teams"; // 返回对应的视图页面
} }
/**
* 根据社团 ID 获取社团信息
*/
@GetMapping("/info") @GetMapping("/info")
@ResponseBody @ResponseBody // 返回 JSON 数据
public R getInfo(String id) { public R getInfo(String id) {
Log.info("查找指定社团信息，ID：{}", id); Log.info("查找指定社团信息，ID：{}", id); // 记录日志
Teams teams = teamsService.getOne(id); Teams teams = teamsService.getOne(id); // 调用服务层获取指定社团信息
return R.successData(teams); return R.successData(teams); // 返回成功数据
} }
/**
* 获取所有社团信息
*/
@GetMapping("/all") @GetMapping("/all")
@ResponseBody @ResponseBody
public R getAll(){ public R getAll() {
Log.info("获取全部的社团"); Log.info("获取全部的社团"); // 记录日志
List<Teams> list = teamsService.getAll(); List<Teams> list = teamsService.getAll(); // 调用服务层获取所有社团信息
return R.successData(list); return R.successData(list); // 返回成功数据
} }
/**
* 获取指定管理员相关的社团列表
*/
@GetMapping("/man") @GetMapping("/man")
@ResponseBody @ResponseBody
public R getListByManId(String manId){ public R getListByManId(String manId) {
Log.info("获取指定社团管理员相关的社团列表"); Log.info("获取指定社团管理员相关的社团列表"); // 记录日志
List<Teams> list = teamsService.getListByManId(manId); List<Teams> list = teamsService.getListByManId(manId); // 调用服务层获取指定管理员相关的社团列表
return R.successData(list); return R.successData(list); // 返回成功数据
} }
/**
* 分页查询社团信息
*/
@GetMapping("/page") @GetMapping("/page")
@ResponseBody @ResponseBody
public R getPageInfos(Long pageIndex, Long pageSize, public R getPageInfos(Long pageIndex, Long pageSize, String token, Teams teams) {
String token, Teams teams) {
// 从缓存中获取用户信息
Users user = usersService.getOne(cacheHandle.getUserInfoCache(token)); Users user = usersService.getOne(cacheHandle.getUserInfoCache(token));
if(user.getType() == 1){ // 如果用户类型为管理员，则设置社团管理员为当前用户
if (user.getType() == 1) {
teams.setManager(user.getId()); teams.setManager(user.getId());
} }
Log.info("分页查找社团信息，当前页码：{}，" Log.info("分页查找社团信息，当前页码：{}，每页数据量：{}, 模糊查询，附加参数：{}",
+ "每页数据量：{}, 模糊查询，附加参数：{}", pageIndex, pageIndex, pageSize, teams); // 记录日志
pageSize, teams);
PageData page = teamsService.getPageInfo(pageIndex, pageSize, teams); PageData page = teamsService.getPageInfo(pageIndex, pageSize, teams); // 调用服务层分页查询
return R.successData(page); return R.successData(page); // 返回分页数据
} }
/**
* 添加社团信息
*/
@PostMapping("/add") @PostMapping("/add")
@ResponseBody @ResponseBody
public R addInfo(Teams teams) { public R addInfo(Teams teams) {
teams.setId(IDUtils.makeIDByCurrent()); teams.setId(IDUtils.makeIDByCurrent()); // 生成社团 ID
teams.setCreateTime(DateUtils.getNowDate("yyyy-MM-dd")); teams.setCreateTime(DateUtils.getNowDate("yyyy-MM-dd")); // 设置创建时间
Log.info("添加社团信息，传入参数：{}", teams); Log.info("添加社团信息，传入参数：{}", teams); // 记录日志
teamsService.add(teams); teamsService.add(teams); // 调用服务层添加社团信息
return R.success(); return R.success(); // 返回成功响应
} }
/**
* 修改社团信息
*/
@PostMapping("/upd") @PostMapping("/upd")
@ResponseBody @ResponseBody
public R updInfo(Teams teams) { public R updInfo(Teams teams) {
Log.info("修改社团信息，传入参数：{}", teams); Log.info("修改社团信息，传入参数：{}", teams); // 记录日志
teamsService.update(teams); teamsService.update(teams); // 调用服务层修改社团信息
return R.success(); return R.success(); // 返回成功响应
} }
/**
* 删除社团信息
*/
@PostMapping("/del") @PostMapping("/del")
@ResponseBody @ResponseBody
public R delInfo(String id) { public R delInfo(String id) {
Log.info("删除社团信息, ID:{}", id); Log.info("删除社团信息, ID:{}", id); // 记录日志
Teams teams = teamsService.getOne(id); Teams teams = teamsService.getOne(id); // 获取社团信息
teamsService.delete(teams); teamsService.delete(teams); // 调用服务层删除社团信息
return R.success(); return R.success(); // 返回成功响应
} }
} }

113
server/src/main/java/self/cases/teams/controller/UsersController.java
Unescape View File

@ -1,117 +1,134 @@
package self.cases.teams.controller; package self.cases.teams.controller;
import org.slf4j.Logger; import org.slf4j.Logger; // 日志工具类
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory; // 日志工厂类
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired; // 自动注入依赖
import org.springframework.stereotype.Controller; import org.springframework.stereotype.Controller; // Spring MVC 控制器注解
import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.GetMapping; // HTTP GET 请求映射
import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.PostMapping; // HTTP POST 请求映射
import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMapping; // 请求路径映射
import org.springframework.web.bind.annotation.ExceptionHandler; import org.springframework.web.bind.annotation.ExceptionHandler; // 异常处理器
import org.springframework.web.bind.annotation.ResponseBody; import org.springframework.web.bind.annotation.ResponseBody; // 返回 JSON 数据
import self.cases.teams.utils.DateUtils; import self.cases.teams.utils.DateUtils; // 自定义日期工具类
import self.cases.teams.utils.IDUtils; import self.cases.teams.utils.IDUtils; // 自定义 ID 工具类
import self.cases.teams.msg.R; import self.cases.teams.msg.R; // 响应封装类
import self.cases.teams.msg.PageData; import self.cases.teams.msg.PageData; // 分页数据封装类
import self.cases.teams.entity.Users; import self.cases.teams.entity.Users; // 用户实体类
import self.cases.teams.service.UsersService; import self.cases.teams.service.UsersService; // 用户服务接口
/** /**
* 系统请求响应控制器 * 系统请求响应控制器
* 系统用户 * 系统用户相关的请求处理
*/ */
@Controller @Controller
@RequestMapping("/users") @RequestMapping("/users") // 基础路径映射
public class UsersController extends BaseController { public class UsersController extends BaseController {
// 日志记录器
protected static final Logger Log = LoggerFactory.getLogger(UsersController.class); protected static final Logger Log = LoggerFactory.getLogger(UsersController.class);
@Autowired @Autowired // 自动注入 UsersService
private UsersService usersService; private UsersService usersService;
/**
* 用户首页视图
*/
@RequestMapping("") @RequestMapping("")
public String index() { public String index() {
return "pages/Users"; return "pages/Users"; // 返回对应的视图页面
} }
/**
* 根据用户 ID 获取用户信息
*/
@GetMapping("/info") @GetMapping("/info")
@ResponseBody @ResponseBody // 返回 JSON 数据
public R getInfo(String id) { public R getInfo(String id) {
Log.info("查找指定系统用户，ID：{}", id); Log.info("查找指定系统用户，ID：{}", id); // 记录日志
Users users = usersService.getOne(id); Users users = usersService.getOne(id); // 调用服务层获取用户信息
return R.successData(users); return R.successData(users); // 返回成功数据
} }
/**
* 分页查询用户信息
*/
@GetMapping("/page") @GetMapping("/page")
@ResponseBody @ResponseBody
public R getPageInfos(Long pageIndex, Long pageSize, public R getPageInfos(Long pageIndex, Long pageSize, Users users) {
Users users) {
Log.info("分页查找系统用户，当前页码：{}，" Log.info("分页查找系统用户，当前页码：{}，每页数据量：{}, 模糊查询，附加参数：{}",
+ "每页数据量：{}, 模糊查询，附加参数：{}", pageIndex, pageIndex, pageSize, users); // 记录日志
pageSize, users);
PageData page = usersService.getPageInfo(pageIndex, pageSize, users); PageData page = usersService.getPageInfo(pageIndex, pageSize, users); // 调用服务层分页查询
return R.successData(page); return R.successData(page); // 返回分页数据
} }
//注册用户 /**
* 注册用户
*/
@PostMapping("/add") @PostMapping("/add")
@ResponseBody @ResponseBody
public R addInfo(Users users) { public R addInfo(Users users) {
// 检查用户名是否已存在
if(usersService.getUserByUserName(users.getUserName()) == null){ if(usersService.getUserByUserName(users.getUserName()) == null){
users.setId(IDUtils.makeIDByCurrent()); users.setId(IDUtils.makeIDByCurrent()); // 生成用户 ID
users.setCreateTime(DateUtils.getNowDate()); users.setCreateTime(DateUtils.getNowDate()); // 设置创建时间
Log.info("添加系统用户，传入参数：{}", users); Log.info("添加系统用户，传入参数：{}", users); // 记录日志
usersService.add(users); usersService.add(users); // 调用服务层添加用户
return R.success(); return R.success(); // 返回成功响应
}else{ } else {
return R.warn("用户账号已存在，请重新输入"); return R.warn("用户账号已存在，请重新输入"); // 返回警告响应
} }
} }
//修改系统用户 /**
* 修改用户信息
*/
@PostMapping("/upd") @PostMapping("/upd")
@ResponseBody @ResponseBody
public R updInfo(Users users) { public R updInfo(Users users) {
Log.info("修改系统用户，传入参数：{}", users); Log.info("修改系统用户，传入参数：{}", users); // 记录日志
usersService.update(users); usersService.update(users); // 调用服务层更新用户信息
return R.success(); return R.success(); // 返回成功响应
} }
/**
* 删除用户
*/
@PostMapping("/del") @PostMapping("/del")
@ResponseBody @ResponseBody
public R delInfo(String id) { public R delInfo(String id) {
// 检查用户是否可以被删除
if(usersService.isRemove(id)){ if(usersService.isRemove(id)){
Log.info("删除系统用户, ID:{}", id); Log.info("删除系统用户, ID:{}", id); // 记录日志
Users users = usersService.getOne(id); Users users = usersService.getOne(id); // 获取用户信息
usersService.delete(users); usersService.delete(users); // 调用服务层删除用户
return R.success(); return R.success(); // 返回成功响应
}else{ } else {
return R.warn("用户存在关联社团，无法移除"); return R.warn("用户存在关联社团，无法移除"); // 返回警告响应
} }
} }
} }

62
server/src/main/java/self/cases/teams/entity/ActiveLogs.java
Unescape View File

@ -1,97 +1,91 @@
package self.cases.teams.entity; package self.cases.teams.entity;
import com.baomidou.mybatisplus.annotation.TableField; import com.baomidou.mybatisplus.annotation.TableField; // 引入 MyBatis-Plus 字段注解
import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableId; // 引入 MyBatis-Plus 主键注解
import com.baomidou.mybatisplus.annotation.TableName; import com.baomidou.mybatisplus.annotation.TableName; // 引入 MyBatis-Plus 表注解
import java.io.Serializable; import java.io.Serializable; // 引入序列化接口
/** /**
* 数据实体类 * 数据实体类
* 报名记录 * 报名记录
*/ */
@TableName(value = "active_logs") @TableName(value = "active_logs") // 设置对应的数据库表名
public class ActiveLogs implements Serializable { public class ActiveLogs implements Serializable { // 实现 Serializable 接口以便序列化
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L; // 定义序列化版本号
/** /**
* 记录ID * 记录ID
*/ */
@TableId(value = "id") @TableId(value = "id") // 设置主键字段名
private String id; private String id; // 主键字段
/** /**
* 报名时间 * 报名时间
*/ */
@TableField(value = "create_time") @TableField(value = "create_time") // 设置字段名
private String createTime; private String createTime; // 报名时间字段
/** /**
* 活动编号 * 活动编号
*/ */
@TableField(value = "active_id") @TableField(value = "active_id") // 设置字段名
private String activeId; private String activeId; // 活动编号字段
/** /**
* 报名用户 * 报名用户
*/ */
@TableField(value = "user_id") @TableField(value = "user_id") // 设置字段名
private String userId; private String userId; // 用户 ID 字段
// Getter 方法，用于获取 id
public String getId(){ public String getId(){
return id; return id;
} }
// Setter 方法，用于设置 id
public void setId(String id){ public void setId(String id){
this.id = id; this.id = id;
} }
// Getter 方法，用于获取 createTime
public String getCreateTime(){ public String getCreateTime(){
return createTime; return createTime;
} }
// Setter 方法，用于设置 createTime
public void setCreateTime(String createTime){ public void setCreateTime(String createTime){
this.createTime = createTime; this.createTime = createTime;
} }
// Getter 方法，用于获取 activeId
public String getActiveId(){ public String getActiveId(){
return activeId; return activeId;
} }
// Setter 方法，用于设置 activeId
public void setActiveId(String activeId){ public void setActiveId(String activeId){
this.activeId = activeId; this.activeId = activeId;
} }
// Getter 方法，用于获取 userId
public String getUserId(){ public String getUserId(){
return userId; return userId;
} }
// Setter 方法，用于设置 userId
public void setUserId(String userId){ public void setUserId(String userId){
this.userId = userId; this.userId = userId;
} }
// 重写 toString 方法，便于打印对象信息
@Override @Override
public String toString() { public String toString() {
return "ActiveLogs [id=" + id return "ActiveLogs [id=" + id
+ ", createTime=" + createTime + ", createTime=" + createTime
+ ", activeId=" + activeId + ", activeId=" + activeId
+ ", userId=" + userId + ", userId=" + userId
+ "]"; + "]"; // 返回对象属性的字符串表示
} }
} }

106
server/src/main/java/self/cases/teams/entity/Activities.java
Unescape View File

@ -1,160 +1,151 @@
package self.cases.teams.entity; package self.cases.teams.entity;
import com.baomidou.mybatisplus.annotation.TableField; import com.baomidou.mybatisplus.annotation.TableField; // 引入 MyBatis-Plus 字段注解
import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableId; // 引入 MyBatis-Plus 主键注解
import com.baomidou.mybatisplus.annotation.TableName; import com.baomidou.mybatisplus.annotation.TableName; // 引入 MyBatis-Plus 表注解
import java.io.Serializable; import java.io.Serializable; // 引入序列化接口
/** /**
* 数据实体类 * 数据实体类
* 活动信息 * 活动信息
*/ */
@TableName(value = "activities") @TableName(value = "activities") // 设置对应的数据库表名
public class Activities implements Serializable { public class Activities implements Serializable { // 实现 Serializable 接口以便序列化
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L; // 定义序列化版本号
/** /**
* 记录ID * 记录ID
*/ */
@TableId(value = "id") @TableId(value = "id") // 设置主键字段名
private String id; private String id; // 主键字段
/** /**
* 活动名称 * 活动名称
*/ */
@TableField(value = "name") @TableField(value = "name") // 设置字段名
private String name; private String name; // 活动名称字段
/** /**
* 活动概述 * 活动概述
*/ */
@TableField(value = "comm") @TableField(value = "comm") // 设置字段名
private String comm; private String comm; // 活动概述字段
/** /**
* 活动详情 * 活动详情
*/ */
@TableField(value = "detail") @TableField(value = "detail") // 设置字段名
private String detail; private String detail; // 活动详情字段
/** /**
* 活动要求 * 活动要求
*/ */
@TableField(value = "ask") @TableField(value = "ask") // 设置字段名
private String ask; private String ask; // 活动要求字段
/** /**
* 报名人数 * 报名人数
*/ */
@TableField(value = "total") @TableField(value = "total") // 设置字段名
private Integer total; private Integer total; // 报名人数字段
/** /**
* 活动时间 * 活动时间
*/ */
@TableField(value = "active_time") @TableField(value = "active_time") // 设置字段名
private String activeTime; private String activeTime; // 活动时间字段
/** /**
* 发布社团 * 发布社团
*/ */
@TableField(value = "team_id") @TableField(value = "team_id") // 设置字段名
private String teamId; private String teamId; // 社团 ID 字段
// Getter 方法，用于获取 id
public String getId(){ public String getId(){
return id; return id;
} }
// Setter 方法，用于设置 id
public void setId(String id){ public void setId(String id){
this.id = id; this.id = id;
} }
// Getter 方法，用于获取 name
public String getName(){ public String getName(){
return name; return name;
} }
// Setter 方法，用于设置 name
public void setName(String name){ public void setName(String name){
this.name = name; this.name = name;
} }
// Getter 方法，用于获取 comm
public String getComm(){ public String getComm(){
return comm; return comm;
} }
// Setter 方法，用于设置 comm
public void setComm(String comm){ public void setComm(String comm){
this.comm = comm; this.comm = comm;
} }
// Getter 方法，用于获取 detail
public String getDetail(){ public String getDetail(){
return detail; return detail;
} }
// Setter 方法，用于设置 detail
public void setDetail(String detail){ public void setDetail(String detail){
this.detail = detail; this.detail = detail;
} }
// Getter 方法，用于获取 ask
public String getAsk(){ public String getAsk(){
return ask; return ask;
} }
// Setter 方法，用于设置 ask
public void setAsk(String ask){ public void setAsk(String ask){
this.ask = ask; this.ask = ask;
} }
// Getter 方法，用于获取 total
public Integer getTotal(){ public Integer getTotal(){
return total; return total;
} }
// Setter 方法，用于设置 total
public void setTotal(Integer total){ public void setTotal(Integer total){
this.total = total; this.total = total;
} }
// Getter 方法，用于获取 activeTime
public String getActiveTime(){ public String getActiveTime(){
return activeTime; return activeTime;
} }
// Setter 方法，用于设置 activeTime
public void setActiveTime(String activeTime){ public void setActiveTime(String activeTime){
this.activeTime = activeTime; this.activeTime = activeTime;
} }
// Getter 方法，用于获取 teamId
public String getTeamId(){ public String getTeamId(){
return teamId; return teamId;
} }
// Setter 方法，用于设置 teamId
public void setTeamId(String teamId){ public void setTeamId(String teamId){
this.teamId = teamId; this.teamId = teamId;
} }
// 重写 toString 方法，便于打印对象信息
@Override @Override
public String toString() { public String toString() {
return "Activities [id=" + id return "Activities [id=" + id
+ ", name=" + name + ", name=" + name
+ ", comm=" + comm + ", comm=" + comm
@ -163,7 +154,6 @@ public class Activities implements Serializable {
+ ", total=" + total + ", total=" + total
+ ", activeTime=" + activeTime + ", activeTime=" + activeTime
+ ", teamId=" + teamId + ", teamId=" + teamId
+ "]"; + "]"; // 返回对象属性的字符串表示
} }
} }

73
server/src/main/java/self/cases/teams/entity/ApplyLogs.java
Unescape View File

@ -1,115 +1,108 @@
package self.cases.teams.entity; package self.cases.teams.entity;
import com.baomidou.mybatisplus.annotation.TableField; import com.baomidou.mybatisplus.annotation.TableField; // 引入 MyBatis-Plus 字段注解
import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableId; // 引入 MyBatis-Plus 主键注解
import com.baomidou.mybatisplus.annotation.TableName; import com.baomidou.mybatisplus.annotation.TableName; // 引入 MyBatis-Plus 表注解
import java.io.Serializable; import java.io.Serializable; // 引入序列化接口
/** /**
* 数据实体类 * 数据实体类
* 申请记录 * 申请记录
*/ */
@TableName(value = "apply_logs") @TableName(value = "apply_logs") // 设置对应的数据库表名
public class ApplyLogs implements Serializable { public class ApplyLogs implements Serializable { // 实现 Serializable 接口以便序列化
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L; // 定义序列化版本号
/** /**
* 记录ID * 记录ID
*/ */
@TableId(value = "id") @TableId(value = "id") // 设置主键字段名
private String id; private String id; // 主键字段
/** /**
* 处理状态 * 处理状态
*/ */
@TableField(value = "status") @TableField(value = "status") // 设置字段名
private Integer status; private Integer status; // 状态字段（整数类型）
/** /**
* 申请时间 * 申请时间
*/ */
@TableField(value = "create_time") @TableField(value = "create_time") // 设置字段名
private String createTime; private String createTime; // 申请时间字段
/** /**
* 申请社团 * 申请社团
*/ */
@TableField(value = "team_id") @TableField(value = "team_id") // 设置字段名
private String teamId; private String teamId; // 社团 ID 字段
/** /**
* 申请用户 * 申请用户
*/ */
@TableField(value = "user_id") @TableField(value = "user_id") // 设置字段名
private String userId; private String userId; // 用户 ID 字段
// Getter 方法，用于获取 id
public String getId(){ public String getId(){
return id; return id;
} }
// Setter 方法，用于设置 id
public void setId(String id){ public void setId(String id){
this.id = id; this.id = id;
} }
// Getter 方法，用于获取 status
public Integer getStatus(){ public Integer getStatus(){
return status; return status;
} }
// Setter 方法，用于设置 status
public void setStatus(Integer status){ public void setStatus(Integer status){
this.status = status; this.status = status;
} }
// Getter 方法，用于获取 createTime
public String getCreateTime(){ public String getCreateTime(){
return createTime; return createTime;
} }
// Setter 方法，用于设置 createTime
public void setCreateTime(String createTime){ public void setCreateTime(String createTime){
this.createTime = createTime; this.createTime = createTime;
} }
// Getter 方法，用于获取 teamId
public String getTeamId(){ public String getTeamId(){
return teamId; return teamId;
} }
// Setter 方法，用于设置 teamId
public void setTeamId(String teamId){ public void setTeamId(String teamId){
this.teamId = teamId; this.teamId = teamId;
} }
// Getter 方法，用于获取 userId
public String getUserId(){ public String getUserId(){
return userId; return userId;
} }
// Setter 方法，用于设置 userId
public void setUserId(String userId){ public void setUserId(String userId){
this.userId = userId; this.userId = userId;
} }
// 重写 toString 方法，便于打印对象信息
@Override @Override
public String toString() { public String toString() {
return "ApplyLogs [id=" + id return "ApplyLogs [id=" + id
+ ", status=" + status + ", status=" + status
+ ", createTime=" + createTime + ", createTime=" + createTime
+ ", teamId=" + teamId + ", teamId=" + teamId
+ ", userId=" + userId + ", userId=" + userId
+ "]"; + "]"; // 返回对象属性的字符串表示
} }
} }

100
server/src/main/java/self/cases/teams/entity/Clubshenqing.java
Unescape View File

@ -1,135 +1,133 @@
package self.cases.teams.entity; package self.cases.teams.entity; // 定义包路径
import java.util.Date; // 导入日期类
import java.util.Date;
public class Clubshenqing { // 定义实体类 Clubshenqing
public class Clubshenqing { private String id; // 唯一标识符
private String id; private String clubName; // 社团名称
private String clubName; private String activityName; // 活动名称
private String activityName; private String description; // 活动描述
private String description; private Date startDate; // 活动开始日期
private Date startDate; private Date endDate; // 活动结束日期
private Date endDate; private String location; // 活动地点
private String location; private int maxParticipants; // 最大参与人数
private int maxParticipants; private String contactPerson; // 联系人姓名
private String contactPerson; private String contactEmail; // 联系人邮箱
private String contactEmail; private String contactPhone; // 联系人电话
private String contactPhone; private boolean approved; // 是否已批准
private boolean approved; private Date createdAt; // 创建时间
private Date createdAt; private Date updatedAt; // 更新时间
private Date updatedAt;
// Getter 和 Setter 方法
// Getters and Setters public String getId() { // 获取 id
public String getId() {
return id; return id;
} }
public void setId(String id) { public void setId(String id) { // 设置 id
this.id = id; this.id = id;
} }
public String getClubName() { public String getClubName() { // 获取社团名称
return clubName; return clubName;
} }
public void setClubName(String clubName) { public void setClubName(String clubName) { // 设置社团名称
this.clubName = clubName; this.clubName = clubName;
} }
public String getActivityName() { public String getActivityName() { // 获取活动名称
return activityName; return activityName;
} }
public void setActivityName(String activityName) { public void setActivityName(String activityName) { // 设置活动名称
this.activityName = activityName; this.activityName = activityName;
} }
public String getDescription() { public String getDescription() { // 获取活动描述
return description; return description;
} }
public void setDescription(String description) { public void setDescription(String description) { // 设置活动描述
this.description = description; this.description = description;
} }
public Date getStartDate() { public Date getStartDate() { // 获取活动开始日期
return startDate; return startDate;
} }
public void setStartDate(Date startDate) { public void setStartDate(Date startDate) { // 设置活动开始日期
this.startDate = startDate; this.startDate = startDate;
} }
public Date getEndDate() { public Date getEndDate() { // 获取活动结束日期
return endDate; return endDate;
} }
public void setEndDate(Date endDate) { public void setEndDate(Date endDate) { // 设置活动结束日期
this.endDate = endDate; this.endDate = endDate;
} }
public String getLocation() { public String getLocation() { // 获取活动地点
return location; return location;
} }
public void setLocation(String location) { public void setLocation(String location) { // 设置活动地点
this.location = location; this.location = location;
} }
public int getMaxParticipants() { public int getMaxParticipants() { // 获取最大参与人数
return maxParticipants; return maxParticipants;
} }
public void setMaxParticipants(int maxParticipants) { public void setMaxParticipants(int maxParticipants) { // 设置最大参与人数
this.maxParticipants = maxParticipants; this.maxParticipants = maxParticipants;
} }
public String getContactPerson() { public String getContactPerson() { // 获取联系人姓名
return contactPerson; return contactPerson;
} }
public void setContactPerson(String contactPerson) { public void setContactPerson(String contactPerson) { // 设置联系人姓名
this.contactPerson = contactPerson; this.contactPerson = contactPerson;
} }
public String getContactEmail() { public String getContactEmail() { // 获取联系人邮箱
return contactEmail; return contactEmail;
} }
public void setContactEmail(String contactEmail) { public void setContactEmail(String contactEmail) { // 设置联系人邮箱
this.contactEmail = contactEmail; this.contactEmail = contactEmail;
} }
public String getContactPhone() { public String getContactPhone() { // 获取联系人电话
return contactPhone; return contactPhone;
} }
public void setContactPhone(String contactPhone) { public void setContactPhone(String contactPhone) { // 设置联系人电话
this.contactPhone = contactPhone; this.contactPhone = contactPhone;
} }
public boolean isApproved() { public boolean isApproved() { // 获取是否已批准
return approved; return approved;
} }
public void setApproved(boolean approved) { public void setApproved(boolean approved) { // 设置是否已批准
this.approved = approved; this.approved = approved;
} }
public Date getCreatedAt() { public Date getCreatedAt() { // 获取创建时间
return createdAt; return createdAt;
} }
public void setCreatedAt(Date createdAt) { public void setCreatedAt(Date createdAt) { // 设置创建时间
this.createdAt = createdAt; this.createdAt = createdAt;
} }
public Date getUpdatedAt() { public Date getUpdatedAt() { // 获取更新时间
return updatedAt; return updatedAt;
} }
public void setUpdatedAt(Date updatedAt) { public void setUpdatedAt(Date updatedAt) { // 设置更新时间
this.updatedAt = updatedAt; this.updatedAt = updatedAt;
} }
} }

73
server/src/main/java/self/cases/teams/entity/Members.java
Unescape View File

@ -1,97 +1,84 @@
package self.cases.teams.entity; package self.cases.teams.entity; // 定义包路径
import com.baomidou.mybatisplus.annotation.TableField; import com.baomidou.mybatisplus.annotation.TableField; // 引入 MyBatis-Plus 的字段注解
import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableId; // 引入 MyBatis-Plus 的主键注解
import com.baomidou.mybatisplus.annotation.TableName; import com.baomidou.mybatisplus.annotation.TableName; // 引入 MyBatis-Plus 的表名注解
import java.io.Serializable; // 引入序列化接口
import java.io.Serializable;
/** /**
* 数据实体类 * 数据实体类
* 成员信息 * 成员信息
*/ */
@TableName(value = "members") @TableName(value = "members") // 表名映射为 members
public class Members implements Serializable { public class Members implements Serializable { // 实现 Serializable 接口，支持序列化
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L; // 序列化版本号
/** /**
* 记录ID * 记录ID
*/ */
@TableId(value = "id") @TableId(value = "id") // 主键字段映射到数据库中的 id 列
private String id; private String id; // 成员的唯一标识符
/** /**
* 入团时间 * 入团时间
*/ */
@TableField(value = "create_time") @TableField(value = "create_time") // 字段映射到数据库中的 create_time 列
private String createTime; private String createTime; // 成员加入的时间
/** /**
* 加入社团 * 加入社团
*/ */
@TableField(value = "team_id") @TableField(value = "team_id") // 字段映射到数据库中的 team_id 列
private String teamId; private String teamId; // 成员所属社团的唯一标识符
/** /**
* 申请用户 * 申请用户
*/ */
@TableField(value = "user_id") @TableField(value = "user_id") // 字段映射到数据库中的 user_id 列
private String userId; private String userId; // 申请成员的用户唯一标识符
public String getId(){
// Getter 和 Setter 方法
public String getId(){ // 获取成员 ID
return id; return id;
} }
public void setId(String id){ public void setId(String id){ // 设置成员 ID
this.id = id; this.id = id;
} }
public String getCreateTime(){ // 获取入团时间
public String getCreateTime(){
return createTime; return createTime;
} }
public void setCreateTime(String createTime){ public void setCreateTime(String createTime){ // 设置入团时间
this.createTime = createTime; this.createTime = createTime;
} }
public String getTeamId(){ // 获取社团 ID
public String getTeamId(){
return teamId; return teamId;
} }
public void setTeamId(String teamId){ public void setTeamId(String teamId){ // 设置社团 ID
this.teamId = teamId; this.teamId = teamId;
} }
public String getUserId(){ // 获取用户 ID
public String getUserId(){
return userId; return userId;
} }
public void setUserId(String userId){ public void setUserId(String userId){ // 设置用户 ID
this.userId = userId; this.userId = userId;
} }
// 自定义 toString 方法
@Override @Override
public String toString() { public String toString() {
return "Members [id=" + id return "Members [id=" + id // 返回成员的基本信息
+ ", createTime=" + createTime + ", createTime=" + createTime
+ ", teamId=" + teamId + ", teamId=" + teamId
+ ", userId=" + userId + ", userId=" + userId
+ "]"; + "]";
} }
} }

86
server/src/main/java/self/cases/teams/entity/Notices.java
Unescape View File

@ -1,115 +1,99 @@
package self.cases.teams.entity; package self.cases.teams.entity; // 定义包路径
import com.baomidou.mybatisplus.annotation.TableField; import com.baomidou.mybatisplus.annotation.TableField; // 引入 MyBatis-Plus 的字段注解
import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableId; // 引入 MyBatis-Plus 的主键注解
import com.baomidou.mybatisplus.annotation.TableName; import com.baomidou.mybatisplus.annotation.TableName; // 引入 MyBatis-Plus 的表名注解
import java.io.Serializable; // 引入序列化接口
import java.io.Serializable;
/** /**
* 数据实体类 * 数据实体类
* 通知记录 * 通知记录
*/ */
@TableName(value = "notices") @TableName(value = "notices") // 表名映射为 notices
public class Notices implements Serializable { public class Notices implements Serializable { // 实现 Serializable 接口，支持序列化
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L; // 序列化版本号
/** /**
* 记录ID * 记录ID
*/ */
@TableId(value = "id") @TableId(value = "id") // 主键字段映射到数据库中的 id 列
private String id; private String id; // 通知的唯一标识符
/** /**
* 通知标题 * 通知标题
*/ */
@TableField(value = "title") @TableField(value = "title") // 字段映射到数据库中的 title 列
private String title; private String title; // 通知的标题内容
/** /**
* 通知详情 * 通知详情
*/ */
@TableField(value = "detail") @TableField(value = "detail") // 字段映射到数据库中的 detail 列
private String detail; private String detail; // 通知的具体内容
/** /**
* 发布时间 * 发布时间
*/ */
@TableField(value = "create_time") @TableField(value = "create_time") // 字段映射到数据库中的 create_time 列
private String createTime; private String createTime; // 通知发布时间
/** /**
* 发布社团 * 发布社团
*/ */
@TableField(value = "team_id") @TableField(value = "team_id") // 字段映射到数据库中的 team_id 列
private String teamId; private String teamId; // 通知所属社团的唯一标识符
public String getId(){
// Getter 和 Setter 方法
public String getId(){ // 获取通知 ID
return id; return id;
} }
public void setId(String id){ public void setId(String id){ // 设置通知 ID
this.id = id; this.id = id;
} }
public String getTitle(){ // 获取通知标题
public String getTitle(){
return title; return title;
} }
public void setTitle(String title){ public void setTitle(String title){ // 设置通知标题
this.title = title; this.title = title;
} }
public String getDetail(){ // 获取通知详情
public String getDetail(){
return detail; return detail;
} }
public void setDetail(String detail){ public void setDetail(String detail){ // 设置通知详情
this.detail = detail; this.detail = detail;
} }
public String getCreateTime(){ // 获取发布时间
public String getCreateTime(){
return createTime; return createTime;
} }
public void setCreateTime(String createTime){ public void setCreateTime(String createTime){ // 设置发布时间
this.createTime = createTime; this.createTime = createTime;
} }
public String getTeamId(){ // 获取发布社团 ID
public String getTeamId(){
return teamId; return teamId;
} }
public void setTeamId(String teamId){ public void setTeamId(String teamId){ // 设置发布社团 ID
this.teamId = teamId; this.teamId = teamId;
} }
// 自定义 toString 方法
@Override @Override
public String toString() { public String toString() {
return "Notices [id=" + id return "Notices [id=" + id // 返回通知的基本信息
+ ", title=" + title + ", title=" + title
+ ", detail=" + detail + ", detail=" + detail
+ ", createTime=" + createTime + ", createTime=" + createTime
+ ", teamId=" + teamId + ", teamId=" + teamId
+ "]"; + "]";
} }
} }

86
server/src/main/java/self/cases/teams/entity/PayLogs.java
Unescape View File

@ -1,115 +1,99 @@
package self.cases.teams.entity; package self.cases.teams.entity; // 定义包路径
import com.baomidou.mybatisplus.annotation.TableField; import com.baomidou.mybatisplus.annotation.TableField; // 引入 MyBatis-Plus 的字段注解
import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableId; // 引入 MyBatis-Plus 的主键注解
import com.baomidou.mybatisplus.annotation.TableName; import com.baomidou.mybatisplus.annotation.TableName; // 引入 MyBatis-Plus 的表名注解
import java.io.Serializable; // 引入序列化接口
import java.io.Serializable;
/** /**
* 数据实体类 * 数据实体类
* 缴费记录 * 缴费记录
*/ */
@TableName(value = "pay_logs") @TableName(value = "pay_logs") // 表名映射为 pay_logs
public class PayLogs implements Serializable { public class PayLogs implements Serializable { // 实现 Serializable 接口，支持序列化
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L; // 序列化版本号
/** /**
* 记录ID * 记录ID
*/ */
@TableId(value = "id") @TableId(value = "id") // 主键字段映射到数据库中的 id 列
private String id; private String id; // 缴费记录的唯一标识符
/** /**
* 缴费时间 * 缴费时间
*/ */
@TableField(value = "create_time") @TableField(value = "create_time") // 字段映射到数据库中的 create_time 列
private String createTime; private String createTime; // 缴费发生的日期时间
/** /**
* 缴纳费用 * 缴纳费用
*/ */
@TableField(value = "total") @TableField(value = "total") // 字段映射到数据库中的 total 列
private Double total; private Double total; // 缴纳的总金额
/** /**
* 收费社团 * 收费社团
*/ */
@TableField(value = "team_id") @TableField(value = "team_id") // 字段映射到数据库中的 team_id 列
private String teamId; private String teamId; // 缴费对应的社团唯一标识符
/** /**
* 缴费用户 * 缴费用户
*/ */
@TableField(value = "user_id") @TableField(value = "user_id") // 字段映射到数据库中的 user_id 列
private String userId; private String userId; // 缴费用户的唯一标识符
public String getId(){
// Getter 和 Setter 方法
public String getId(){ // 获取缴费记录 ID
return id; return id;
} }
public void setId(String id){ public void setId(String id){ // 设置缴费记录 ID
this.id = id; this.id = id;
} }
public String getCreateTime(){ // 获取缴费时间
public String getCreateTime(){
return createTime; return createTime;
} }
public void setCreateTime(String createTime){ public void setCreateTime(String createTime){ // 设置缴费时间
this.createTime = createTime; this.createTime = createTime;
} }
public Double getTotal(){ // 获取缴纳费用
public Double getTotal(){
return total; return total;
} }
public void setTotal(Double total){ public void setTotal(Double total){ // 设置缴纳费用
this.total = total; this.total = total;
} }
public String getTeamId(){ // 获取收费社团 ID
public String getTeamId(){
return teamId; return teamId;
} }
public void setTeamId(String teamId){ public void setTeamId(String teamId){ // 设置收费社团 ID
this.teamId = teamId; this.teamId = teamId;
} }
public String getUserId(){ // 获取缴费用户 ID
public String getUserId(){
return userId; return userId;
} }
public void setUserId(String userId){ public void setUserId(String userId){ // 设置缴费用户 ID
this.userId = userId; this.userId = userId;
} }
// 自定义 toString 方法
@Override @Override
public String toString() { public String toString() {
return "PayLogs [id=" + id return "PayLogs [id=" + id // 返回缴费记录的基本信息
+ ", createTime=" + createTime + ", createTime=" + createTime
+ ", total=" + total + ", total=" + total
+ ", teamId=" + teamId + ", teamId=" + teamId
+ ", userId=" + userId + ", userId=" + userId
+ "]"; + "]";
} }
} }

68
server/src/main/java/self/cases/teams/entity/STjiao.java
Unescape View File

@ -1,97 +1,99 @@
package self.cases.teams.entity; package self.cases.teams.entity;// 定义包路径
import java.util.Date; import java.util.Date;
// 定义实体类 STjiao，表示社团缴费相关信息
public class STjiao { public class STjiao {
private String id;
private String clubName; private String id; // 社团缴费记录的唯一标识符
private String memberName; private String clubName; // 社团名称
private double amount; private String memberName; // 缴费成员姓名
private Date paymentDate; private double amount; // 缴费金额
private String paymentMethod; private Date paymentDate; // 缴费日期
private String transactionId; private String paymentMethod; // 缴费方式
private boolean isPaid; private String transactionId; // 交易流水号
private Date createdAt; private boolean isPaid; // 是否已支付（布尔值）
private Date updatedAt; private Date createdAt; // 记录创建时间
private Date updatedAt; // 记录最后更新时间
// Getters and Setters
public String getId() { // Getter 和 Setter 方法
public String getId() { // 获取缴费记录 ID
return id; return id;
} }
public void setId(String id) { public void setId(String id) { // 设置缴费记录 ID
this.id = id; this.id = id;
} }
public String getClubName() { public String getClubName() { // 获取社团名称
return clubName; return clubName;
} }
public void setClubName(String clubName) { public void setClubName(String clubName) { // 设置社团名称
this.clubName = clubName; this.clubName = clubName;
} }
public String getMemberName() { public String getMemberName() { // 获取成员姓名
return memberName; return memberName;
} }
public void setMemberName(String memberName) { public void setMemberName(String memberName) { // 设置成员姓名
this.memberName = memberName; this.memberName = memberName;
} }
public double getAmount() { public double getAmount() { // 获取缴费金额
return amount; return amount;
} }
public void setAmount(double amount) { public void setAmount(double amount) { // 设置缴费金额
this.amount = amount; this.amount = amount;
} }
public Date getPaymentDate() { public Date getPaymentDate() { // 获取缴费日期
return paymentDate; return paymentDate;
} }
public void setPaymentDate(Date paymentDate) { public void setPaymentDate(Date paymentDate) { // 设置缴费日期
this.paymentDate = paymentDate; this.paymentDate = paymentDate;
} }
public String getPaymentMethod() { public String getPaymentMethod() { // 获取缴费方式
return paymentMethod; return paymentMethod;
} }
public void setPaymentMethod(String paymentMethod) { public void setPaymentMethod(String paymentMethod) { // 设置缴费方式
this.paymentMethod = paymentMethod; this.paymentMethod = paymentMethod;
} }
public String getTransactionId() { public String getTransactionId() { // 获取交易流水号
return transactionId; return transactionId;
} }
public void setTransactionId(String transactionId) { public void setTransactionId(String transactionId) { // 设置交易流水号
this.transactionId = transactionId; this.transactionId = transactionId;
} }
public boolean isPaid() { public boolean isPaid() { // 获取是否已支付状态
return isPaid; return isPaid;
} }
public void setPaid(boolean paid) { public void setPaid(boolean paid) { // 设置是否已支付状态
isPaid = paid; isPaid = paid;
} }
public Date getCreatedAt() { public Date getCreatedAt() { // 获取记录创建时间
return createdAt; return createdAt;
} }
public void setCreatedAt(Date createdAt) { public void setCreatedAt(Date createdAt) { // 设置记录创建时间
this.createdAt = createdAt; this.createdAt = createdAt;
} }
public Date getUpdatedAt() { public Date getUpdatedAt() { // 获取记录最后更新时间
return updatedAt; return updatedAt;
} }
public void setUpdatedAt(Date updatedAt) { public void setUpdatedAt(Date updatedAt) { // 设置记录最后更新时间
this.updatedAt = updatedAt; this.updatedAt = updatedAt;
} }
} }

98
server/src/main/java/self/cases/teams/entity/TeamTypes.java
Unescape View File

@ -1,79 +1,87 @@
package self.cases.teams.entity; package self.cases.teams.entity; // 定义包路径
import com.baomidou.mybatisplus.annotation.TableField; import com.baomidou.mybatisplus.annotation.TableField; // 引入 MyBatis-Plus 的 TableField 注解
import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableId; // 引入 MyBatis-Plus 的 TableId 注解
import com.baomidou.mybatisplus.annotation.TableName; import com.baomidou.mybatisplus.annotation.TableName; // 引入 MyBatis-Plus 的 TableName 注解
import java.io.Serializable; // 引入 Serializable 接口，用于序列化
import java.io.Serializable;
/** /**
* 数据实体类 * 数据实体类
* 社团类型 * 社团类型
*/ */
@TableName(value = "team_types") @TableName(value = "team_types") // 指定数据库表名为 "team_types"
public class TeamTypes implements Serializable { public class TeamTypes implements Serializable { // 实现 Serializable 接口，支持序列化
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L; // 定义序列化版本号
/** /**
* 记录ID * 记录ID
*/ */
@TableId(value = "id") @TableId(value = "id") // 表明该字段为主键，对应的数据库字段名为 "id"
private String id; private String id; // 社团类型的唯一标识符
/** /**
* 类型名称 * 类型名称
*/ */
@TableField(value = "name") @TableField(value = "name") // 对应数据库字段名为 "name"
private String name; private String name; // 社团类型的名称
/** /**
* 创建时间 * 创建时间
*/ */
@TableField(value = "create_time") @TableField(value = "create_time") // 对应数据库字段名为 "create_time"
private String createTime; private String createTime; // 社团类型的创建时间
public String getId(){ /**
* Getter 方法：获取记录ID
return id; */
public String getId() {
return id; // 返回社团类型的记录ID
} }
public void setId(String id){ /**
* Setter 方法：设置记录ID
this.id = id; */
public void setId(String id) {
this.id = id; // 设置社团类型的记录ID
} }
/**
public String getName(){ * Getter 方法：获取类型名称
*/
return name; public String getName() {
return name; // 返回社团类型的名称
} }
public void setName(String name){ /**
* Setter 方法：设置类型名称
this.name = name; */
public void setName(String name) {
this.name = name; // 设置社团类型的名称
} }
/**
public String getCreateTime(){ * Getter 方法：获取创建时间
*/
return createTime; public String getCreateTime() {
return createTime; // 返回社团类型的创建时间
} }
public void setCreateTime(String createTime){ /**
* Setter 方法：设置创建时间
this.createTime = createTime; */
public void setCreateTime(String createTime) {
this.createTime = createTime; // 设置社团类型的创建时间
} }
/**
* 覆写 toString 方法，便于打印对象信息
*/
@Override @Override
public String toString() { public String toString() {
return "TeamTypes [id=" + id // 打印社团类型的记录ID
return "TeamTypes [id=" + id + ", name=" + name // 打印社团类型的名称
+ ", name=" + name + ", createTime=" + createTime // 打印创建时间
+ ", createTime=" + createTime + "]"; // 打印结束
+ "]";
} }
} }

147
server/src/main/java/self/cases/teams/entity/Teams.java
Unescape View File

@ -1,133 +1,150 @@
package self.cases.teams.entity; package self.cases.teams.entity; // 定义包路径
import com.baomidou.mybatisplus.annotation.TableField; import com.baomidou.mybatisplus.annotation.TableField; // 引入 MyBatis-Plus 的 TableField 注解
import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableId; // 引入 MyBatis-Plus 的 TableId 注解
import com.baomidou.mybatisplus.annotation.TableName; import com.baomidou.mybatisplus.annotation.TableName; // 引入 MyBatis-Plus 的 TableName 注解
import java.io.Serializable; // 引入 Serializable 接口，用于序列化
import java.io.Serializable;
/** /**
* 数据实体类 * 数据实体类
* 社团信息 * 社团信息
*/ */
@TableName(value = "teams") @TableName(value = "teams") // 指定数据库表名为 "teams"
public class Teams implements Serializable { public class Teams implements Serializable { // 实现 Serializable 接口，支持序列化
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L; // 定义序列化版本号
/** /**
* 记录ID * 记录ID
*/ */
@TableId(value = "id") @TableId(value = "id") // 表明该字段为主键，对应的数据库字段名为 "id"
private String id; private String id; // 社团记录的唯一标识符
/** /**
* 社团名称 * 社团名称
*/ */
@TableField(value = "name") @TableField(value = "name") // 对应数据库字段名为 "name"
private String name; private String name; // 社团的名称
/** /**
* 建立时间 * 建立时间
*/ */
@TableField(value = "create_time") @TableField(value = "create_time") // 对应数据库字段名为 "create_time"
private String createTime; private String createTime; // 社团的建立时间
/** /**
* 社团人数 * 社团人数
*/ */
@TableField(value = "total") @TableField(value = "total") // 对应数据库字段名为 "total"
private Integer total; private Integer total; // 社团的总人数
/** /**
* 社团团长 * 社团团长
*/ */
@TableField(value = "manager") @TableField(value = "manager") // 对应数据库字段名为 "manager"
private String manager; private String manager; // 社团团长的名字
/** /**
* 社团编号 * 社团编号
*/ */
@TableField(value = "type_id") @TableField(value = "type_id") // 对应数据库字段名为 "type_id"
private String typeId; private String typeId; // 社团的编号
public String getId(){
/**
* Getter 方法：获取记录ID
*/
public String getId() {
return id; return id;
} }
public void setId(String id){ /**
* Setter 方法：设置记录ID
*/
public void setId(String id) {
this.id = id; this.id = id;
} }
/**
public String getName(){ * Getter 方法：获取社团名称
*/
public String getName() {
return name; return name;
} }
public void setName(String name){ /**
* Setter 方法：设置社团名称
*/
public void setName(String name) {
this.name = name; this.name = name;
} }
/**
public String getCreateTime(){ * Getter 方法：获取建立时间
*/
public String getCreateTime() {
return createTime; return createTime;
} }
public void setCreateTime(String createTime){ /**
* Setter 方法：设置建立时间
*/
public void setCreateTime(String createTime) {
this.createTime = createTime; this.createTime = createTime;
} }
/**
public Integer getTotal(){ * Getter 方法：获取社团人数
*/
public Integer getTotal() {
return total; return total;
} }
public void setTotal(Integer total){ /**
* Setter 方法：设置社团人数
*/
public void setTotal(Integer total) {
this.total = total; this.total = total;
} }
/**
public String getManager(){ * Getter 方法：获取社团团长
*/
public String getManager() {
return manager; return manager;
} }
public void setManager(String manager){ /**
* Setter 方法：设置社团团长
*/
public void setManager(String manager) {
this.manager = manager; this.manager = manager;
} }
/**
public String getTypeId(){ * Getter 方法：获取社团编号
*/
public String getTypeId() {
return typeId; return typeId;
} }
public void setTypeId(String typeId){ /**
* Setter 方法：设置社团编号
*/
public void setTypeId(String typeId) {
this.typeId = typeId; this.typeId = typeId;
} }
/**
* 覆写 toString 方法，便于打印对象信息
*/
@Override @Override
public String toString() { public String toString() {
return "Teams [id=" + id // 打印社团记录ID
return "Teams [id=" + id + ", name=" + name // 打印社团名称
+ ", name=" + name + ", createTime=" + createTime // 打印建立时间
+ ", createTime=" + createTime + ", total=" + total // 打印社团人数
+ ", total=" + total + ", manager=" + manager // 打印社团团长
+ ", manager=" + manager + ", typeId=" + typeId // 打印社团编号
+ ", typeId=" + typeId
+ "]"; + "]";
} }
} }

298
server/src/main/java/self/cases/teams/entity/Users.java
Unescape View File

@ -1,223 +1,255 @@
package self.cases.teams.entity; package self.cases.teams.entity; // 定义包路径
import com.baomidou.mybatisplus.annotation.TableField; import com.baomidou.mybatisplus.annotation.TableField; // 引入 MyBatis-Plus 的 TableField 注解
import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableId; // 引入 MyBatis-Plus 的 TableId 注解
import com.baomidou.mybatisplus.annotation.TableName; import com.baomidou.mybatisplus.annotation.TableName; // 引入 MyBatis-Plus 的 TableName 注解
import java.io.Serializable; // 引入 Serializable 接口，用于序列化
import java.io.Serializable;
/** /**
* 数据实体类 * 数据实体类
* 系统用户 * 系统用户
*/ */
@TableName(value = "users") @TableName(value = "users") // 指定数据库表名为 "users"
public class Users implements Serializable { public class Users implements Serializable { // 实现 Serializable 接口，支持序列化
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L; // 定义序列化版本号
/** /**
* 记录ID * 记录ID
*/ */
@TableId(value = "id") @TableId(value = "id") // 表明该字段为主键，对应的数据库字段名为 "id"
private String id; private String id; // 用户的唯一标识符
/** /**
* 用户账号 * 用户账号
*/ */
@TableField(value = "user_name") @TableField(value = "user_name") // 对应数据库字段名为 "user_name"
private String userName; private String userName; // 用户登录时使用的账号
/** /**
* 用户密码 * 用户密码
*/ */
@TableField(value = "pass_word") @TableField(value = "pass_word") // 对应数据库字段名为 "pass_word"
private String passWord; private String passWord; // 用户的密码（注意：实际应用中应加密存储）
/** /**
* 用户姓名 * 用户姓名
*/ */
@TableField(value = "name") @TableField(value = "name") // 对应数据库字段名为 "name"
private String name; private String name; // 用户的真实姓名
/** /**
* 用户性别 * 用户性别
*/ */
@TableField(value = "gender") @TableField(value = "gender") // 对应数据库字段名为 "gender"
private String gender; private String gender; // 用户的性别，通常为 "男" 或 "女"
/** /**
* 用户年龄 * 用户年龄
*/ */
@TableField(value = "age") @TableField(value = "age") // 对应数据库字段名为 "age"
private Integer age; private Integer age; // 用户的年龄
/** /**
* 联系电话 * 联系电话
*/ */
@TableField(value = "phone") @TableField(value = "phone") // 对应数据库字段名为 "phone"
private String phone; private String phone; // 用户的联系电话
/** /**
* 联系地址 * 联系地址
*/ */
@TableField(value = "address") @TableField(value = "address") // 对应数据库字段名为 "address"
private String address; private String address; // 用户的联系地址
/** /**
* 信息状态 * 信息状态
*/ */
@TableField(value = "status") @TableField(value = "status") // 对应数据库字段名为 "status"
private Integer status; private Integer status; // 用户信息的状态，例如启用、禁用等
/** /**
* 添加时间 * 添加时间
*/ */
@TableField(value = "create_time") @TableField(value = "create_time") // 对应数据库字段名为 "create_time"
private String createTime; private String createTime; // 用户信息的添加时间
/** /**
* 用户身份 * 用户身份
*/ */
@TableField(value = "type") @TableField(value = "type") // 对应数据库字段名为 "type"
private Integer type; private Integer type; // 用户的身份类型，例如管理员、普通用户等
public String getId(){ /**
* Getter 方法：获取记录ID
return id; */
public String getId() {
return id; // 返回用户的唯一标识符
} }
public void setId(String id){ /**
* Setter 方法：设置记录ID
this.id = id; */
public void setId(String id) {
this.id = id; // 设置用户的唯一标识符
} }
/**
public String getUserName(){ * Getter 方法：获取用户账号
*/
return userName; public String getUserName() {
return userName; // 返回用户的登录账号
} }
public void setUserName(String userName){ /**
* Setter 方法：设置用户账号
this.userName = userName; */
public void setUserName(String userName) {
this.userName = userName; // 设置用户的登录账号
} }
/**
public String getPassWord(){ * Getter 方法：获取用户密码
*/
return passWord; public String getPassWord() {
return passWord; // 返回用户的密码
} }
public void setPassWord(String passWord){ /**
* Setter 方法：设置用户密码
this.passWord = passWord; */
public void setPassWord(String passWord) {
this.passWord = passWord; // 设置用户的密码
} }
/**
public String getName(){ * Getter 方法：获取用户姓名
*/
return name; public String getName() {
return name; // 返回用户的真实姓名
} }
public void setName(String name){ /**
* Setter 方法：设置用户姓名
this.name = name; */
public void setName(String name) {
this.name = name; // 设置用户的真实姓名
} }
/**
public String getGender(){ * Getter 方法：获取用户性别
*/
return gender; public String getGender() {
return gender; // 返回用户的性别
} }
public void setGender(String gender){ /**
* Setter 方法：设置用户性别
this.gender = gender; */
public void setGender(String gender) {
this.gender = gender; // 设置用户的性别
} }
/**
public Integer getAge(){ * Getter 方法：获取用户年龄
*/
return age; public Integer getAge() {
return age; // 返回用户的年龄
} }
public void setAge(Integer age){ /**
* Setter 方法：设置用户年龄
this.age = age; */
public void setAge(Integer age) {
this.age = age; // 设置用户的年龄
} }
/**
public String getPhone(){ * Getter 方法：获取联系电话
*/
return phone; public String getPhone() {
return phone; // 返回用户的联系电话
} }
public void setPhone(String phone){ /**
* Setter 方法：设置联系电话
this.phone = phone; */
public void setPhone(String phone) {
this.phone = phone; // 设置用户的联系电话
} }
/**
public String getAddress(){ * Getter 方法：获取联系地址
*/
return address; public String getAddress() {
return address; // 返回用户的联系地址
} }
public void setAddress(String address){ /**
* Setter 方法：设置联系地址
this.address = address; */
public void setAddress(String address) {
this.address = address; // 设置用户的联系地址
} }
/**
public Integer getStatus(){ * Getter 方法：获取信息状态
*/
return status; public Integer getStatus() {
return status; // 返回用户信息的状态
} }
public void setStatus(Integer status){ /**
* Setter 方法：设置信息状态
this.status = status; */
public void setStatus(Integer status) {
this.status = status; // 设置用户信息的状态
} }
/**
public String getCreateTime(){ * Getter 方法：获取添加时间
*/
return createTime; public String getCreateTime() {
return createTime; // 返回用户信息的添加时间
} }
public void setCreateTime(String createTime){ /**
* Setter 方法：设置添加时间
this.createTime = createTime; */
public void setCreateTime(String createTime) {
this.createTime = createTime; // 设置用户信息的添加时间
} }
/**
public Integer getType(){ * Getter 方法：获取用户身份
*/
return type; public Integer getType() {
return type; // 返回用户的身份类型
} }
public void setType(Integer type){ /**
* Setter 方法：设置用户身份
this.type = type; */
public void setType(Integer type) {
this.type = type; // 设置用户的身份类型
} }
/**
* 覆写 toString 方法，便于打印对象信息
*/
@Override @Override
public String toString() { public String toString() {
return "Users [id=" + id // 打印用户的唯一标识符
return "Users [id=" + id + ", userName=" + userName // 打印用户的登录账号
+ ", userName=" + userName + ", passWord=" + passWord // 打印用户的密码
+ ", passWord=" + passWord + ", name=" + name // 打印用户的真实姓名
+ ", name=" + name + ", gender=" + gender // 打印用户的性别
+ ", gender=" + gender + ", age=" + age // 打印用户的年龄
+ ", age=" + age + ", phone=" + phone // 打印用户的联系电话
+ ", phone=" + phone + ", address=" + address // 打印用户的联系地址
+ ", address=" + address + ", status=" + status // 打印用户信息的状态
+ ", status=" + status + ", createTime=" + createTime // 打印用户信息的添加时间
+ ", createTime=" + createTime + ", type=" + type // 打印用户的身份类型
+ ", type=" + type + "]"; // 打印结束
+ "]";
} }
} }

BIN
server/target/classes/self/cases/teams/Application$1.class
View File

Binary file not shown.

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

Binary file not shown.

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

Binary file not shown.

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

Binary file not shown.

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

Binary file not shown.

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

Binary file not shown.

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

Binary file not shown.

BIN
server/target/classes/self/cases/teams/controller/ActiveLogsController.class
View File

Binary file not shown.

BIN
server/target/classes/self/cases/teams/controller/ApplyLogsController.class
View File

Binary file not shown.

BIN
server/target/classes/self/cases/teams/controller/BaseController.class
View File

Binary file not shown.

BIN
server/target/classes/self/cases/teams/controller/IndexController.class
View File

Binary file not shown.

BIN
server/target/classes/self/cases/teams/controller/TeamTypesController.class
View File

Binary file not shown.

BIN
server/target/classes/self/cases/teams/controller/TeamsController.class
View File

Binary file not shown.

BIN
server/target/classes/self/cases/teams/controller/UsersController.class
View File

Binary file not shown.

BIN
server/target/classes/self/cases/teams/entity/ActiveLogs.class
View File

Binary file not shown.

BIN
server/target/classes/self/cases/teams/entity/Activities.class
View File

Binary file not shown.

BIN
server/target/classes/self/cases/teams/entity/ApplyLogs.class
View File

Binary file not shown.

BIN
server/target/classes/self/cases/teams/entity/Clubshenqing.class
View File

Binary file not shown.

BIN
server/target/classes/self/cases/teams/entity/Members.class
View File

Binary file not shown.

BIN
server/target/classes/self/cases/teams/entity/Notices.class
View File

Binary file not shown.

BIN
server/target/classes/self/cases/teams/entity/PayLogs.class
View File

Binary file not shown.

BIN
server/target/classes/self/cases/teams/entity/STjiao.class
View File

Binary file not shown.

BIN
server/target/classes/self/cases/teams/entity/TeamTypes.class
View File

Binary file not shown.

BIN
server/target/classes/self/cases/teams/entity/Teams.class
View File

Binary file not shown.

BIN
server/target/classes/self/cases/teams/entity/Users.class
View File

Binary file not shown.

BIN
server/target/classes/self/cases/teams/teaa/PaymentRecord.class
View File

Binary file not shown.

BIN
server/target/classes/self/cases/teams/teaa/STcx.class
View File

Binary file not shown.
Write Preview
Loading…
Cancel
Save