321

COVID-vue

@@ -0,0 +1 @@
+Subproject commit df30c6ee517297783b8f1e46eba280b0300862b7

src/main/java/com/liu/covid/CovidApplication.java

@@ -4,21 +4,11 @@ import org.mybatis.spring.annotation.MapperScan;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 
-/**
- * COVID应用程序的主类
- * 用于启动Spring Boot应用程序，并扫描MyBatis Mapper接口。
- */
 @SpringBootApplication
 @MapperScan("com.liu.covid.mapper")
 public class CovidApplication {
 
-    /**
-     * 程序入口方法
-     * 使用SpringApplication.run()方法启动Spring Boot应用程序。
-     *
-     * @param args 命令行参数
-     */
     public static void main(String[] args) {
         SpringApplication.run(CovidApplication.class, args);
     }
-}
+}

src/main/java/com/liu/covid/config/CrosConfig.java

@@ -4,31 +4,24 @@ import org.springframework.context.annotation.Configuration;
 import org.springframework.web.servlet.config.annotation.CorsRegistry;
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
-/**
- * 跨域配置类
- * 用于设置全局跨域访问的规则，允许前端应用从不同的源访问后端服务。
- */
+// 配置类，用于设置全局跨域访问的规则
 @Configuration
 public class CrosConfig implements WebMvcConfigurer {
-    /**
-     * 重写 addCorsMappings 方法，配置跨域访问规则
-     * 该方法用于定义哪些域可以访问后端服务，以及访问时的权限。
-     *
-     * @param registry 用于注册跨域规则的注册表
-     */
+    // 重写 addCorsMappings 方法，配置跨域访问规则
     @Override
     public void addCorsMappings(CorsRegistry registry) {
         // 允许所有路径的跨域请求
         registry.addMapping("/**")
                 // 允许的来源，"*" 表示任意来源
                 .allowedOrigins("*")
-                // 允许的 HTTP 方法，这里列出了常用的几种方法
-                .allowedMethods("GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS")
-                // 是否允许携带凭据（如 Cookie），true 表示允许
+                // 允许的 HTTP 方法
+                .allowedMethods("GET","HEAD","POST","PUT","DELETE","OPTIONS")
+                // 是否允许携带凭据（如 Cookie）
                 .allowCredentials(true)
-                // 预检请求的缓存时间，单位为秒，这里设置为3600秒即1小时
+                // 预检请求的缓存时间，单位为秒
                 .maxAge(3600)
                 // 允许的请求头，"*" 表示任意请求头
                 .allowedHeaders("*");
     }
-}
+}
+

src/main/java/com/liu/covid/controller/EmpController.java

@@ -9,115 +9,70 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.*;
 
 import java.util.List;
-
-/**
- * 员工健康信息控制器类
- * 用于处理与员工健康信息相关的HTTP请求。
- */
+// 控制器类，用于处理与员工健康信息相关的请求
 @RestController
 @RequestMapping("/emp")
 public class EmpController {
-    /**
-     * 自动注入EmpMapper对象
-     * EmpMapper是MyBatis Plus的Mapper接口，用于数据库操作。
-     */
+    // 自动注入 EmpMapper 对象
     @Autowired
     private EmpMapper mapper;
 
-    /**
-     * 分页查询员工健康信息
-     * 根据给定的页码和页面大小，查询对应的员工健康信息。
-     *
-     * @param page   当前页码
-     * @param size   每页显示的记录数
-     * @return 分页后的员工健康信息
-     */
+    // 分页查询员工健康信息
     @GetMapping("/findAll/{page}/{size}")
-    public Page<EmpHealth> findAll(@PathVariable("page") Integer page, @PathVariable("size") Integer size) {
+    public Page<EmpHealth> findAll(@PathVariable("page") Integer page, @PathVariable("size") Integer size){
         // 创建查询条件，按创建时间降序排列
-        QueryWrapper<EmpHealth> wrapper = new QueryWrapper<>();
+        QueryWrapper<EmpHealth> wrapper=new QueryWrapper<>();
         wrapper.orderByDesc("createTime");
         // 创建分页对象
-        Page<EmpHealth> page1 = new Page<>(page, size);
+        Page<EmpHealth> page1= new Page<>(page,size);
         // 执行分页查询并返回结果
-        Page<EmpHealth> result = mapper.selectPage(page1, wrapper).addOrder();
+        Page<EmpHealth> result=mapper.selectPage(page1,wrapper).addOrder();
         return result;
     }
 
-    /**
-     * 保存员工健康信息
-     * 将传入的员工健康信息保存到数据库。
-     *
-     * @param emp 员工健康信息对象
-     * @return 操作结果，成功返回"success"，失败返回"error"
-     */
+    // 保存员工健康信息
     @PostMapping("/save")
-    public String save(@RequestBody EmpHealth emp) {
+    public String save(@RequestBody EmpHealth emp){
         // 插入数据并返回操作结果
         int result = mapper.insert(emp);
-        if (result == 1) {
+        if (result==1){
             return "success";
-        } else {
+        }else {
             return "error";
         }
     }
 
-    /**
-     * 根据员工ID查询健康信息
-     * 根据给定的员工ID，查询对应的员工健康信息。
-     *
-     * @param id 员工ID
-     * @return 员工健康信息对象
-     */
+    // 根据员工 ID 查询健康信息
     @GetMapping("/findById/{id}")
-    public EmpHealth findById(@PathVariable("id") Integer id) {
+    public EmpHealth findById(@PathVariable("id") Integer id){
         return mapper.selectById(id);
-    }
+    }// 根据 ID 查询数据并返回
 
-    /**
-     * 更新员工健康信息
-     * 根据给定的员工健康信息对象，更新数据库中的记录。
-     *
-     * @param emp 员工健康信息对象
-     * @return 操作结果，成功返回"success"，失败返回"error"
-     */
+    // 更新员工健康信息
     @PutMapping("/update")
-    public String update(@RequestBody EmpHealth emp) {
+    public String update(@RequestBody EmpHealth emp){
         // 更新数据并返回操作结果
-        int result = mapper.updateById(emp);
-        if (result == 1) {
+        int result=mapper.updateById(emp);
+        if (result==1){
             return "success";
-        } else {
+        }else {
             return "error";
         }
     }
 
-    /**
-     * 根据员工ID删除健康信息
-     * 根据给定的员工ID，删除对应的员工健康信息。
-     *
-     * @param id 员工ID
-     */
+    // 根据员工 ID 删除健康信息
     @DeleteMapping("/deleteById/{id}")
-    public void deleteById(@PathVariable("id") Long id) {
-        // 这里有一个错误，应该是直接传递id，而不是id+"L"
-        mapper.deleteById(id);
-    }
+    public void deleteById(@PathVariable("id")Long id){
+        mapper.deleteById(id+"L");
+    }// 删除指定 ID 的数据
 
-    /**
-     * 根据指定字段和内容搜索员工健康信息
-     * 根据给定的搜索字段和搜索内容，进行模糊搜索并返回匹配的员工健康信息列表。
-     *
-     * @param searchkey 搜索字段
-     * @param stext     搜索内容
-     * @return 匹配的员工健康信息列表
-     */
+    // 根据指定字段和内容搜索员工健康信息
     @GetMapping("/search/{searchkey}/{stext}")
-    public List<EmpHealth> search(@PathVariable("searchkey") String searchkey, @PathVariable("stext") String stext) {
+    public List<EmpHealth> search(@PathVariable("searchkey")String searchkey, @PathVariable("stext")String stext){
         // 创建查询条件，按指定字段进行模糊搜索
         QueryWrapper<EmpHealth> userQueryWrapper = Wrappers.query();
-        userQueryWrapper.like(searchkey, stext);
+        userQueryWrapper.like(searchkey,stext);
         // 返回符合条件的数据列表
         return mapper.selectList(userQueryWrapper);
     }
-}
+}

src/main/java/com/liu/covid/controller/MaterialController.java

@@ -11,24 +11,17 @@ import org.springframework.web.bind.annotation.*;
 import java.util.List;
 
 /**
- * 物资管理控制器类
- * 用于处理与物资管理相关的HTTP请求，提供物资信息的增删改查功能。
+ * 物资管理控制器
  */
 @RestController
 @RequestMapping("/Material")
 public class MaterialController {
 
-    /**
-     * 自动注入MaterialMapper对象
-     * MaterialMapper是MyBatis Plus的Mapper接口，用于数据库操作。
-     */
     @Autowired
-    private MaterialMapper mapper;
+    private MaterialMapper mapper; // 物资管理的 Mapper
 
     /**
      * 分页查询物资信息
-     * 使用MyBatis Plus的分页插件进行分页查询，返回分页后的物资信息列表。
-     *
      * @param page 当前页码
      * @param size 每页显示条数
      * @return 分页后的物资信息列表
@@ -42,8 +35,6 @@ public class MaterialController {
 
     /**
      * 保存新的物资信息
-     * 将传入的物资管理对象保存到数据库。
-     *
      * @param material 物资管理对象
      * @return 操作结果：成功返回 "success"，失败返回 "error"
      */
@@ -58,10 +49,8 @@ public class MaterialController {
     }
 
     /**
-     * 根据ID查询物资信息
-     * 根据给定的物资ID，查询对应的物资信息。
-     *
-     * @param id 物资ID
+     * 根据 ID 查询物资信息
+     * @param id 物资 ID
      * @return 对应的物资管理对象
      */
     @GetMapping("/findById/{id}")
@@ -71,8 +60,6 @@ public class MaterialController {
 
     /**
      * 更新物资信息
-     * 根据给定的物资管理对象，更新数据库中的记录。
-     *
      * @param material 物资管理对象
      * @return 操作结果：成功返回 "success"，失败返回 "error"
      */
@@ -87,21 +74,16 @@ public class MaterialController {
     }
 
     /**
-     * 根据物资ID删除物资信息
-     * 根据给定的物资ID，删除对应的物资信息。
-     *
-     * @param id 物资ID
+     * 根据物资 ID 删除物资信息
+     * @param id 物资 ID
      */
     @DeleteMapping("/deleteById/{id}")
     public void deleteById(@PathVariable("id") Long id) {
-        // 这里有一个错误，应该是直接传递id，而不是id+"L"
-        mapper.deleteById(id);
+        mapper.deleteById(id + "L");
     }
 
     /**
      * 根据字段名和关键字模糊查询物资信息
-     * 使用MyBatis Plus的QueryWrapper进行模糊查询，返回符合条件的物资信息列表。
-     *
      * @param searchkey 字段名
      * @param stext 查询关键字
      * @return 符合条件的物资信息列表
@@ -112,4 +94,4 @@ public class MaterialController {
         userQueryWrapper.like(searchkey, stext); // 模糊查询
         return mapper.selectList(userQueryWrapper);
     }
-}
+}

src/main/java/com/liu/covid/entity/Department.java

@@ -3,28 +3,10 @@ package com.liu.covid.entity;
 import com.baomidou.mybatisplus.annotation.TableId;
 import lombok.Data;
 
-/**
- * 部门实体类
- * 用于表示一个部门的信息，包括部门ID、名称和负责人。
- */
 @Data
 public class Department {
-    /**
-     * 部门ID
-     * 唯一标识一个部门的整数ID。
-     */
     @TableId
     private Integer id;
-
-    /**
-     * 部门名称
-     * 表示部门的名称，如"人力资源部"、"财务部"等。
-     */
     private String name;
-
-    /**
-     * 部门负责人
-     * 表示负责该部门的人员姓名或职位。
-     */
     private String charge;
-}
+}

src/main/java/com/liu/covid/entity/EmpHealth.java

@@ -50,9 +50,3 @@ public class EmpHealth {
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
     private Date createTime;
 }
-//
-//
-//
-//
-//
-//

src/main/java/com/liu/covid/entity/Enum/ImpEnum.java

@@ -11,41 +11,13 @@ public enum ImpEnum {
     是(1, "是"), // 表示重要，code为1
     否(0, "否"); // 表示不重要，code为0
 
-    /**
-     * 枚举项的构造函数
-     * 用于初始化枚举项的code和isImp属性。
-     *
-     * @param code   是否重要的代码：1表示“是”，0表示“否”
-     * @param isImp  是否重要的名称：可以是“是”或“否”
-     */
+    // 枚举类的构造函数，传入code和isImp值
     ImpEnum(Integer code, String isImp) {
         this.code = code;
         this.isImp = isImp;
     }
 
-    /**
-     * 标记该字段为数据库存储的值
-     * MyBatis Plus在操作数据库时将使用此字段的值来表示枚举。
-     */
-    @EnumValue
-    private Integer code; // 是否重要的代码：1为“是”，0为“否”
-
+    @EnumValue // 标记该字段为数据库存储的值
+    private Integer code; // 是否重要的代码：1为是，0为否
     private String isImp; // 是否重要的名称：是或否
-
-    // Getter和Setter方法
-    public Integer getCode() {
-        return code;
-    }
-
-    public void setCode(Integer code) {
-        this.code = code;
-    }
-
-    public String getIsImp() {
-        return isImp;
-    }
-
-    public void setIsImp(String isImp) {
-        this.isImp = isImp;
-    }
-}
+}

src/main/java/com/liu/covid/entity/User.java

@@ -4,34 +4,12 @@ import com.baomidou.mybatisplus.annotation.IdType;
 import com.baomidou.mybatisplus.annotation.TableId;
 import lombok.Data;
 
-/**
- * 用户实体类
- * 用于表示一个用户的信息，包括用户ID、用户名、密码和所属部门。
- */
 @Data
 public class User {
-    /**
-     * 用户ID
-     * 唯一标识一个用户的长整型ID，数据库中自动增长。
-     */
     @TableId(type = IdType.AUTO)
     private Long id;
-
-    /**
-     * 用户名
-     * 用户的登录名或昵称。
-     */
     private String username;
-
-    /**
-     * 密码
-     * 用户的登录密码，存储时应进行加密处理。
-     */
     private String password;
-
-    /**
-     * 所属部门
-     * 用户所属的部门名称或部门ID。
-     */
     private String depart;
-}
+
+}

src/main/java/com/liu/covid/handler/MyMetaObjectHandler.java

@@ -15,17 +15,13 @@ public class MyMetaObjectHandler implements MetaObjectHandler {
 
     /**
      * 插入时自动填充字段
-     * 在插入数据时，自动填充 createTime、updateTime 字段为当前时间。
-     * 注意：通常不建议在同一个实体中同时使用 createTime 和 register 字段来记录时间，
-     * 因为这种做法可能会导致字段含义不明确。这里假设 register 字段有其他特定用途。
-     *
-     * @param metaObject 元对象，代表当前操作的数据对象
+     * 在插入数据时，自动填充 createTime、register 和 updateTime 字段。
      */
     @Override
     public void insertFill(MetaObject metaObject) {
         // 设置 createTime 字段为当前时间
         this.setFieldValByName("createTime", new Date(), metaObject);
-        // 设置 register 字段为当前时间，这里假设 register 字段有其他特定用途
+        // 设置 register 字段为当前时间
         this.setFieldValByName("register", new Date(), metaObject);
         // 设置 updateTime 字段为当前时间
         this.setFieldValByName("updateTime", new Date(), metaObject);
@@ -34,12 +30,10 @@ public class MyMetaObjectHandler implements MetaObjectHandler {
     /**
      * 更新时自动填充字段
      * 在更新数据时，自动填充 updateTime 字段为当前时间。
-     *
-     * @param metaObject 元对象，代表当前操作的数据对象
      */
     @Override
     public void updateFill(MetaObject metaObject) {
         // 设置 updateTime 字段为当前时间
         this.setFieldValByName("updateTime", new Date(), metaObject);
     }
-}
+}

src/main/java/com/liu/covid/service/ChartService.java

@@ -8,24 +8,7 @@ import com.liu.covid.vo.PieVo;
 import java.util.List;
 import java.util.Map;
 
-/**
- * 图表服务接口
- * 提供员工身份信息相关的图表数据服务，包括折线图和饼图的数据。
- */
 public interface ChartService extends IService<EmpIden> {
-    /**
-     * 获取折线图视图对象列表
-     * 用于生成折线图所需的数据，例如时间序列数据。
-     *
-     * @return 折线图视图对象，包含折线图所需的所有数据
-     */
     public LineVO lineVOList();
-
-    /**
-     * 获取饼图视图对象列表
-     * 用于生成饼图所需的数据，例如不同类别的比例数据。
-     *
-     * @return 饼图视图对象列表，每个对象包含一个饼图所需的所有数据
-     */
     public List<PieVo> pieVOMap();
-}
+}

src/main/java/com/liu/covid/service/DepartService.java

@@ -5,16 +5,6 @@ import com.liu.covid.entity.Department;
 
 import java.util.List;
 
-/**
- * 部门服务接口
- * 提供部门信息的管理和查询服务。
- */
 public interface DepartService extends IService<Department> {
-    /**
-     * 获取所有部门的名称列表
-     * 用于获取系统中所有部门的名称，通常用于下拉列表、筛选等场景。
-     *
-     * @return 包含所有部门名称的列表
-     */
     public List<String> getAll();
-}
+}

src/main/java/com/liu/covid/service/UserService.java

@@ -3,26 +3,7 @@ package com.liu.covid.service;
 import com.baomidou.mybatisplus.extension.service.IService;
 import com.liu.covid.entity.User;
 
-/**
- * 用户服务接口
- * 提供用户相关的业务操作，包括登录和注册。
- */
 public interface UserService extends IService<User> {
-    /**
-     * 用户登录
-     * 根据提供的用户名和密码进行用户身份验证。
-     *
-     * @param user 用户实体，包含登录所需的用户名和密码
-     * @return 登录结果，成功或失败的相关信息
-     */
     public String login(User user);
-
-    /**
-     * 用户注册
-     * 将新用户的信息保存到数据库中。
-     *
-     * @param user 用户实体，包含注册所需的详细信息
-     * @return 注册结果，成功或失败的相关信息
-     */
     public String register(User user);
-}
+}

src/main/java/com/liu/covid/util/JDBCUtils.java

@@ -7,35 +7,26 @@ import java.sql.*;
  */
 public class JDBCUtils {
 
-    /**
-     * 数据库连接的 URL，包含数据库名称、字符编码及时区设置。
-     */
+    // 数据库连接的 URL，包含数据库名称、字符编码及时区设置
     static final String url = "jdbc:mysql://localhost:3306/covid?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai";
 
-    /**
-     * 数据库的用户名。
-     */
+    // 数据库的用户名
     static final String user = "root";
 
-    /**
-     * 数据库的密码。
-     */
+    // 数据库的密码
     static final String password = "123456";
 
-    /**
-     * 数据库连接对象。
-     */
+    // 数据库连接对象
     private static Connection con;
 
     /**
      * 连接数据库
-     * 加载数据库驱动，并尝试建立数据库连接。
-     * @return 返回数据库连接对象，如果连接失败则返回 null。
+     * @return 返回数据库连接对象，如果连接失败则返回 null
      */
     public static Connection getConnection(){
         // 加载数据库驱动
         try {
-            Class.forName("com.mysql.cj.jdbc.Driver"); // 加载 MySQL 驱动（8.0 版本及以上）
+            Class.forName("coym.msql.cj.jdbc.Driver"); // 加载 MySQL 驱动（8.0 版本及以上）
         } catch (ClassNotFoundException e) {
             e.printStackTrace();  // 如果驱动加载失败，打印异常
         }
@@ -43,11 +34,11 @@ public class JDBCUtils {
         // 进行数据库连接
         try {
             con = DriverManager.getConnection(url, user, password);  // 使用 JDBC URL、用户名和密码进行连接
-            con.setAutoCommit(false);  // 设置自动提交事务为 false，以便管理事务
+            con.setAutoCommit(true);  // 设置自动提交事务
         } catch (SQLException e) {
             e.printStackTrace();  // 如果连接失败，打印异常
         }
 
         return con;  // 返回连接对象
     }
-}
+}

src/main/java/com/liu/covid/util/test.java

@@ -3,28 +3,14 @@ package com.liu.covid.util;
 import java.sql.Connection;
 import java.sql.SQLException;
 
-/**
- * 测试数据库连接的工具类
- * 用于验证数据库连接是否成功。
- */
-public class Test {
-    /**
-     * 程序入口方法
-     * 通过JDBCUtils获取数据库连接，并打印连接结果。
-     *
-     * @param args 命令行参数（在此方法中未使用）
-     * @throws SQLException 如果数据库连接失败
-     */
+public class test{
     public static void main(String[] args) throws SQLException {
-        // 实例化JDBCUtils工具类
-        JDBCUtils jdbcConnection = new JDBCUtils();
-        // 通过JDBCUtils获取数据库连接
-        Connection connection = jdbcConnection.getConnection();
-        // 检查连接是否成功，并打印相应信息
-        if (connection != null) {
+        JDBCUtils jdbcConnection=new JDBCUtils();
+        Connection connection=jdbcConnection.getConnection();
+        if(connection!=null){
             System.out.println("数据库连接成功");
-        } else {
+        }else {
             System.out.println("数据库连接失败");
         }
     }
-}
+}

src/main/java/com/liu/covid/vo/LineVO.java

@@ -6,22 +6,8 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
-/**
- * 折线图视图对象
- * 用于封装折线图中的数据，包括时间序列和对应的状态数据。
- */
 @Data
 public class LineVO {
-    /**
-     * 月份列表
-     * 存储折线图的横坐标数据，通常是月份。
-     */
     private List<String> month;
-
-    /**
-     * 状态数据映射
-     * 存储折线图的纵坐标数据，通常是与月份对应的各种状态的数量。
-     * 键为状态名称，值为该状态下的数量列表。
-     */
-    private Map<String, List> status;
-}
+    private Map<String,List> status;
+}

src/main/java/com/liu/covid/vo/PieVo.java

@@ -2,21 +2,8 @@ package com.liu.covid.vo;
 
 import lombok.Data;
 
-/**
- * 饼图视图对象
- * 用于封装饼图中每个切片的数据，包括名称和值。
- */
 @Data
 public class PieVo {
-    /**
-     * 切片名称
-     * 表示饼图中每个切片的名称或类别。
-     */
     private String name;
-
-    /**
-     * 切片值
-     * 表示饼图中每个切片对应的数值。
-     */
     private Integer value;
-}
+}

src/main/java/org/example/App.java

@@ -1,7 +1,7 @@
 package org.example;
 
 /**
- * Hello world! wangciurui
+ * Hello world!
  *
  */
 public class App 

src/plugins/axios.js

@@ -3,60 +3,42 @@
 import Vue from 'vue';
 import axios from "axios";
 
-// Full config:  https://github.com/axios/axios#request-config 
+// Full config:  https://github.com/axios/axios#request-config
 // axios.defaults.baseURL = process.env.baseURL || process.env.apiUrl || '';
 // axios.defaults.headers.common['Authorization'] = AUTH_TOKEN;
 // axios.defaults.headers.post['Content-Type'] = 'application/x-www-form-urlencoded';
 
-/**
- * Axios configuration object
- * Defines the default settings for axios instances created by this configuration.
- */
 let config = {
-  // baseURL: process.env.baseURL || process.env.apiUrl || "",
-  // timeout: 60 * 1000, // Timeout in milliseconds
+  // baseURL: process.env.baseURL || process.env.apiUrl || ""
+  // timeout: 60 * 1000, // Timeout
   // withCredentials: true, // Check cross-site Access-Control
 };
 
-/**
- * Creates an axios instance with the specified configuration.
- */
 const _axios = axios.create(config);
 
-/**
- * Adds a request interceptor to the axios instance.
- * The interceptor modifies the request configuration before it is sent.
- */
 _axios.interceptors.request.use(
   function(config) {
-    // Do something before request is sent, e.g., add authentication tokens
+    // Do something before request is sent
     return config;
   },
   function(error) {
-    // Do something with request error, e.g., log the error
+    // Do something with request error
     return Promise.reject(error);
   }
 );
 
-/**
- * Adds a response interceptor to the axios instance.
- * The interceptor modifies the response data before it is handled by `then` or `catch`.
- */
+// Add a response interceptor
 _axios.interceptors.response.use(
   function(response) {
-    // Do something with response data, e.g., transform the data format
+    // Do something with response data
     return response;
   },
   function(error) {
-    // Do something with response error, e.g., display an error message
+    // Do something with response error
     return Promise.reject(error);
   }
 );
 
-/**
- * Plugin installation function for Vue.
- * This function integrates the axios instance into Vue, making it accessible as `this.$axios` in Vue components.
- */
 Plugin.install = function(Vue, options) {
   Vue.axios = _axios;
   window.axios = _axios;
@@ -74,7 +56,6 @@ Plugin.install = function(Vue, options) {
   });
 };
 
-// Automatically install the plugin if Vue is available
 Vue.use(Plugin)
 
-export default Plugin;
+export default Plugin;

src/router/index.js

@@ -1,97 +1,85 @@
 import Vue from 'vue'
 import VueRouter from 'vue-router'
 import Index from '../views/Index.vue'
-import Login from '../views/Login.vue'
+import Login from '../views/login.vue'
 Vue.use(VueRouter)
 
-/**
- * Router configuration for the application
- * Defines the routes and their corresponding components.
- */
 const routes = [
-  // Configure the default path to display the login page
-  {
-    path: '/',
-    meta: false,
-    component: () => import('../views/Login.vue')
-  },
-  
+      //配置默认的路径，默认显示登录页
+      { path: '/', meta:false, component: () => import('../views/login.vue')},
+ 
   {
     path: "/Index",
-    name: "日常防控管理",
-    component: Index,
-    meta: true,
-    children: [
+    name:"日常防控管理",
+    component:Index,
+    meta:true,
+    children:[
       {
-        path: "/RecordManage",
-        name: "打卡记录",
-        component: () => import('../views/RecordManage.vue')
+        path:"/RecordManage",
+        name:"打卡记录",
+        component:() => import('../views/RecordManage.vue') 
       },
       {
-        path: "/AddRecord",
-        name: "健康打卡申报",
-        component: () => import('../views/AddRecord.vue')
+        path:"/AddRecord",
+        name:"健康打卡申报",
+        component:()=>import('../views/AddRecord.vue') 
       }
     ]
   },
   {
     path: "/Index",
-    name: "异常人员管理",
-    component: Index,
-    meta: true,
-    children: [
+    name:"异常人员管理",
+    component:Index,
+    meta:true,
+    children:[
       {
-        path: "/IdenManage",
-        name: "疑似/确诊人员登记",
-        component: () => import('../views/IdenManage.vue')
+        path:"/IdenManage",
+        name:"疑似/确诊人员登记",
+        component:() => import(/* webpackChunkName: "BlogManage" */ '../views/IdenManage.vue') 
+        //const Foo = () => import(/* webpackChunkName: "group-foo" */ './Foo.vue')
       },
       {
-        path: "/IsManage",
-        name: "隔离人员登记",
-        component: () => import('../views/IsManage.vue')
+        path:"/IsManage",
+        name:"隔离人员登记",
+        component:()=>import(/* webpackChunkName:"AddBlog" */ '../views/IsManage.vue') 
       }
     ]
   },
   {
     path: "/Index",
-    name: "防疫物资管理",
-    component: Index,
-    meta: true,
-    children: [
-      {
-        path: "/MaterialManage",
-        name: "防疫物资查看",
-        component: () => import('../views/MaterialManage.vue')
-      },
-      {
-        path: "/AddMaterial",
-        name: "新增防疫物资",
-        component: () => import('../views/AddMaterial.vue')
-      }
-    ]
+    name:"防疫物资管理",
+    component:Index,
+    meta:true,
+    children:[{
+      path:"/MaterialManage",
+      name:"防疫物资查看",
+      component:()=>import(/* webpackChunkName:"MaterialManage" */ '../views/MaterialManage.vue') 
+    },{
+      path:"/AddMaterial",
+      name:"新增防疫物资",
+      component:()=>import(/* webpackChunkName:"AddMaterial" */ '../views/AddMaterial.vue') 
+    }
+  ]
   },
   {
     path: "/Index",
-    name: "疫情概况",
-    component: Index,
-    meta: true,
-    children: [
-      {
-        path: "/EChart",
-        name: "防疫数据可视化",
-        component: () => import('../views/EChart.vue')
-      }
+    name:"疫情概况",
+    component:Index,
+    meta:true,
+    children:[{
+      path:"/EChart",
+      name:"防疫数据可视化",
+      component:()=>import(/* webpackChunkName:"MaterialManage" */ '../views/EChart.vue')
+    }
     ]
   }
+
 ]
 
-/**
- * Creates a new VueRouter instance with the defined routes.
- */
 const router = new VueRouter({
-  mode: 'history', // Use HTML5 history mode
-  base: process.env.BASE_URL, // Base URL for the application
-  routes // Define the routes
+  mode: 'history',
+  base: process.env.BASE_URL,
+  routes
 })
 
-export default router
+export default router

src/store/index.js

@@ -3,58 +3,13 @@ import Vuex from 'vuex'
 
 Vue.use(Vuex)
 
-/**
- * Creates a new Vuex store instance.
- * This store will be used to manage the state, mutations, actions, and modules of the Vue application.
- */
 export default new Vuex.Store({
-  /**
-   * The state object contains the initial state of the Vuex store.
-   * It can be mutated only by using mutations or actions.
-   */
   state: {
-    // Initial state properties go here. For example:
-    // user: null,
-    // isAuthenticated: false,
   },
-  
-  /**
-   * The mutations object contains functions that can mutate the state.
-   * These functions are the only way to actually change state in the store.
-   */
   mutations: {
-    // Mutation functions go here. For example:
-    // SET_USER(state, user) {
-    //   state.user = user;
-    // },
-    // SET_AUTHENTICATION(state, status) {
-    //   state.isAuthenticated = status;
-    // },
   },
-  
-  /**
-   * The actions object contains functions that cause side effects.
-   * These functions can call mutations or other actions, but they shouldn't mutate the state directly.
-   */
   actions: {
-    // Action functions go here. For example:
-    // loginUser({ commit }, user) {
-    //   // Perform login logic here, then commit a mutation
-    //   commit('SET_USER', user);
-    //   commit('SET_AUTHENTICATION', true);
-    // },
   },
-  
-  /**
-   * The modules object contains other Vuex modules.
-   * This allows you to split your store into smaller chunks of logic.
-   */
   modules: {
-    // Vuex module objects go here. For example:
-    // user: {
-    //   state: { /* user-specific state */ },
-    //   mutations: { /* user-specific mutations */ },
-    //   actions: { /* user-specific actions */ },
-    // },
   }
-})
+})

src/test/java/com/liu/covid/controller/LoginServiceTest.java

@@ -1,28 +1,30 @@
 package com.liu.covid.controller;
 
+import com.liu.covid.entity.EmpHealth;
 import com.liu.covid.entity.User;
+import com.liu.covid.mapper.EmpMapper;
 import com.liu.covid.mapper.UserMapper;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.util.DigestUtils;
 
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+
+
 @SpringBootTest
 class LoginServiceTest {
     @Autowired
-    private UserMapper mapper; // 注入UserMapper，用于数据库操作
-
-    /**
-     * 测试用户注册功能
-     * 此方法用于测试用户注册功能，通过加密密码并插入用户信息到数据库。
-     */
+private UserMapper mapper;
     @Test
-    void register() {
-        User user = new User(); // 创建一个新的User对象
-        String pw = DigestUtils.md5DigestAsHex("99409".getBytes()); // 使用MD5加密密码
-        user.setUsername("994091246"); // 设置用户名
-        user.setPassword(pw); // 设置加密后的密码
-        int message = mapper.insert(user); // 将用户信息插入数据库，并返回影响的行数
-        System.out.println(message); // 打印插入结果
+    void register(){
+        User user=new User();
+        String pw=DigestUtils.md5DigestAsHex("99409".getBytes());
+        user.setUsername("994091246");
+        user.setPassword(pw);
+        int message= mapper.insert(user);
+        System.out.println(message);
     }
 }

src/test/java/com/liu/covid/controller/MaterialControllerTest.java

@@ -3,59 +3,58 @@ package com.liu.covid.controller;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.liu.covid.entity.EmpIden;
+import com.liu.covid.entity.EmpIs;
+
+import com.liu.covid.mapper.EmpIdenMapper;
+import com.liu.covid.mapper.EmpIsMapper;
 import com.liu.covid.vo.LineVO;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 
+import java.sql.Wrapper;
 import java.text.SimpleDateFormat;
 import java.util.*;
 
+
 @SpringBootTest
 class MaterialControllerTest {
     @Autowired
-    private EmpIdenMapper mapper; // 注入EmpIdenMapper，用于数据库操作
+    private EmpIdenMapper mapper;
 
-    /**
-     * 测试查询并生成折线图数据
-     * 此方法用于测试查询数据库并生成折线图所需的数据。
-     */
     @Test
     void find() {
-        LineVO lineVO = new LineVO(); // 创建LineVO对象，用于存储折线图数据
-        Date date = new Date(); // 获取当前日期
-        Calendar cal = Calendar.getInstance(); // 获取日历实例
-        List<String> month = new ArrayList<>(); // 存储月份的列表
-        Map<String, Integer> status = new HashMap<>(); // 存储每个月份的状态计数
-        Map<String, Map> all = new HashMap<>(); // 存储所有状态的数据
-
-        String type[] = {"确诊", "疑似", "治愈", "死亡"}; // 定义状态类型
-
-        // 向前推算7个月的月份数据
-        for (int i = 0; i < 7; i++) {
+        LineVO lineVO=new LineVO();
+        Date date=new Date();
+        Calendar cal = Calendar.getInstance();
+        List<String> month=new ArrayList<>();
+        Map<String,Integer> status=new HashMap<>();
+        Map<String,Map> all=new HashMap<>();
+        String type[]={"确诊","疑似","治愈","死亡"};
+
+        for (int i=0;i<7;i++) {
             cal.setTime(date);
             cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) - i);
-            SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM");
-            String mon = ft.format(cal.getTime());
+            SimpleDateFormat ft=new SimpleDateFormat("yyyy-MM");
+            String mon=ft.format(cal.getTime());
             month.add(mon);
         }
-        // 设置折线图月份
+        //设置折线图月份
         lineVO.setMonth(month);
-
-        // 遍历每种状态类型，查询并设置数据
+        //  设置 类型-数量 键值对
         for (String t : type) {
-            int j = 0;
-            while (j < 7) {
-                QueryWrapper<EmpIden> userQueryWrapper = Wrappers.query();
-                userQueryWrapper.like("status", t).likeRight("idate", month.get(j));
-                Integer count = mapper.selectCount(userQueryWrapper);
-                status.put(month.get(j++), count);
-                userQueryWrapper.clear();
-            }
-            all.put(t, status);
+        int j=0;
+        while (j<7){
+            QueryWrapper<EmpIden> userQueryWrapper = Wrappers.query();
+            userQueryWrapper.like("status", t).likeRight("idate", month.get(j));
+            Integer count = mapper.selectCount(userQueryWrapper);
+            status.put(month.get(j++),count);
+            userQueryWrapper.clear();
         }
+        all.put(t,status);
 
-        // 打印所有数据
+    }
         System.out.println(all.toString());
     }
+
 }

src/test/java/org/example/AppTest.java

@@ -5,32 +5,34 @@ import junit.framework.TestCase;
 import junit.framework.TestSuite;
 
 /**
- * 单元测试类，用于测试简单的应用程序
- * 这个类继承自junit.framework.TestCase，提供了一个测试用例的框架。
+ * Unit test for simple App.
  */
-public class AppTest extends TestCase {
+public class AppTest 
+    extends TestCase
+{
     /**
-     * 构造测试用例
-     * 
-     * @param testName 测试用例的名称
+     * Create the test case
+     *
+     * @param testName name of the test case
      */
-    public AppTest(String testName) {
-        super(testName); // 调用父类的构造函数，设置测试用例的名称
+    public AppTest( String testName )
+    {
+        super( testName );
     }
 
     /**
-     * 返回被测试的测试套件
-     * 这个静态方法返回一个包含所有测试用例的测试套件。
+     * @return the suite of tests being tested
      */
-    public static Test suite() {
-        return new TestSuite(AppTest.class); // 创建并返回一个包含当前类中所有测试方法的测试套件
+    public static Test suite()
+    {
+        return new TestSuite( AppTest.class );
     }
 
     /**
-     * 严格的测试方法
-     * 这是一个简单的测试方法，它测试一个恒真命题（assertTrue(true)）。
+     * Rigourous Test :-)
      */
-    public void testApp() {
-        assertTrue(true); // 测试一个恒真命题，确保测试框架运行正常
+    public void testApp()
+    {
+        assertTrue( true );
     }
-}
+}