From 29eb2681806cc0b1871010c60fec65818d00df58 Mon Sep 17 00:00:00 2001 From: zzy <2450266535@qq.com> Date: Sun, 24 May 2026 00:24:56 +0800 Subject: [PATCH] init --- .gitignore | 5 + pom.xml | 90 + .../com/example/SpringbootApplication.java | 18 + .../java/com/example/common/Constants.java | 9 + src/main/java/com/example/common/Result.java | 72 + .../com/example/common/config/CorsConfig.java | 25 + .../example/common/config/JwtInterceptor.java | 82 + .../com/example/common/config/TokenUtils.java | 88 + .../com/example/common/config/WebConfig.java | 24 + .../example/common/enums/ResultCodeEnum.java | 27 + .../example/config/RestTemplateConfig.java | 14 + .../com/example/config/WebSocketConfig.java | 20 + .../example/controller/AIChatController.java | 56 + .../example/controller/AccountController.java | 48 + .../example/controller/AdminController.java | 93 + .../controller/AnnouncementController.java | 109 + .../AssessmentReportController.java | 116 + .../controller/ChatMessageController.java | 48 + .../example/controller/DoctorController.java | 147 + .../controller/DoctorPatientController.java | 137 + .../example/controller/FileController.java | 102 + .../example/controller/PatientController.java | 256 ++ .../controller/RecommendationController.java | 47 + .../ResourceCategoryController.java | 86 + .../controller/ResourceRatingController.java | 167 + .../controller/SymptomRecordController.java | 91 + .../SymptomStatisticsController.java | 66 + .../TreatmentResourceController.java | 220 ++ .../com/example/controller/WebController.java | 93 + src/main/java/com/example/entity/Account.java | 30 + src/main/java/com/example/entity/Admin.java | 33 + .../java/com/example/entity/Announcement.java | 59 + .../com/example/entity/AssessmentReport.java | 41 + .../java/com/example/entity/ChatMessage.java | 92 + src/main/java/com/example/entity/Doctor.java | 41 + .../com/example/entity/DoctorPatient.java | 56 + src/main/java/com/example/entity/Patient.java | 35 + .../com/example/entity/ResourceCategory.java | 17 + .../com/example/entity/ResourceRating.java | 57 + .../com/example/entity/SymptomRecord.java | 121 + .../com/example/entity/TreatmentResource.java | 33 + .../example/exception/CustomException.java | 35 + .../exception/GlobalExceptionHandler.java | 30 + .../java/com/example/mapper/AdminMapper.java | 32 + .../example/mapper/AnnouncementMapper.java | 41 + .../mapper/AssessmentReportMapper.java | 50 + .../com/example/mapper/ChatMessageMapper.java | 51 + .../java/com/example/mapper/DoctorMapper.java | 29 + .../example/mapper/DoctorPatientMapper.java | 28 + .../com/example/mapper/PatientMapper.java | 29 + .../mapper/ResourceCategoryMapper.java | 20 + .../example/mapper/ResourceRatingMapper.java | 46 + .../example/mapper/SymptomRecordMapper.java | 36 + .../mapper/TreatmentResourceMapper.java | 67 + .../com/example/service/AIChatService.java | 171 + .../com/example/service/AdminService.java | 134 + .../example/service/AnnouncementService.java | 164 + .../service/AssessmentReportService.java | 530 +++ .../example/service/ChatMessageService.java | 221 ++ .../example/service/DoctorPatientService.java | 121 + .../com/example/service/DoctorService.java | 132 + .../com/example/service/PatientService.java | 200 + .../service/RecommendationService.java | 385 ++ .../service/ResourceCategoryService.java | 88 + .../service/ResourceRatingService.java | 161 + .../example/service/SymptomRecordService.java | 735 ++++ .../service/TreatmentResourceService.java | 256 ++ .../com/example/websocket/ChatWebSocket.java | 195 + src/main/resources/application.yml | 28 + src/main/resources/mapper/AdminMapper.xml | 26 + src/main/resources/mapper/DoctorMapper.xml | 25 + .../resources/mapper/DoctorPatientMapper.xml | 91 + src/main/resources/mapper/PatientMapper.xml | 25 + .../resources/mapper/SymptomRecordMapper.xml | 61 + vue/.env.development | 1 + vue/.env.production | 1 + vue/.gitignore | 33 + vue/index.html | 16 + vue/jsconfig.json | 8 + vue/package-lock.json | 3399 +++++++++++++++++ vue/package.json | 32 + vue/src/App.vue | 3 + vue/src/assets/css/global.css | 21 + vue/src/assets/css/index.scss | 7 + vue/src/assets/css/manager.css | 108 + vue/src/assets/fonts/FontAwesome.otf | Bin 0 -> 134808 bytes vue/src/assets/fonts/font-awesome.css | 2337 ++++++++++++ vue/src/assets/fonts/fontawesome-webfont.eot | Bin 0 -> 165742 bytes vue/src/assets/fonts/fontawesome-webfont.svg | 2671 +++++++++++++ vue/src/assets/fonts/fontawesome-webfont.ttf | Bin 0 -> 165548 bytes vue/src/assets/fonts/fontawesome-webfont.woff | Bin 0 -> 98024 bytes .../assets/fonts/fontawesome-webfont.woff2 | Bin 0 -> 77160 bytes vue/src/assets/imgs/404.jpg | Bin 0 -> 156674 bytes vue/src/assets/imgs/VCG41N1408837996.jpg | Bin 0 -> 196997 bytes vue/src/assets/imgs/avatar.png | Bin 0 -> 4097 bytes vue/src/assets/imgs/login.svg | 1 + vue/src/assets/imgs/logo.png | Bin 0 -> 6849 bytes vue/src/assets/imgs/register.svg | 1 + vue/src/assets/logo.png | Bin 0 -> 6849 bytes vue/src/main.js | 21 + vue/src/router/index.js | 46 + vue/src/utils/request.js | 54 + vue/src/views/404.vue | 28 + vue/src/views/Login.vue | 339 ++ vue/src/views/Manager.vue | 408 ++ vue/src/views/Register.vue | 394 ++ vue/src/views/manager/AIChat.vue | 430 +++ vue/src/views/manager/Admin.vue | 159 + vue/src/views/manager/Announcement.vue | 248 ++ vue/src/views/manager/AnnouncementList.vue | 252 ++ vue/src/views/manager/AssessmentReports.vue | 446 +++ vue/src/views/manager/Chat.vue | 733 ++++ vue/src/views/manager/Doctor.vue | 195 + vue/src/views/manager/GenerateReport.vue | 232 ++ vue/src/views/manager/Home.vue | 692 ++++ vue/src/views/manager/MyReports.vue | 239 ++ vue/src/views/manager/MyResources.vue | 438 +++ vue/src/views/manager/Password.vue | 74 + vue/src/views/manager/Patient.vue | 230 ++ vue/src/views/manager/PatientReports.vue | 253 ++ vue/src/views/manager/ReportDetail.vue | 366 ++ vue/src/views/manager/ResourceCategory.vue | 245 ++ .../views/manager/ResourceRecommendation.vue | 496 +++ vue/src/views/manager/SymptomRecord.vue | 490 +++ vue/src/views/manager/SymptomStatistics.vue | 641 ++++ vue/src/views/manager/TreatmentResource.vue | 791 ++++ vue/src/views/manager/User.vue | 167 + vue/src/views/manager/pAdmin.vue | 110 + vue/src/views/manager/pDoctor.vue | 171 + vue/src/views/manager/pPatient.vue | 156 + vue/vite.config.js | 103 + 131 files changed, 25500 insertions(+) create mode 100644 .gitignore create mode 100644 pom.xml create mode 100644 src/main/java/com/example/SpringbootApplication.java create mode 100644 src/main/java/com/example/common/Constants.java create mode 100644 src/main/java/com/example/common/Result.java create mode 100644 src/main/java/com/example/common/config/CorsConfig.java create mode 100644 src/main/java/com/example/common/config/JwtInterceptor.java create mode 100644 src/main/java/com/example/common/config/TokenUtils.java create mode 100644 src/main/java/com/example/common/config/WebConfig.java create mode 100644 src/main/java/com/example/common/enums/ResultCodeEnum.java create mode 100644 src/main/java/com/example/config/RestTemplateConfig.java create mode 100644 src/main/java/com/example/config/WebSocketConfig.java create mode 100644 src/main/java/com/example/controller/AIChatController.java create mode 100644 src/main/java/com/example/controller/AccountController.java create mode 100644 src/main/java/com/example/controller/AdminController.java create mode 100644 src/main/java/com/example/controller/AnnouncementController.java create mode 100644 src/main/java/com/example/controller/AssessmentReportController.java create mode 100644 src/main/java/com/example/controller/ChatMessageController.java create mode 100644 src/main/java/com/example/controller/DoctorController.java create mode 100644 src/main/java/com/example/controller/DoctorPatientController.java create mode 100644 src/main/java/com/example/controller/FileController.java create mode 100644 src/main/java/com/example/controller/PatientController.java create mode 100644 src/main/java/com/example/controller/RecommendationController.java create mode 100644 src/main/java/com/example/controller/ResourceCategoryController.java create mode 100644 src/main/java/com/example/controller/ResourceRatingController.java create mode 100644 src/main/java/com/example/controller/SymptomRecordController.java create mode 100644 src/main/java/com/example/controller/SymptomStatisticsController.java create mode 100644 src/main/java/com/example/controller/TreatmentResourceController.java create mode 100644 src/main/java/com/example/controller/WebController.java create mode 100644 src/main/java/com/example/entity/Account.java create mode 100644 src/main/java/com/example/entity/Admin.java create mode 100644 src/main/java/com/example/entity/Announcement.java create mode 100644 src/main/java/com/example/entity/AssessmentReport.java create mode 100644 src/main/java/com/example/entity/ChatMessage.java create mode 100644 src/main/java/com/example/entity/Doctor.java create mode 100644 src/main/java/com/example/entity/DoctorPatient.java create mode 100644 src/main/java/com/example/entity/Patient.java create mode 100644 src/main/java/com/example/entity/ResourceCategory.java create mode 100644 src/main/java/com/example/entity/ResourceRating.java create mode 100644 src/main/java/com/example/entity/SymptomRecord.java create mode 100644 src/main/java/com/example/entity/TreatmentResource.java create mode 100644 src/main/java/com/example/exception/CustomException.java create mode 100644 src/main/java/com/example/exception/GlobalExceptionHandler.java create mode 100644 src/main/java/com/example/mapper/AdminMapper.java create mode 100644 src/main/java/com/example/mapper/AnnouncementMapper.java create mode 100644 src/main/java/com/example/mapper/AssessmentReportMapper.java create mode 100644 src/main/java/com/example/mapper/ChatMessageMapper.java create mode 100644 src/main/java/com/example/mapper/DoctorMapper.java create mode 100644 src/main/java/com/example/mapper/DoctorPatientMapper.java create mode 100644 src/main/java/com/example/mapper/PatientMapper.java create mode 100644 src/main/java/com/example/mapper/ResourceCategoryMapper.java create mode 100644 src/main/java/com/example/mapper/ResourceRatingMapper.java create mode 100644 src/main/java/com/example/mapper/SymptomRecordMapper.java create mode 100644 src/main/java/com/example/mapper/TreatmentResourceMapper.java create mode 100644 src/main/java/com/example/service/AIChatService.java create mode 100644 src/main/java/com/example/service/AdminService.java create mode 100644 src/main/java/com/example/service/AnnouncementService.java create mode 100644 src/main/java/com/example/service/AssessmentReportService.java create mode 100644 src/main/java/com/example/service/ChatMessageService.java create mode 100644 src/main/java/com/example/service/DoctorPatientService.java create mode 100644 src/main/java/com/example/service/DoctorService.java create mode 100644 src/main/java/com/example/service/PatientService.java create mode 100644 src/main/java/com/example/service/RecommendationService.java create mode 100644 src/main/java/com/example/service/ResourceCategoryService.java create mode 100644 src/main/java/com/example/service/ResourceRatingService.java create mode 100644 src/main/java/com/example/service/SymptomRecordService.java create mode 100644 src/main/java/com/example/service/TreatmentResourceService.java create mode 100644 src/main/java/com/example/websocket/ChatWebSocket.java create mode 100644 src/main/resources/application.yml create mode 100644 src/main/resources/mapper/AdminMapper.xml create mode 100644 src/main/resources/mapper/DoctorMapper.xml create mode 100644 src/main/resources/mapper/DoctorPatientMapper.xml create mode 100644 src/main/resources/mapper/PatientMapper.xml create mode 100644 src/main/resources/mapper/SymptomRecordMapper.xml create mode 100644 vue/.env.development create mode 100644 vue/.env.production create mode 100644 vue/.gitignore create mode 100644 vue/index.html create mode 100644 vue/jsconfig.json create mode 100644 vue/package-lock.json create mode 100644 vue/package.json create mode 100644 vue/src/App.vue create mode 100644 vue/src/assets/css/global.css create mode 100644 vue/src/assets/css/index.scss create mode 100644 vue/src/assets/css/manager.css create mode 100644 vue/src/assets/fonts/FontAwesome.otf create mode 100644 vue/src/assets/fonts/font-awesome.css create mode 100644 vue/src/assets/fonts/fontawesome-webfont.eot create mode 100644 vue/src/assets/fonts/fontawesome-webfont.svg create mode 100644 vue/src/assets/fonts/fontawesome-webfont.ttf create mode 100644 vue/src/assets/fonts/fontawesome-webfont.woff create mode 100644 vue/src/assets/fonts/fontawesome-webfont.woff2 create mode 100644 vue/src/assets/imgs/404.jpg create mode 100644 vue/src/assets/imgs/VCG41N1408837996.jpg create mode 100644 vue/src/assets/imgs/avatar.png create mode 100644 vue/src/assets/imgs/login.svg create mode 100644 vue/src/assets/imgs/logo.png create mode 100644 vue/src/assets/imgs/register.svg create mode 100644 vue/src/assets/logo.png create mode 100644 vue/src/main.js create mode 100644 vue/src/router/index.js create mode 100644 vue/src/utils/request.js create mode 100644 vue/src/views/404.vue create mode 100644 vue/src/views/Login.vue create mode 100644 vue/src/views/Manager.vue create mode 100644 vue/src/views/Register.vue create mode 100644 vue/src/views/manager/AIChat.vue create mode 100644 vue/src/views/manager/Admin.vue create mode 100644 vue/src/views/manager/Announcement.vue create mode 100644 vue/src/views/manager/AnnouncementList.vue create mode 100644 vue/src/views/manager/AssessmentReports.vue create mode 100644 vue/src/views/manager/Chat.vue create mode 100644 vue/src/views/manager/Doctor.vue create mode 100644 vue/src/views/manager/GenerateReport.vue create mode 100644 vue/src/views/manager/Home.vue create mode 100644 vue/src/views/manager/MyReports.vue create mode 100644 vue/src/views/manager/MyResources.vue create mode 100644 vue/src/views/manager/Password.vue create mode 100644 vue/src/views/manager/Patient.vue create mode 100644 vue/src/views/manager/PatientReports.vue create mode 100644 vue/src/views/manager/ReportDetail.vue create mode 100644 vue/src/views/manager/ResourceCategory.vue create mode 100644 vue/src/views/manager/ResourceRecommendation.vue create mode 100644 vue/src/views/manager/SymptomRecord.vue create mode 100644 vue/src/views/manager/SymptomStatistics.vue create mode 100644 vue/src/views/manager/TreatmentResource.vue create mode 100644 vue/src/views/manager/User.vue create mode 100644 vue/src/views/manager/pAdmin.vue create mode 100644 vue/src/views/manager/pDoctor.vue create mode 100644 vue/src/views/manager/pPatient.vue create mode 100644 vue/vite.config.js diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..bf068a3 --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +target/ +.idea/ +springboot.iml + +file/ diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..846a7dd --- /dev/null +++ b/pom.xml @@ -0,0 +1,90 @@ + + + 4.0.0 + + org.springframework.boot + spring-boot-starter-parent + 3.2.0 + + + com.example + springboot + 0.0.1-SNAPSHOT + + + UTF-8 + UTF-8 + 21 + + + + + org.springframework.boot + spring-boot-starter-web + + + + + com.mysql + mysql-connector-j + + + + com.baomidou + mybatis-plus-spring-boot3-starter + 3.5.5 + + + + org.projectlombok + lombok + + + + com.github.pagehelper + pagehelper-spring-boot-starter + 1.4.6 + + + org.mybatis + mybatis + + + + + + cn.hutool + hutool-all + 5.8.18 + + + + com.auth0 + java-jwt + 4.3.0 + + + + org.apache.poi + poi-ooxml + 4.1.2 + + + + org.springframework.boot + spring-boot-starter-websocket + + + + + + + org.springframework.boot + spring-boot-maven-plugin + + + + + \ No newline at end of file diff --git a/src/main/java/com/example/SpringbootApplication.java b/src/main/java/com/example/SpringbootApplication.java new file mode 100644 index 0000000..dc8a215 --- /dev/null +++ b/src/main/java/com/example/SpringbootApplication.java @@ -0,0 +1,18 @@ +package com.example; + + +import org.mybatis.spring.annotation.MapperScan; +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.scheduling.annotation.EnableScheduling; + +@SpringBootApplication +@MapperScan("com.example.mapper") +@EnableScheduling +public class SpringbootApplication { + + public static void main(String[] args) { + SpringApplication.run(SpringbootApplication.class, args); + } + +} diff --git a/src/main/java/com/example/common/Constants.java b/src/main/java/com/example/common/Constants.java new file mode 100644 index 0000000..2c2b1af --- /dev/null +++ b/src/main/java/com/example/common/Constants.java @@ -0,0 +1,9 @@ +package com.example.common; + +public interface Constants { + + String TOKEN = "token"; + + String USER_DEFAULT_PASSWORD = "123456"; + +} diff --git a/src/main/java/com/example/common/Result.java b/src/main/java/com/example/common/Result.java new file mode 100644 index 0000000..ac82767 --- /dev/null +++ b/src/main/java/com/example/common/Result.java @@ -0,0 +1,72 @@ +package com.example.common; + +public class Result { + private String code; + private String msg; + private Object data; + + private Result(Object data) { + this.data = data; + } + + public Result() { + } + + public static Result success() { + Result result = new Result(); + result.setCode("200"); + result.setMsg("请求成功"); + return result; + } + + public static Result success(Object data) { + Result result = success(); + result.setData(data); + return result; + } + + public static Result error() { + Result result = new Result(); + result.setCode("500"); + result.setMsg("请求失败"); + return result; + } + + public static Result error(String code, String msg) { + Result result = new Result(); + result.setCode(code); + result.setMsg(msg); + return result; + } + + public static Result error(String msg) { + Result result = new Result(); + result.setCode("500"); + result.setMsg(msg); + return result; + } + + public String getCode() { + return code; + } + + public void setCode(String code) { + this.code = code; + } + + public String getMsg() { + return msg; + } + + public void setMsg(String msg) { + this.msg = msg; + } + + public Object getData() { + return data; + } + + public void setData(Object data) { + this.data = data; + } +} diff --git a/src/main/java/com/example/common/config/CorsConfig.java b/src/main/java/com/example/common/config/CorsConfig.java new file mode 100644 index 0000000..9be21e6 --- /dev/null +++ b/src/main/java/com/example/common/config/CorsConfig.java @@ -0,0 +1,25 @@ +package com.example.common.config; + +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.web.cors.CorsConfiguration; +import org.springframework.web.cors.UrlBasedCorsConfigurationSource; +import org.springframework.web.filter.CorsFilter; + +/** + * 跨域配置 + */ +@Configuration +public class CorsConfig { + + @Bean + public CorsFilter corsFilter() { + UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource(); + CorsConfiguration corsConfiguration = new CorsConfiguration(); + corsConfiguration.addAllowedOrigin("*"); // 1 设置访问源地址 + corsConfiguration.addAllowedHeader("*"); // 2 设置访问源请求头 + corsConfiguration.addAllowedMethod("*"); // 3 设置访问源请求方法 + source.registerCorsConfiguration("/**", corsConfiguration); // 4 对接口配置跨域设置 + return new CorsFilter(source); + } +} \ No newline at end of file diff --git a/src/main/java/com/example/common/config/JwtInterceptor.java b/src/main/java/com/example/common/config/JwtInterceptor.java new file mode 100644 index 0000000..6e7d347 --- /dev/null +++ b/src/main/java/com/example/common/config/JwtInterceptor.java @@ -0,0 +1,82 @@ +package com.example.common.config; + +import cn.hutool.core.util.ObjectUtil; +import com.auth0.jwt.JWT; +import com.auth0.jwt.JWTVerifier; +import com.auth0.jwt.algorithms.Algorithm; +import com.auth0.jwt.exceptions.JWTVerificationException; +import com.example.common.Constants; +import com.example.common.enums.ResultCodeEnum; +import com.example.entity.*; +import com.example.exception.CustomException; +import com.example.service.*; +import jakarta.annotation.Resource; +import jakarta.servlet.http.HttpServletRequest; +import jakarta.servlet.http.HttpServletResponse; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.stereotype.Component; +import org.springframework.web.servlet.HandlerInterceptor; + +/** + * jwt拦截器 + */ +@Component +public class JwtInterceptor implements HandlerInterceptor { + + private static final Logger log = LoggerFactory.getLogger(JwtInterceptor.class); + + @Resource + private AdminService adminService; + @Resource + private DoctorService doctorService; + @Resource + private PatientService patientService; + + + @Override + public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) { + // 1. 从http请求的header中获取token + String token = request.getHeader(Constants.TOKEN); + if (ObjectUtil.isEmpty(token)) { + // 如果没拿到，从参数里再拿一次 + token = request.getParameter(Constants.TOKEN); + } + // 2. 开始执行认证 + if (ObjectUtil.isEmpty(token)) { + throw new CustomException(ResultCodeEnum.TOKEN_INVALID_ERROR); + } + Account account = null; + try { + // 解析token获取存储的数据 + String userRole = JWT.decode(token).getAudience().get(0); + String userId = userRole.split("-")[0]; + String role = userRole.split("-")[1]; + // 根据userId查询数据库 + if ("admin".equals(role)) { + account = adminService.selectById(Integer.valueOf(userId)); + } + if ("doctor".equals(role)) { + account = doctorService.selectById(Integer.valueOf(userId)); + } + if ("patient".equals(role)) { + account = patientService.selectById(Integer.valueOf(userId)); + } + + + } catch (Exception e) { + throw new CustomException(ResultCodeEnum.TOKEN_CHECK_ERROR); + } + if (ObjectUtil.isNull(account)) { + throw new CustomException(ResultCodeEnum.USER_NOT_EXIST_ERROR); + } + try { + // 用户密码加签验证 token + JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256(account.getPassword())).build(); + jwtVerifier.verify(token); // 验证token + } catch (JWTVerificationException e) { + throw new CustomException(ResultCodeEnum.TOKEN_CHECK_ERROR); + } + return true; + } +} \ No newline at end of file diff --git a/src/main/java/com/example/common/config/TokenUtils.java b/src/main/java/com/example/common/config/TokenUtils.java new file mode 100644 index 0000000..fbe82e9 --- /dev/null +++ b/src/main/java/com/example/common/config/TokenUtils.java @@ -0,0 +1,88 @@ +package com.example.common.config; + +import cn.hutool.core.date.DateUtil; +import cn.hutool.core.util.StrUtil; +import com.auth0.jwt.JWT; +import com.auth0.jwt.algorithms.Algorithm; +import com.example.entity.Account; +import com.example.service.*; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.stereotype.Component; +import org.springframework.web.context.request.RequestContextHolder; +import org.springframework.web.context.request.ServletRequestAttributes; + +import jakarta.annotation.PostConstruct; +import jakarta.annotation.Resource; +import jakarta.servlet.http.HttpServletRequest; +import java.util.Date; + +@Component +public class TokenUtils { + + private static AdminService staticAdminService; + private static DoctorService staticDoctorService; + private static PatientService staticPatientService; + + private static final Logger log = LoggerFactory.getLogger(TokenUtils.class); + + @Resource + private AdminService adminService; + @Resource + private DoctorService doctorService; + @Resource + private PatientService patientService; + + @PostConstruct + public void setUserService() { + staticAdminService = adminService; + staticDoctorService = doctorService; + staticPatientService = patientService; + } + + /** + * 生成token + */ + public static String genToken(String userRole, String password) { + return JWT.create().withAudience(userRole) // 将 userId-role 保存到 token 里面,作为载荷 + .withExpiresAt(DateUtil.offsetHour(new Date(), 2)) // 2小时后token过期 + .sign(Algorithm.HMAC256(password)); // 以 password 作为 token 的密钥 + } + + /** + * 获取当前登录的用户信息 + */ + public static Account getCurrentUser() { + String token = null; + try { + HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest(); + token = request.getHeader("token"); + if (StrUtil.isBlank(token)) { + token = request.getParameter("token"); + } + if (StrUtil.isBlank(token)) { + log.error("获取当前登录的token失败， token: {}", token); + return null; + } + // 解析token，获取用户的id + String userRole = JWT.decode(token).getAudience().get(0); + String userId = userRole.split("-")[0]; + String role = userRole.split("-")[1]; + Account account = null; + if ("admin".equals(role)) { + account = staticAdminService.selectById(Integer.valueOf(userId)); + } + if ("doctor".equals(role)) { + account = staticDoctorService.selectById(Integer.valueOf(userId)); + } + if ("patient".equals(role)) { + account = staticPatientService.selectById(Integer.valueOf(userId)); + } + + return account; + } catch (Exception e) { + log.error("获取当前登录的管理员信息失败, token={}", token, e); + return null; + } + } +} \ No newline at end of file diff --git a/src/main/java/com/example/common/config/WebConfig.java b/src/main/java/com/example/common/config/WebConfig.java new file mode 100644 index 0000000..5a0627b --- /dev/null +++ b/src/main/java/com/example/common/config/WebConfig.java @@ -0,0 +1,24 @@ +package com.example.common.config; + +import jakarta.annotation.Resource; +import org.springframework.context.annotation.Configuration; +import org.springframework.web.servlet.config.annotation.InterceptorRegistry; +import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; + +@Configuration +public class WebConfig implements WebMvcConfigurer { + + @Resource + private JwtInterceptor jwtInterceptor; + + // 加自定义拦截器JwtInterceptor，设置拦截规则 + @Override + public void addInterceptors(InterceptorRegistry registry) { + registry.addInterceptor(jwtInterceptor).addPathPatterns("/**") + .excludePathPatterns("/") + .excludePathPatterns("/login", "/register", "/files/**", "/role/selectAll","/institution/selectAll") + .excludePathPatterns("/doctor") // 放行医生列表获取接口，用于患者注册时选择医生 + .excludePathPatterns("/ws/**", "/notification/**") // 放行WebSocket和通知相关的路径 + .excludePathPatterns("/eventInstitution/checkAndUpdateEventStatus"); // 放行事件状态检查接口 + } +} \ No newline at end of file diff --git a/src/main/java/com/example/common/enums/ResultCodeEnum.java b/src/main/java/com/example/common/enums/ResultCodeEnum.java new file mode 100644 index 0000000..56a803f --- /dev/null +++ b/src/main/java/com/example/common/enums/ResultCodeEnum.java @@ -0,0 +1,27 @@ +package com.example.common.enums; + +public enum ResultCodeEnum { + SUCCESS("200", "成功"), + + PARAM_ERROR("400", "参数异常"), + TOKEN_INVALID_ERROR("401", "无效的token"), + TOKEN_CHECK_ERROR("401", "token验证失败，请重新登录"), + PARAM_LOST_ERROR("4001", "参数缺失"), + NO_AUTH_ERROR("403", "没有操作权限"), + + SYSTEM_ERROR("500", "系统异常"), + USER_EXIST_ERROR("5001", "用户名已存在"), + USER_NOT_LOGIN("5002", "用户未登录"), + USER_ACCOUNT_ERROR("5003", "账号或密码错误"), + USER_NOT_EXIST_ERROR("5004", "用户不存在"), + PARAM_PASSWORD_ERROR("5005", "原密码输入错误"), + ; + + public String code; + public String msg; + + ResultCodeEnum(String code, String msg) { + this.code = code; + this.msg = msg; + } +} diff --git a/src/main/java/com/example/config/RestTemplateConfig.java b/src/main/java/com/example/config/RestTemplateConfig.java new file mode 100644 index 0000000..88e398a --- /dev/null +++ b/src/main/java/com/example/config/RestTemplateConfig.java @@ -0,0 +1,14 @@ +package com.example.config; + +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.web.client.RestTemplate; + +@Configuration +public class RestTemplateConfig { + + @Bean + public RestTemplate restTemplate() { + return new RestTemplate(); + } +} \ No newline at end of file diff --git a/src/main/java/com/example/config/WebSocketConfig.java b/src/main/java/com/example/config/WebSocketConfig.java new file mode 100644 index 0000000..8c55302 --- /dev/null +++ b/src/main/java/com/example/config/WebSocketConfig.java @@ -0,0 +1,20 @@ +package com.example.config; + +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.web.socket.server.standard.ServerEndpointExporter; + +/** + * WebSocket配置类 + */ +@Configuration +public class WebSocketConfig { + + /** + * 注入ServerEndpointExporter，自动注册使用了@ServerEndpoint注解的bean + */ + @Bean + public ServerEndpointExporter serverEndpointExporter() { + return new ServerEndpointExporter(); + } +} \ No newline at end of file diff --git a/src/main/java/com/example/controller/AIChatController.java b/src/main/java/com/example/controller/AIChatController.java new file mode 100644 index 0000000..40a4a4d --- /dev/null +++ b/src/main/java/com/example/controller/AIChatController.java @@ -0,0 +1,56 @@ +package com.example.controller; + +import com.example.common.Result; +import com.example.common.config.TokenUtils; +import com.example.entity.Account; +import com.example.service.AIChatService; +import jakarta.annotation.Resource; +import org.springframework.web.bind.annotation.*; + +import java.time.LocalDateTime; +import java.util.HashMap; +import java.util.Map; + +/** + * AI聊天控制器 + */ +@RestController +@RequestMapping("/aiChat") +public class AIChatController { + + @Resource + private AIChatService aiChatService; + + /** + * 发送消息到AI并获取回复 + */ + @PostMapping("/sendMessage") + public Result sendMessage(@RequestBody Map params) { + String message = params.get("message"); + + // 获取当前登录用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + return Result.error("401", "请先登录"); + } + + // 获取AI回复 + String aiReply = aiChatService.sendMessage(message); + + Map userMessage = new HashMap<>(); + userMessage.put("content", message); + userMessage.put("messageType", "user"); + userMessage.put("createTime", LocalDateTime.now()); + + Map aiMessage = new HashMap<>(); + aiMessage.put("content", aiReply); + aiMessage.put("messageType", "ai"); + aiMessage.put("createTime", LocalDateTime.now()); + + Map resultMap = new HashMap<>(); + resultMap.put("userMessage", userMessage); + resultMap.put("aiMessage", aiMessage); + + return Result.success(resultMap); + } +} \ No newline at end of file diff --git a/src/main/java/com/example/controller/AccountController.java b/src/main/java/com/example/controller/AccountController.java new file mode 100644 index 0000000..b2865d0 --- /dev/null +++ b/src/main/java/com/example/controller/AccountController.java @@ -0,0 +1,48 @@ +package com.example.controller; + +import com.example.common.Result; +import com.example.common.config.TokenUtils; +import com.example.entity.Account; +import com.example.entity.Patient; +import com.example.service.PatientService; +import jakarta.annotation.Resource; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestParam; +import org.springframework.web.bind.annotation.RestController; + +import java.util.List; + +/** + * 账号相关接口 + */ +@RestController +@RequestMapping("/account") +public class AccountController { + + @Resource + private PatientService patientService; + + /** + * 获取所有患者列表（仅管理员可用） + * + * @param name 可选的患者姓名过滤 + * @return 患者列表 + */ + @GetMapping("/listPatients") + public Result listPatients(@RequestParam(required = false) String name) { + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null || !"admin".equals(currentUser.getRole())) { + return Result.error("401", "无权限，只有管理员可以访问此接口"); + } + + Patient searchParam = null; + if (name != null && !name.isEmpty()) { + searchParam = new Patient(); + searchParam.setName(name); + } + + List patients = patientService.selectAll(searchParam); + return Result.success(patients); + } +} \ No newline at end of file diff --git a/src/main/java/com/example/controller/AdminController.java b/src/main/java/com/example/controller/AdminController.java new file mode 100644 index 0000000..2ef7f62 --- /dev/null +++ b/src/main/java/com/example/controller/AdminController.java @@ -0,0 +1,93 @@ +package com.example.controller; + +import com.example.common.Result; +import com.example.entity.Admin; +import com.example.service.AdminService; +import com.github.pagehelper.PageInfo; +import jakarta.annotation.Resource; +import org.springframework.web.bind.annotation.*; + +import java.util.List; + +/** +* 描述：管理员相关接口 +*/ +@RestController +@RequestMapping("/admin") +public class AdminController { + + @Resource + AdminService adminService; + + /** + * 新增 + */ + @PostMapping("/add") + public Result add(@RequestBody Admin admin) { + + adminService.add(admin); + return Result.success(); + } + + /** + * 删除 + */ + @DeleteMapping("/delete/{id}") + public Result delete(@PathVariable Integer id) { + adminService.deleteById(id); + return Result.success(); + } + + /** + * 批量删除 + */ + @DeleteMapping("/delete/batch") + public Result delete(@RequestBody List ids) { + adminService.deleteBatch(ids); + return Result.success(); + } + + /** + * 更新 + */ + @PutMapping("/update") + public Result update(@RequestBody Admin admin) { + + adminService.updateById(admin); + return Result.success(); + } + + /** + * 查询单个 + */ + @GetMapping("/selectById/{id}") + public Result selectById(@PathVariable Integer id) { + Admin admin = adminService.selectById(id); + return Result.success(admin); + } + + /** + * 查询所有 + */ + @GetMapping("/selectAll") + public Result selectAll(Admin admin) { + List list = adminService.selectAll(admin); + return Result.success(list); + } + + /** + * 查询所有 + */ + @GetMapping("/selectPage") + public Result selectPage( + Admin admin, + @RequestParam(defaultValue = "1") Integer pageNum, + @RequestParam(defaultValue = "10") Integer pageSize) { + PageInfo pageInfo = adminService.selectPage(admin, pageNum, pageSize); + return Result.success(pageInfo); + } + + + + +} diff --git a/src/main/java/com/example/controller/AnnouncementController.java b/src/main/java/com/example/controller/AnnouncementController.java new file mode 100644 index 0000000..fcc84e7 --- /dev/null +++ b/src/main/java/com/example/controller/AnnouncementController.java @@ -0,0 +1,109 @@ +package com.example.controller; + +import com.example.common.Result; +import com.example.entity.Announcement; +import com.example.service.AnnouncementService; +import com.github.pagehelper.PageInfo; +import jakarta.annotation.Resource; +import org.springframework.web.bind.annotation.*; + +import java.util.List; + +/** + * 公告控制器 + */ +@RestController +@RequestMapping("/announcement") +public class AnnouncementController { + + @Resource + private AnnouncementService announcementService; + + /** + * 添加公告 + * @param announcement 公告信息 + * @return 结果 + */ + @PostMapping + public Result add(@RequestBody Announcement announcement) { + announcementService.add(announcement); + return Result.success(); + } + + /** + * 更新公告 + * @param announcement 公告信息 + * @return 结果 + */ + @PutMapping + public Result update(@RequestBody Announcement announcement) { + announcementService.update(announcement); + return Result.success(); + } + + /** + * 删除公告 + * @param id 公告ID + * @return 结果 + */ + @DeleteMapping("/{id}") + public Result delete(@PathVariable Integer id) { + announcementService.delete(id); + return Result.success(); + } + + /** + * 获取公告详情 + * @param id 公告ID + * @return 公告信息 + */ + @GetMapping("/{id}") + public Result getById(@PathVariable Integer id) { + Announcement announcement = announcementService.getById(id); + return Result.success(announcement); + } + + /** + * 获取所有已发布的公告（分页，所有用户可访问） + * @param pageNum 页码 + * @param pageSize 每页大小 + * @param title 标题关键字 + * @return 分页公告列表 + */ + @GetMapping("/page") + public Result getPublishedPage( + @RequestParam(defaultValue = "1") Integer pageNum, + @RequestParam(defaultValue = "10") Integer pageSize, + @RequestParam(required = false) String title) { + PageInfo pageInfo = announcementService.getPublishedPage(pageNum, pageSize, title); + return Result.success(pageInfo); + } + + /** + * 获取所有公告（分页，包括草稿，仅管理员可用） + * @param pageNum 页码 + * @param pageSize 每页大小 + * @param title 标题关键字 + * @return 分页公告列表 + */ + @GetMapping("/adminPage") + public Result getAllForAdmin( + @RequestParam(defaultValue = "1") Integer pageNum, + @RequestParam(defaultValue = "10") Integer pageSize, + @RequestParam(required = false) String title) { + PageInfo pageInfo = announcementService.getAllForAdmin(pageNum, pageSize, title); + return Result.success(pageInfo); + } + + /** + * 获取最新的几条已发布公告（用于首页展示） + * @param limit 限制条数 + * @return 公告列表 + */ + @GetMapping("/latest") + public Result getLatestPublished( + @RequestParam(defaultValue = "5") Integer limit) { + List list = announcementService.getLatestPublished(limit); + return Result.success(list); + } +} \ No newline at end of file diff --git a/src/main/java/com/example/controller/AssessmentReportController.java b/src/main/java/com/example/controller/AssessmentReportController.java new file mode 100644 index 0000000..8abaeb4 --- /dev/null +++ b/src/main/java/com/example/controller/AssessmentReportController.java @@ -0,0 +1,116 @@ +package com.example.controller; + +import com.example.common.Result; +import com.example.common.config.TokenUtils; +import com.example.entity.Account; +import com.example.entity.AssessmentReport; +import com.example.service.AssessmentReportService; +import jakarta.annotation.Resource; +import org.springframework.web.bind.annotation.*; + +import java.util.List; +import java.util.Map; + +/** + * 评估报告控制器 + */ +@RestController +@RequestMapping("/assessmentReport") +public class AssessmentReportController { + + @Resource + private AssessmentReportService assessmentReportService; + + /** + * 手动生成评估报告 + */ + @PostMapping("/generate") + public Result generate(@RequestBody Map params) { + Integer patientId = params.get("patientId") != null ? Integer.valueOf(params.get("patientId").toString()) : null; + String reportPeriod = params.get("reportPeriod") != null ? params.get("reportPeriod").toString() : null; + + if (patientId == null) { + return Result.error("400", "缺少必要参数patientId"); + } + if (reportPeriod == null) { + return Result.error("400", "缺少必要参数reportPeriod"); + } + + AssessmentReport report = assessmentReportService.generateReport(patientId, reportPeriod); + return Result.success(report); + } + + /** + * 获取患者的评估报告列表 + */ + @GetMapping("/patient/{patientId}") + public Result getReportsByPatientId(@PathVariable Integer patientId) { + List reports = assessmentReportService.getReportsByPatientId(patientId); + return Result.success(reports); + } + + /** + * 获取医生负责的患者的评估报告列表 + */ + @GetMapping("/doctor") + public Result getReportsByDoctor() { + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + return Result.error("401", "未登录"); + } + + List reports = assessmentReportService.getReportsByDoctorId(currentUser.getId()); + return Result.success(reports); + } + + /** + * 获取所有评估报告列表（管理员使用） + */ + @GetMapping("/admin") + public Result getAllReports() { + List reports = assessmentReportService.getAllReports(); + return Result.success(reports); + } + + /** + * 添加医生批注 + */ + @PutMapping("/comment/{reportId}") + public Result addComment(@PathVariable Integer reportId, @RequestParam(required = false) String comment) { + if (comment == null || comment.isEmpty()) { + return Result.error("400", "评论内容不能为空"); + } + assessmentReportService.addDoctorComment(reportId, comment); + return Result.success(); + } + + /** + * 更新报告状态为已读 + */ + @PutMapping("/read/{reportId}") + public Result markAsRead(@PathVariable Integer reportId) { + assessmentReportService.markAsRead(reportId); + return Result.success(); + } + + /** + * 获取评估报告详情 + */ + @GetMapping("/{reportId}") + public Result getReportById(@PathVariable Integer reportId) { + // 获取当前用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + return Result.error("401", "未登录"); + } + + // 通过ID获取报告 + AssessmentReport report = assessmentReportService.getReportById(reportId); + + if (report == null) { + return Result.error("404", "报告不存在"); + } + + return Result.success(report); + } +} \ No newline at end of file diff --git a/src/main/java/com/example/controller/ChatMessageController.java b/src/main/java/com/example/controller/ChatMessageController.java new file mode 100644 index 0000000..9327ff7 --- /dev/null +++ b/src/main/java/com/example/controller/ChatMessageController.java @@ -0,0 +1,48 @@ +package com.example.controller; + +import com.example.common.Result; +import com.example.entity.ChatMessage; +import com.example.service.ChatMessageService; +import jakarta.annotation.Resource; +import org.springframework.web.bind.annotation.*; + +import java.util.List; +import java.util.Map; + +/** + * 聊天消息控制器 + */ +@RestController +@RequestMapping("/chat") +public class ChatMessageController { + + @Resource + private ChatMessageService chatMessageService; + + /** + * 发送消息 + */ + @PostMapping("/send") + public Result send(@RequestBody ChatMessage chatMessage) { + ChatMessage message = chatMessageService.sendMessage(chatMessage); + return Result.success(message); + } + + /** + * 获取聊天历史记录 + */ + @GetMapping("/history") + public Result getChatHistory(@RequestParam Integer contactId, @RequestParam String contactType) { + List messages = chatMessageService.getChatHistory(contactId, contactType); + return Result.success(messages); + } + + /** + * 获取聊天联系人列表 + */ + @GetMapping("/contacts") + public Result getContactList() { + List> contacts = chatMessageService.getContactList(); + return Result.success(contacts); + } +} \ No newline at end of file diff --git a/src/main/java/com/example/controller/DoctorController.java b/src/main/java/com/example/controller/DoctorController.java new file mode 100644 index 0000000..0fc8556 --- /dev/null +++ b/src/main/java/com/example/controller/DoctorController.java @@ -0,0 +1,147 @@ +package com.example.controller; + +import com.example.common.Result; +import com.example.common.config.TokenUtils; +import com.example.entity.Account; +import com.example.entity.Doctor; +import com.example.entity.DoctorPatient; +import com.example.service.DoctorPatientService; +import com.example.service.DoctorService; +import com.github.pagehelper.PageInfo; +import jakarta.annotation.Resource; +import org.springframework.web.bind.annotation.*; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * 医生相关接口 + */ +@RestController +@RequestMapping("/doctor") +public class DoctorController { + + @Resource + private DoctorService doctorService; + + @Resource + private DoctorPatientService doctorPatientService; + + /** + * 添加医生 + */ + @PostMapping + public Result add(@RequestBody Doctor doctor) { + doctorService.add(doctor); + return Result.success(); + } + + /** + * 删除医生 + */ + @DeleteMapping("/{id}") + public Result delete(@PathVariable Integer id) { + doctorService.deleteById(id); + return Result.success(); + } + + /** + * 批量删除医生 + */ + @DeleteMapping("/batch") + public Result deleteBatch(@RequestBody List ids) { + doctorService.deleteBatch(ids); + return Result.success(); + } + + /** + * 修改医生 + */ + @PutMapping + public Result update(@RequestBody Doctor doctor) { + doctorService.updateById(doctor); + return Result.success(); + } + + /** + * 根据ID查询医生 + */ + @GetMapping("/{id}") + public Result getById(@PathVariable Integer id) { + Doctor doctor = doctorService.selectById(id); + return Result.success(doctor); + } + + /** + * 查询所有医生 + */ + @GetMapping + public Result getAll(Doctor doctor) { + List list = doctorService.selectAll(doctor); + return Result.success(list); + } + + /** + * 分页查询医生 + */ + @GetMapping("/page") + public Result page(Doctor doctor, + @RequestParam(defaultValue = "1") Integer pageNum, + @RequestParam(defaultValue = "10") Integer pageSize) { + PageInfo page = doctorService.selectPage(doctor, pageNum, pageSize); + return Result.success(page); + } + + /** + * 分页查询医生（与Admin页面保持一致的接口） + */ + @GetMapping("/selectPage") + public Result selectPage( + Doctor doctor, + @RequestParam(defaultValue = "1") Integer pageNum, + @RequestParam(defaultValue = "10") Integer pageSize) { + PageInfo pageInfo = doctorService.selectPage(doctor, pageNum, pageSize); + return Result.success(pageInfo); + } + + /** + * 获取当前医生负责的患者列表 + * 此接口是为了兼容之前的路径 + * @param name 患者姓名（可选） + * @return 患者列表 + */ + @GetMapping("/myPatients") + public Result myPatients(@RequestParam(required = false) String name) { + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null || !"doctor".equals(currentUser.getRole())) { + return Result.error("401", "无权限"); + } + + List list = doctorPatientService.selectByDoctorId(currentUser.getId(), name); + return Result.success(list); + } + + /** + * 更新医生个人资料 + */ + @PutMapping("/update") + public Result updateProfile(@RequestBody Doctor doctor) { + // 获取当前登录用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null || !"doctor".equals(currentUser.getRole())) { + return Result.error("401", "无权限"); + } + + // 确保只能更新自己的信息 + if (!currentUser.getId().equals(doctor.getId())) { + return Result.error("403", "只能更新自己的信息"); + } + + // 更新个人资料 + doctorService.updateById(doctor); + + return Result.success(); + } +} \ No newline at end of file diff --git a/src/main/java/com/example/controller/DoctorPatientController.java b/src/main/java/com/example/controller/DoctorPatientController.java new file mode 100644 index 0000000..61bea65 --- /dev/null +++ b/src/main/java/com/example/controller/DoctorPatientController.java @@ -0,0 +1,137 @@ +package com.example.controller; + +import com.example.common.Result; +import com.example.common.config.TokenUtils; +import com.example.entity.Account; +import com.example.entity.DoctorPatient; +import com.example.entity.Patient; +import com.example.service.DoctorPatientService; +import com.example.service.PatientService; +import jakarta.annotation.Resource; +import org.springframework.web.bind.annotation.*; + +import java.util.List; + +/** + * 医生与患者关系控制器 + */ +@RestController +@RequestMapping("/doctor-patient") +public class DoctorPatientController { + + @Resource + private DoctorPatientService doctorPatientService; + + @Resource + private PatientService patientService; + + /** + * 新增医生患者关系 + * @param doctorPatient 医生患者关系信息 + * @return 结果 + */ + @PostMapping + public Result add(@RequestBody DoctorPatient doctorPatient) { + doctorPatientService.add(doctorPatient); + return Result.success(); + } + + /** + * 更新医生患者关系 + * @param doctorPatient 医生患者关系信息 + * @return 结果 + */ + @PutMapping + public Result update(@RequestBody DoctorPatient doctorPatient) { + doctorPatientService.update(doctorPatient); + return Result.success(); + } + + /** + * 删除医生患者关系 + * @param id 关系ID + * @return 结果 + */ + @DeleteMapping("/{id}") + public Result delete(@PathVariable Integer id) { + doctorPatientService.delete(id); + return Result.success(); + } + + /** + * 结束医生患者关系 + * @param id 关系ID + * @return 结果 + */ + @PutMapping("/end/{id}") + public Result endRelationship(@PathVariable Integer id) { + doctorPatientService.endRelationship(id); + return Result.success(); + } + + /** + * 获取当前医生的患者列表 + * @param name 患者姓名（可选） + * @return 患者列表 + */ + @GetMapping("/doctor/patients") + public Result getPatientsByDoctor(@RequestParam(required = false) String name) { + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null || !"doctor".equals(currentUser.getRole())) { + return Result.error("401", "无权限"); + } + + List list = doctorPatientService.selectByDoctorId(currentUser.getId(), name); + return Result.success(list); + } + + /** + * 获取当前患者的医生列表 + * @param name 医生姓名（可选） + * @return 医生列表 + */ + @GetMapping("/patient/doctors") + public Result getDoctorsByPatient(@RequestParam(required = false) String name) { + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null || !"patient".equals(currentUser.getRole())) { + return Result.error("401", "无权限"); + } + + List list = doctorPatientService.selectByPatientId(currentUser.getId(), name); + return Result.success(list); + } + + /** + * 根据医生ID获取其患者列表（管理员使用） + * @param doctorId 医生ID + * @param name 患者姓名（可选） + * @return 患者列表 + */ + @GetMapping("/admin/doctor/{doctorId}/patients") + public Result getPatientsByDoctorForAdmin(@PathVariable Integer doctorId, @RequestParam(required = false) String name) { + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null || !"admin".equals(currentUser.getRole())) { + return Result.error("401", "无权限"); + } + + List list = doctorPatientService.selectByDoctorId(doctorId, name); + return Result.success(list); + } + + /** + * 根据患者ID获取其医生列表（管理员使用） + * @param patientId 患者ID + * @param name 医生姓名（可选） + * @return 医生列表 + */ + @GetMapping("/admin/patient/{patientId}/doctors") + public Result getDoctorsByPatientForAdmin(@PathVariable Integer patientId, @RequestParam(required = false) String name) { + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null || !"admin".equals(currentUser.getRole())) { + return Result.error("401", "无权限"); + } + + List list = doctorPatientService.selectByPatientId(patientId, name); + return Result.success(list); + } +} \ No newline at end of file diff --git a/src/main/java/com/example/controller/FileController.java b/src/main/java/com/example/controller/FileController.java new file mode 100644 index 0000000..89a1658 --- /dev/null +++ b/src/main/java/com/example/controller/FileController.java @@ -0,0 +1,102 @@ +package com.example.controller; + +import cn.hutool.core.collection.CollUtil; +import cn.hutool.core.io.FileUtil; +import cn.hutool.core.io.resource.ResourceUtil; +import cn.hutool.core.lang.Dict; +import cn.hutool.core.util.StrUtil; +import com.example.common.Result; +import org.springframework.util.ResourceUtils; +import org.springframework.web.bind.annotation.*; +import org.springframework.web.multipart.MultipartFile; + +import jakarta.servlet.http.HttpServletResponse; +import java.io.FileNotFoundException; +import java.io.OutputStream; +import java.net.URLEncoder; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * 文件上传接口 + */ +@RestController +@RequestMapping("/files") +public class FileController { + + // 文件上传存储路径 + private static final String filePath = System.getProperty("user.dir") + "/file/"; + private static final String http = "http://localhost:9090/files/"; + + /** + * 文件上传 + */ + @PostMapping("/upload") + public Result upload(MultipartFile file) { + synchronized (FileController.class) { + String flag = System.currentTimeMillis() + ""; + String fileName = file.getOriginalFilename(); + try { + if (!FileUtil.isDirectory(filePath)) { + FileUtil.mkdir(filePath); + } + // 文件存储形式：时间戳-文件名 + FileUtil.writeBytes(file.getBytes(), filePath + flag + "-" + fileName); + System.out.println(fileName + "--上传成功"); + Thread.sleep(1L); + } catch (Exception e) { + System.err.println(fileName + "--文件上传失败"); + } + return Result.success(http + flag + "-" + fileName); + } + } + + + /** + * 获取文件 + * + * @param flag + * @param response + */ + @GetMapping("/{flag}") + public void avatarPath(@PathVariable String flag, HttpServletResponse response) { + if (!FileUtil.isDirectory(filePath)) { + FileUtil.mkdir(filePath); + } + OutputStream os; + List fileNames = FileUtil.listFileNames(filePath); + String avatar = fileNames.stream().filter(name -> name.contains(flag)).findAny().orElse(""); + try { + if (StrUtil.isNotEmpty(avatar)) { + response.addHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(avatar, "UTF-8")); + response.setContentType("application/octet-stream"); + byte[] bytes = FileUtil.readBytes(filePath + avatar); + os = response.getOutputStream(); + os.write(bytes); + os.flush(); + os.close(); + } + } catch (Exception e) { + System.out.println("文件下载失败"); + } + } + + /** + * 删除文件 + * + * @param flag + */ + @DeleteMapping("/{flag}") + public void delFile(@PathVariable String flag) { + if (!FileUtil.isDirectory(filePath)) { + FileUtil.mkdir(filePath); + } + List fileNames = FileUtil.listFileNames(filePath); + String filename = fileNames.stream().filter(name -> name.contains(flag)).findAny().orElse(""); + FileUtil.del(filePath + filename); + System.out.println("删除文件" + filename + "成功"); + } + + +} diff --git a/src/main/java/com/example/controller/PatientController.java b/src/main/java/com/example/controller/PatientController.java new file mode 100644 index 0000000..c50174c --- /dev/null +++ b/src/main/java/com/example/controller/PatientController.java @@ -0,0 +1,256 @@ +package com.example.controller; + +import cn.hutool.core.util.ObjectUtil; +import com.example.common.Result; +import com.example.common.config.TokenUtils; +import com.example.entity.Account; +import com.example.entity.Doctor; +import com.example.entity.DoctorPatient; +import com.example.entity.Patient; +import com.example.service.DoctorPatientService; +import com.example.service.PatientService; +import com.github.pagehelper.PageHelper; +import com.github.pagehelper.PageInfo; +import jakarta.annotation.Resource; +import org.springframework.web.bind.annotation.*; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; + +/** + * 患者控制器 + */ +@RestController +@RequestMapping("/patient") +public class PatientController { + + @Resource + private PatientService patientService; + + @Resource + private DoctorPatientService doctorPatientService; + + /** + * 新增 + */ + @PostMapping + public Result add(@RequestBody Patient patient) { + patientService.add(patient); + return Result.success(); + } + + /** + * 删除 + */ + @DeleteMapping("/{id}") + public Result delete(@PathVariable Integer id) { + patientService.deleteById(id); + return Result.success(); + } + + /** + * 更新 + */ + @PutMapping + public Result update(@RequestBody Patient patient) { + patientService.updateById(patient); + return Result.success(); + } + + /** + * 根据ID查询 + */ + @GetMapping("/{id}") + public Result getById(@PathVariable Integer id) { + Patient patient = patientService.selectById(id); + return Result.success(patient); + } + + /** + * 查询全部 + */ + @GetMapping + public Result findAll() { + Account currentUser = TokenUtils.getCurrentUser(); + List patients = new ArrayList<>(); + + // 管理员可以查看所有患者 + if (currentUser != null && "admin".equals(currentUser.getRole())) { + patients = patientService.selectAll(null); + } + // 医生只能查看自己的患者 + else if (currentUser != null && "doctor".equals(currentUser.getRole())) { + List doctorPatients = doctorPatientService.selectByDoctorId(currentUser.getId(), null); + if (!doctorPatients.isEmpty()) { + // 提取患者信息 + patients = doctorPatients.stream() + .map(DoctorPatient::getPatient) + .filter(p -> p != null) + .collect(Collectors.toList()); + } + } + // 患者只能查看自己的信息 + else if (currentUser != null && "patient".equals(currentUser.getRole())) { + Patient patient = patientService.selectById(currentUser.getId()); + if (patient != null) { + patients.add(patient); + } + } + + return Result.success(patients); + } + + /** + * 分页查询 + */ + @GetMapping("/page") + public Result findPage(@RequestParam(defaultValue = "1") Integer pageNum, + @RequestParam(defaultValue = "10") Integer pageSize, + @RequestParam(required = false) String name) { + Account currentUser = TokenUtils.getCurrentUser(); + + // 管理员可以查看所有患者 + if (currentUser != null && "admin".equals(currentUser.getRole())) { + return Result.success(patientService.selectPage(pageNum, pageSize, name)); + } + // 医生只能查看自己的患者 + else if (currentUser != null && "doctor".equals(currentUser.getRole())) { + List doctorPatients = doctorPatientService.selectByDoctorId(currentUser.getId(), name); + + if (!doctorPatients.isEmpty()) { + // 提取患者信息 + List patients = doctorPatients.stream() + .map(DoctorPatient::getPatient) + .filter(p -> p != null) + .collect(Collectors.toList()); + + // 手动进行分页 + int total = patients.size(); + int fromIndex = (pageNum - 1) * pageSize; + int toIndex = Math.min(fromIndex + pageSize, total); + + if (fromIndex >= total) { + patients = new ArrayList<>(); + } else { + patients = patients.subList(fromIndex, toIndex); + } + + return Result.success(patients); + } else { + return Result.success(new ArrayList<>()); + } + } + // 患者只能查看自己的信息 + else if (currentUser != null && "patient".equals(currentUser.getRole())) { + Patient patient = patientService.selectById(currentUser.getId()); + List list = new ArrayList<>(); + if (patient != null) { + list.add(patient); + } + return Result.success(list); + } + + return Result.error("401", "无权限"); + } + + /** + * 分页查询（与Admin页面保持一致的接口） + */ + @GetMapping("/selectPage") + public Result selectPage( + Patient patient, + @RequestParam(defaultValue = "1") Integer pageNum, + @RequestParam(defaultValue = "10") Integer pageSize) { + Account currentUser = TokenUtils.getCurrentUser(); + + // 管理员可以查看所有患者 + if (currentUser != null && "admin".equals(currentUser.getRole())) { + // 使用PageHelper手动创建PageInfo + PageHelper.startPage(pageNum, pageSize); + List patients = patientService.selectAll(patient); + PageInfo pageInfo = new PageInfo<>(patients); + return Result.success(pageInfo); + } + // 医生只能查看自己的患者 + else if (currentUser != null && "doctor".equals(currentUser.getRole())) { + List doctorPatients = doctorPatientService.selectByDoctorId(currentUser.getId(), patient.getName()); + + if (!doctorPatients.isEmpty()) { + // 提取患者信息 + List patients = doctorPatients.stream() + .map(DoctorPatient::getPatient) + .filter(p -> p != null) + .collect(Collectors.toList()); + + // 手动进行分页 + int total = patients.size(); + int fromIndex = (pageNum - 1) * pageSize; + int toIndex = Math.min(fromIndex + pageSize, total); + + if (fromIndex >= total) { + patients = new ArrayList<>(); + } else { + patients = patients.subList(fromIndex, toIndex); + } + + // 创建PageInfo对象 + PageInfo pageInfo = new PageInfo<>(); + pageInfo.setList(patients); + pageInfo.setTotal(total); + pageInfo.setPageNum(pageNum); + pageInfo.setPageSize(pageSize); + pageInfo.setPages((total + pageSize - 1) / pageSize); + + return Result.success(pageInfo); + } else { + PageInfo pageInfo = new PageInfo<>(); + pageInfo.setList(new ArrayList<>()); + pageInfo.setTotal(0); + return Result.success(pageInfo); + } + } + // 患者只能查看自己的信息 + else if (currentUser != null && "patient".equals(currentUser.getRole())) { + Patient currentPatient = patientService.selectById(currentUser.getId()); + List list = new ArrayList<>(); + if (currentPatient != null) { + list.add(currentPatient); + } + + // 创建PageInfo对象 + PageInfo pageInfo = new PageInfo<>(); + pageInfo.setList(list); + pageInfo.setTotal(list.size()); + pageInfo.setPageNum(1); + pageInfo.setPageSize(pageSize); + pageInfo.setPages(1); + + return Result.success(pageInfo); + } + + return Result.error("401", "无权限"); + } + + /** + * 更新患者个人资料 + */ + @PutMapping("/update") + public Result updateProfile(@RequestBody Patient patient) { + // 获取当前登录用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null || !"patient".equals(currentUser.getRole())) { + return Result.error("401", "无权限"); + } + + // 确保只能更新自己的信息 + if (!currentUser.getId().equals(patient.getId())) { + return Result.error("403", "只能更新自己的信息"); + } + + // 更新个人资料 + patientService.updateById(patient); + + return Result.success(); + } +} \ No newline at end of file diff --git a/src/main/java/com/example/controller/RecommendationController.java b/src/main/java/com/example/controller/RecommendationController.java new file mode 100644 index 0000000..9e9ae53 --- /dev/null +++ b/src/main/java/com/example/controller/RecommendationController.java @@ -0,0 +1,47 @@ +package com.example.controller; + +import com.example.common.Result; +import com.example.common.config.TokenUtils; +import com.example.entity.Account; +import com.example.service.RecommendationService; +import jakarta.annotation.Resource; +import org.springframework.web.bind.annotation.*; + +import java.util.List; +import java.util.Map; + +/** + * 推荐系统控制器 + */ +@RestController +@RequestMapping("/recommendation") +public class RecommendationController { + + @Resource + private RecommendationService recommendationService; + + /** + * 获取个性化推荐资源 + * @param limit 推荐资源数量，默认为4 + * @return 推荐资源列表 + */ + @GetMapping("/resources") + public Result getRecommendedResources(@RequestParam(defaultValue = "4") Integer limit) { + // 获取当前登录用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + return Result.error("401", "用户未登录"); + } + + // 验证用户是否为患者 + if (!"patient".equals(currentUser.getRole())) { + return Result.error("403", "只有患者才能获取个性化推荐"); + } + + // 获取推荐资源 + List> recommendations = + recommendationService.getRecommendationsForUser(currentUser.getId(), limit); + + return Result.success(recommendations); + } +} \ No newline at end of file diff --git a/src/main/java/com/example/controller/ResourceCategoryController.java b/src/main/java/com/example/controller/ResourceCategoryController.java new file mode 100644 index 0000000..f19e49a --- /dev/null +++ b/src/main/java/com/example/controller/ResourceCategoryController.java @@ -0,0 +1,86 @@ +package com.example.controller; + +import com.example.common.Result; +import com.example.entity.ResourceCategory; +import com.example.service.ResourceCategoryService; +import com.github.pagehelper.PageInfo; +import jakarta.annotation.Resource; +import org.springframework.web.bind.annotation.*; + +import java.util.List; + +/** + * 资源分类控制器 + */ +@RestController +@RequestMapping("/resourceCategory") +public class ResourceCategoryController { + + @Resource + private ResourceCategoryService resourceCategoryService; + + /** + * 获取所有分类 + */ + @GetMapping + public Result findAll() { + List list = resourceCategoryService.findAll(); + return Result.success(list); + } + + /** + * 根据父分类ID获取子分类 + */ + @GetMapping("/parent/{parentId}") + public Result findByParentId(@PathVariable Integer parentId) { + List list = resourceCategoryService.findByParentId(parentId); + return Result.success(list); + } + + /** + * 根据ID获取分类 + */ + @GetMapping("/{id}") + public Result findById(@PathVariable Integer id) { + ResourceCategory category = resourceCategoryService.findById(id); + return Result.success(category); + } + + /** + * 新增分类 + */ + @PostMapping + public Result add(@RequestBody ResourceCategory category) { + resourceCategoryService.add(category); + return Result.success(); + } + + /** + * 更新分类 + */ + @PutMapping + public Result update(@RequestBody ResourceCategory category) { + resourceCategoryService.update(category); + return Result.success(); + } + + /** + * 删除分类 + */ + @DeleteMapping("/{id}") + public Result delete(@PathVariable Integer id) { + resourceCategoryService.delete(id); + return Result.success(); + } + + /** + * 分页查询 + */ + @GetMapping("/selectPage") + public Result selectPage(@RequestParam(defaultValue = "1") Integer pageNum, + @RequestParam(defaultValue = "10") Integer pageSize, + ResourceCategory category) { + PageInfo pageInfo = resourceCategoryService.selectPage(category, pageNum, pageSize); + return Result.success(pageInfo); + } +} \ No newline at end of file diff --git a/src/main/java/com/example/controller/ResourceRatingController.java b/src/main/java/com/example/controller/ResourceRatingController.java new file mode 100644 index 0000000..366b60a --- /dev/null +++ b/src/main/java/com/example/controller/ResourceRatingController.java @@ -0,0 +1,167 @@ +package com.example.controller; + +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.example.common.Result; +import com.example.common.config.TokenUtils; +import com.example.entity.Account; +import com.example.entity.ResourceRating; +import com.example.service.ResourceRatingService; +import jakarta.annotation.Resource; +import org.springframework.web.bind.annotation.*; + +import java.util.Date; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * 资源评分控制器 + */ +@RestController +@RequestMapping("/resourceRating") +public class ResourceRatingController { + + @Resource + private ResourceRatingService resourceRatingService; + + /** + * 获取资源评分列表（分页） + */ + @GetMapping("/resource/{resourceId}") + public Result findResourceRatingsPage( + @PathVariable Integer resourceId, + @RequestParam(defaultValue = "1") Integer pageNum, + @RequestParam(defaultValue = "10") Integer pageSize) { + + // 查询评分列表 + List ratings = resourceRatingService.findByResourceId(resourceId); + + // 构建分页结果 + Map pageResult = new HashMap<>(); + int start = (pageNum - 1) * pageSize; + int end = Math.min(start + pageSize, ratings.size()); + + // 截取当前页数据 + List pageRatings = ratings.subList( + start < ratings.size() ? start : 0, + end < ratings.size() ? end : 0 + ); + + pageResult.put("list", pageRatings); + pageResult.put("total", ratings.size()); + pageResult.put("pageNum", pageNum); + pageResult.put("pageSize", pageSize); + + return Result.success(pageResult); + } + + /** + * 获取资源平均评分 + */ + @GetMapping("/average/{resourceId}") + public Result getAverageRating(@PathVariable Integer resourceId) { + Double averageRating = resourceRatingService.getAverageRating(resourceId); + return Result.success(averageRating); + } + + /** + * 获取资源评分数量 + */ + @GetMapping("/count/{resourceId}") + public Result getRatingCount(@PathVariable Integer resourceId) { + Integer count = resourceRatingService.getRatingCount(resourceId); + return Result.success(count); + } + + /** + * 添加或更新评分 + */ + @PostMapping + public Result add(@RequestBody ResourceRating resourceRating) { + resourceRatingService.rateResource(resourceRating); + return Result.success(); + } + + /** + * 获取当前用户的所有评分 + */ + @GetMapping("/user") + public Result getUserRatings() { + // 获取当前登录用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + return Result.error("401", "用户未登录"); + } + + // 验证用户是否为患者 + if (!"patient".equals(currentUser.getRole())) { + return Result.error("403", "只有患者可以查看自己的评分"); + } + + // 获取用户评分列表 + List ratings = resourceRatingService.findByPatientId(currentUser.getId()); + return Result.success(ratings); + } + + /** + * 获取所有评分数据（用于推荐算法） + */ + @GetMapping("/all") + public Result getAllRatings() { + // 获取当前登录用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + return Result.error("401", "用户未登录"); + } + + // 验证用户是否为患者 + if (!"patient".equals(currentUser.getRole())) { + return Result.error("403", "只有患者可以访问评分数据"); + } + + // 获取所有评分列表 + List ratings = resourceRatingService.findAll(); + return Result.success(ratings); + } + + /** + * 获取资源的平均评分和评分数量 + */ + @GetMapping("/resource/{resourceId}/stats") + public Result getResourceRatingStats(@PathVariable Integer resourceId) { + Double averageRating = resourceRatingService.getAverageRating(resourceId); + Integer count = resourceRatingService.getRatingCount(resourceId); + + Map stats = new HashMap<>(); + stats.put("averageRating", averageRating); + stats.put("ratingCount", count); + + return Result.success(stats); + } + + /** + * 删除评价 + */ + @DeleteMapping("/{id}") + public Result deleteRating(@PathVariable Integer id) { + resourceRatingService.deleteRating(id); + return Result.success(); + } + + /** + * 根据资源ID查询评分记录 + */ + @GetMapping("/{resourceId}") + public Result findByResourceId(@PathVariable Integer resourceId) { + List ratings = resourceRatingService.findByResourceId(resourceId); + double averageRating = resourceRatingService.getAverageRating(resourceId); + Integer count = resourceRatingService.getRatingCount(resourceId); + + Map result = new HashMap<>(); + result.put("ratings", ratings); + result.put("averageRating", averageRating); + result.put("count", count != null ? count : 0); + + return Result.success(result); + } +} \ No newline at end of file diff --git a/src/main/java/com/example/controller/SymptomRecordController.java b/src/main/java/com/example/controller/SymptomRecordController.java new file mode 100644 index 0000000..35fbe61 --- /dev/null +++ b/src/main/java/com/example/controller/SymptomRecordController.java @@ -0,0 +1,91 @@ +package com.example.controller; + +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.example.common.Result; +import com.example.entity.SymptomRecord; +import com.example.service.SymptomRecordService; +import jakarta.annotation.Resource; +import org.springframework.web.bind.annotation.*; + +import java.util.List; + +/** + * 症状记录控制器 + */ +@RestController +@RequestMapping("/symptomRecord") +public class SymptomRecordController { + + @Resource + private SymptomRecordService symptomRecordService; + + /** + * 添加症状记录 + */ + @PostMapping + public Result add(@RequestBody SymptomRecord symptomRecord) { + symptomRecordService.add(symptomRecord); + return Result.success(); + } + + /** + * 更新症状记录 + */ + @PutMapping + public Result update(@RequestBody SymptomRecord symptomRecord) { + symptomRecordService.update(symptomRecord); + return Result.success(); + } + + /** + * 删除症状记录 + */ + @DeleteMapping("/{id}") + public Result delete(@PathVariable Integer id) { + symptomRecordService.delete(id); + return Result.success(); + } + + /** + * 根据ID查询症状记录 + */ + @GetMapping("/{id}") + public Result getById(@PathVariable Integer id) { + SymptomRecord symptomRecord = symptomRecordService.getById(id); + return Result.success(symptomRecord); + } + + /** + * 根据患者ID查询症状记录 + */ + @GetMapping("/patient/{patientId}") + public Result getByPatientId(@PathVariable Integer patientId) { + List list = symptomRecordService.getByPatientId(patientId); + return Result.success(list); + } + + /** + * 查询当前登录患者的症状记录 + */ + @GetMapping("/my") + public Result getMyRecords() { + List list = symptomRecordService.getByPatientId(null); + return Result.success(list); + } + + /** + * 分页查询症状记录 + */ + @GetMapping("/selectPage") + public Result selectPage( + @RequestParam(required = false) String patientName, + @RequestParam(required = false) String startDate, + @RequestParam(required = false) String endDate, + @RequestParam(defaultValue = "1") Integer pageNum, + @RequestParam(defaultValue = "10") Integer pageSize) { + SymptomRecord symptomRecord = new SymptomRecord(); + symptomRecord.setPatientName(patientName); + com.github.pagehelper.PageInfo pageInfo = symptomRecordService.selectPage(symptomRecord, pageNum, pageSize, startDate, endDate); + return Result.success(pageInfo); + } +} \ No newline at end of file diff --git a/src/main/java/com/example/controller/SymptomStatisticsController.java b/src/main/java/com/example/controller/SymptomStatisticsController.java new file mode 100644 index 0000000..b6ea877 --- /dev/null +++ b/src/main/java/com/example/controller/SymptomStatisticsController.java @@ -0,0 +1,66 @@ +package com.example.controller; + +import com.example.common.Result; +import com.example.common.config.TokenUtils; +import com.example.entity.Account; +import com.example.service.SymptomRecordService; +import jakarta.annotation.Resource; +import org.springframework.format.annotation.DateTimeFormat; +import org.springframework.web.bind.annotation.*; + +import java.util.Date; +import java.util.Map; + +/** + * 症状记录统计控制器 + */ +@RestController +@RequestMapping("/symptomStatistics") +public class SymptomStatisticsController { + + @Resource + private SymptomRecordService symptomRecordService; + + /** + * 获取症状记录统计数据 + */ + @GetMapping + public Result getStatistics( + @RequestParam(required = false) Integer patientId, + @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date startDate, + @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date endDate) { + + // 获取当前登录用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + return Result.error("401", "请先登录"); + } + + Map result; + + // 根据用户角色获取不同的统计数据 + switch (currentUser.getRole()) { + case "admin": + // 管理员可以查看所有数据或指定患者的数据 + result = symptomRecordService.getStatisticsData(patientId, startDate, endDate); + break; + case "doctor": + // 如果请求包含patientId且该患者属于当前医生，则返回该患者的数据 + // 否则返回该医生的所有患者数据 + if (patientId != null) { + result = symptomRecordService.getStatisticsData(patientId, startDate, endDate); + } else { + result = symptomRecordService.getStatisticsByDoctor(currentUser.getId(), startDate, endDate); + } + break; + case "patient": + // 患者只能查看自己的数据 + result = symptomRecordService.getStatisticsData(currentUser.getId(), startDate, endDate); + break; + default: + return Result.error("403", "无权限访问"); + } + + return Result.success(result); + } +} \ No newline at end of file diff --git a/src/main/java/com/example/controller/TreatmentResourceController.java b/src/main/java/com/example/controller/TreatmentResourceController.java new file mode 100644 index 0000000..af79d50 --- /dev/null +++ b/src/main/java/com/example/controller/TreatmentResourceController.java @@ -0,0 +1,220 @@ +package com.example.controller; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.example.common.Result; +import com.example.common.config.TokenUtils; +import com.example.entity.Account; +import com.example.entity.ResourceCategory; +import com.example.entity.TreatmentResource; +import com.example.service.ResourceCategoryService; +import com.example.service.TreatmentResourceService; +import com.github.pagehelper.PageInfo; +import jakarta.annotation.Resource; +import org.springframework.web.bind.annotation.*; + +import java.util.List; + +/** + * 心理治疗资源控制器 + */ +@RestController +@RequestMapping("/treatmentResource") +public class TreatmentResourceController { + + @Resource + private TreatmentResourceService treatmentResourceService; + + @Resource + private ResourceCategoryService resourceCategoryService; + + /** + * 分页搜索资源 + */ + @GetMapping("/search") + public Result search( + @RequestParam(defaultValue = "1") Integer pageNum, + @RequestParam(defaultValue = "10") Integer pageSize, + @RequestParam(defaultValue = "") String keyword) { + + // 获取当前用户角色 + Account currentUser = TokenUtils.getCurrentUser(); + String role = currentUser != null ? currentUser.getRole() : "patient"; + + Page page = new Page<>(pageNum, pageSize); + page = treatmentResourceService.search(page, keyword, role); + + return Result.success(page); + } + + /** + * 分页查询 + */ + @GetMapping("/selectPage") + public Result selectPage( + @RequestParam(defaultValue = "1") Integer pageNum, + @RequestParam(defaultValue = "10") Integer pageSize, + TreatmentResource resource) { + + PageInfo pageInfo = treatmentResourceService.selectPage(resource, pageNum, pageSize); + return Result.success(pageInfo); + } + + /** + * 根据分类获取资源 + */ + @GetMapping("/category/{categoryId}") + public Result findByCategoryId(@PathVariable Integer categoryId) { + List list = treatmentResourceService.findByCategoryId(categoryId); + return Result.success(list); + } + + /** + * 根据ID获取资源 + */ + @GetMapping("/{id}") + public Result findById(@PathVariable Integer id) { + TreatmentResource resource = treatmentResourceService.findById(id); + treatmentResourceService.incrementVisitCount(id); + return Result.success(resource); + } + + /** + * 新增资源 + */ + @PostMapping + public Result add(@RequestBody TreatmentResource resource) { + treatmentResourceService.add(resource); + return Result.success(); + } + + /** + * 更新资源 + */ + @PutMapping + public Result update(@RequestBody TreatmentResource resource) { + treatmentResourceService.update(resource); + return Result.success(); + } + + /** + * 删除资源 + */ + @DeleteMapping("/{id}") + public Result delete(@PathVariable Integer id) { + treatmentResourceService.delete(id); + return Result.success(); + } + + /** + * 审核资源 + */ + @PutMapping("/audit/{id}") + public Result audit(@PathVariable Integer id, @RequestParam String status) { + treatmentResourceService.changeAuditStatus(id, status); + return Result.success(); + } + + /** + * 下载资源 + */ + @GetMapping("/download/{id}") + public Result download(@PathVariable Integer id) { + TreatmentResource resource = treatmentResourceService.findById(id); + if (resource != null) { + treatmentResourceService.incrementDownloadCount(id); + } + return Result.success(resource); + } + + /** + * 增加资源访问次数（新路径） + */ + @PutMapping("/incrementVisit/{id}") + public Result incrementVisit(@PathVariable Integer id) { + treatmentResourceService.incrementVisitCount(id); + return Result.success(); + } + + /** + * 增加资源下载次数（新路径） + */ + @PutMapping("/incrementDownload/{id}") + public Result incrementDownload(@PathVariable Integer id) { + treatmentResourceService.incrementDownloadCount(id); + return Result.success(); + } + + /** + * 查询医生自己发布的资源 + */ + @GetMapping("/myResources") + public Result myResources( + @RequestParam(defaultValue = "1") Integer pageNum, + @RequestParam(defaultValue = "10") Integer pageSize, + TreatmentResource resource) { + + // 获取当前登录用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + return Result.error("401", "未登录"); + } + + // 只有医生可以查询自己发布的资源 + if (!"doctor".equals(currentUser.getRole())) { + return Result.error("403", "无权限查询"); + } + + // 强制设置发布者ID为当前登录用户 + resource.setPublisherId(currentUser.getId()); + + // 使用PageHelper进行分页 + PageInfo pageInfo = treatmentResourceService.findByPublisher(resource, pageNum, pageSize); + + return Result.success(pageInfo); + } + + /** + * 获取资源使用情况统计数据 + */ + @GetMapping("/statistics") + public Result getStatistics() { + return Result.success(treatmentResourceService.getResourceStatistics()); + } + + /** + * 获取所有已审核通过的心理资源 + */ + @GetMapping("/all") + public Result getAllApprovedResources(@RequestParam(required = false) String auditStatus) { + // 获取当前登录用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + return Result.error("401", "用户未登录"); + } + + // 查询关键词为空，表示获取所有资源 + String keyword = ""; + + // 根据审核状态查询资源 + List resources; + + if (auditStatus != null && !auditStatus.isEmpty()) { + // 使用TreatmentResourceService的selectPage方法 + TreatmentResource queryParam = new TreatmentResource(); + queryParam.setAuditStatus(auditStatus); + // 这里不使用分页，所以传一个很大的pageSize + PageInfo pageInfo = treatmentResourceService.selectPage(queryParam, 1, 1000); + resources = pageInfo.getList(); + } else { + // 默认只返回已通过审核的资源 + TreatmentResource queryParam = new TreatmentResource(); + queryParam.setAuditStatus("已通过"); + // 这里不使用分页，所以传一个很大的pageSize + PageInfo pageInfo = treatmentResourceService.selectPage(queryParam, 1, 1000); + resources = pageInfo.getList(); + } + + return Result.success(resources); + } +} \ No newline at end of file diff --git a/src/main/java/com/example/controller/WebController.java b/src/main/java/com/example/controller/WebController.java new file mode 100644 index 0000000..7a1dc5b --- /dev/null +++ b/src/main/java/com/example/controller/WebController.java @@ -0,0 +1,93 @@ +package com.example.controller; + +import com.example.common.config.TokenUtils; +import cn.hutool.core.collection.CollectionUtil; +import cn.hutool.core.util.ObjectUtil; +import cn.hutool.core.io.IoUtil; +import cn.hutool.poi.excel.ExcelUtil; +import cn.hutool.poi.excel.ExcelWriter; +import com.example.common.Result; +import com.example.entity.*; +import com.example.service.*; +import com.example.exception.CustomException; +import org.springframework.beans.BeanUtils; +import org.springframework.web.bind.annotation.*; +import org.springframework.web.multipart.MultipartFile; + +import jakarta.annotation.Resource; +import jakarta.servlet.ServletOutputStream; +import jakarta.servlet.http.HttpServletRequest; +import jakarta.servlet.http.HttpServletResponse; +import java.io.IOException; +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.*; + +/** + * 描述：系统用户操作相关接口 + */ +@RestController +public class WebController { + + @Resource + private AdminService adminService; + @Resource + private DoctorService doctorService; + @Resource + private PatientService patientService; + + /** + * 描述：用户登录接口 + */ + @PostMapping("/login") + public Result login(@RequestBody Account account) { + Account loginAccount = null; + if ("admin".equals(account.getRole())) { + loginAccount = adminService.login(account); + } + if ("doctor".equals(account.getRole())) { + loginAccount = doctorService.login(account); + } + if ("patient".equals(account.getRole())) { + loginAccount = patientService.login(account); + } + + return Result.success(loginAccount); + } + + /** + * 描述：用户注册接口 + */ + @PostMapping("/register") + public Result register(@RequestBody Account account) { + if ("admin".equals(account.getRole())) { + adminService.register(account); + } + if ("doctor".equals(account.getRole())) { + doctorService.register(account); + } + if ("patient".equals(account.getRole())) { + patientService.register(account); + } + + return Result.success(); + } + + /** + * 描述：更新密码接口 + */ + @PutMapping("/updatePassword") + public Result updatePassword(@RequestBody Account account) { + if ("admin".equals(account.getRole())) { + adminService.updatePassword(account); + } + if ("doctor".equals(account.getRole())) { + doctorService.updatePassword(account); + } + if ("patient".equals(account.getRole())) { + patientService.updatePassword(account); + } + + return Result.success(); + } +} diff --git a/src/main/java/com/example/entity/Account.java b/src/main/java/com/example/entity/Account.java new file mode 100644 index 0000000..8c70498 --- /dev/null +++ b/src/main/java/com/example/entity/Account.java @@ -0,0 +1,30 @@ +package com.example.entity; + +import com.baomidou.mybatisplus.annotation.TableField; +import lombok.Data; + +@Data +public class Account { + private Integer id; + /** 账号 */ + private String username; + /** 密码 */ + private String password; + /** 姓名 */ + private String name; + /** 性别 */ + private String sex; + /** 手机号 */ + private String phone; + /** 邮箱 */ + private String email; + /** 角色 */ + private String role; + @TableField(exist = false) + private String newPassword; + @TableField(exist = false) + private String token; + /** 医生ID (用于患者注册时选择医生) */ + @TableField(exist = false) + private Integer doctorId; +} diff --git a/src/main/java/com/example/entity/Admin.java b/src/main/java/com/example/entity/Admin.java new file mode 100644 index 0000000..3774149 --- /dev/null +++ b/src/main/java/com/example/entity/Admin.java @@ -0,0 +1,33 @@ +package com.example.entity; + +import cn.hutool.core.annotation.Alias; +import java.util.List; +import com.baomidou.mybatisplus.annotation.TableField; +import com.baomidou.mybatisplus.annotation.TableName; +import com.baomidou.mybatisplus.annotation.IdType; +import com.baomidou.mybatisplus.annotation.TableId; +import lombok.Data; + +/** + * 管理员 + */ +@Data +@TableName("admin") +public class Admin extends Account { + + /** id */ + @TableId(type = IdType.AUTO) + private Integer id; + /** 账号 */ + private String username; + /** 密码 */ + private String password; + /** 名称 */ + private String name; + /** 头像 */ + private String avatar; + /** 性别 */ + private String sex; + /** 手机号 */ + private String phone; +} diff --git a/src/main/java/com/example/entity/Announcement.java b/src/main/java/com/example/entity/Announcement.java new file mode 100644 index 0000000..7f44b02 --- /dev/null +++ b/src/main/java/com/example/entity/Announcement.java @@ -0,0 +1,59 @@ +package com.example.entity; + +import com.baomidou.mybatisplus.annotation.IdType; +import com.baomidou.mybatisplus.annotation.TableId; +import com.baomidou.mybatisplus.annotation.TableName; +import com.fasterxml.jackson.annotation.JsonFormat; +import lombok.Data; + +import java.util.Date; + +/** + * 公告实体类 + */ +@Data +@TableName("announcement") +public class Announcement { + + /** + * ID + */ + @TableId(type = IdType.AUTO) + private Integer id; + + /** + * 标题 + */ + private String title; + + /** + * 内容 + */ + private String content; + + /** + * 创建时间 + */ + @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8") + private Date createTime; + + /** + * 是否置顶 + */ + private Boolean isTop; + + /** + * 状态（1-发布，0-草稿） + */ + private Integer status; + + /** + * 发布人ID + */ + private Integer publisherId; + + /** + * 发布人姓名 + */ + private String publisherName; +} \ No newline at end of file diff --git a/src/main/java/com/example/entity/AssessmentReport.java b/src/main/java/com/example/entity/AssessmentReport.java new file mode 100644 index 0000000..5173834 --- /dev/null +++ b/src/main/java/com/example/entity/AssessmentReport.java @@ -0,0 +1,41 @@ +package com.example.entity; + +import com.baomidou.mybatisplus.annotation.IdType; +import com.baomidou.mybatisplus.annotation.TableId; +import com.baomidou.mybatisplus.annotation.TableName; +import lombok.Data; + +import java.time.LocalDate; +import java.time.LocalDateTime; + +@Data +@TableName("assessment_report") +public class AssessmentReport { + + @TableId(type = IdType.AUTO) + private Integer id; + + private Integer patientId; + + private String reportPeriod; + + private LocalDate startDate; + + private LocalDate endDate; + + private String summary; + + private String trendAnalysis; + + private String recommendation; + + private String doctorComment; + + private String status; + + private LocalDateTime createTime; + + // 非数据库字段，用于前端显示 + private String patientName; + private String doctorName; +} \ No newline at end of file diff --git a/src/main/java/com/example/entity/ChatMessage.java b/src/main/java/com/example/entity/ChatMessage.java new file mode 100644 index 0000000..640bb2d --- /dev/null +++ b/src/main/java/com/example/entity/ChatMessage.java @@ -0,0 +1,92 @@ +package com.example.entity; + +import com.baomidou.mybatisplus.annotation.IdType; +import com.baomidou.mybatisplus.annotation.TableField; +import com.baomidou.mybatisplus.annotation.TableId; +import com.baomidou.mybatisplus.annotation.TableName; +import com.fasterxml.jackson.annotation.JsonFormat; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import lombok.Data; + +import java.util.Date; + +/** + * 聊天消息实体类 + */ +@Data +@TableName("chat_message") +@JsonIgnoreProperties(ignoreUnknown = true) // 忽略未知属性 +public class ChatMessage { + + /** + * 消息ID + */ + @TableId(type = IdType.AUTO) + private Integer id; + + /** + * 发送者ID + */ + private Integer senderId; + + /** + * 接收者ID + */ + private Integer receiverId; + + /** + * 发送者类型(doctor/patient) + */ + private String senderType; + + /** + * 接收者类型(doctor/patient) + */ + private String receiverType; + + /** + * 消息内容 + */ + private String content; + + /** + * 发送时间 + */ + @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8") + private Date sendTime; + + /** + * 是否已读(0-未读,1-已读) + */ + private Boolean isRead; + + /** + * 阅读时间 + */ + @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8") + private Date readTime; + + /** + * 发送者名称(非数据库字段) + */ + @TableField(exist = false) + private String senderName; + + /** + * 接收者名称(非数据库字段) + */ + @TableField(exist = false) + private String receiverName; + + /** + * 发送者头像(非数据库字段) + */ + @TableField(exist = false) + private String senderAvatar; + + /** + * 临时消息ID(用于前端标识临时消息，非数据库字段) + */ + @TableField(exist = false) + private String tempId; +} \ No newline at end of file diff --git a/src/main/java/com/example/entity/Doctor.java b/src/main/java/com/example/entity/Doctor.java new file mode 100644 index 0000000..31a239c --- /dev/null +++ b/src/main/java/com/example/entity/Doctor.java @@ -0,0 +1,41 @@ +package com.example.entity; + +import cn.hutool.core.annotation.Alias; +import java.util.List; +import com.baomidou.mybatisplus.annotation.TableField; +import com.baomidou.mybatisplus.annotation.TableName; +import com.baomidou.mybatisplus.annotation.IdType; +import com.baomidou.mybatisplus.annotation.TableId; +import lombok.Data; + +/** + * 医生 + */ +@Data +@TableName("doctor") +public class Doctor extends Account { + + /** id */ + @TableId(type = IdType.AUTO) + private Integer id; + /** 账号 */ + private String username; + /** 密码 */ + private String password; + /** 名称 */ + private String name; + /** 头像 */ + private String avatar; + /** 性别 */ + private String sex; + /** 手机号 */ + private String phone; + /** 邮箱 */ + private String email; + /** 执业证书编号 */ + private String certificateNo; + /** 所属医院 */ + private String hospital; + /** 科室 */ + private String department; +} \ No newline at end of file diff --git a/src/main/java/com/example/entity/DoctorPatient.java b/src/main/java/com/example/entity/DoctorPatient.java new file mode 100644 index 0000000..ad37046 --- /dev/null +++ b/src/main/java/com/example/entity/DoctorPatient.java @@ -0,0 +1,56 @@ +package com.example.entity; + +import com.baomidou.mybatisplus.annotation.IdType; +import com.baomidou.mybatisplus.annotation.TableField; +import com.baomidou.mybatisplus.annotation.TableId; +import com.baomidou.mybatisplus.annotation.TableName; +import lombok.Data; + +import java.util.Date; + +@TableName("doctor_patient") +@Data +public class DoctorPatient { + /** + * ID + */ + @TableId(type = IdType.AUTO) + private Integer id; + + /** + * 医生ID + */ + private Integer doctorId; + + /** + * 患者ID + */ + private Integer patientId; + + /** + * 关系建立时间 + */ + private Date relationshipStart; + + /** + * 状态(正常/已结束) + */ + private String status; + + /** + * 创建时间 + */ + private Date createTime; + + /** + * 医生信息 + */ + @TableField(exist = false) + private Doctor doctor; + + /** + * 患者信息 + */ + @TableField(exist = false) + private Patient patient; +} \ No newline at end of file diff --git a/src/main/java/com/example/entity/Patient.java b/src/main/java/com/example/entity/Patient.java new file mode 100644 index 0000000..902198b --- /dev/null +++ b/src/main/java/com/example/entity/Patient.java @@ -0,0 +1,35 @@ +package com.example.entity; + +import cn.hutool.core.annotation.Alias; +import java.util.List; +import com.baomidou.mybatisplus.annotation.TableField; +import com.baomidou.mybatisplus.annotation.TableName; +import com.baomidou.mybatisplus.annotation.IdType; +import com.baomidou.mybatisplus.annotation.TableId; +import lombok.Data; + +/** + * 患者 + */ +@Data +@TableName("patient") +public class Patient extends Account { + + /** id */ + @TableId(type = IdType.AUTO) + private Integer id; + /** 账号 */ + private String username; + /** 密码 */ + private String password; + /** 名称 */ + private String name; + /** 头像 */ + private String avatar; + /** 性别 */ + private String sex; + /** 手机号 */ + private String phone; + /** 邮箱 */ + private String email; +} \ No newline at end of file diff --git a/src/main/java/com/example/entity/ResourceCategory.java b/src/main/java/com/example/entity/ResourceCategory.java new file mode 100644 index 0000000..535165b --- /dev/null +++ b/src/main/java/com/example/entity/ResourceCategory.java @@ -0,0 +1,17 @@ +package com.example.entity; + +import com.baomidou.mybatisplus.annotation.IdType; +import com.baomidou.mybatisplus.annotation.TableId; +import com.baomidou.mybatisplus.annotation.TableName; +import lombok.Data; + +@Data +@TableName("resource_category") +public class ResourceCategory { + + @TableId(type = IdType.AUTO) + private Integer id; + private String name; + private String description; + private Integer parentId; +} \ No newline at end of file diff --git a/src/main/java/com/example/entity/ResourceRating.java b/src/main/java/com/example/entity/ResourceRating.java new file mode 100644 index 0000000..ec89025 --- /dev/null +++ b/src/main/java/com/example/entity/ResourceRating.java @@ -0,0 +1,57 @@ +package com.example.entity; + +import java.time.LocalDateTime; + +import com.baomidou.mybatisplus.annotation.IdType; +import com.baomidou.mybatisplus.annotation.TableField; +import com.baomidou.mybatisplus.annotation.TableId; +import com.baomidou.mybatisplus.annotation.TableName; +import lombok.Data; + +/** + * 资源评分实体类 + */ +@Data +@TableName("resource_rating") +public class ResourceRating { + + /** + * ID + */ + @TableId(value = "id", type = IdType.AUTO) + private Integer id; + + /** + * 资源ID + */ + private Integer resourceId; + + /** + * 患者ID + */ + private Integer patientId; + + /** + * 评分(1-5) + */ + private Integer rating; + + /** + * 评价内容 + */ + private String comment; + + /** + * 创建时间 + */ + private LocalDateTime createTime; + + /** + * 患者姓名 (非数据库字段) + */ + @TableField(exist = false) + private String patientName; + + @TableField(exist = false) + private String resourceTitle; +} \ No newline at end of file diff --git a/src/main/java/com/example/entity/SymptomRecord.java b/src/main/java/com/example/entity/SymptomRecord.java new file mode 100644 index 0000000..7eb6176 --- /dev/null +++ b/src/main/java/com/example/entity/SymptomRecord.java @@ -0,0 +1,121 @@ +package com.example.entity; + +import com.baomidou.mybatisplus.annotation.IdType; +import com.baomidou.mybatisplus.annotation.TableField; +import com.baomidou.mybatisplus.annotation.TableId; +import com.baomidou.mybatisplus.annotation.TableName; +import lombok.Data; + +import java.util.Date; + +@TableName("symptom_record") +@Data +public class SymptomRecord { + /** + * ID + */ + @TableId(type = IdType.AUTO) + private Integer id; + + /** + * 患者ID + */ + private Integer patientId; + + /** + * 症状描述 + */ + private String symptomDesc; + + /** + * 严重程度等级(1-10) + */ + private Integer severityLevel; + + /** + * 情绪基线值(1-10) + */ + private Integer emotionScore; + + /** + * 活力持续时间(小时) + */ + private Integer energyDuration; + + /** + * 兴趣恢复度(百分比) + */ + private Integer interestRecovery; + + /** + * 入睡所需时间(分钟) + */ + private Integer sleepTime; + + /** + * 夜间觉醒次数 + */ + private Integer wakeCount; + + /** + * 晨醒时间 + */ + private String morningWake; + + /** + * 进食完成度(百分比) + */ + private Integer mealCompletion; + + /** + * 疼痛位置 + */ + private String painLocation; + + /** + * 疼痛强度(1-10) + */ + private Integer painIntensity; + + /** + * 短期记忆测试成功数(0-3) + */ + private Integer memoryTest; + + /** + * 决策耗时(分钟) + */ + private Integer decisionTime; + + /** + * 注意力跨度(分钟) + */ + private Integer attentionSpan; + + /** + * 自杀意念频率(次数) + */ + private Integer suicidalThought; + + /** + * 记录时间 + */ + private Date recordTime; + + /** + * 创建时间 + */ + private Date createTime; + + /** + * 患者信息（非数据库字段） + */ + @TableField(exist = false) + private Patient patient; + + /** + * 患者名称（非数据库字段，用于搜索） + */ + @TableField(exist = false) + private String patientName; +} \ No newline at end of file diff --git a/src/main/java/com/example/entity/TreatmentResource.java b/src/main/java/com/example/entity/TreatmentResource.java new file mode 100644 index 0000000..d4eccae --- /dev/null +++ b/src/main/java/com/example/entity/TreatmentResource.java @@ -0,0 +1,33 @@ +package com.example.entity; + +import com.baomidou.mybatisplus.annotation.IdType; +import com.baomidou.mybatisplus.annotation.TableField; +import com.baomidou.mybatisplus.annotation.TableId; +import com.baomidou.mybatisplus.annotation.TableName; +import lombok.Data; + +import java.time.LocalDateTime; + +@Data +@TableName("treatment_resource") +public class TreatmentResource { + + @TableId(type = IdType.AUTO) + private Integer id; + private String title; + private Integer categoryId; + private String content; + private String resourceUrl; + private String applicableSymptoms; + private Integer visitCount; + private Integer downloadCount; + private Integer publisherId; + private String auditStatus; + private LocalDateTime createTime; + + @TableField(exist = false) + private String categoryName; + + @TableField(exist = false) + private String publisherName; +} \ No newline at end of file diff --git a/src/main/java/com/example/exception/CustomException.java b/src/main/java/com/example/exception/CustomException.java new file mode 100644 index 0000000..a4116f3 --- /dev/null +++ b/src/main/java/com/example/exception/CustomException.java @@ -0,0 +1,35 @@ +package com.example.exception; + +import com.example.common.enums.ResultCodeEnum; + +public class CustomException extends RuntimeException { + private String code; + private String msg; + + public CustomException(ResultCodeEnum resultCodeEnum) { + this.code = resultCodeEnum.code; + this.msg = resultCodeEnum.msg; + } + + public CustomException(String code, String msg) { + this.code = code; + this.msg = msg; + } + + + public String getCode() { + return code; + } + + public void setCode(String code) { + this.code = code; + } + + public String getMsg() { + return msg; + } + + public void setMsg(String msg) { + this.msg = msg; + } +} diff --git a/src/main/java/com/example/exception/GlobalExceptionHandler.java b/src/main/java/com/example/exception/GlobalExceptionHandler.java new file mode 100644 index 0000000..fd8eb35 --- /dev/null +++ b/src/main/java/com/example/exception/GlobalExceptionHandler.java @@ -0,0 +1,30 @@ +package com.example.exception; + +import cn.hutool.log.Log; +import cn.hutool.log.LogFactory; +import com.example.common.Result; +import jakarta.servlet.http.HttpServletRequest; +import org.springframework.web.bind.annotation.ControllerAdvice; +import org.springframework.web.bind.annotation.ExceptionHandler; +import org.springframework.web.bind.annotation.ResponseBody; + +@ControllerAdvice(basePackages="com.example.controller") +public class GlobalExceptionHandler { + + private static final Log log = LogFactory.get(); + + + //统一异常处理@ExceptionHandler,主要用于Exception + @ExceptionHandler(Exception.class) + @ResponseBody//返回json串 + public Result error(HttpServletRequest request, Exception e){ + log.error("异常信息：",e); + return Result.error(); + } + + @ExceptionHandler(CustomException.class) + @ResponseBody//返回json串 + public Result customError(HttpServletRequest request, CustomException e){ + return Result.error(e.getCode(), e.getMsg()); + } +} diff --git a/src/main/java/com/example/mapper/AdminMapper.java b/src/main/java/com/example/mapper/AdminMapper.java new file mode 100644 index 0000000..ef38319 --- /dev/null +++ b/src/main/java/com/example/mapper/AdminMapper.java @@ -0,0 +1,32 @@ +package com.example.mapper; + +import com.example.entity.*; +import org.apache.ibatis.annotations.Param; +import org.apache.ibatis.annotations.Select; +import org.springframework.stereotype.Repository; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import java.util.List; + +public interface AdminMapper extends BaseMapper { + + /** + * 查询所有 + */ + List selectAll(Admin admin); + + /** + * 根据ID查询 + */ + Admin selectById(Integer id); + + /** + * 删除 + */ + int deleteById(Integer id); + + @Select("select * from admin where `username` = #{name}") + Admin selectByUsername(@Param("name") String userName); + + + +} \ No newline at end of file diff --git a/src/main/java/com/example/mapper/AnnouncementMapper.java b/src/main/java/com/example/mapper/AnnouncementMapper.java new file mode 100644 index 0000000..454d56f --- /dev/null +++ b/src/main/java/com/example/mapper/AnnouncementMapper.java @@ -0,0 +1,41 @@ +package com.example.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.example.entity.Announcement; +import org.apache.ibatis.annotations.Select; +import org.apache.ibatis.annotations.Param; + +import java.util.List; + +/** + * 公告Mapper + */ +public interface AnnouncementMapper extends BaseMapper { + + /** + * 查询所有已发布的公告 + * @return 公告列表 + */ + @Select("SELECT * FROM announcement WHERE status = 1 ORDER BY is_top DESC, create_time DESC") + List selectAllPublished(); + + /** + * 查询所有已发布的公告（分页） + * @param title 标题关键字 + * @return 公告列表 + */ + @Select("") + List selectAllPublishedWithKeyword(@Param("title") String title); + + /** + * 查询所有公告（包括草稿，仅管理员可用） + * @param title 标题关键字 + * @return 公告列表 + */ + @Select("") + List selectAllForAdmin(@Param("title") String title); +} \ No newline at end of file diff --git a/src/main/java/com/example/mapper/AssessmentReportMapper.java b/src/main/java/com/example/mapper/AssessmentReportMapper.java new file mode 100644 index 0000000..b1bf782 --- /dev/null +++ b/src/main/java/com/example/mapper/AssessmentReportMapper.java @@ -0,0 +1,50 @@ +package com.example.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.example.entity.AssessmentReport; +import org.apache.ibatis.annotations.Param; +import org.apache.ibatis.annotations.Select; + +import java.util.List; + +public interface AssessmentReportMapper extends BaseMapper { + + /** + * 查询患者的评估报告列表 + */ + @Select("SELECT ar.*, p.name as patientName " + + "FROM assessment_report ar " + + "LEFT JOIN patient p ON ar.patient_id = p.id " + + "WHERE ar.patient_id = #{patientId} " + + "ORDER BY ar.create_time DESC") + List selectByPatientId(@Param("patientId") Integer patientId); + + /** + * 查询医生负责的患者的评估报告列表 + */ + @Select("SELECT ar.*, p.name as patientName " + + "FROM assessment_report ar " + + "LEFT JOIN patient p ON ar.patient_id = p.id " + + "INNER JOIN doctor_patient dp ON ar.patient_id = dp.patient_id " + + "WHERE dp.doctor_id = #{doctorId} " + + "ORDER BY ar.create_time DESC") + List selectByDoctorId(@Param("doctorId") Integer doctorId); + + /** + * 查询所有评估报告（管理员使用） + */ + @Select("SELECT ar.*, p.name as patientName " + + "FROM assessment_report ar " + + "LEFT JOIN patient p ON ar.patient_id = p.id " + + "ORDER BY ar.create_time DESC") + List selectAllReports(); + + /** + * 根据ID查询评估报告 + */ + @Select("SELECT id, patient_id, report_period, start_date, end_date, summary, trend_analysis, " + + "recommendation, doctor_comment, status, create_time " + + "FROM assessment_report " + + "WHERE id = #{id}") + AssessmentReport selectById(@Param("id") Integer id); +} \ No newline at end of file diff --git a/src/main/java/com/example/mapper/ChatMessageMapper.java b/src/main/java/com/example/mapper/ChatMessageMapper.java new file mode 100644 index 0000000..bd6696f --- /dev/null +++ b/src/main/java/com/example/mapper/ChatMessageMapper.java @@ -0,0 +1,51 @@ +package com.example.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.example.entity.ChatMessage; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; +import org.apache.ibatis.annotations.Select; +import org.apache.ibatis.annotations.Update; + +import java.util.List; + +@Mapper +public interface ChatMessageMapper extends BaseMapper { + + /** + * 查询两个用户之间的聊天记录 + */ + @Select("SELECT * FROM chat_message WHERE " + + "((sender_id = #{userId1} AND sender_type = #{userType1} AND receiver_id = #{userId2} AND receiver_type = #{userType2}) OR " + + "(sender_id = #{userId2} AND sender_type = #{userType2} AND receiver_id = #{userId1} AND receiver_type = #{userType1})) " + + "ORDER BY send_time ASC") + List selectChatHistory(@Param("userId1") Integer userId1, @Param("userType1") String userType1, + @Param("userId2") Integer userId2, @Param("userType2") String userType2); + + /** + * 将消息标记为已读 + */ + @Update("UPDATE chat_message SET is_read = 1, read_time = NOW() " + + "WHERE receiver_id = #{receiverId} AND receiver_type = #{receiverType} " + + "AND sender_id = #{senderId} AND sender_type = #{senderType} AND is_read = 0") + int markAsRead(@Param("receiverId") Integer receiverId, @Param("receiverType") String receiverType, + @Param("senderId") Integer senderId, @Param("senderType") String senderType); + + /** + * 查询用户的聊天列表（最近联系人） + */ + @Select("SELECT DISTINCT " + + "CASE WHEN sender_id = #{userId} AND sender_type = #{userType} THEN receiver_id ELSE sender_id END AS contact_id, " + + "CASE WHEN sender_id = #{userId} AND sender_type = #{userType} THEN receiver_type ELSE sender_type END AS contact_type " + + "FROM chat_message " + + "WHERE (sender_id = #{userId} AND sender_type = #{userType}) OR (receiver_id = #{userId} AND receiver_type = #{userType}) " + + "ORDER BY MAX(send_time) DESC") + List selectChatContacts(@Param("userId") Integer userId, @Param("userType") String userType); + + /** + * 统计未读消息数 + */ + @Select("SELECT COUNT(*) FROM chat_message WHERE receiver_id = #{receiverId} AND receiver_type = #{receiverType} AND sender_id = #{senderId} AND sender_type = #{senderType} AND is_read = 0") + int countUnreadMessages(@Param("receiverId") Integer receiverId, @Param("receiverType") String receiverType, + @Param("senderId") Integer senderId, @Param("senderType") String senderType); +} \ No newline at end of file diff --git a/src/main/java/com/example/mapper/DoctorMapper.java b/src/main/java/com/example/mapper/DoctorMapper.java new file mode 100644 index 0000000..bd514a9 --- /dev/null +++ b/src/main/java/com/example/mapper/DoctorMapper.java @@ -0,0 +1,29 @@ +package com.example.mapper; + +import com.example.entity.*; +import org.apache.ibatis.annotations.Param; +import org.apache.ibatis.annotations.Select; +import org.springframework.stereotype.Repository; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import java.util.List; + +public interface DoctorMapper extends BaseMapper { + + /** + * 查询所有 + */ + List selectAll(Doctor doctor); + + /** + * 根据ID查询 + */ + Doctor selectById(Integer id); + + /** + * 删除 + */ + int deleteById(Integer id); + + @Select("select * from doctor where `username` = #{name}") + Doctor selectByUsername(@Param("name") String userName); +} \ No newline at end of file diff --git a/src/main/java/com/example/mapper/DoctorPatientMapper.java b/src/main/java/com/example/mapper/DoctorPatientMapper.java new file mode 100644 index 0000000..2d32e30 --- /dev/null +++ b/src/main/java/com/example/mapper/DoctorPatientMapper.java @@ -0,0 +1,28 @@ +package com.example.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.example.entity.DoctorPatient; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; + +import java.util.List; + +@Mapper +public interface DoctorPatientMapper extends BaseMapper { + + /** + * 根据医生ID查询关联的患者 + * @param doctorId 医生ID + * @param name 患者姓名（可选） + * @return 患者列表 + */ + List selectByDoctorId(@Param("doctorId") Integer doctorId, @Param("name") String name); + + /** + * 根据患者ID查询关联的医生 + * @param patientId 患者ID + * @param name 医生姓名（可选） + * @return 医生列表 + */ + List selectByPatientId(@Param("patientId") Integer patientId, @Param("name") String name); +} \ No newline at end of file diff --git a/src/main/java/com/example/mapper/PatientMapper.java b/src/main/java/com/example/mapper/PatientMapper.java new file mode 100644 index 0000000..176e225 --- /dev/null +++ b/src/main/java/com/example/mapper/PatientMapper.java @@ -0,0 +1,29 @@ +package com.example.mapper; + +import com.example.entity.*; +import org.apache.ibatis.annotations.Param; +import org.apache.ibatis.annotations.Select; +import org.springframework.stereotype.Repository; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import java.util.List; + +public interface PatientMapper extends BaseMapper { + + /** + * 查询所有 + */ + List selectAll(Patient patient); + + /** + * 根据ID查询 + */ + Patient selectById(Integer id); + + /** + * 删除 + */ + int deleteById(Integer id); + + @Select("select * from patient where `username` = #{name}") + Patient selectByUsername(@Param("name") String userName); +} \ No newline at end of file diff --git a/src/main/java/com/example/mapper/ResourceCategoryMapper.java b/src/main/java/com/example/mapper/ResourceCategoryMapper.java new file mode 100644 index 0000000..8935053 --- /dev/null +++ b/src/main/java/com/example/mapper/ResourceCategoryMapper.java @@ -0,0 +1,20 @@ +package com.example.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.example.entity.ResourceCategory; +import org.apache.ibatis.annotations.Param; +import org.apache.ibatis.annotations.Select; + +import java.util.List; + +public interface ResourceCategoryMapper extends BaseMapper { + + @Select("SELECT * FROM resource_category WHERE parent_id = #{parentId}") + List selectByParentId(Integer parentId); + + @Select("SELECT * FROM resource_category ORDER BY parent_id, id") + List selectAllCategories(); + + @Select("SELECT * FROM resource_category WHERE name LIKE CONCAT('%', #{name}, '%') ORDER BY parent_id, id") + List selectPage(@Param("name") String name); +} \ No newline at end of file diff --git a/src/main/java/com/example/mapper/ResourceRatingMapper.java b/src/main/java/com/example/mapper/ResourceRatingMapper.java new file mode 100644 index 0000000..e7b369a --- /dev/null +++ b/src/main/java/com/example/mapper/ResourceRatingMapper.java @@ -0,0 +1,46 @@ +package com.example.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.example.entity.ResourceRating; +import org.apache.ibatis.annotations.Param; +import org.apache.ibatis.annotations.Select; + +import java.util.List; + +public interface ResourceRatingMapper extends BaseMapper { + + /** + * 根据资源ID查询评分记录，包含用户名信息 + */ + @Select("SELECT r.*, p.name as patient_name " + + "FROM resource_rating r " + + "LEFT JOIN patient p ON r.patient_id = p.id " + + "WHERE r.resource_id = #{resourceId} " + + "ORDER BY r.create_time DESC") + List selectByResourceId(@Param("resourceId") Integer resourceId); + + /** + * 查询用户是否已对某资源评分 + */ + @Select("SELECT COUNT(*) FROM resource_rating WHERE resource_id = #{resourceId} AND patient_id = #{patientId}") + int countByResourceIdAndPatientId(@Param("resourceId") Integer resourceId, @Param("patientId") Integer patientId); + + /** + * 获取资源的平均评分 + */ + @Select("SELECT IFNULL(AVG(rating), 0) FROM resource_rating WHERE resource_id = #{resourceId}") + double getAverageRating(@Param("resourceId") Integer resourceId); + + /** + * 获取资源的评价数量 + */ + @Select("SELECT COUNT(*) FROM resource_rating WHERE resource_id = #{resourceId}") + Integer getRatingCount(@Param("resourceId") Integer resourceId); + + /** + * 根据资源ID和患者ID查询评分记录 + */ + @Select("SELECT * FROM resource_rating WHERE resource_id = #{resourceId} AND patient_id = #{patientId} LIMIT 1") + ResourceRating findByResourceAndPatient(@Param("resourceId") Integer resourceId, @Param("patientId") Integer patientId); +} \ No newline at end of file diff --git a/src/main/java/com/example/mapper/SymptomRecordMapper.java b/src/main/java/com/example/mapper/SymptomRecordMapper.java new file mode 100644 index 0000000..a545d61 --- /dev/null +++ b/src/main/java/com/example/mapper/SymptomRecordMapper.java @@ -0,0 +1,36 @@ +package com.example.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.example.entity.SymptomRecord; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; +import org.apache.ibatis.annotations.Select; + +import java.time.LocalDate; +import java.util.List; + +/** + * 症状记录Mapper接口 + */ +@Mapper +public interface SymptomRecordMapper extends BaseMapper { + + /** + * 查询症状记录并关联患者信息 + * @param patientId 患者ID (可选) + * @return 症状记录列表 + */ + List selectWithPatient(@Param("patientId") Integer patientId); + + /** + * 根据患者ID和日期范围查询症状记录 + */ + @Select("SELECT * FROM symptom_record " + + "WHERE patient_id = #{patientId} " + + "AND record_time BETWEEN #{startDate} AND #{endDate} " + + "ORDER BY record_time ASC") + List selectByPatientIdAndDateRange( + @Param("patientId") Integer patientId, + @Param("startDate") LocalDate startDate, + @Param("endDate") LocalDate endDate); +} \ No newline at end of file diff --git a/src/main/java/com/example/mapper/TreatmentResourceMapper.java b/src/main/java/com/example/mapper/TreatmentResourceMapper.java new file mode 100644 index 0000000..9f6793f --- /dev/null +++ b/src/main/java/com/example/mapper/TreatmentResourceMapper.java @@ -0,0 +1,67 @@ +package com.example.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.example.entity.TreatmentResource; +import org.apache.ibatis.annotations.Param; +import org.apache.ibatis.annotations.Select; +import org.apache.ibatis.annotations.Update; + +import java.util.List; + +public interface TreatmentResourceMapper extends BaseMapper { + + @Select("SELECT r.*, c.name as category_name " + + "FROM treatment_resource r " + + "LEFT JOIN resource_category c ON r.category_id = c.id " + + "WHERE r.audit_status = '已通过' " + + "AND (r.title LIKE CONCAT('%', #{keyword}, '%') " + + "OR r.applicable_symptoms LIKE CONCAT('%', #{keyword}, '%')) " + + "ORDER BY r.create_time DESC") + Page searchResourcesForPatient(Page page, @Param("keyword") String keyword); + + @Select("SELECT r.*, c.name as category_name " + + "FROM treatment_resource r " + + "LEFT JOIN resource_category c ON r.category_id = c.id " + + "WHERE (r.title LIKE CONCAT('%', #{keyword}, '%') " + + "OR r.applicable_symptoms LIKE CONCAT('%', #{keyword}, '%')) " + + "ORDER BY r.create_time DESC") + Page searchResourcesForAdmin(Page page, @Param("keyword") String keyword); + + @Select("SELECT r.*, c.name as category_name " + + "FROM treatment_resource r " + + "LEFT JOIN resource_category c ON r.category_id = c.id " + + "WHERE (r.title LIKE CONCAT('%', #{keyword}, '%') " + + "OR r.applicable_symptoms LIKE CONCAT('%', #{keyword}, '%')) " + + "ORDER BY r.create_time DESC") + List selectAll(@Param("keyword") String keyword); + + @Select("SELECT r.*, c.name as category_name " + + "FROM treatment_resource r " + + "LEFT JOIN resource_category c ON r.category_id = c.id " + + "WHERE r.audit_status = '已通过' " + + "AND (r.title LIKE CONCAT('%', #{keyword}, '%') " + + "OR r.applicable_symptoms LIKE CONCAT('%', #{keyword}, '%')) " + + "ORDER BY r.create_time DESC") + List selectAllAudited(@Param("keyword") String keyword); + + @Select("SELECT r.*, c.name as category_name " + + "FROM treatment_resource r " + + "LEFT JOIN resource_category c ON r.category_id = c.id " + + "WHERE r.category_id = #{categoryId} " + + "AND r.audit_status = '已通过' " + + "ORDER BY r.create_time DESC") + List selectByCategoryId(@Param("categoryId") Integer categoryId); + + @Update("UPDATE treatment_resource SET visit_count = visit_count + 1 WHERE id = #{id}") + int incrementVisitCount(@Param("id") Integer id); + + @Update("UPDATE treatment_resource SET download_count = download_count + 1 WHERE id = #{id}") + int incrementDownloadCount(@Param("id") Integer id); + + /** + * 根据发布者ID查询所有资源 + */ + @Select("SELECT * FROM treatment_resource WHERE publisher_id = #{publisherId} AND (title LIKE CONCAT('%', #{keyword}, '%') OR applicable_symptoms LIKE CONCAT('%', #{keyword}, '%'))") + List selectByPublisher(@Param("publisherId") Integer publisherId, @Param("keyword") String keyword); +} \ No newline at end of file diff --git a/src/main/java/com/example/service/AIChatService.java b/src/main/java/com/example/service/AIChatService.java new file mode 100644 index 0000000..f7af1a6 --- /dev/null +++ b/src/main/java/com/example/service/AIChatService.java @@ -0,0 +1,171 @@ +package com.example.service; + +import com.example.common.config.TokenUtils; +import com.example.common.enums.ResultCodeEnum; +import com.example.entity.Account; +import com.example.exception.CustomException; +import jakarta.annotation.Resource; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.http.*; +import org.springframework.stereotype.Service; +import org.springframework.web.client.RestTemplate; + +import java.util.*; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@Service +public class AIChatService { + + private static final Logger log = LoggerFactory.getLogger(AIChatService.class); + + @Resource + private RestTemplate restTemplate; + + @Value("${dashscope.api-key}") + private String apiKey; + + @Value("${dashscope.model}") + private String model; + + private final String API_URL = "https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation"; + + /** + * 发送消息到通义千问API并获取回复 + */ + public String sendMessage(String message) { + // 获取当前登录用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_CHECK_ERROR); + } + + log.info("准备发送消息到通义千问API，用户ID: {}, 消息内容: {}", currentUser.getId(), message); + + // 构建请求头 + HttpHeaders headers = new HttpHeaders(); + headers.setContentType(MediaType.APPLICATION_JSON); + headers.set("Authorization", "Bearer " + apiKey); + + // 构建请求体 + Map requestBody = new HashMap<>(); + requestBody.put("model", model); + + // 添加参数 + Map parameters = new HashMap<>(); + parameters.put("temperature", 0.7); + parameters.put("top_p", 0.8); + parameters.put("result_format", "message"); + requestBody.put("parameters", parameters); + + // 添加用户消息 + Map input = new HashMap<>(); + List> messages = new ArrayList<>(); + + Map userMessage = new HashMap<>(); + userMessage.put("role", "user"); + userMessage.put("content", message); + messages.add(userMessage); + + input.put("messages", messages); + requestBody.put("input", input); + + try { + // 记录完整请求 + log.info("发送请求到API: {}", API_URL); + log.info("请求体: {}", requestBody); + + // 发送请求 + HttpEntity> requestEntity = new HttpEntity<>(requestBody, headers); + ResponseEntity response = restTemplate.exchange(API_URL, HttpMethod.POST, requestEntity, Map.class); + + // 记录响应 + log.info("API响应状态码: {}", response.getStatusCode()); + log.debug("API响应内容: {}", response.getBody()); + + if (response.getStatusCode() == HttpStatus.OK) { + Map responseBody = response.getBody(); + if (responseBody != null) { + // 检查错误字段 + if (responseBody.containsKey("code") && !responseBody.get("code").equals(200) && responseBody.containsKey("message")) { + String errorMessage = (String) responseBody.get("message"); + log.error("API返回错误: {}", errorMessage); + return "API错误: " + errorMessage; + } + + // 尝试多种可能的响应格式 + String content = extractContentFromResponse(responseBody); + if (content != null) { + return content; + } + } + + log.warn("无法从API响应中提取内容: {}", responseBody); + return "抱歉，我无法理解您的问题。"; + } else { + log.error("API响应错误状态码: {}", response.getStatusCode()); + throw new CustomException(ResultCodeEnum.SYSTEM_ERROR.code, "AI服务异常，请稍后再试"); + } + } catch (Exception e) { + log.error("调用通义千问API出错: ", e); + throw new CustomException(ResultCodeEnum.SYSTEM_ERROR.code, "AI服务异常: " + e.getMessage()); + } + } + + /** + * 尝试从不同格式的响应中提取内容 + */ + private String extractContentFromResponse(Map responseBody) { + // 格式1: output.choices[0].message.content + try { + if (responseBody.containsKey("output")) { + Map output = (Map) responseBody.get("output"); + if (output.containsKey("choices")) { + List> choices = (List>) output.get("choices"); + if (choices != null && !choices.isEmpty()) { + Map choice = choices.get(0); + if (choice.containsKey("message")) { + Map message = (Map) choice.get("message"); + if (message.containsKey("content")) { + return (String) message.get("content"); + } + } + } + } + } + } catch (Exception e) { + log.warn("尝试格式1提取内容失败: ", e); + } + + // 格式2: data.choices[0].content + try { + if (responseBody.containsKey("data")) { + Map data = (Map) responseBody.get("data"); + if (data.containsKey("choices")) { + List> choices = (List>) data.get("choices"); + if (choices != null && !choices.isEmpty()) { + Map choice = choices.get(0); + if (choice.containsKey("content")) { + return (String) choice.get("content"); + } + } + } + } + } catch (Exception e) { + log.warn("尝试格式2提取内容失败: ", e); + } + + // 格式3: result + try { + if (responseBody.containsKey("result")) { + return (String) responseBody.get("result"); + } + } catch (Exception e) { + log.warn("尝试格式3提取内容失败: ", e); + } + + // 记录完整响应，便于调试 + log.info("响应体解析失败，完整响应: {}", responseBody); + return null; + } +} \ No newline at end of file diff --git a/src/main/java/com/example/service/AdminService.java b/src/main/java/com/example/service/AdminService.java new file mode 100644 index 0000000..ea9163e --- /dev/null +++ b/src/main/java/com/example/service/AdminService.java @@ -0,0 +1,134 @@ +package com.example.service; + +import cn.hutool.core.util.ObjectUtil; +import com.example.common.Constants; +import com.example.common.enums.ResultCodeEnum; +import com.example.entity.*; +import com.example.exception.CustomException; +import com.example.mapper.*; +import com.example.common.config.TokenUtils; +import com.github.pagehelper.PageHelper; +import com.github.pagehelper.PageInfo; +import jakarta.annotation.Resource; +import org.springframework.stereotype.Service; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +@Service +public class AdminService { + + @Resource + private AdminMapper adminMapper; + + /** + * 新增 + */ + public void add(Admin admin) { + // 唯一校验 + Admin dbAdmin = adminMapper.selectByUsername(admin.getUsername()); + if (ObjectUtil.isNotNull(dbAdmin)) { + throw new CustomException(ResultCodeEnum.USER_EXIST_ERROR); + } + if (ObjectUtil.isEmpty(admin.getPassword())) { + admin.setPassword(Constants.USER_DEFAULT_PASSWORD); + } + if (ObjectUtil.isEmpty(admin.getName())) { + admin.setName(admin.getUsername()); + } + admin.setRole("admin"); + adminMapper.insert(admin); + } + + /** + * 删除 + */ + public void deleteById(Integer id) { + adminMapper.deleteById(id); + } + + /** + * 批量删除 + */ + public void deleteBatch(List ids) { + for (Integer id : ids) { + adminMapper.deleteById(id); + } + } + + /** + * 修改 + */ + public void updateById(Admin admin) { + adminMapper.updateById(admin); + } + + /** + * 根据ID查询 + */ + public Admin selectById(Integer id) { + return adminMapper.selectById(id); + } + + /** + * 查询所有 + */ + public List selectAll(Admin admin) { + return adminMapper.selectAll(admin); + } + + /** + * 分页查询 + */ + public PageInfo selectPage(Admin admin, Integer pageNum, Integer pageSize) { + + PageHelper.startPage(pageNum, pageSize); + List list = adminMapper.selectAll(admin); + + return PageInfo.of(list); + } + + /** + * 注册 + */ + public void register(Account account) { + Admin admin = new Admin(); + admin.setUsername(account.getUsername()); + admin.setPassword(account.getPassword()); + this.add(admin); + } + + public Admin login(Account account) { + Admin dbAdmin = adminMapper.selectByUsername(account.getUsername()); + if (ObjectUtil.isNull(dbAdmin)) { + throw new CustomException(ResultCodeEnum.USER_NOT_EXIST_ERROR); + } + if (!account.getPassword().equals(dbAdmin.getPassword())) { + throw new CustomException(ResultCodeEnum.USER_ACCOUNT_ERROR); + } + // 生成token + String tokenData = dbAdmin.getId() + "-admin"; + String token = TokenUtils.genToken(tokenData, dbAdmin.getPassword()); + dbAdmin.setToken(token); + + + return dbAdmin; + } + + /** + * 修改密码 + */ + public void updatePassword(Account account) { + Admin dbAdmin = adminMapper.selectByUsername(account.getUsername()); + if (ObjectUtil.isNull(dbAdmin)) { + throw new CustomException(ResultCodeEnum.USER_NOT_EXIST_ERROR); + } + if (!account.getPassword().equals(dbAdmin.getPassword())) { + throw new CustomException(ResultCodeEnum.PARAM_PASSWORD_ERROR); + } + dbAdmin.setPassword(account.getNewPassword()); + adminMapper.updateById(dbAdmin); + } + +} \ No newline at end of file diff --git a/src/main/java/com/example/service/AnnouncementService.java b/src/main/java/com/example/service/AnnouncementService.java new file mode 100644 index 0000000..57bfc8d --- /dev/null +++ b/src/main/java/com/example/service/AnnouncementService.java @@ -0,0 +1,164 @@ +package com.example.service; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.example.common.config.TokenUtils; +import com.example.common.enums.ResultCodeEnum; +import com.example.entity.Account; +import com.example.entity.Announcement; +import com.example.exception.CustomException; +import com.example.mapper.AnnouncementMapper; +import com.github.pagehelper.PageHelper; +import com.github.pagehelper.PageInfo; +import jakarta.annotation.Resource; +import org.springframework.stereotype.Service; + +import java.util.Date; +import java.util.List; + +/** + * 公告服务类 + */ +@Service +public class AnnouncementService { + + @Resource + private AnnouncementMapper announcementMapper; + + /** + * 添加公告 + * @param announcement 公告信息 + */ + public void add(Announcement announcement) { + // 获取当前用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_CHECK_ERROR); + } + + // 验证权限 + if (!"admin".equals(currentUser.getRole())) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "只有管理员可以发布公告"); + } + + // 设置默认值 + if (announcement.getIsTop() == null) { + announcement.setIsTop(false); + } + + if (announcement.getStatus() == null) { + announcement.setStatus(0); // 默认为草稿状态 + } + + announcement.setCreateTime(new Date()); + announcement.setPublisherId(currentUser.getId()); + announcement.setPublisherName(currentUser.getName()); + + announcementMapper.insert(announcement); + } + + /** + * 更新公告 + * @param announcement 公告信息 + */ + public void update(Announcement announcement) { + // 获取当前用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_CHECK_ERROR); + } + + // 验证权限 + if (!"admin".equals(currentUser.getRole())) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "只有管理员可以修改公告"); + } + + // 获取原公告 + Announcement dbAnnouncement = announcementMapper.selectById(announcement.getId()); + if (dbAnnouncement == null) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "公告不存在"); + } + + // 只更新部分字段，保留创建时间等信息 + dbAnnouncement.setTitle(announcement.getTitle()); + dbAnnouncement.setContent(announcement.getContent()); + dbAnnouncement.setIsTop(announcement.getIsTop()); + dbAnnouncement.setStatus(announcement.getStatus()); + + announcementMapper.updateById(dbAnnouncement); + } + + /** + * 删除公告 + * @param id 公告ID + */ + public void delete(Integer id) { + // 获取当前用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_CHECK_ERROR); + } + + // 验证权限 + if (!"admin".equals(currentUser.getRole())) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "只有管理员可以删除公告"); + } + + announcementMapper.deleteById(id); + } + + /** + * 获取公告详情 + * @param id 公告ID + * @return 公告信息 + */ + public Announcement getById(Integer id) { + return announcementMapper.selectById(id); + } + + /** + * 获取所有已发布的公告（分页，所有用户可访问） + * @param pageNum 页码 + * @param pageSize 每页大小 + * @param title 标题关键字 + * @return 分页公告列表 + */ + public PageInfo getPublishedPage(Integer pageNum, Integer pageSize, String title) { + PageHelper.startPage(pageNum, pageSize); + List list = announcementMapper.selectAllPublishedWithKeyword(title); + return new PageInfo<>(list); + } + + /** + * 获取所有公告（分页，包括草稿，仅管理员可用） + * @param pageNum 页码 + * @param pageSize 每页大小 + * @param title 标题关键字 + * @return 分页公告列表 + */ + public PageInfo getAllForAdmin(Integer pageNum, Integer pageSize, String title) { + // 获取当前用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_CHECK_ERROR); + } + + // 验证权限 + if (!"admin".equals(currentUser.getRole())) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "只有管理员可以查看所有公告"); + } + + PageHelper.startPage(pageNum, pageSize); + List list = announcementMapper.selectAllForAdmin(title); + return new PageInfo<>(list); + } + + /** + * 获取最新的几条已发布公告（用于首页展示） + * @param limit 限制条数 + * @return 公告列表 + */ + public List getLatestPublished(Integer limit) { + PageHelper.startPage(1, limit); + return announcementMapper.selectAllPublished(); + } +} \ No newline at end of file diff --git a/src/main/java/com/example/service/AssessmentReportService.java b/src/main/java/com/example/service/AssessmentReportService.java new file mode 100644 index 0000000..eb9555a --- /dev/null +++ b/src/main/java/com/example/service/AssessmentReportService.java @@ -0,0 +1,530 @@ +package com.example.service; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.example.common.enums.ResultCodeEnum; +import com.example.common.config.TokenUtils; +import com.example.entity.Account; +import com.example.entity.AssessmentReport; +import com.example.entity.Patient; +import com.example.entity.SymptomRecord; +import com.example.exception.CustomException; +import com.example.mapper.AssessmentReportMapper; +import com.example.mapper.SymptomRecordMapper; +import jakarta.annotation.Resource; +import org.springframework.stereotype.Service; +import org.springframework.scheduling.annotation.Scheduled; + +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; +import java.time.temporal.ChronoUnit; +import java.util.ArrayList; +import java.util.Date; +import java.util.DoubleSummaryStatistics; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; +import java.util.HashMap; + +@Service +public class AssessmentReportService { + + @Resource + private AssessmentReportMapper assessmentReportMapper; + + @Resource + private SymptomRecordMapper symptomRecordMapper; + + @Resource + private PatientService patientService; + + /** + * 生成评估报告 + * @param patientId 患者ID + * @param reportPeriod 报告周期类型（"week"/"month"） + * @return 生成的评估报告 + */ + public AssessmentReport generateReport(Integer patientId, String reportPeriod) { + // 获取当前用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_CHECK_ERROR); + } + + // 验证权限 + String role = currentUser.getRole(); + if (!"admin".equals(role) && !"doctor".equals(role) && + (!"patient".equals(role) || !currentUser.getId().equals(patientId))) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "无权生成该患者的评估报告"); + } + + // 设置报告时间范围 + LocalDate endDate = LocalDate.now(); + LocalDate startDate; + + if ("week".equals(reportPeriod)) { + startDate = endDate.minusWeeks(1); + } else if ("month".equals(reportPeriod)) { + startDate = endDate.minusMonths(1); + } else { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "无效的报告周期类型"); + } + + // 获取时间范围内的症状记录 + List records = symptomRecordMapper.selectByPatientIdAndDateRange( + patientId, startDate, endDate); + + if (records.isEmpty()) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "所选时间范围内没有症状记录"); + } + + // 创建评估报告 + AssessmentReport report = new AssessmentReport(); + report.setPatientId(patientId); + report.setReportPeriod("week".equals(reportPeriod) ? "周报" : "月报"); + report.setStartDate(startDate); + report.setEndDate(endDate); + report.setStatus("未读"); + report.setCreateTime(LocalDateTime.now()); + + // 生成报告内容 + generateReportContent(report, records); + + // 保存报告 + assessmentReportMapper.insert(report); + + return report; + } + + /** + * 生成报告内容 + */ + private void generateReportContent(AssessmentReport report, List records) { + // 计算统计数据 + DoubleSummaryStatistics severityStats = records.stream() + .map(SymptomRecord::getSeverityLevel) + .filter(val -> val != null) + .mapToDouble(Integer::doubleValue) + .summaryStatistics(); + + DoubleSummaryStatistics emotionStats = records.stream() + .map(SymptomRecord::getEmotionScore) + .filter(val -> val != null) + .mapToDouble(Integer::doubleValue) + .summaryStatistics(); + + DoubleSummaryStatistics sleepStats = records.stream() + .map(SymptomRecord::getSleepTime) + .filter(val -> val != null) + .mapToDouble(Integer::doubleValue) + .summaryStatistics(); + + // 生成总体评估 + StringBuilder summary = new StringBuilder(); + summary.append("本") + .append(report.getReportPeriod()) + .append("期间（") + .append(report.getStartDate().format(DateTimeFormatter.ISO_LOCAL_DATE)) + .append(" 至 ") + .append(report.getEndDate().format(DateTimeFormatter.ISO_LOCAL_DATE)) + .append("），共记录了 ") + .append(records.size()) + .append(" 条症状数据。\n\n"); + + summary.append("严重程度评分：平均 ") + .append(String.format("%.1f", severityStats.getAverage())) + .append("，最高 ") + .append((int)severityStats.getMax()) + .append("，最低 ") + .append((int)severityStats.getMin()) + .append("。\n"); + + summary.append("情绪基线评分：平均 ") + .append(String.format("%.1f", emotionStats.getAverage())) + .append("，最高 ") + .append((int)emotionStats.getMax()) + .append("，最低 ") + .append((int)emotionStats.getMin()) + .append("。\n"); + + summary.append("入睡时间：平均 ") + .append(String.format("%.1f", sleepStats.getAverage())) + .append(" 分钟，最长 ") + .append((int)sleepStats.getMax()) + .append(" 分钟，最短 ") + .append((int)sleepStats.getMin()) + .append(" 分钟。\n"); + + // 设置总体评估 + report.setSummary(summary.toString()); + + // 生成趋势分析 + StringBuilder trend = new StringBuilder(); + + // 按记录时间转换为LocalDate进行分组 + Map> recordsByDate = new HashMap<>(); + for (SymptomRecord record : records) { + Date recordTime = record.getRecordTime(); + if (recordTime != null) { + LocalDate recordDate = new java.sql.Date(recordTime.getTime()).toLocalDate(); + if (!recordsByDate.containsKey(recordDate)) { + recordsByDate.put(recordDate, new ArrayList<>()); + } + recordsByDate.get(recordDate).add(record); + } + } + + // 获取排序后的日期列表 + List dates = new ArrayList<>(recordsByDate.keySet()); + dates.sort(LocalDate::compareTo); + + if (dates.size() > 1) { + // 计算首尾日期的平均严重程度 + double firstDaySeverity = recordsByDate.get(dates.get(0)).stream() + .map(SymptomRecord::getSeverityLevel) + .filter(val -> val != null) + .mapToDouble(Integer::doubleValue) + .average() + .orElse(0); + + double lastDaySeverity = recordsByDate.get(dates.get(dates.size() - 1)).stream() + .map(SymptomRecord::getSeverityLevel) + .filter(val -> val != null) + .mapToDouble(Integer::doubleValue) + .average() + .orElse(0); + + // 趋势分析 + trend.append("症状严重程度："); + if (lastDaySeverity < firstDaySeverity) { + trend.append("整体呈下降趋势，相比初始记录降低了 ") + .append(String.format("%.1f", firstDaySeverity - lastDaySeverity)) + .append(" 点，病情有所好转。"); + } else if (lastDaySeverity > firstDaySeverity) { + trend.append("整体呈上升趋势，相比初始记录增加了 ") + .append(String.format("%.1f", lastDaySeverity - firstDaySeverity)) + .append(" 点，病情有所加重。"); + } else { + trend.append("整体保持稳定，症状严重程度变化不明显。"); + } + trend.append("\n\n"); + + // 情绪基线趋势分析 + double firstDayEmotion = recordsByDate.get(dates.get(0)).stream() + .map(SymptomRecord::getEmotionScore) + .filter(val -> val != null) + .mapToDouble(Integer::doubleValue) + .average() + .orElse(0); + + double lastDayEmotion = recordsByDate.get(dates.get(dates.size() - 1)).stream() + .map(SymptomRecord::getEmotionScore) + .filter(val -> val != null) + .mapToDouble(Integer::doubleValue) + .average() + .orElse(0); + + trend.append("情绪状态："); + if (lastDayEmotion > firstDayEmotion) { + trend.append("呈积极改善趋势，情绪基线提高了 ") + .append(String.format("%.1f", lastDayEmotion - firstDayEmotion)) + .append(" 点。"); + } else if (lastDayEmotion < firstDayEmotion) { + trend.append("呈下降趋势，情绪基线降低了 ") + .append(String.format("%.1f", firstDayEmotion - lastDayEmotion)) + .append(" 点，需要关注情绪变化。"); + } else { + trend.append("情绪基线保持稳定。"); + } + } else { + trend.append("记录天数不足，无法进行趋势分析。建议持续记录症状，以便更准确地评估病情变化。"); + } + + // 设置趋势分析 + report.setTrendAnalysis(trend.toString()); + + // 生成建议 + StringBuilder recommendation = new StringBuilder(); + + // 基于严重程度的建议 + double avgSeverity = severityStats.getAverage(); + if (avgSeverity >= 7) { + recommendation.append("● 症状严重程度较高，建议及时就医或保持与医生的密切沟通。\n"); + recommendation.append("● 注意休息，避免过度劳累和压力。\n"); + } else if (avgSeverity >= 4) { + recommendation.append("● 症状处于中等程度，建议遵循医嘱进行调整。\n"); + recommendation.append("● 可以尝试适当的放松训练和心理调适方法。\n"); + } else { + recommendation.append("● 症状程度较轻，建议继续保持良好的生活习惯。\n"); + } + + // 基于情绪状态的建议 + double avgEmotion = emotionStats.getAverage(); + if (avgEmotion <= 4) { + recommendation.append("● 情绪基线较低，建议尝试以下方法改善情绪：\n"); + recommendation.append(" - 每天进行至少30分钟的适当运动\n"); + recommendation.append(" - 学习简单的冥想或深呼吸放松技巧\n"); + recommendation.append(" - 与亲友多交流，分享感受\n"); + } + + // 基于睡眠情况的建议 + double avgSleep = sleepStats.getAverage(); + if (avgSleep > 30) { + recommendation.append("● 入睡时间较长，建议改善睡眠习惯：\n"); + recommendation.append(" - 保持规律的睡眠时间表\n"); + recommendation.append(" - 睡前一小时避免使用电子设备\n"); + recommendation.append(" - 睡前可以喝杯温热的牛奶或进行轻度放松活动\n"); + } + + // 一般性建议 + recommendation.append("\n持续记录症状变化，这将帮助您和医生更好地了解病情发展，制定更适合的治疗方案。"); + + // 设置建议 + report.setRecommendation(recommendation.toString()); + } + + /** + * 每周一凌晨2点自动生成周报 + */ + @Scheduled(cron = "0 0 2 ? * MON") + public void generateWeeklyReports() { + List patients = getPatients(); + for (Account patient : patients) { + try { + generateReportForPatient(patient.getId(), "week"); + } catch (Exception e) { + // 记录错误但不中断流程 + System.err.println("为患者 " + patient.getId() + " 生成周报失败: " + e.getMessage()); + } + } + } + + /** + * 每月1日凌晨3点自动生成月报 + */ + @Scheduled(cron = "0 0 3 1 * ?") + public void generateMonthlyReports() { + List patients = getPatients(); + for (Account patient : patients) { + try { + generateReportForPatient(patient.getId(), "month"); + } catch (Exception e) { + // 记录错误但不中断流程 + System.err.println("为患者 " + patient.getId() + " 生成月报失败: " + e.getMessage()); + } + } + } + + /** + * 为患者生成报告（内部方法，用于定时任务） + */ + private AssessmentReport generateReportForPatient(Integer patientId, String reportPeriod) { + LocalDate endDate = LocalDate.now(); + LocalDate startDate; + + if ("week".equals(reportPeriod)) { + startDate = endDate.minusWeeks(1); + } else { + startDate = endDate.minusMonths(1); + } + + // 获取时间范围内的症状记录 + List records = symptomRecordMapper.selectByPatientIdAndDateRange( + patientId, startDate, endDate); + + // 如果没有记录，则不生成报告 + if (records.isEmpty()) { + return null; + } + + // 创建评估报告 + AssessmentReport report = new AssessmentReport(); + report.setPatientId(patientId); + report.setReportPeriod("week".equals(reportPeriod) ? "周报" : "月报"); + report.setStartDate(startDate); + report.setEndDate(endDate); + report.setStatus("未读"); + report.setCreateTime(LocalDateTime.now()); + + // 生成报告内容 + generateReportContent(report, records); + + // 保存报告 + assessmentReportMapper.insert(report); + + return report; + } + + /** + * 获取所有患者列表 + */ + private List getPatients() { + // 使用PatientService获取所有患者 + Patient queryPatient = new Patient(); + return new ArrayList<>(patientService.selectAll(queryPatient)); + } + + /** + * 获取患者的评估报告列表 + */ + public List getReportsByPatientId(Integer patientId) { + // 获取当前用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_CHECK_ERROR); + } + + // 验证权限 + String role = currentUser.getRole(); + if (!"admin".equals(role) && !"doctor".equals(role) && + (!"patient".equals(role) || !currentUser.getId().equals(patientId))) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "无权查看该患者的评估报告"); + } + + return assessmentReportMapper.selectByPatientId(patientId); + } + + /** + * 获取医生负责的患者的评估报告列表 + */ + public List getReportsByDoctorId(Integer doctorId) { + // 获取当前用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_CHECK_ERROR); + } + + // 验证权限 + String role = currentUser.getRole(); + if (!"admin".equals(role) && + (!"doctor".equals(role) || !currentUser.getId().equals(doctorId))) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "无权查看该医生负责的评估报告"); + } + + return assessmentReportMapper.selectByDoctorId(doctorId); + } + + /** + * 获取所有评估报告列表（管理员使用） + */ + public List getAllReports() { + // 获取当前用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_CHECK_ERROR); + } + + // 验证权限 + if (!"admin".equals(currentUser.getRole())) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "无权查看所有评估报告"); + } + + return assessmentReportMapper.selectAllReports(); + } + + /** + * 添加医生批注 + */ + public void addDoctorComment(Integer reportId, String comment) { + // 获取当前用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_CHECK_ERROR); + } + + // 验证权限 + if (!"doctor".equals(currentUser.getRole()) && !"admin".equals(currentUser.getRole())) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "无权添加批注"); + } + + // 获取报告 + AssessmentReport report = assessmentReportMapper.selectById(reportId); + if (report == null) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "报告不存在"); + } + + // 更新批注 + report.setDoctorComment(comment); + assessmentReportMapper.updateById(report); + } + + /** + * 更新报告状态为已读 + */ + public void markAsRead(Integer reportId) { + // 获取当前用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_CHECK_ERROR); + } + + // 获取报告 + AssessmentReport report = assessmentReportMapper.selectById(reportId); + if (report == null) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "报告不存在"); + } + + // 验证权限 + if (!"admin".equals(currentUser.getRole()) && + !"doctor".equals(currentUser.getRole()) && + (!"patient".equals(currentUser.getRole()) || !currentUser.getId().equals(report.getPatientId()))) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "无权操作该报告"); + } + + // 更新状态 + report.setStatus("已读"); + assessmentReportMapper.updateById(report); + } + + /** + * 通过ID获取单个报告 + * @param reportId 报告ID + * @return 评估报告对象 + */ + public AssessmentReport getReportById(Integer reportId) { + if (reportId == null) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "报告ID不能为空"); + } + + // 获取当前用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_CHECK_ERROR); + } + + // 查询报告 + AssessmentReport report = assessmentReportMapper.selectById(reportId); + + if (report == null) { + return null; + } + + // 权限检查 + String role = currentUser.getRole(); + Integer userId = currentUser.getId(); + + // 管理员可以查看所有报告 + if ("admin".equals(role)) { + return report; + } + + // 医生可以查看自己负责的患者的报告 + if ("doctor".equals(role)) { + List doctorReports = getReportsByDoctorId(userId); + boolean hasAccess = doctorReports.stream() + .anyMatch(r -> r.getId().equals(reportId)); + + if (hasAccess) { + return report; + } + } + + // 患者只能查看自己的报告 + if ("patient".equals(role) && userId.equals(report.getPatientId())) { + return report; + } + + // 无权限访问 + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "无权访问该报告"); + } +} \ No newline at end of file diff --git a/src/main/java/com/example/service/ChatMessageService.java b/src/main/java/com/example/service/ChatMessageService.java new file mode 100644 index 0000000..d1d980a --- /dev/null +++ b/src/main/java/com/example/service/ChatMessageService.java @@ -0,0 +1,221 @@ +package com.example.service; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.example.common.config.TokenUtils; +import com.example.common.enums.ResultCodeEnum; +import com.example.entity.Account; +import com.example.entity.ChatMessage; +import com.example.entity.Doctor; +import com.example.entity.DoctorPatient; +import com.example.entity.Patient; +import com.example.exception.CustomException; +import com.example.mapper.ChatMessageMapper; +import com.example.mapper.DoctorMapper; +import com.example.mapper.PatientMapper; +import jakarta.annotation.Resource; +import org.springframework.stereotype.Service; + +import java.util.*; +import java.util.stream.Collectors; + +@Service +public class ChatMessageService { + + @Resource + private ChatMessageMapper chatMessageMapper; + + @Resource + private DoctorPatientService doctorPatientService; + + @Resource + private DoctorMapper doctorMapper; + + @Resource + private PatientMapper patientMapper; + + /** + * 发送消息 - 通过HTTP接口调用 + */ + public ChatMessage sendMessage(ChatMessage chatMessage) { + // 获取当前用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_CHECK_ERROR); + } + + // 根据当前用户角色设置发送者信息 + chatMessage.setSenderId(currentUser.getId()); + chatMessage.setSenderType(currentUser.getRole()); + + // 检查发送者和接收者是否有关联关系 + checkRelationship(chatMessage.getSenderId(), chatMessage.getSenderType(), + chatMessage.getReceiverId(), chatMessage.getReceiverType()); + + // 设置消息状态 + chatMessage.setSendTime(new Date()); + chatMessage.setIsRead(false); + + // 保存消息 + chatMessageMapper.insert(chatMessage); + + return chatMessage; + } + + /** + * 直接保存消息 - 通过WebSocket调用，不依赖TokenUtils + */ + public ChatMessage directSaveMessage(ChatMessage chatMessage) { + // 检查发送者和接收者是否有关联关系 + checkRelationship(chatMessage.getSenderId(), chatMessage.getSenderType(), + chatMessage.getReceiverId(), chatMessage.getReceiverType()); + + // 保存消息 + chatMessageMapper.insert(chatMessage); + + return chatMessage; + } + + /** + * 获取聊天历史记录 + */ + public List getChatHistory(Integer contactId, String contactType) { + // 获取当前用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_CHECK_ERROR); + } + + // 检查关系 + checkRelationship(currentUser.getId(), currentUser.getRole(), contactId, contactType); + + // 查询聊天记录 + List messages = chatMessageMapper.selectChatHistory( + currentUser.getId(), currentUser.getRole(), contactId, contactType); + + // 将对方发送的未读消息标记为已读 + chatMessageMapper.markAsRead(currentUser.getId(), currentUser.getRole(), contactId, contactType); + + // 填充发送者和接收者的名称 + fillUserInfo(messages); + + return messages; + } + + /** + * 获取联系人列表 + */ + public List> getContactList() { + // 获取当前用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_CHECK_ERROR); + } + + List> result = new ArrayList<>(); + + // 根据用户角色获取联系人 + if ("doctor".equals(currentUser.getRole())) { + // 医生获取其患者列表 + List relations = doctorPatientService.selectByDoctorId(currentUser.getId(), null); + for (DoctorPatient relation : relations) { + if ("正常".equals(relation.getStatus()) && relation.getPatient() != null) { + Map contact = new HashMap<>(); + contact.put("contactId", relation.getPatientId()); + contact.put("contactType", "patient"); + contact.put("contactName", relation.getPatient().getName()); + contact.put("contactAvatar", relation.getPatient().getAvatar()); + // 查询未读消息数 + int unread = chatMessageMapper.countUnreadMessages( + currentUser.getId(), currentUser.getRole(), relation.getPatientId(), "patient"); + contact.put("unreadCount", unread); + + // 查询最新一条消息 + List lastMessages = chatMessageMapper.selectChatHistory( + currentUser.getId(), currentUser.getRole(), relation.getPatientId(), "patient"); + if (!lastMessages.isEmpty()) { + contact.put("lastMessage", lastMessages.get(lastMessages.size() - 1)); + } + + result.add(contact); + } + } + } else if ("patient".equals(currentUser.getRole())) { + // 患者获取其医生列表 + List relations = doctorPatientService.selectByPatientId(currentUser.getId(), null); + for (DoctorPatient relation : relations) { + if ("正常".equals(relation.getStatus()) && relation.getDoctor() != null) { + Map contact = new HashMap<>(); + contact.put("contactId", relation.getDoctorId()); + contact.put("contactType", "doctor"); + contact.put("contactName", relation.getDoctor().getName()); + contact.put("contactAvatar", relation.getDoctor().getAvatar()); + // 查询未读消息数 + int unread = chatMessageMapper.countUnreadMessages( + currentUser.getId(), currentUser.getRole(), relation.getDoctorId(), "doctor"); + contact.put("unreadCount", unread); + + // 查询最新一条消息 + List lastMessages = chatMessageMapper.selectChatHistory( + currentUser.getId(), currentUser.getRole(), relation.getDoctorId(), "doctor"); + if (!lastMessages.isEmpty()) { + contact.put("lastMessage", lastMessages.get(lastMessages.size() - 1)); + } + + result.add(contact); + } + } + } + + return result; + } + + /** + * 检查用户关系 + */ + private void checkRelationship(Integer senderId, String senderType, Integer receiverId, String receiverType) { + // 检查医生和患者是否存在关联关系 + if ("doctor".equals(senderType) && "patient".equals(receiverType)) { + List relations = doctorPatientService.selectByDoctorId(senderId, null); + boolean hasRelation = relations.stream() + .anyMatch(dp -> dp.getPatientId().equals(receiverId) && "正常".equals(dp.getStatus())); + + if (!hasRelation) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "您与该患者没有关联关系"); + } + } else if ("patient".equals(senderType) && "doctor".equals(receiverType)) { + List relations = doctorPatientService.selectByPatientId(senderId, null); + boolean hasRelation = relations.stream() + .anyMatch(dp -> dp.getDoctorId().equals(receiverId) && "正常".equals(dp.getStatus())); + + if (!hasRelation) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "您与该医生没有关联关系"); + } + } else { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "无效的聊天关系"); + } + } + + /** + * 填充用户信息 + */ + private void fillUserInfo(List messages) { + for (ChatMessage message : messages) { + // 填充发送者信息 + if ("doctor".equals(message.getSenderType())) { + Doctor doctor = doctorMapper.selectById(message.getSenderId()); + if (doctor != null) { + message.setSenderName(doctor.getName()); + message.setSenderAvatar(doctor.getAvatar()); + } + } else if ("patient".equals(message.getSenderType())) { + Patient patient = patientMapper.selectById(message.getSenderId()); + if (patient != null) { + message.setSenderName(patient.getName()); + message.setSenderAvatar(patient.getAvatar()); + } + } + + // 可以根据需要填充接收者信息 + } + } +} \ No newline at end of file diff --git a/src/main/java/com/example/service/DoctorPatientService.java b/src/main/java/com/example/service/DoctorPatientService.java new file mode 100644 index 0000000..9b5c16c --- /dev/null +++ b/src/main/java/com/example/service/DoctorPatientService.java @@ -0,0 +1,121 @@ +package com.example.service; + +import cn.hutool.core.date.DateUtil; +import cn.hutool.core.util.ObjectUtil; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.example.common.Result; +import com.example.entity.Doctor; +import com.example.entity.DoctorPatient; +import com.example.entity.Patient; +import com.example.mapper.DoctorMapper; +import com.example.mapper.DoctorPatientMapper; +import com.example.mapper.PatientMapper; +import jakarta.annotation.Resource; +import org.springframework.stereotype.Service; + +import java.util.Date; +import java.util.List; + +@Service +public class DoctorPatientService { + + @Resource + private DoctorPatientMapper doctorPatientMapper; + + @Resource + private DoctorMapper doctorMapper; + + @Resource + private PatientMapper patientMapper; + + /** + * 新增医生患者关系 + * @param doctorPatient 关系信息 + */ + public void add(DoctorPatient doctorPatient) { + // 检查医生ID是否存在 + Doctor doctor = doctorMapper.selectById(doctorPatient.getDoctorId()); + if (ObjectUtil.isEmpty(doctor)) { + throw new RuntimeException("医生不存在"); + } + + // 检查患者ID是否存在 + Patient patient = patientMapper.selectById(doctorPatient.getPatientId()); + if (ObjectUtil.isEmpty(patient)) { + throw new RuntimeException("患者不存在"); + } + + // 检查关系是否已存在 + LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>(); + queryWrapper.eq(DoctorPatient::getDoctorId, doctorPatient.getDoctorId()) + .eq(DoctorPatient::getPatientId, doctorPatient.getPatientId()) + .eq(DoctorPatient::getStatus, "正常"); + + if (doctorPatientMapper.selectCount(queryWrapper) > 0) { + throw new RuntimeException("医生和患者关系已存在"); + } + + // 设置默认值 + doctorPatient.setRelationshipStart(new Date()); + doctorPatient.setStatus("正常"); + doctorPatient.setCreateTime(new Date()); + + doctorPatientMapper.insert(doctorPatient); + } + + /** + * 更新医生患者关系 + * @param doctorPatient 关系信息 + */ + public void update(DoctorPatient doctorPatient) { + DoctorPatient dbDoctorPatient = doctorPatientMapper.selectById(doctorPatient.getId()); + if (ObjectUtil.isEmpty(dbDoctorPatient)) { + throw new RuntimeException("关系不存在"); + } + + doctorPatientMapper.updateById(doctorPatient); + } + + /** + * 删除医生患者关系 + * @param id 关系ID + */ + public void delete(Integer id) { + doctorPatientMapper.deleteById(id); + } + + /** + * 结束医生患者关系 + * @param id 关系ID + */ + public void endRelationship(Integer id) { + DoctorPatient doctorPatient = doctorPatientMapper.selectById(id); + if (ObjectUtil.isEmpty(doctorPatient)) { + throw new RuntimeException("关系不存在"); + } + + doctorPatient.setStatus("已结束"); + doctorPatientMapper.updateById(doctorPatient); + } + + /** + * 根据医生ID查询患者 + * @param doctorId 医生ID + * @param name 患者姓名（可选） + * @return 患者列表 + */ + public List selectByDoctorId(Integer doctorId, String name) { + return doctorPatientMapper.selectByDoctorId(doctorId, name); + } + + /** + * 根据患者ID查询医生 + * @param patientId 患者ID + * @param name 医生姓名（可选） + * @return 医生列表 + */ + public List selectByPatientId(Integer patientId, String name) { + return doctorPatientMapper.selectByPatientId(patientId, name); + } +} \ No newline at end of file diff --git a/src/main/java/com/example/service/DoctorService.java b/src/main/java/com/example/service/DoctorService.java new file mode 100644 index 0000000..e0eca51 --- /dev/null +++ b/src/main/java/com/example/service/DoctorService.java @@ -0,0 +1,132 @@ +package com.example.service; + +import cn.hutool.core.util.ObjectUtil; +import com.example.common.Constants; +import com.example.common.enums.ResultCodeEnum; +import com.example.entity.*; +import com.example.exception.CustomException; +import com.example.mapper.*; +import com.example.common.config.TokenUtils; +import com.github.pagehelper.PageHelper; +import com.github.pagehelper.PageInfo; +import jakarta.annotation.Resource; +import org.springframework.stereotype.Service; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +@Service +public class DoctorService { + + @Resource + private DoctorMapper doctorMapper; + + /** + * 新增 + */ + public void add(Doctor doctor) { + // 唯一校验 + Doctor dbDoctor = doctorMapper.selectByUsername(doctor.getUsername()); + if (ObjectUtil.isNotNull(dbDoctor)) { + throw new CustomException(ResultCodeEnum.USER_EXIST_ERROR); + } + if (ObjectUtil.isEmpty(doctor.getPassword())) { + doctor.setPassword(Constants.USER_DEFAULT_PASSWORD); + } + if (ObjectUtil.isEmpty(doctor.getName())) { + doctor.setName(doctor.getUsername()); + } + doctor.setRole("doctor"); + doctorMapper.insert(doctor); + } + + /** + * 删除 + */ + public void deleteById(Integer id) { + doctorMapper.deleteById(id); + } + + /** + * 批量删除 + */ + public void deleteBatch(List ids) { + for (Integer id : ids) { + doctorMapper.deleteById(id); + } + } + + /** + * 修改 + */ + public void updateById(Doctor doctor) { + doctorMapper.updateById(doctor); + } + + /** + * 根据ID查询 + */ + public Doctor selectById(Integer id) { + return doctorMapper.selectById(id); + } + + /** + * 查询所有 + */ + public List selectAll(Doctor doctor) { + return doctorMapper.selectAll(doctor); + } + + /** + * 分页查询 + */ + public PageInfo selectPage(Doctor doctor, Integer pageNum, Integer pageSize) { + PageHelper.startPage(pageNum, pageSize); + List list = doctorMapper.selectAll(doctor); + return PageInfo.of(list); + } + + /** + * 注册 + */ + public void register(Account account) { + Doctor doctor = new Doctor(); + doctor.setUsername(account.getUsername()); + doctor.setPassword(account.getPassword()); + doctor.setSex(account.getSex()); + doctor.setName(account.getName()); + doctor.setPhone(account.getPhone()); + this.add(doctor); + } + + public Doctor login(Account account) { + Doctor dbDoctor = doctorMapper.selectByUsername(account.getUsername()); + if (ObjectUtil.isNull(dbDoctor)) { + throw new CustomException(ResultCodeEnum.USER_NOT_EXIST_ERROR); + } + if (!account.getPassword().equals(dbDoctor.getPassword())) { + throw new CustomException(ResultCodeEnum.USER_ACCOUNT_ERROR); + } + // 生成token + String tokenData = dbDoctor.getId() + "-doctor"; + String token = TokenUtils.genToken(tokenData, dbDoctor.getPassword()); + dbDoctor.setToken(token); + return dbDoctor; + } + + /** + * 修改密码 + */ + public void updatePassword(Account account) { + Doctor dbDoctor = doctorMapper.selectByUsername(account.getUsername()); + if (ObjectUtil.isNull(dbDoctor)) { + throw new CustomException(ResultCodeEnum.USER_NOT_EXIST_ERROR); + } + if (!account.getPassword().equals(dbDoctor.getPassword())) { + throw new CustomException(ResultCodeEnum.PARAM_PASSWORD_ERROR); + } + dbDoctor.setPassword(account.getNewPassword()); + doctorMapper.updateById(dbDoctor); + } +} \ No newline at end of file diff --git a/src/main/java/com/example/service/PatientService.java b/src/main/java/com/example/service/PatientService.java new file mode 100644 index 0000000..5b3014f --- /dev/null +++ b/src/main/java/com/example/service/PatientService.java @@ -0,0 +1,200 @@ +package com.example.service; + +import cn.hutool.core.util.ObjectUtil; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.example.common.Constants; +import com.example.common.enums.ResultCodeEnum; +import com.example.entity.*; +import com.example.exception.CustomException; +import com.example.mapper.*; +import com.example.common.config.TokenUtils; +import com.github.pagehelper.PageHelper; +import com.github.pagehelper.PageInfo; +import jakarta.annotation.Resource; +import org.springframework.stereotype.Service; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Date; +import java.util.List; + +@Service +public class PatientService { + + @Resource + private PatientMapper patientMapper; + + @Resource + private DoctorPatientMapper doctorPatientMapper; + + /** + * 新增 + */ + public void add(Patient patient) { + // 校验数据 + if (ObjectUtil.isEmpty(patient.getUsername()) || ObjectUtil.isEmpty(patient.getPassword())) { + throw new CustomException(ResultCodeEnum.PARAM_LOST_ERROR); + } + + // 检查用户名是否存在 + Patient dbPatient = selectByUsername(patient.getUsername()); + if (dbPatient != null) { + throw new CustomException(ResultCodeEnum.USER_EXIST_ERROR); + } + + // 设置默认值 + if (ObjectUtil.isEmpty(patient.getName())) { + patient.setName(patient.getUsername()); + } + patient.setRole("patient"); + + patientMapper.insert(patient); + } + + /** + * 通过ID删除 + */ + public void deleteById(Integer id) { + patientMapper.deleteById(id); + } + + /** + * 批量删除 + */ + public void deleteBatch(List ids) { + for (Integer id : ids) { + patientMapper.deleteById(id); + } + } + + /** + * 更新 + */ + public void updateById(Patient patient) { + patientMapper.updateById(patient); + } + + /** + * 通过ID查询 + */ + public Patient selectById(Integer id) { + return patientMapper.selectById(id); + } + + /** + * 通过用户名查询 + */ + public Patient selectByUsername(String username) { + LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>(); + queryWrapper.eq(Patient::getUsername, username); + return patientMapper.selectOne(queryWrapper); + } + + /** + * 查询所有 + */ + public List selectAll(Patient patient) { + LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>(); + return patientMapper.selectList(queryWrapper); + } + + /** + * 分页查询 - 按患者信息查询 + */ + public Page selectPage(Patient patient, Integer pageNum, Integer pageSize) { + LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>(); + if (ObjectUtil.isNotEmpty(patient.getName())) { + queryWrapper.like(Patient::getName, patient.getName()); + } + + return patientMapper.selectPage(new Page<>(pageNum, pageSize), queryWrapper); + } + + /** + * 分页查询 - 按患者姓名查询 + */ + public Page selectPage(Integer pageNum, Integer pageSize, String name) { + LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>(); + if (ObjectUtil.isNotEmpty(name)) { + queryWrapper.like(Patient::getName, name); + } + + return patientMapper.selectPage(new Page<>(pageNum, pageSize), queryWrapper); + } + + /** + * 用户登录 + */ + public Account login(Account account) { + LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>(); + queryWrapper.eq(Patient::getUsername, account.getUsername()); + queryWrapper.eq(Patient::getPassword, account.getPassword()); + Patient patient = patientMapper.selectOne(queryWrapper); + + if (ObjectUtil.isEmpty(patient)) { + throw new CustomException(ResultCodeEnum.USER_ACCOUNT_ERROR); + } + + // 生成token + String tokenData = patient.getId() + "-" + patient.getRole(); + String token = TokenUtils.genToken(tokenData, patient.getPassword()); + patient.setToken(token); + + return patient; + } + + /** + * 用户注册 + */ + public void register(Account account) { + // 检查用户名是否已存在 + LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>(); + queryWrapper.eq(Patient::getUsername, account.getUsername()); + if (patientMapper.selectCount(queryWrapper) > 0) { + throw new CustomException(ResultCodeEnum.USER_EXIST_ERROR); + } + + Patient patient = new Patient(); + patient.setUsername(account.getUsername()); + patient.setPassword(account.getPassword()); + patient.setName(account.getName()); + patient.setSex(account.getSex()); + patient.setPhone(account.getPhone()); + patient.setEmail(account.getEmail()); + patient.setRole("patient"); + add(patient); + + // 如果选择了医生，则建立医患关系 + if (account.getDoctorId() != null) { + DoctorPatient doctorPatient = new DoctorPatient(); + doctorPatient.setDoctorId(account.getDoctorId()); + doctorPatient.setPatientId(patient.getId()); + doctorPatient.setRelationshipStart(new Date()); + doctorPatient.setStatus("正常"); + doctorPatient.setCreateTime(new Date()); + + doctorPatientMapper.insert(doctorPatient); + } + } + + /** + * 修改密码 + */ + public void updatePassword(Account account) { + Patient dbPatient = selectById(account.getId()); + if (ObjectUtil.isEmpty(dbPatient)) { + throw new CustomException(ResultCodeEnum.USER_NOT_EXIST_ERROR); + } + + if (!account.getPassword().equals(dbPatient.getPassword())) { + throw new CustomException(ResultCodeEnum.PARAM_PASSWORD_ERROR); + } + + Patient patient = new Patient(); + patient.setId(account.getId()); + patient.setPassword(account.getNewPassword()); + + updateById(patient); + } +} \ No newline at end of file diff --git a/src/main/java/com/example/service/RecommendationService.java b/src/main/java/com/example/service/RecommendationService.java new file mode 100644 index 0000000..a0211ce --- /dev/null +++ b/src/main/java/com/example/service/RecommendationService.java @@ -0,0 +1,385 @@ +package com.example.service; + +import com.example.common.config.TokenUtils; +import com.example.common.enums.ResultCodeEnum; +import com.example.entity.Account; +import com.example.entity.ResourceRating; +import com.example.entity.TreatmentResource; +import com.example.exception.CustomException; +import com.example.mapper.ResourceCategoryMapper; +import com.example.mapper.ResourceRatingMapper; +import com.example.mapper.TreatmentResourceMapper; +import jakarta.annotation.Resource; +import org.springframework.stereotype.Service; + +import java.util.*; +import java.util.stream.Collectors; + +/** + * 基于协同过滤的推荐服务 + */ +@Service +public class RecommendationService { + + @Resource + private ResourceRatingMapper resourceRatingMapper; + + @Resource + private TreatmentResourceMapper treatmentResourceMapper; + + @Resource + private ResourceCategoryMapper resourceCategoryMapper; + + /** + * 获取针对特定用户的资源推荐 + * @param userId 用户ID + * @param limit 推荐数量限制 + * @return 推荐资源列表 + */ + public List> getRecommendationsForUser(Integer userId, Integer limit) { + // 获取当前登录用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null || !userId.equals(currentUser.getId())) { + throw new CustomException(ResultCodeEnum.TOKEN_CHECK_ERROR); + } + + // 只有患者才能获取推荐 + if (!"patient".equals(currentUser.getRole())) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "只有患者才能获取推荐"); + } + + // 获取所有评分数据 + List allRatings = resourceRatingMapper.selectList(null); + + // 获取目标用户的评分记录 + List userRatings = allRatings.stream() + .filter(r -> r.getPatientId().equals(userId)) + .collect(Collectors.toList()); + + // 如果用户没有评分记录，返回热门资源 + if (userRatings.isEmpty()) { + return getPopularResources(limit); + } + + // 计算用户相似度 + List> userSimilarities = calculateUserSimilarity(userId, allRatings); + + // 获取用户已评分的资源ID + Set userRatedResourceIds = userRatings.stream() + .map(ResourceRating::getResourceId) + .collect(Collectors.toSet()); + + // 获取所有已审核通过的资源 + List allResources = treatmentResourceMapper.selectAllAudited(""); + + // 获取用户未评分的资源 + List unratedResources = allResources.stream() + .filter(resource -> !userRatedResourceIds.contains(resource.getId())) + .collect(Collectors.toList()); + + // 对每个未评分资源预测评分并生成推荐 + List> recommendationsWithScores = new ArrayList<>(); + + for (TreatmentResource resource : unratedResources) { + double predictedRating = predictRating(resource.getId(), userSimilarities, allRatings); + + // 只推荐预测评分大于0的资源 + if (predictedRating > 0) { + Map recommendation = new HashMap<>(); + recommendation.put("resource", resource); + recommendation.put("predictedRating", predictedRating); + recommendation.put("similarityScore", Math.min(100, predictedRating * 20)); // 将5分制转换为100分制 + recommendation.put("reason", getRecommendationReason(resource, userSimilarities, allRatings, userRatings, allResources)); + + // 添加分类名称 + com.example.entity.ResourceCategory category = resourceCategoryMapper.selectById(resource.getCategoryId()); + if (category != null) { + recommendation.put("categoryName", category.getName()); + } + + recommendationsWithScores.add(recommendation); + } + } + + // 按预测评分降序排序，取前几个作为推荐 + recommendationsWithScores.sort((a, b) -> + Double.compare((Double) b.get("predictedRating"), (Double) a.get("predictedRating"))); + + // 限制推荐数量 + int resultLimit = Math.min(limit, recommendationsWithScores.size()); + return recommendationsWithScores.subList(0, resultLimit); + } + + /** + * 获取热门资源作为推荐（用于冷启动问题） + */ + private List> getPopularResources(Integer limit) { + // 获取所有已审核通过的资源 + List allResources = treatmentResourceMapper.selectAllAudited(""); + + // 按照访问次数和下载次数之和排序 + allResources.sort((a, b) -> { + int aPopularity = (a.getVisitCount() != null ? a.getVisitCount() : 0) + + (a.getDownloadCount() != null ? a.getDownloadCount() : 0); + int bPopularity = (b.getVisitCount() != null ? b.getVisitCount() : 0) + + (b.getDownloadCount() != null ? b.getDownloadCount() : 0); + return Integer.compare(bPopularity, aPopularity); + }); + + // 转换为推荐格式 + List> recommendations = new ArrayList<>(); + int resultLimit = Math.min(limit, allResources.size()); + + for (int i = 0; i < resultLimit; i++) { + TreatmentResource resource = allResources.get(i); + Map recommendation = new HashMap<>(); + recommendation.put("resource", resource); + recommendation.put("predictedRating", 4.0); // 默认预测评分 + recommendation.put("similarityScore", 80.0); // 默认相似度分数 + recommendation.put("reason", "系统热门资源推荐"); + + // 添加分类名称 + com.example.entity.ResourceCategory category = resourceCategoryMapper.selectById(resource.getCategoryId()); + if (category != null) { + recommendation.put("categoryName", category.getName()); + } + + recommendations.add(recommendation); + } + + return recommendations; + } + + /** + * 计算用户相似度 - 使用余弦相似度 + */ + private List> calculateUserSimilarity(Integer targetUserId, List allRatings) { + // 获取目标用户的评分记录 + List targetUserRatings = allRatings.stream() + .filter(r -> r.getPatientId().equals(targetUserId)) + .collect(Collectors.toList()); + + if (targetUserRatings.isEmpty()) { + return Collections.emptyList(); + } + + // 用户ID列表（去除目标用户） + List userIds = allRatings.stream() + .map(ResourceRating::getPatientId) + .distinct() + .filter(id -> !id.equals(targetUserId)) + .collect(Collectors.toList()); + + // 计算每个用户与目标用户的相似度 + List> similarities = new ArrayList<>(); + + for (Integer userId : userIds) { + // 获取当前用户的评分记录 + List userRatings = allRatings.stream() + .filter(r -> r.getPatientId().equals(userId)) + .collect(Collectors.toList()); + + if (userRatings.isEmpty()) { + continue; + } + + // 找出两个用户共同评分的资源 + Set targetResourceIds = targetUserRatings.stream() + .map(ResourceRating::getResourceId) + .collect(Collectors.toSet()); + + Set userResourceIds = userRatings.stream() + .map(ResourceRating::getResourceId) + .collect(Collectors.toSet()); + + Set commonResourceIds = new HashSet<>(targetResourceIds); + commonResourceIds.retainAll(userResourceIds); + + // 如果没有共同评分的资源，相似度为0 + if (commonResourceIds.isEmpty()) { + continue; + } + + // 提取两个用户对共同资源的评分向量 + double[] targetVector = new double[commonResourceIds.size()]; + double[] userVector = new double[commonResourceIds.size()]; + + int index = 0; + for (Integer resourceId : commonResourceIds) { + double targetRating = targetUserRatings.stream() + .filter(r -> r.getResourceId().equals(resourceId)) + .findFirst() + .map(r -> (double) r.getRating()) + .orElse(0.0); + + double userRating = userRatings.stream() + .filter(r -> r.getResourceId().equals(resourceId)) + .findFirst() + .map(r -> (double) r.getRating()) + .orElse(0.0); + + targetVector[index] = targetRating; + userVector[index] = userRating; + index++; + } + + // 计算余弦相似度 + // 余弦相似度 = (A·B) / (||A|| * ||B||) + double dotProduct = 0.0; + double targetMagnitude = 0.0; + double userMagnitude = 0.0; + + for (int i = 0; i < targetVector.length; i++) { + dotProduct += targetVector[i] * userVector[i]; + targetMagnitude += targetVector[i] * targetVector[i]; + userMagnitude += userVector[i] * userVector[i]; + } + + targetMagnitude = Math.sqrt(targetMagnitude); + userMagnitude = Math.sqrt(userMagnitude); + + // 避免除以零 + double similarity = (targetMagnitude > 0 && userMagnitude > 0) + ? dotProduct / (targetMagnitude * userMagnitude) + : 0; + + Map userSimilarity = new HashMap<>(); + userSimilarity.put("userId", userId); + userSimilarity.put("similarity", similarity); + similarities.add(userSimilarity); + } + + // 按相似度降序排序 + similarities.sort((a, b) -> Double.compare( + (Double) b.get("similarity"), + (Double) a.get("similarity") + )); + + return similarities; + } + + /** + * 预测用户对资源的评分 + */ + private double predictRating(Integer resourceId, List> userSimilarities, + List allRatings) { + // 获取已对该资源评分的相似用户 + List> similarUsersWithRating = userSimilarities.stream() + .filter(s -> allRatings.stream() + .anyMatch(r -> r.getPatientId().equals(s.get("userId")) && + r.getResourceId().equals(resourceId))) + .collect(Collectors.toList()); + + // 如果没有相似用户对该资源评分，返回默认预测值 + if (similarUsersWithRating.isEmpty()) { + return 0; + } + + // 计算加权评分和 + double weightedSum = 0.0; + double similaritySum = 0.0; + + for (Map user : similarUsersWithRating) { + Integer userId = (Integer) user.get("userId"); + double similarity = (Double) user.get("similarity"); + + // 找到该用户对该资源的评分 + double rating = allRatings.stream() + .filter(r -> r.getPatientId().equals(userId) && r.getResourceId().equals(resourceId)) + .findFirst() + .map(r -> (double) r.getRating()) + .orElse(0.0); + + // 加权和 + weightedSum += similarity * rating; + similaritySum += similarity; + } + + // 计算加权平均 + return similaritySum > 0 ? weightedSum / similaritySum : 0; + } + + /** + * 获取推荐理由 + */ + private String getRecommendationReason(TreatmentResource resource, + List> userSimilarities, + List allRatings, + List userRatings, + List allResources) { + // 找出评分最高的相似用户对该资源的评价 + List> topSimilarUsers = userSimilarities.stream() + .limit(3) + .collect(Collectors.toList()); + + // 找出这些用户中有对该资源评分的用户 + List> usersWithRating = topSimilarUsers.stream() + .filter(s -> allRatings.stream() + .anyMatch(r -> r.getPatientId().equals(s.get("userId")) && + r.getResourceId().equals(resource.getId()))) + .collect(Collectors.toList()); + + if (usersWithRating.isEmpty()) { + // 基于内容的推荐理由 + if (!userRatings.isEmpty()) { + // 查找用户评分最高的资源 + ResourceRating topRatedRating = userRatings.stream() + .max(Comparator.comparing(ResourceRating::getRating)) + .orElse(null); + + if (topRatedRating != null) { + // 获取用户最喜欢的资源详情 + Integer topRatedResourceId = topRatedRating.getResourceId(); + TreatmentResource topRatedResource = allResources.stream() + .filter(r -> r.getId().equals(topRatedResourceId)) + .findFirst() + .orElse(null); + + // 如果当前资源与用户最喜欢的资源属于同一分类 + if (topRatedResource != null && resource.getCategoryId().equals(topRatedResource.getCategoryId())) { + return "根据您对同类资源的偏好推荐"; + } + + // 如果当前资源适用的症状与用户评分高的资源相似 + List userPreferredSymptoms = userRatings.stream() + .filter(r -> r.getRating() >= 4) + .map(r -> { + // 获取资源详情 + Optional res = allResources.stream() + .filter(tr -> tr.getId().equals(r.getResourceId())) + .findFirst(); + return res.map(TreatmentResource::getApplicableSymptoms).orElse(""); + }) + .flatMap(s -> Arrays.stream(s.split("[,、]"))) + .map(String::trim) + .filter(s -> !s.isEmpty()) + .collect(Collectors.toList()); + + List resourceSymptoms = Arrays.stream( + resource.getApplicableSymptoms() != null + ? resource.getApplicableSymptoms().split("[,、]") + : new String[0]) + .map(String::trim) + .filter(s -> !s.isEmpty()) + .collect(Collectors.toList()); + + boolean hasCommonSymptoms = resourceSymptoms.stream() + .anyMatch(userPreferredSymptoms::contains); + + if (hasCommonSymptoms) { + return "包含您可能关注的症状"; + } + } + } + + return "基于系统热门资源推荐"; + } + + // 基于相似用户的推荐理由 + if (usersWithRating.size() == 1) { + return "与您兴趣相似的用户喜欢此资源"; + } + + return usersWithRating.size() + "位与您兴趣相似的用户喜欢此资源"; + } +} \ No newline at end of file diff --git a/src/main/java/com/example/service/ResourceCategoryService.java b/src/main/java/com/example/service/ResourceCategoryService.java new file mode 100644 index 0000000..3653c53 --- /dev/null +++ b/src/main/java/com/example/service/ResourceCategoryService.java @@ -0,0 +1,88 @@ +package com.example.service; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.example.common.enums.ResultCodeEnum; +import com.example.entity.ResourceCategory; +import com.example.entity.TreatmentResource; +import com.example.exception.CustomException; +import com.example.mapper.ResourceCategoryMapper; +import com.example.mapper.TreatmentResourceMapper; +import jakarta.annotation.Resource; +import org.springframework.stereotype.Service; +import com.github.pagehelper.PageHelper; +import com.github.pagehelper.PageInfo; + +import java.util.List; + +@Service +public class ResourceCategoryService { + + @Resource + private ResourceCategoryMapper resourceCategoryMapper; + + @Resource + private TreatmentResourceMapper treatmentResourceMapper; + + public List findAll() { + return resourceCategoryMapper.selectAllCategories(); + } + + public List findByParentId(Integer parentId) { + return resourceCategoryMapper.selectByParentId(parentId); + } + + public ResourceCategory findById(Integer id) { + return resourceCategoryMapper.selectById(id); + } + + public void add(ResourceCategory category) { + // 检查是否存在同名分类 + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + wrapper.eq(ResourceCategory::getName, category.getName()) + .eq(ResourceCategory::getParentId, category.getParentId()); + + if (resourceCategoryMapper.selectCount(wrapper) > 0) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "已存在同名分类"); + } + + resourceCategoryMapper.insert(category); + } + + public void update(ResourceCategory category) { + // 检查是否存在同名分类（排除自身） + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + wrapper.eq(ResourceCategory::getName, category.getName()) + .eq(ResourceCategory::getParentId, category.getParentId()) + .ne(ResourceCategory::getId, category.getId()); + + if (resourceCategoryMapper.selectCount(wrapper) > 0) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "已存在同名分类"); + } + + resourceCategoryMapper.updateById(category); + } + + public void delete(Integer id) { + // 检查是否有子分类 + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + wrapper.eq(ResourceCategory::getParentId, id); + + if (resourceCategoryMapper.selectCount(wrapper) > 0) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "该分类下存在子分类，无法删除"); + } + + // 检查是否有关联的资源 + List resources = treatmentResourceMapper.selectByCategoryId(id); + if (resources != null && !resources.isEmpty()) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "该分类下存在资源，无法删除"); + } + + resourceCategoryMapper.deleteById(id); + } + + public PageInfo selectPage(ResourceCategory category, Integer pageNum, Integer pageSize) { + PageHelper.startPage(pageNum, pageSize); + List list = resourceCategoryMapper.selectPage(category.getName() != null ? category.getName() : ""); + return new PageInfo<>(list); + } +} \ No newline at end of file diff --git a/src/main/java/com/example/service/ResourceRatingService.java b/src/main/java/com/example/service/ResourceRatingService.java new file mode 100644 index 0000000..bf7cbd0 --- /dev/null +++ b/src/main/java/com/example/service/ResourceRatingService.java @@ -0,0 +1,161 @@ +package com.example.service; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.example.common.config.TokenUtils; +import com.example.common.enums.ResultCodeEnum; +import com.example.entity.Account; +import com.example.entity.ResourceRating; +import com.example.entity.TreatmentResource; +import com.example.exception.CustomException; +import com.example.mapper.ResourceRatingMapper; +import com.example.mapper.TreatmentResourceMapper; +import jakarta.annotation.Resource; +import org.springframework.stereotype.Service; + +import java.time.LocalDateTime; +import java.util.List; + +@Service +public class ResourceRatingService { + + @Resource + private ResourceRatingMapper resourceRatingMapper; + + @Resource + private TreatmentResourceMapper treatmentResourceMapper; + + /** + * 添加评分 + */ + public void add(ResourceRating resourceRating) { + // 获取当前登录用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_CHECK_ERROR); + } + + // 只有患者可以添加评分 + if (!"patient".equals(currentUser.getRole())) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "只有患者可以评分"); + } + + // 设置患者ID + resourceRating.setPatientId(currentUser.getId()); + + // 检查评分是否有效 + if (resourceRating.getRating() == null || resourceRating.getRating() < 1 || resourceRating.getRating() > 5) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "评分必须在1-5之间"); + } + + // 检查是否已经评分过 + int count = resourceRatingMapper.countByResourceIdAndPatientId(resourceRating.getResourceId(), currentUser.getId()); + if (count > 0) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "您已经评价过该资源"); + } + + // 设置创建时间 + resourceRating.setCreateTime(LocalDateTime.now()); + + // 保存评分 + resourceRatingMapper.insert(resourceRating); + } + + /** + * 根据资源ID查询评分记录 + */ + public List findByResourceId(Integer resourceId) { + return resourceRatingMapper.selectByResourceId(resourceId); + } + + /** + * 获取资源的平均评分 + */ + public double getAverageRating(Integer resourceId) { + return resourceRatingMapper.getAverageRating(resourceId); + } + + public Integer getRatingCount(Integer resourceId) { + return resourceRatingMapper.getRatingCount(resourceId); + } + + public void rateResource(ResourceRating rating) { + // 获取当前登录用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_CHECK_ERROR); + } + + // 只有患者才能评价资源 + if (!"patient".equals(currentUser.getRole())) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "只有患者才能评价资源"); + } + + // 检查资源是否存在 + TreatmentResource resource = treatmentResourceMapper.selectById(rating.getResourceId()); + if (resource == null) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "资源不存在"); + } + + // 检查资源是否已通过审核 + if (!"已通过".equals(resource.getAuditStatus())) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "资源未通过审核，无法评价"); + } + + // 检查患者是否已经评价过该资源 + ResourceRating existingRating = resourceRatingMapper.findByResourceAndPatient( + rating.getResourceId(), currentUser.getId()); + + if (existingRating != null) { + // 更新评价 + existingRating.setRating(rating.getRating()); + existingRating.setComment(rating.getComment()); + resourceRatingMapper.updateById(existingRating); + } else { + // 新增评价 + rating.setPatientId(currentUser.getId()); + rating.setCreateTime(LocalDateTime.now()); + resourceRatingMapper.insert(rating); + } + } + + public void deleteRating(Integer id) { + // 获取当前登录用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_CHECK_ERROR); + } + + // 查询评价 + ResourceRating rating = resourceRatingMapper.selectById(id); + if (rating == null) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "评价不存在"); + } + + // 只有评价的患者本人或管理员才能删除评价 + if (!currentUser.getId().equals(rating.getPatientId()) && !"admin".equals(currentUser.getRole())) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "无权限删除该评价"); + } + + resourceRatingMapper.deleteById(id); + } + + /** + * 根据患者ID查询评分记录 + */ + public List findByPatientId(Integer patientId) { + LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>(); + queryWrapper.eq(ResourceRating::getPatientId, patientId); + queryWrapper.orderByDesc(ResourceRating::getCreateTime); + return resourceRatingMapper.selectList(queryWrapper); + } + + /** + * 查询所有评分记录 + */ + public List findAll() { + LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>(); + queryWrapper.orderByDesc(ResourceRating::getCreateTime); + return resourceRatingMapper.selectList(queryWrapper); + } +} \ No newline at end of file diff --git a/src/main/java/com/example/service/SymptomRecordService.java b/src/main/java/com/example/service/SymptomRecordService.java new file mode 100644 index 0000000..7fae10b --- /dev/null +++ b/src/main/java/com/example/service/SymptomRecordService.java @@ -0,0 +1,735 @@ +package com.example.service; + +import cn.hutool.core.date.DateUtil; +import cn.hutool.core.util.ObjectUtil; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.example.common.config.TokenUtils; +import com.example.common.enums.ResultCodeEnum; +import com.example.entity.Account; +import com.example.entity.DoctorPatient; +import com.example.entity.SymptomRecord; +import com.example.exception.CustomException; +import com.example.mapper.SymptomRecordMapper; +import com.github.pagehelper.PageHelper; +import jakarta.annotation.Resource; +import org.springframework.stereotype.Service; + +import java.util.ArrayList; +import java.util.Date; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.DoubleSummaryStatistics; +import java.text.SimpleDateFormat; +import java.util.Calendar; + +/** + * 症状记录服务类 + */ +@Service +public class SymptomRecordService { + + @Resource + private SymptomRecordMapper symptomRecordMapper; + + @Resource + private DoctorPatientService doctorPatientService; + + /** + * 添加症状记录 + */ + public void add(SymptomRecord symptomRecord) { + // 获取当前登录用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_INVALID_ERROR); + } + + // 只有患者可以添加症状记录 + if (!"patient".equals(currentUser.getRole())) { + throw new CustomException(ResultCodeEnum.NO_AUTH_ERROR); + } + + // 设置患者ID + symptomRecord.setPatientId(currentUser.getId()); + + // 设置记录时间和创建时间 + if (symptomRecord.getRecordTime() == null) { + symptomRecord.setRecordTime(new Date()); + } + symptomRecord.setCreateTime(new Date()); + + symptomRecordMapper.insert(symptomRecord); + } + + /** + * 更新症状记录 + */ + public void update(SymptomRecord symptomRecord) { + // 获取当前登录用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_INVALID_ERROR); + } + + // 检查记录是否存在 + SymptomRecord existRecord = symptomRecordMapper.selectById(symptomRecord.getId()); + if (existRecord == null) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR); + } + + // 权限检查 + checkPermission(currentUser, existRecord.getPatientId()); + + // 更新记录 + symptomRecordMapper.updateById(symptomRecord); + } + + /** + * 删除症状记录 + */ + public void delete(Integer id) { + // 获取当前登录用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_INVALID_ERROR); + } + + // 检查记录是否存在 + SymptomRecord existRecord = symptomRecordMapper.selectById(id); + if (existRecord == null) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR); + } + + // 权限检查：患者只能删除自己的记录，医生不能删除记录，管理员可以删除所有记录 + if ("patient".equals(currentUser.getRole())) { + if (!currentUser.getId().equals(existRecord.getPatientId())) { + throw new CustomException(ResultCodeEnum.NO_AUTH_ERROR); + } + } else if ("doctor".equals(currentUser.getRole())) { + throw new CustomException(ResultCodeEnum.NO_AUTH_ERROR); + } + + symptomRecordMapper.deleteById(id); + } + + /** + * 根据ID查询症状记录 + */ + public SymptomRecord getById(Integer id) { + // 获取当前登录用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_INVALID_ERROR); + } + + SymptomRecord record = symptomRecordMapper.selectById(id); + if (record == null) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR); + } + + // 权限检查 + checkPermission(currentUser, record.getPatientId()); + + return record; + } + + /** + * 根据患者ID查询所有症状记录 + */ + public List getByPatientId(Integer patientId) { + // 获取当前登录用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_INVALID_ERROR); + } + + // 根据角色处理 + if ("patient".equals(currentUser.getRole())) { + // 患者只能查看自己的记录 + patientId = currentUser.getId(); + } else if ("doctor".equals(currentUser.getRole())) { + // 医生只能查看自己负责的患者记录 + if (patientId != null) { + // 检查该患者是否是该医生负责的 + checkDoctorPatientRelationship(currentUser.getId(), patientId); + } else { + // 获取医生负责的所有患者 + List doctorPatients = doctorPatientService.selectByDoctorId(currentUser.getId(), null); + List patientIds = doctorPatients.stream() + .map(DoctorPatient::getPatientId) + .collect(Collectors.toList()); + + if (patientIds.isEmpty()) { + return new ArrayList<>(); + } + + // 查询这些患者的所有记录 + LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>(); + queryWrapper.in(SymptomRecord::getPatientId, patientIds); + queryWrapper.orderByDesc(SymptomRecord::getRecordTime); + return symptomRecordMapper.selectList(queryWrapper); + } + } + + // 查询记录 + return symptomRecordMapper.selectWithPatient(patientId); + } + + /** + * 分页查询症状记录 + */ + public Page getPage(Integer pageNum, Integer pageSize, String startDate, String endDate) { + // 获取当前登录用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_INVALID_ERROR); + } + + // 创建查询条件 + LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>(); + + // 根据角色设置查询条件 + if ("patient".equals(currentUser.getRole())) { + // 患者只能查看自己的记录 + queryWrapper.eq(SymptomRecord::getPatientId, currentUser.getId()); + } else if ("doctor".equals(currentUser.getRole())) { + // 医生只能查看自己负责的患者记录 + List doctorPatients = doctorPatientService.selectByDoctorId(currentUser.getId(), null); + List patientIds = doctorPatients.stream() + .map(DoctorPatient::getPatientId) + .collect(Collectors.toList()); + + if (patientIds.isEmpty()) { + // 没有负责的患者，返回空结果 + return new Page<>(pageNum, pageSize); + } + + queryWrapper.in(SymptomRecord::getPatientId, patientIds); + } + + // 添加日期条件 + if (ObjectUtil.isNotEmpty(startDate) && ObjectUtil.isNotEmpty(endDate)) { + Date start = DateUtil.parseDate(startDate); + Date end = DateUtil.parseDate(endDate); + queryWrapper.between(SymptomRecord::getRecordTime, start, end); + } + + // 按记录时间降序排序 + queryWrapper.orderByDesc(SymptomRecord::getRecordTime); + + // 执行分页查询 + return symptomRecordMapper.selectPage(new Page<>(pageNum, pageSize), queryWrapper); + } + + /** + * 检查用户是否有权限操作指定患者的记录 + */ + private void checkPermission(Account currentUser, Integer patientId) { + if ("patient".equals(currentUser.getRole())) { + // 患者只能操作自己的记录 + if (!currentUser.getId().equals(patientId)) { + throw new CustomException(ResultCodeEnum.NO_AUTH_ERROR); + } + } else if ("doctor".equals(currentUser.getRole())) { + // 医生只能操作自己负责的患者的记录 + checkDoctorPatientRelationship(currentUser.getId(), patientId); + } + // 管理员可以操作所有记录 + } + + /** + * 检查医生与患者是否存在关联关系 + */ + private void checkDoctorPatientRelationship(Integer doctorId, Integer patientId) { + List doctorPatients = doctorPatientService.selectByDoctorId(doctorId, null); + boolean isResponsible = doctorPatients.stream() + .anyMatch(dp -> dp.getPatientId().equals(patientId)); + + if (!isResponsible) { + throw new CustomException(ResultCodeEnum.NO_AUTH_ERROR); + } + } + + /** + * 批量查询症状记录关联的患者信息 + */ + public List getRecordsWithPatient(List records) { + if (records == null || records.isEmpty()) { + return records; + } + + // 从记录中提取所有患者ID + List patientIds = records.stream() + .map(SymptomRecord::getPatientId) + .distinct() + .collect(Collectors.toList()); + + // 这里利用Mapper中已有的selectWithPatient方法，查询所有关联患者信息的记录 + List recordsWithPatient = new ArrayList<>(); + for (Integer patientId : patientIds) { + List patientRecords = symptomRecordMapper.selectWithPatient(patientId); + recordsWithPatient.addAll(patientRecords); + } + + // 根据原记录ID匹配，返回带患者信息的记录 + Map recordMap = recordsWithPatient.stream() + .collect(Collectors.toMap(SymptomRecord::getId, record -> record, (a, b) -> a)); + + return records.stream() + .map(record -> { + SymptomRecord recordWithPatient = recordMap.get(record.getId()); + return recordWithPatient != null ? recordWithPatient : record; + }) + .collect(Collectors.toList()); + } + + /** + * 分页查询症状记录（使用PageHelper） + */ + public com.github.pagehelper.PageInfo selectPage(SymptomRecord symptomRecord, Integer pageNum, Integer pageSize, String startDate, String endDate) { + // 获取当前登录用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_INVALID_ERROR); + } + + // 构建查询条件获取所有符合条件的记录 + List allRecords = new ArrayList<>(); + + // 获取患者名称搜索条件 + final String patientName; + if (symptomRecord != null && ObjectUtil.isNotEmpty(symptomRecord.getPatientName())) { + patientName = symptomRecord.getPatientName().trim().toLowerCase(); + } else { + patientName = ""; + } + + // 根据角色设置查询条件 + if ("patient".equals(currentUser.getRole())) { + // 患者只能查看自己的记录 + symptomRecord = symptomRecord == null ? new SymptomRecord() : symptomRecord; + symptomRecord.setPatientId(currentUser.getId()); + allRecords = symptomRecordMapper.selectWithPatient(currentUser.getId()); + } else if ("doctor".equals(currentUser.getRole())) { + // 医生只能查看自己负责的患者记录 + List doctorPatients = doctorPatientService.selectByDoctorId(currentUser.getId(), null); + List patientIds = doctorPatients.stream() + .map(DoctorPatient::getPatientId) + .collect(Collectors.toList()); + + if (patientIds.isEmpty()) { + // 没有负责的患者，返回空结果 + return new com.github.pagehelper.PageInfo<>(new ArrayList<>()); + } + + // 查询患者ID在列表中的记录，并带上患者信息 + for (Integer patientId : patientIds) { + List patientRecords = symptomRecordMapper.selectWithPatient(patientId); + allRecords.addAll(patientRecords); + } + } else { + // 管理员可以查看所有记录 + // 这里需要查询所有带有患者信息的记录，但由于没有查询全部的接口，我们先查询所有患者ID + List tempRecords = symptomRecordMapper.selectList(null); + List allPatientIds = tempRecords.stream() + .map(SymptomRecord::getPatientId) + .distinct() + .collect(Collectors.toList()); + + // 查询每个患者的记录并带上患者信息 + for (Integer patientId : allPatientIds) { + List patientRecords = symptomRecordMapper.selectWithPatient(patientId); + allRecords.addAll(patientRecords); + } + } + + // 根据患者名称过滤 + if (ObjectUtil.isNotEmpty(patientName)) { + allRecords = allRecords.stream() + .filter(record -> { + if (record.getPatient() != null && ObjectUtil.isNotEmpty(record.getPatient().getName())) { + return record.getPatient().getName().toLowerCase().contains(patientName); + } + return false; + }) + .collect(Collectors.toList()); + } + + // 根据日期过滤 + if (ObjectUtil.isNotEmpty(startDate) && ObjectUtil.isNotEmpty(endDate)) { + Date start = DateUtil.parseDate(startDate); + Date end = DateUtil.parseDate(endDate); + allRecords = allRecords.stream() + .filter(record -> { + Date recordTime = record.getRecordTime(); + return recordTime != null && !recordTime.before(start) && !recordTime.after(end); + }) + .collect(Collectors.toList()); + } + + // 按记录时间降序排序 + allRecords.sort((a, b) -> { + if (a.getRecordTime() == null || b.getRecordTime() == null) { + return 0; + } + return b.getRecordTime().compareTo(a.getRecordTime()); + }); + + // 在内存中执行分页 + int start = (pageNum - 1) * pageSize; + int end = Math.min(start + pageSize, allRecords.size()); + + List pagedRecords; + if (start < allRecords.size()) { + pagedRecords = allRecords.subList(start, end); + } else { + pagedRecords = new ArrayList<>(); + } + + // 创建PageInfo对象 + com.github.pagehelper.PageInfo pageInfo = new com.github.pagehelper.PageInfo<>(pagedRecords); + // 手动设置分页信息 + pageInfo.setPageNum(pageNum); + pageInfo.setPageSize(pageSize); + pageInfo.setTotal(allRecords.size()); + pageInfo.setPages((int) Math.ceil((double) allRecords.size() / pageSize)); + + return pageInfo; + } + + /** + * 获取症状记录统计数据 + * @param patientId 患者ID（可选，为null表示查询所有） + * @param startDate 开始日期（可选） + * @param endDate 结束日期（可选） + * @return 统计数据 + */ + public Map getStatisticsData(Integer patientId, Date startDate, Date endDate) { + Map result = new HashMap<>(); + + try { + // 构建查询条件 + LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>(); + if (patientId != null) { + queryWrapper.eq(SymptomRecord::getPatientId, patientId); + } + + if (startDate != null) { + queryWrapper.ge(SymptomRecord::getRecordTime, startDate); + } + + if (endDate != null) { + queryWrapper.le(SymptomRecord::getRecordTime, endDate); + } + + // 获取所有符合条件的记录 + List records = symptomRecordMapper.selectList(queryWrapper); + + // 按日期分组的严重程度平均值 + Map severityByDate = new LinkedHashMap<>(); + Map emotionByDate = new LinkedHashMap<>(); + Map sleepByDate = new LinkedHashMap<>(); + + // 过去7天的日期 + List last7Days = new ArrayList<>(); + SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd"); + Calendar calendar = Calendar.getInstance(); + + for (int i = 6; i >= 0; i--) { + calendar.setTime(new Date()); + calendar.add(Calendar.DAY_OF_MONTH, -i); + String dateStr = dateFormat.format(calendar.getTime()); + last7Days.add(dateStr); + + // 初始化数据 + severityByDate.put(dateStr, 0.0); + emotionByDate.put(dateStr, 0.0); + sleepByDate.put(dateStr, 0.0); + } + + // 记录每个日期的记录数量 + Map countByDate = new HashMap<>(); + for (String date : last7Days) { + countByDate.put(date, 0); + } + + // 处理记录 + for (SymptomRecord record : records) { + if (record.getRecordTime() != null) { + String recordDate = dateFormat.format(record.getRecordTime()); + + // 只处理过去7天的数据 + if (last7Days.contains(recordDate)) { + // 更新计数 + countByDate.put(recordDate, countByDate.getOrDefault(recordDate, 0) + 1); + + // 更新严重程度总和 + if (record.getSeverityLevel() != null) { + severityByDate.put(recordDate, severityByDate.getOrDefault(recordDate, 0.0) + record.getSeverityLevel()); + } + + // 更新情绪评分总和 + if (record.getEmotionScore() != null) { + emotionByDate.put(recordDate, emotionByDate.getOrDefault(recordDate, 0.0) + record.getEmotionScore()); + } + + // 更新入睡时间总和 + if (record.getSleepTime() != null) { + sleepByDate.put(recordDate, sleepByDate.getOrDefault(recordDate, 0.0) + record.getSleepTime()); + } + } + } + } + + // 计算每日平均值 + for (String date : last7Days) { + int count = countByDate.get(date); + if (count > 0) { + severityByDate.put(date, severityByDate.get(date) / count); + emotionByDate.put(date, emotionByDate.get(date) / count); + sleepByDate.put(date, sleepByDate.get(date) / count); + } + } + + // 构建返回结果 + result.put("dates", last7Days); + result.put("severityData", last7Days.stream().map(severityByDate::get).collect(Collectors.toList())); + result.put("emotionData", last7Days.stream().map(emotionByDate::get).collect(Collectors.toList())); + result.put("sleepData", last7Days.stream().map(sleepByDate::get).collect(Collectors.toList())); + + // 计算总体统计数据 + DoubleSummaryStatistics severityStats = records.stream() + .filter(r -> r.getSeverityLevel() != null) + .mapToDouble(SymptomRecord::getSeverityLevel) + .summaryStatistics(); + + DoubleSummaryStatistics emotionStats = records.stream() + .filter(r -> r.getEmotionScore() != null) + .mapToDouble(SymptomRecord::getEmotionScore) + .summaryStatistics(); + + DoubleSummaryStatistics sleepStats = records.stream() + .filter(r -> r.getSleepTime() != null) + .mapToDouble(SymptomRecord::getSleepTime) + .summaryStatistics(); + + // 添加总体统计 + Map summaryStats = new HashMap<>(); + summaryStats.put("recordCount", records.size()); + summaryStats.put("avgSeverity", severityStats.getAverage()); + summaryStats.put("avgEmotion", emotionStats.getAverage()); + summaryStats.put("avgSleepTime", sleepStats.getAverage()); + + result.put("summary", summaryStats); + + // 计算各项分布 + Map severityDistribution = records.stream() + .filter(r -> r.getSeverityLevel() != null) + .collect(Collectors.groupingBy(SymptomRecord::getSeverityLevel, Collectors.counting())); + + Map emotionDistribution = records.stream() + .filter(r -> r.getEmotionScore() != null) + .collect(Collectors.groupingBy(SymptomRecord::getEmotionScore, Collectors.counting())); + + result.put("severityDistribution", severityDistribution); + result.put("emotionDistribution", emotionDistribution); + + } catch (Exception e) { + e.printStackTrace(); + } + + return result; + } + + /** + * 根据医生ID获取其患者的症状记录统计数据 + * @param doctorId 医生ID + * @param startDate 开始日期（可选） + * @param endDate 结束日期（可选） + * @return 统计数据 + */ + public Map getStatisticsByDoctor(Integer doctorId, Date startDate, Date endDate) { + Map result = new HashMap<>(); + + // 获取医生的所有患者 + List patientIds = new ArrayList<>(); + try { + LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>(); + queryWrapper.eq(DoctorPatient::getDoctorId, doctorId); + queryWrapper.eq(DoctorPatient::getStatus, "正常"); + + List doctorPatients = doctorPatientService.selectByDoctorId(doctorId, null); + patientIds = doctorPatients.stream() + .map(DoctorPatient::getPatientId) + .collect(Collectors.toList()); + } catch (Exception e) { + e.printStackTrace(); + return result; + } + + if (patientIds.isEmpty()) { + return result; + } + + try { + // 构建查询条件 + LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>(); + queryWrapper.in(SymptomRecord::getPatientId, patientIds); + + if (startDate != null) { + queryWrapper.ge(SymptomRecord::getRecordTime, startDate); + } + + if (endDate != null) { + queryWrapper.le(SymptomRecord::getRecordTime, endDate); + } + + // 获取所有符合条件的记录 + List records = symptomRecordMapper.selectList(queryWrapper); + + // 处理和上面的方法相同...（后续统计处理逻辑与上面的方法相同） + // 按日期分组的严重程度平均值 + Map severityByDate = new LinkedHashMap<>(); + Map emotionByDate = new LinkedHashMap<>(); + Map sleepByDate = new LinkedHashMap<>(); + + // 过去7天的日期 + List last7Days = new ArrayList<>(); + SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd"); + Calendar calendar = Calendar.getInstance(); + + for (int i = 6; i >= 0; i--) { + calendar.setTime(new Date()); + calendar.add(Calendar.DAY_OF_MONTH, -i); + String dateStr = dateFormat.format(calendar.getTime()); + last7Days.add(dateStr); + + // 初始化数据 + severityByDate.put(dateStr, 0.0); + emotionByDate.put(dateStr, 0.0); + sleepByDate.put(dateStr, 0.0); + } + + // 记录每个日期的记录数量 + Map countByDate = new HashMap<>(); + for (String date : last7Days) { + countByDate.put(date, 0); + } + + // 处理记录 + for (SymptomRecord record : records) { + if (record.getRecordTime() != null) { + String recordDate = dateFormat.format(record.getRecordTime()); + + // 只处理过去7天的数据 + if (last7Days.contains(recordDate)) { + // 更新计数 + countByDate.put(recordDate, countByDate.getOrDefault(recordDate, 0) + 1); + + // 更新严重程度总和 + if (record.getSeverityLevel() != null) { + severityByDate.put(recordDate, severityByDate.getOrDefault(recordDate, 0.0) + record.getSeverityLevel()); + } + + // 更新情绪评分总和 + if (record.getEmotionScore() != null) { + emotionByDate.put(recordDate, emotionByDate.getOrDefault(recordDate, 0.0) + record.getEmotionScore()); + } + + // 更新入睡时间总和 + if (record.getSleepTime() != null) { + sleepByDate.put(recordDate, sleepByDate.getOrDefault(recordDate, 0.0) + record.getSleepTime()); + } + } + } + } + + // 计算每日平均值 + for (String date : last7Days) { + int count = countByDate.get(date); + if (count > 0) { + severityByDate.put(date, severityByDate.get(date) / count); + emotionByDate.put(date, emotionByDate.get(date) / count); + sleepByDate.put(date, sleepByDate.get(date) / count); + } + } + + // 构建返回结果 + result.put("dates", last7Days); + result.put("severityData", last7Days.stream().map(severityByDate::get).collect(Collectors.toList())); + result.put("emotionData", last7Days.stream().map(emotionByDate::get).collect(Collectors.toList())); + result.put("sleepData", last7Days.stream().map(sleepByDate::get).collect(Collectors.toList())); + + // 计算总体统计数据 + DoubleSummaryStatistics severityStats = records.stream() + .filter(r -> r.getSeverityLevel() != null) + .mapToDouble(SymptomRecord::getSeverityLevel) + .summaryStatistics(); + + DoubleSummaryStatistics emotionStats = records.stream() + .filter(r -> r.getEmotionScore() != null) + .mapToDouble(SymptomRecord::getEmotionScore) + .summaryStatistics(); + + DoubleSummaryStatistics sleepStats = records.stream() + .filter(r -> r.getSleepTime() != null) + .mapToDouble(SymptomRecord::getSleepTime) + .summaryStatistics(); + + // 添加总体统计 + Map summaryStats = new HashMap<>(); + summaryStats.put("recordCount", records.size()); + summaryStats.put("avgSeverity", severityStats.getAverage()); + summaryStats.put("avgEmotion", emotionStats.getAverage()); + summaryStats.put("avgSleepTime", sleepStats.getAverage()); + summaryStats.put("patientCount", patientIds.size()); + + result.put("summary", summaryStats); + + // 计算各项分布 + Map severityDistribution = records.stream() + .filter(r -> r.getSeverityLevel() != null) + .collect(Collectors.groupingBy(SymptomRecord::getSeverityLevel, Collectors.counting())); + + Map emotionDistribution = records.stream() + .filter(r -> r.getEmotionScore() != null) + .collect(Collectors.groupingBy(SymptomRecord::getEmotionScore, Collectors.counting())); + + result.put("severityDistribution", severityDistribution); + result.put("emotionDistribution", emotionDistribution); + + // 按患者分组的数据 + Map> recordsByPatient = records.stream() + .collect(Collectors.groupingBy(SymptomRecord::getPatientId)); + + Map patientStats = new HashMap<>(); + for (Map.Entry> entry : recordsByPatient.entrySet()) { + Integer pid = entry.getKey(); + List patientRecords = entry.getValue(); + + DoubleSummaryStatistics patientSeverityStats = patientRecords.stream() + .filter(r -> r.getSeverityLevel() != null) + .mapToDouble(SymptomRecord::getSeverityLevel) + .summaryStatistics(); + + Map pStats = new HashMap<>(); + pStats.put("recordCount", patientRecords.size()); + pStats.put("avgSeverity", patientSeverityStats.getAverage()); + pStats.put("maxSeverity", patientSeverityStats.getMax()); + + patientStats.put(pid, pStats); + } + + result.put("patientStats", patientStats); + + } catch (Exception e) { + e.printStackTrace(); + } + + return result; + } +} \ No newline at end of file diff --git a/src/main/java/com/example/service/TreatmentResourceService.java b/src/main/java/com/example/service/TreatmentResourceService.java new file mode 100644 index 0000000..779925f --- /dev/null +++ b/src/main/java/com/example/service/TreatmentResourceService.java @@ -0,0 +1,256 @@ +package com.example.service; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.example.common.config.TokenUtils; +import com.example.common.enums.ResultCodeEnum; +import com.example.entity.Account; +import com.example.entity.TreatmentResource; +import com.example.exception.CustomException; +import com.example.mapper.TreatmentResourceMapper; +import jakarta.annotation.Resource; +import org.springframework.stereotype.Service; +import com.github.pagehelper.PageHelper; +import com.github.pagehelper.PageInfo; + +import java.time.LocalDateTime; +import java.util.List; +import java.util.Map; +import java.util.HashMap; +import java.util.Comparator; +import java.util.stream.Collectors; + +@Service +public class TreatmentResourceService { + + @Resource + private TreatmentResourceMapper treatmentResourceMapper; + + public Page search(Page page, String keyword, String role) { + if ("admin".equals(role)) { + return treatmentResourceMapper.searchResourcesForAdmin(page, keyword); + } else { + return treatmentResourceMapper.searchResourcesForPatient(page, keyword); + } + } + + public List findByCategoryId(Integer categoryId) { + return treatmentResourceMapper.selectByCategoryId(categoryId); + } + + public TreatmentResource findById(Integer id) { + return treatmentResourceMapper.selectById(id); + } + + public void add(TreatmentResource resource) { + // 获取当前登录用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_CHECK_ERROR); + } + + // 允许管理员和医生添加资源 + if (!"admin".equals(currentUser.getRole()) && !"doctor".equals(currentUser.getRole())) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "无权限添加资源"); + } + + // 设置默认值 + resource.setPublisherId(currentUser.getId()); + resource.setVisitCount(0); + resource.setDownloadCount(0); + + // 如果是医生添加，则默认为待审核状态 + if ("doctor".equals(currentUser.getRole())) { + resource.setAuditStatus("待审核"); + } else { + // 管理员添加的资源默认已审核 + resource.setAuditStatus("已通过"); + } + + resource.setCreateTime(LocalDateTime.now()); + + treatmentResourceMapper.insert(resource); + } + + public void update(TreatmentResource resource) { + // 获取当前登录用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_CHECK_ERROR); + } + + // 仅允许管理员修改资源 + if (!"admin".equals(currentUser.getRole())) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "无权限修改资源"); + } + + // 检查资源是否存在 + TreatmentResource dbResource = treatmentResourceMapper.selectById(resource.getId()); + if (dbResource == null) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "资源不存在"); + } + + treatmentResourceMapper.updateById(resource); + } + + public void delete(Integer id) { + // 获取当前登录用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_CHECK_ERROR); + } + + // 仅允许管理员删除资源 + if (!"admin".equals(currentUser.getRole())) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "无权限删除资源"); + } + + // 检查资源是否存在 + TreatmentResource dbResource = treatmentResourceMapper.selectById(id); + if (dbResource == null) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "资源不存在"); + } + + treatmentResourceMapper.deleteById(id); + } + + public void changeAuditStatus(Integer id, String status) { + // 获取当前登录用户 + Account currentUser = TokenUtils.getCurrentUser(); + if (currentUser == null) { + throw new CustomException(ResultCodeEnum.TOKEN_CHECK_ERROR); + } + + // 仅允许管理员审核资源 + if (!"admin".equals(currentUser.getRole())) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "无权限审核资源"); + } + + // 检查资源是否存在 + TreatmentResource dbResource = treatmentResourceMapper.selectById(id); + if (dbResource == null) { + throw new CustomException(ResultCodeEnum.PARAM_ERROR.code, "资源不存在"); + } + + // 更新审核状态 + TreatmentResource resource = new TreatmentResource(); + resource.setId(id); + resource.setAuditStatus(status); + + treatmentResourceMapper.updateById(resource); + } + + public void incrementVisitCount(Integer id) { + treatmentResourceMapper.incrementVisitCount(id); + } + + public void incrementDownloadCount(Integer id) { + treatmentResourceMapper.incrementDownloadCount(id); + } + + public PageInfo selectPage(TreatmentResource resource, Integer pageNum, Integer pageSize) { + // 获取当前用户角色 + Account currentUser = TokenUtils.getCurrentUser(); + String role = currentUser != null ? currentUser.getRole() : "patient"; + + // 使用PageHelper进行分页，与Admin页面一致 + PageHelper.startPage(pageNum, pageSize); + + // 获取查询关键词 + String keyword = resource.getTitle() != null ? resource.getTitle() : ""; + + // 直接使用Mapper的查询方法 + List list; + if ("admin".equals(role)) { + list = treatmentResourceMapper.selectAll(keyword); + } else { + list = treatmentResourceMapper.selectAllAudited(keyword); + } + + // 创建PageInfo对象 + return new PageInfo<>(list); + } + + /** + * 查询特定发布者的资源 + */ + public PageInfo findByPublisher(TreatmentResource resource, Integer pageNum, Integer pageSize) { + // 使用PageHelper进行分页，与Admin页面一致 + PageHelper.startPage(pageNum, pageSize); + + // 获取查询关键词 + String keyword = resource.getTitle() != null ? resource.getTitle() : ""; + + // 调用Mapper查询方法，需要添加对应的Mapper方法 + List list = treatmentResourceMapper.selectByPublisher(resource.getPublisherId(), keyword); + + // 创建PageInfo对象 + return new PageInfo<>(list); + } + + /** + * 获取资源使用情况统计数据 + * @return 资源使用情况统计数据 + */ + public Map getResourceStatistics() { + Map statistics = new HashMap<>(); + + try { + // 查询所有资源 + List resources = treatmentResourceMapper.selectList(null); + + // 按分类统计资源数量 + Map countByCategory = resources.stream() + .collect(Collectors.groupingBy(TreatmentResource::getCategoryId, Collectors.counting())); + + // 统计总访问次数和总下载次数 + int totalVisits = resources.stream() + .mapToInt(r -> r.getVisitCount() != null ? r.getVisitCount() : 0) + .sum(); + + int totalDownloads = resources.stream() + .mapToInt(r -> r.getDownloadCount() != null ? r.getDownloadCount() : 0) + .sum(); + + // 访问次数最多的资源TOP5 + List topVisitResources = resources.stream() + .sorted(Comparator.comparing(r -> r.getVisitCount() != null ? -r.getVisitCount() : 0)) + .limit(5) + .collect(Collectors.toList()); + + // 下载次数最多的资源TOP5 + List topDownloadResources = resources.stream() + .sorted(Comparator.comparing(r -> r.getDownloadCount() != null ? -r.getDownloadCount() : 0)) + .limit(5) + .collect(Collectors.toList()); + + // 按资源分类统计访问次数和下载次数 + Map visitsByCategory = new HashMap<>(); + Map downloadsByCategory = new HashMap<>(); + + for (TreatmentResource resource : resources) { + Integer categoryId = resource.getCategoryId(); + Integer visitCount = resource.getVisitCount() != null ? resource.getVisitCount() : 0; + Integer downloadCount = resource.getDownloadCount() != null ? resource.getDownloadCount() : 0; + + visitsByCategory.put(categoryId, visitsByCategory.getOrDefault(categoryId, 0) + visitCount); + downloadsByCategory.put(categoryId, downloadsByCategory.getOrDefault(categoryId, 0) + downloadCount); + } + + // 构建返回结果 + statistics.put("totalResources", resources.size()); + statistics.put("totalVisits", totalVisits); + statistics.put("totalDownloads", totalDownloads); + statistics.put("countByCategory", countByCategory); + statistics.put("visitsByCategory", visitsByCategory); + statistics.put("downloadsByCategory", downloadsByCategory); + statistics.put("topVisitResources", topVisitResources); + statistics.put("topDownloadResources", topDownloadResources); + + } catch (Exception e) { + e.printStackTrace(); + } + + return statistics; + } +} \ No newline at end of file diff --git a/src/main/java/com/example/websocket/ChatWebSocket.java b/src/main/java/com/example/websocket/ChatWebSocket.java new file mode 100644 index 0000000..8c88cda --- /dev/null +++ b/src/main/java/com/example/websocket/ChatWebSocket.java @@ -0,0 +1,195 @@ +package com.example.websocket; + +import com.fasterxml.jackson.databind.ObjectMapper; +import com.example.entity.ChatMessage; +import com.example.service.ChatMessageService; +import jakarta.annotation.Resource; +import jakarta.websocket.*; +import jakarta.websocket.server.PathParam; +import jakarta.websocket.server.ServerEndpoint; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.stereotype.Component; + +import java.io.IOException; +import java.util.Date; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + +@ServerEndpoint("/ws/chat/{userId}/{userType}") +@Component +public class ChatWebSocket { + + private static final Logger log = LoggerFactory.getLogger(ChatWebSocket.class); + + // 静态变量，用来记录当前在线连接数 + private static int onlineCount = 0; + + // 用户ID和WebSocket的映射关系 + private static Map clients = new ConcurrentHashMap<>(); + + // 与某个客户端的连接会话，用于发送数据 + private Session session; + + // 当前连接用户ID + private Integer userId; + + // 当前连接用户类型 + private String userType; + + // 注入Service，因为@ServerEndpoint不支持直接注入，需要通过静态变量 + private static ChatMessageService chatMessageService; + + private static final ObjectMapper objectMapper = new ObjectMapper(); + + @Resource + public void setChatMessageService(ChatMessageService chatMessageService) { + ChatWebSocket.chatMessageService = chatMessageService; + } + + /** + * 连接建立成功调用的方法 + */ + @OnOpen + public void onOpen(Session session, @PathParam("userId") Integer userId, @PathParam("userType") String userType) { + this.session = session; + this.userId = userId; + this.userType = userType; + + // 将当前WebSocket对象加入到Map中 + String key = userId + ":" + userType; + clients.put(key, this); + + addOnlineCount(); + log.info("有新连接加入，当前在线人数为：{}", getOnlineCount()); + } + + /** + * 连接关闭调用的方法 + */ + @OnClose + public void onClose() { + // 从Map中移除 + String key = userId + ":" + userType; + clients.remove(key); + + subOnlineCount(); + log.info("有一连接关闭，当前在线人数为：{}", getOnlineCount()); + } + + /** + * 收到客户端消息后调用的方法 + */ + @OnMessage + public void onMessage(String message, Session session) { + log.info("收到来自用户{}:{}的消息：{}", userId, userType, message); + + try { + // 解析消息 + ChatMessage chatMessage = objectMapper.readValue(message, ChatMessage.class); + + // 直接设置发送者信息，不再通过TokenUtils获取 + chatMessage.setSenderId(userId); + chatMessage.setSenderType(userType); + chatMessage.setSendTime(new Date()); + chatMessage.setIsRead(false); + + // 保存临时ID，用于前端识别消息 + String tempId = null; + try { + // 从消息中提取tempId字段 + Map messageMap = objectMapper.readValue(message, Map.class); + if (messageMap.containsKey("tempId")) { + tempId = messageMap.get("tempId").toString(); + } + } catch (Exception e) { + log.warn("提取tempId失败", e); + } + + // 保存消息到数据库 + try { + // 检查发送者和接收者是否有关联关系并保存消息 + chatMessageService.directSaveMessage(chatMessage); + + // 将保存后的消息转为Map，以便添加tempId + Map responseMap = objectMapper.convertValue(chatMessage, Map.class); + if (tempId != null) { + responseMap.put("tempId", tempId); + } + String responseJson = objectMapper.writeValueAsString(responseMap); + + // 转发消息给接收者 + String receiverKey = chatMessage.getReceiverId() + ":" + chatMessage.getReceiverType(); + ChatWebSocket receiverSocket = clients.get(receiverKey); + if (receiverSocket != null) { + // 接收者在线，发送消息 + receiverSocket.sendMessage(responseJson); + } + + // 同时也返回给发送者 + sendMessage(responseJson); + } catch (Exception e) { + log.error("处理消息时发生错误", e); + // 发送错误消息给客户端 + ChatMessage errorMessage = new ChatMessage(); + errorMessage.setSenderId(0); + errorMessage.setSenderType("system"); + errorMessage.setReceiverId(userId); + errorMessage.setReceiverType(userType); + errorMessage.setContent("发送消息失败：" + e.getMessage()); + errorMessage.setSendTime(new Date()); + + // 将错误消息转为Map，以便添加tempId + Map errorMap = objectMapper.convertValue(errorMessage, Map.class); + if (tempId != null) { + errorMap.put("tempId", tempId); + } + sendMessage(objectMapper.writeValueAsString(errorMap)); + } + } catch (Exception e) { + log.error("处理消息时发生错误", e); + } + } + + /** + * 发生错误时调用 + */ + @OnError + public void onError(Session session, Throwable error) { + log.error("发生错误", error); + } + + /** + * 发送消息 + */ + public void sendMessage(String message) { + try { + this.session.getBasicRemote().sendText(message); + } catch (IOException e) { + log.error("发送消息失败", e); + } + } + + /** + * 服务端主动推送消息 + */ + public static void sendMessage(Integer userId, String userType, String message) { + String key = userId + ":" + userType; + ChatWebSocket socket = clients.get(key); + if (socket != null) { + socket.sendMessage(message); + } + } + + public static synchronized int getOnlineCount() { + return onlineCount; + } + + public static synchronized void addOnlineCount() { + ChatWebSocket.onlineCount++; + } + + public static synchronized void subOnlineCount() { + ChatWebSocket.onlineCount--; + } +} \ No newline at end of file diff --git a/src/main/resources/application.yml b/src/main/resources/application.yml new file mode 100644 index 0000000..68c667f --- /dev/null +++ b/src/main/resources/application.yml @@ -0,0 +1,28 @@ +server: + port: 9090 + +# 数据库配置 +spring: + datasource: + driver-class-name: com.mysql.cj.jdbc.Driver + username: root + password: 123456 + url: jdbc:mysql://localhost:3306/psychologicaltreatment?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&useSSL=false&serverTimezone=GMT%2b8&allowPublicKeyRetrieval=true + servlet: + multipart: + max-file-size: 100MB + max-request-size: 100MB + +# 配置mybatis实体和xml映射 +mybatis: + configuration: + log-impl: org.apache.ibatis.logging.stdout.StdOutImpl + map-underscore-to-camel-case: true + mapper-locations: classpath:mapper/*.xml + +fileBaseUrl: http://localhost:${server.port} + +# 通义千问API配置 +dashscope: + api-key: sk-0b1b6c3287364c2d8b8e1f656bfafece + model: qwen-turbo diff --git a/src/main/resources/mapper/AdminMapper.xml b/src/main/resources/mapper/AdminMapper.xml new file mode 100644 index 0000000..e7fc083 --- /dev/null +++ b/src/main/resources/mapper/AdminMapper.xml @@ -0,0 +1,26 @@ + + + + + + + + + + delete from admin where id = #{id} + + + \ No newline at end of file diff --git a/src/main/resources/mapper/DoctorMapper.xml b/src/main/resources/mapper/DoctorMapper.xml new file mode 100644 index 0000000..ef37ac3 --- /dev/null +++ b/src/main/resources/mapper/DoctorMapper.xml @@ -0,0 +1,25 @@ + + + + + + + + + + delete from doctor where id = #{id} + + + \ No newline at end of file diff --git a/src/main/resources/mapper/DoctorPatientMapper.xml b/src/main/resources/mapper/DoctorPatientMapper.xml new file mode 100644 index 0000000..f9752b1 --- /dev/null +++ b/src/main/resources/mapper/DoctorPatientMapper.xml @@ -0,0 +1,91 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/main/resources/mapper/PatientMapper.xml b/src/main/resources/mapper/PatientMapper.xml new file mode 100644 index 0000000..263e8ac --- /dev/null +++ b/src/main/resources/mapper/PatientMapper.xml @@ -0,0 +1,25 @@ + + + + + + + + + + delete from patient where id = #{id} + + + \ No newline at end of file diff --git a/src/main/resources/mapper/SymptomRecordMapper.xml b/src/main/resources/mapper/SymptomRecordMapper.xml new file mode 100644 index 0000000..695e1f6 --- /dev/null +++ b/src/main/resources/mapper/SymptomRecordMapper.xml @@ -0,0 +1,61 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/vue/.env.development b/vue/.env.development new file mode 100644 index 0000000..62bb4ac --- /dev/null +++ b/vue/.env.development @@ -0,0 +1 @@ +VITE_BASE_URL='http://localhost:9090' \ No newline at end of file diff --git a/vue/.env.production b/vue/.env.production new file mode 100644 index 0000000..2beb7d1 --- /dev/null +++ b/vue/.env.production @@ -0,0 +1 @@ +VITE_BASE_URL='http://:9090' \ No newline at end of file diff --git a/vue/.gitignore b/vue/.gitignore new file mode 100644 index 0000000..0d3640a --- /dev/null +++ b/vue/.gitignore @@ -0,0 +1,33 @@ +# Logs +logs +*.log +npm-debug.log* +yarn-debug.log* +yarn-error.log* +pnpm-debug.log* +lerna-debug.log* + +node_modules +.DS_Store +dist +dist-ssr +coverage +*.local + +/cypress/videos/ +/cypress/screenshots/ + +# Editor directories and files +.vscode/* +!.vscode/extensions.json +.idea +*.suo +*.ntvs* +*.njsproj +*.sln +*.sw? + +*.tsbuildinfo + +node_modules/ +public/ diff --git a/vue/index.html b/vue/index.html new file mode 100644 index 0000000..8f9ac0a --- /dev/null +++ b/vue/index.html @@ -0,0 +1,16 @@ + + + + + + + + 管理系统 + + + +
+ + + + diff --git a/vue/jsconfig.json b/vue/jsconfig.json new file mode 100644 index 0000000..5a1f2d2 --- /dev/null +++ b/vue/jsconfig.json @@ -0,0 +1,8 @@ +{ + "compilerOptions": { + "paths": { + "@/*": ["./src/*"] + } + }, + "exclude": ["node_modules", "dist"] +} diff --git a/vue/package-lock.json b/vue/package-lock.json new file mode 100644 index 0000000..83a512b --- /dev/null +++ b/vue/package-lock.json @@ -0,0 +1,3399 @@ +{ + "name": "vue", + "version": "0.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "vue", + "version": "0.0.0", + "dependencies": { + "@element-plus/icons-vue": "^2.3.1", + "@wangeditor/editor": "^5.1.23", + "@wangeditor/editor-for-vue": "^5.1.12", + "axios": "^1.6.8", + "china-area-data": "^5.0.1", + "echarts": "^5.5.0", + "element-china-area-data": "^6.1.0", + "element-plus": "^2.7.2", + "pinia": "^3.0.1", + "vue": "^3.4.21", + "vue-router": "^4.3.0" + }, + "devDependencies": { + "@vitejs/plugin-vue": "^5.0.4", + "sass": "^1.71.1", + "unplugin-auto-import": "^0.17.5", + "unplugin-element-plus": "^0.8.0", + "unplugin-vue-components": "^0.26.0", + "vite": "^5.2.8" + } + }, + "node_modules/@antfu/utils": { + "version": "0.7.10", + "resolved": "https://registry.npmmirror.com/@antfu/utils/-/utils-0.7.10.tgz", + "integrity": "sha512-+562v9k4aI80m1+VuMHehNJWLOFjBnXn3tdOitzD0il5b7smkSBal4+a3oKiQTbrwMmN/TBUMDvbdoWDehgOww==", + "dev": true, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/@babel/helper-string-parser": { + "version": "7.27.1", + "resolved": "https://registry.npmmirror.com/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz", + "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.28.5", + "resolved": "https://registry.npmmirror.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz", + "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/parser": { + "version": "7.29.3", + "resolved": "https://registry.npmmirror.com/@babel/parser/-/parser-7.29.3.tgz", + "integrity": "sha512-b3ctpQwp+PROvU/cttc4OYl4MzfJUWy6FZg+PMXfzmt/+39iHVF0sDfqay8TQM3JA2EUOyKcFZt75jWriQijsA==", + "dependencies": { + "@babel/types": "^7.29.0" + }, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/runtime": { + "version": "7.29.2", + "resolved": "https://registry.npmmirror.com/@babel/runtime/-/runtime-7.29.2.tgz", + "integrity": "sha512-JiDShH45zKHWyGe4ZNVRrCjBz8Nh9TMmZG1kh4QTK8hCBTWBi8Da+i7s1fJw7/lYpM4ccepSNfqzZ/QvABBi5g==", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/types": { + "version": "7.29.0", + "resolved": "https://registry.npmmirror.com/@babel/types/-/types-7.29.0.tgz", + "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==", + "dependencies": { + "@babel/helper-string-parser": "^7.27.1", + "@babel/helper-validator-identifier": "^7.28.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@ctrl/tinycolor": { + "version": "4.2.0", + "resolved": "https://registry.npmmirror.com/@ctrl/tinycolor/-/tinycolor-4.2.0.tgz", + "integrity": "sha512-kzyuwOAQnXJNLS9PSyrk0CWk35nWJW/zl/6KvnTBMFK65gm7U1/Z5BqjxeapjZCIhQcM/DsrEmcbRwDyXyXK4A==", + "engines": { + "node": ">=14" + } + }, + "node_modules/@element-plus/icons-vue": { + "version": "2.3.2", + "resolved": "https://registry.npmmirror.com/@element-plus/icons-vue/-/icons-vue-2.3.2.tgz", + "integrity": "sha512-OzIuTaIfC8QXEPmJvB4Y4kw34rSXdCJzxcD1kFStBvr8bK6X1zQAYDo0CNMjojnfTqRQCJ0I7prlErcoRiET2A==", + "peerDependencies": { + "vue": "^3.2.0" + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.21.5", + "resolved": "https://registry.npmmirror.com/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz", + "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.21.5", + "resolved": "https://registry.npmmirror.com/@esbuild/android-arm/-/android-arm-0.21.5.tgz", + "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmmirror.com/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz", + "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmmirror.com/@esbuild/android-x64/-/android-x64-0.21.5.tgz", + "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmmirror.com/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz", + "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmmirror.com/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz", + "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmmirror.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz", + "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmmirror.com/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz", + "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.21.5", + "resolved": "https://registry.npmmirror.com/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz", + "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmmirror.com/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz", + "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.21.5", + "resolved": "https://registry.npmmirror.com/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz", + "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==", + "cpu": [ + "ia32" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.21.5", + "resolved": "https://registry.npmmirror.com/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz", + "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==", + "cpu": [ + "loong64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.21.5", + "resolved": "https://registry.npmmirror.com/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz", + "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==", + "cpu": [ + "mips64el" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.21.5", + "resolved": "https://registry.npmmirror.com/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz", + "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==", + "cpu": [ + "ppc64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.21.5", + "resolved": "https://registry.npmmirror.com/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz", + "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==", + "cpu": [ + "riscv64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.21.5", + "resolved": "https://registry.npmmirror.com/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz", + "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==", + "cpu": [ + "s390x" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmmirror.com/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz", + "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmmirror.com/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz", + "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmmirror.com/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz", + "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmmirror.com/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz", + "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmmirror.com/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz", + "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.21.5", + "resolved": "https://registry.npmmirror.com/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz", + "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==", + "cpu": [ + "ia32" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmmirror.com/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz", + "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@floating-ui/core": { + "version": "1.7.5", + "resolved": "https://registry.npmmirror.com/@floating-ui/core/-/core-1.7.5.tgz", + "integrity": "sha512-1Ih4WTWyw0+lKyFMcBHGbb5U5FtuHJuujoyyr5zTaWS5EYMeT6Jb2AuDeftsCsEuchO+mM2ij5+q9crhydzLhQ==", + "dependencies": { + "@floating-ui/utils": "^0.2.11" + } + }, + "node_modules/@floating-ui/dom": { + "version": "1.7.6", + "resolved": "https://registry.npmmirror.com/@floating-ui/dom/-/dom-1.7.6.tgz", + "integrity": "sha512-9gZSAI5XM36880PPMm//9dfiEngYoC6Am2izES1FF406YFsjvyBMmeJ2g4SAju3xWwtuynNRFL2s9hgxpLI5SQ==", + "dependencies": { + "@floating-ui/core": "^1.7.5", + "@floating-ui/utils": "^0.2.11" + } + }, + "node_modules/@floating-ui/utils": { + "version": "0.2.11", + "resolved": "https://registry.npmmirror.com/@floating-ui/utils/-/utils-0.2.11.tgz", + "integrity": "sha512-RiB/yIh78pcIxl6lLMG0CgBXAZ2Y0eVHqMPYugu+9U0AeT6YBeiJpf7lbdJNIugFP5SIjwNRgo4DhR1Qxi26Gg==" + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.5.5", + "resolved": "https://registry.npmmirror.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", + "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==" + }, + "node_modules/@nodelib/fs.scandir": { + "version": "2.1.5", + "resolved": "https://registry.npmmirror.com/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", + "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", + "dev": true, + "dependencies": { + "@nodelib/fs.stat": "2.0.5", + "run-parallel": "^1.1.9" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.stat": { + "version": "2.0.5", + "resolved": "https://registry.npmmirror.com/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", + "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", + "dev": true, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.walk": { + "version": "1.2.8", + "resolved": "https://registry.npmmirror.com/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", + "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", + "dev": true, + "dependencies": { + "@nodelib/fs.scandir": "2.1.5", + "fastq": "^1.6.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@parcel/watcher": { + "version": "2.5.6", + "resolved": "https://registry.npmmirror.com/@parcel/watcher/-/watcher-2.5.6.tgz", + "integrity": "sha512-tmmZ3lQxAe/k/+rNnXQRawJ4NjxO2hqiOLTHvWchtGZULp4RyFeh6aU4XdOYBFe2KE1oShQTv4AblOs2iOrNnQ==", + "dev": true, + "hasInstallScript": true, + "optional": true, + "dependencies": { + "detect-libc": "^2.0.3", + "is-glob": "^4.0.3", + "node-addon-api": "^7.0.0", + "picomatch": "^4.0.3" + }, + "engines": { + "node": ">= 10.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + }, + "optionalDependencies": { + "@parcel/watcher-android-arm64": "2.5.6", + "@parcel/watcher-darwin-arm64": "2.5.6", + "@parcel/watcher-darwin-x64": "2.5.6", + "@parcel/watcher-freebsd-x64": "2.5.6", + "@parcel/watcher-linux-arm-glibc": "2.5.6", + "@parcel/watcher-linux-arm-musl": "2.5.6", + "@parcel/watcher-linux-arm64-glibc": "2.5.6", + "@parcel/watcher-linux-arm64-musl": "2.5.6", + "@parcel/watcher-linux-x64-glibc": "2.5.6", + "@parcel/watcher-linux-x64-musl": "2.5.6", + "@parcel/watcher-win32-arm64": "2.5.6", + "@parcel/watcher-win32-ia32": "2.5.6", + "@parcel/watcher-win32-x64": "2.5.6" + } + }, + "node_modules/@parcel/watcher-android-arm64": { + "version": "2.5.6", + "resolved": "https://registry.npmmirror.com/@parcel/watcher-android-arm64/-/watcher-android-arm64-2.5.6.tgz", + "integrity": "sha512-YQxSS34tPF/6ZG7r/Ih9xy+kP/WwediEUsqmtf0cuCV5TPPKw/PQHRhueUo6JdeFJaqV3pyjm0GdYjZotbRt/A==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">= 10.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/@parcel/watcher-darwin-arm64": { + "version": "2.5.6", + "resolved": "https://registry.npmmirror.com/@parcel/watcher-darwin-arm64/-/watcher-darwin-arm64-2.5.6.tgz", + "integrity": "sha512-Z2ZdrnwyXvvvdtRHLmM4knydIdU9adO3D4n/0cVipF3rRiwP+3/sfzpAwA/qKFL6i1ModaabkU7IbpeMBgiVEA==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 10.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/@parcel/watcher-darwin-x64": { + "version": "2.5.6", + "resolved": "https://registry.npmmirror.com/@parcel/watcher-darwin-x64/-/watcher-darwin-x64-2.5.6.tgz", + "integrity": "sha512-HgvOf3W9dhithcwOWX9uDZyn1lW9R+7tPZ4sug+NGrGIo4Rk1hAXLEbcH1TQSqxts0NYXXlOWqVpvS1SFS4fRg==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 10.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/@parcel/watcher-freebsd-x64": { + "version": "2.5.6", + "resolved": "https://registry.npmmirror.com/@parcel/watcher-freebsd-x64/-/watcher-freebsd-x64-2.5.6.tgz", + "integrity": "sha512-vJVi8yd/qzJxEKHkeemh7w3YAn6RJCtYlE4HPMoVnCpIXEzSrxErBW5SJBgKLbXU3WdIpkjBTeUNtyBVn8TRng==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">= 10.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/@parcel/watcher-linux-arm-glibc": { + "version": "2.5.6", + "resolved": "https://registry.npmmirror.com/@parcel/watcher-linux-arm-glibc/-/watcher-linux-arm-glibc-2.5.6.tgz", + "integrity": "sha512-9JiYfB6h6BgV50CCfasfLf/uvOcJskMSwcdH1PHH9rvS1IrNy8zad6IUVPVUfmXr+u+Km9IxcfMLzgdOudz9EQ==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/@parcel/watcher-linux-arm-musl": { + "version": "2.5.6", + "resolved": "https://registry.npmmirror.com/@parcel/watcher-linux-arm-musl/-/watcher-linux-arm-musl-2.5.6.tgz", + "integrity": "sha512-Ve3gUCG57nuUUSyjBq/MAM0CzArtuIOxsBdQ+ftz6ho8n7s1i9E1Nmk/xmP323r2YL0SONs1EuwqBp2u1k5fxg==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/@parcel/watcher-linux-arm64-glibc": { + "version": "2.5.6", + "resolved": "https://registry.npmmirror.com/@parcel/watcher-linux-arm64-glibc/-/watcher-linux-arm64-glibc-2.5.6.tgz", + "integrity": "sha512-f2g/DT3NhGPdBmMWYoxixqYr3v/UXcmLOYy16Bx0TM20Tchduwr4EaCbmxh1321TABqPGDpS8D/ggOTaljijOA==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/@parcel/watcher-linux-arm64-musl": { + "version": "2.5.6", + "resolved": "https://registry.npmmirror.com/@parcel/watcher-linux-arm64-musl/-/watcher-linux-arm64-musl-2.5.6.tgz", + "integrity": "sha512-qb6naMDGlbCwdhLj6hgoVKJl2odL34z2sqkC7Z6kzir8b5W65WYDpLB6R06KabvZdgoHI/zxke4b3zR0wAbDTA==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/@parcel/watcher-linux-x64-glibc": { + "version": "2.5.6", + "resolved": "https://registry.npmmirror.com/@parcel/watcher-linux-x64-glibc/-/watcher-linux-x64-glibc-2.5.6.tgz", + "integrity": "sha512-kbT5wvNQlx7NaGjzPFu8nVIW1rWqV780O7ZtkjuWaPUgpv2NMFpjYERVi0UYj1msZNyCzGlaCWEtzc+exjMGbQ==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/@parcel/watcher-linux-x64-musl": { + "version": "2.5.6", + "resolved": "https://registry.npmmirror.com/@parcel/watcher-linux-x64-musl/-/watcher-linux-x64-musl-2.5.6.tgz", + "integrity": "sha512-1JRFeC+h7RdXwldHzTsmdtYR/Ku8SylLgTU/reMuqdVD7CtLwf0VR1FqeprZ0eHQkO0vqsbvFLXUmYm/uNKJBg==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/@parcel/watcher-win32-arm64": { + "version": "2.5.6", + "resolved": "https://registry.npmmirror.com/@parcel/watcher-win32-arm64/-/watcher-win32-arm64-2.5.6.tgz", + "integrity": "sha512-3ukyebjc6eGlw9yRt678DxVF7rjXatWiHvTXqphZLvo7aC5NdEgFufVwjFfY51ijYEWpXbqF5jtrK275z52D4Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 10.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/@parcel/watcher-win32-ia32": { + "version": "2.5.6", + "resolved": "https://registry.npmmirror.com/@parcel/watcher-win32-ia32/-/watcher-win32-ia32-2.5.6.tgz", + "integrity": "sha512-k35yLp1ZMwwee3Ez/pxBi5cf4AoBKYXj00CZ80jUz5h8prpiaQsiRPKQMxoLstNuqe2vR4RNPEAEcjEFzhEz/g==", + "cpu": [ + "ia32" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 10.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/@parcel/watcher-win32-x64": { + "version": "2.5.6", + "resolved": "https://registry.npmmirror.com/@parcel/watcher-win32-x64/-/watcher-win32-x64-2.5.6.tgz", + "integrity": "sha512-hbQlYcCq5dlAX9Qx+kFb0FHue6vbjlf0FrNzSKdYK2APUf7tGfGxQCk2ihEREmbR6ZMc0MVAD5RIX/41gpUzTw==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 10.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/@popperjs/core": { + "name": "@sxzz/popperjs-es", + "version": "2.11.8", + "resolved": "https://registry.npmmirror.com/@sxzz/popperjs-es/-/popperjs-es-2.11.8.tgz", + "integrity": "sha512-wOwESXvvED3S8xBmcPWHs2dUuzrE4XiZeFu7e1hROIJkm02a49N120pmOXxY33sBb6hArItm5W5tcg1cBtV+HQ==", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/popperjs" + } + }, + "node_modules/@rollup/pluginutils": { + "version": "5.3.0", + "resolved": "https://registry.npmmirror.com/@rollup/pluginutils/-/pluginutils-5.3.0.tgz", + "integrity": "sha512-5EdhGZtnu3V88ces7s53hhfK5KSASnJZv8Lulpc04cWO3REESroJXg73DFsOmgbU2BhwV0E20bu2IDZb3VKW4Q==", + "dev": true, + "dependencies": { + "@types/estree": "^1.0.0", + "estree-walker": "^2.0.2", + "picomatch": "^4.0.2" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0" + }, + "peerDependenciesMeta": { + "rollup": { + "optional": true + } + } + }, + "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.60.2", + "resolved": "https://registry.npmmirror.com/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.60.2.tgz", + "integrity": "sha512-dnlp69efPPg6Uaw2dVqzWRfAWRnYVb1XJ8CyyhIbZeaq4CA5/mLeZ1IEt9QqQxmbdvagjLIm2ZL8BxXv5lH4Yw==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-android-arm64": { + "version": "4.60.2", + "resolved": "https://registry.npmmirror.com/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.60.2.tgz", + "integrity": "sha512-OqZTwDRDchGRHHm/hwLOL7uVPB9aUvI0am/eQuWMNyFHf5PSEQmyEeYYheA0EPPKUO/l0uigCp+iaTjoLjVoHg==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.60.2", + "resolved": "https://registry.npmmirror.com/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.60.2.tgz", + "integrity": "sha512-UwRE7CGpvSVEQS8gUMBe1uADWjNnVgP3Iusyda1nSRwNDCsRjnGc7w6El6WLQsXmZTbLZx9cecegumcitNfpmA==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.60.2", + "resolved": "https://registry.npmmirror.com/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.60.2.tgz", + "integrity": "sha512-gjEtURKLCC5VXm1I+2i1u9OhxFsKAQJKTVB8WvDAHF+oZlq0GTVFOlTlO1q3AlCTE/DF32c16ESvfgqR7343/g==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-freebsd-arm64": { + "version": "4.60.2", + "resolved": "https://registry.npmmirror.com/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.60.2.tgz", + "integrity": "sha512-Bcl6CYDeAgE70cqZaMojOi/eK63h5Me97ZqAQoh77VPjMysA/4ORQBRGo3rRy45x4MzVlU9uZxs8Uwy7ZaKnBw==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-freebsd-x64": { + "version": "4.60.2", + "resolved": "https://registry.npmmirror.com/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.60.2.tgz", + "integrity": "sha512-LU+TPda3mAE2QB0/Hp5VyeKJivpC6+tlOXd1VMoXV/YFMvk/MNk5iXeBfB4MQGRWyOYVJ01625vjkr0Az98OJQ==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.60.2", + "resolved": "https://registry.npmmirror.com/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.60.2.tgz", + "integrity": "sha512-2QxQrM+KQ7DAW4o22j+XZ6RKdxjLD7BOWTP0Bv0tmjdyhXSsr2Ul1oJDQqh9Zf5qOwTuTc7Ek83mOFaKnodPjg==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm-musleabihf": { + "version": "4.60.2", + "resolved": "https://registry.npmmirror.com/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.60.2.tgz", + "integrity": "sha512-TbziEu2DVsTEOPif2mKWkMeDMLoYjx95oESa9fkQQK7r/Orta0gnkcDpzwufEcAO2BLBsD7mZkXGFqEdMRRwfw==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.60.2", + "resolved": "https://registry.npmmirror.com/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.60.2.tgz", + "integrity": "sha512-bO/rVDiDUuM2YfuCUwZ1t1cP+/yqjqz+Xf2VtkdppefuOFS2OSeAfgafaHNkFn0t02hEyXngZkxtGqXcXwO8Rg==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.60.2", + "resolved": "https://registry.npmmirror.com/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.60.2.tgz", + "integrity": "sha512-hr26p7e93Rl0Za+JwW7EAnwAvKkehh12BU1Llm9Ykiibg4uIr2rbpxG9WCf56GuvidlTG9KiiQT/TXT1yAWxTA==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-gnu": { + "version": "4.60.2", + "resolved": "https://registry.npmmirror.com/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.60.2.tgz", + "integrity": "sha512-pOjB/uSIyDt+ow3k/RcLvUAOGpysT2phDn7TTUB3n75SlIgZzM6NKAqlErPhoFU+npgY3/n+2HYIQVbF70P9/A==", + "cpu": [ + "loong64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-musl": { + "version": "4.60.2", + "resolved": "https://registry.npmmirror.com/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.60.2.tgz", + "integrity": "sha512-2/w+q8jszv9Ww1c+6uJT3OwqhdmGP2/4T17cu8WuwyUuuaCDDJ2ojdyYwZzCxx0GcsZBhzi3HmH+J5pZNXnd+Q==", + "cpu": [ + "loong64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-gnu": { + "version": "4.60.2", + "resolved": "https://registry.npmmirror.com/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.60.2.tgz", + "integrity": "sha512-11+aL5vKheYgczxtPVVRhdptAM2H7fcDR5Gw4/bTcteuZBlH4oP9f5s9zYO9aGZvoGeBpqXI/9TZZihZ609wKw==", + "cpu": [ + "ppc64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-musl": { + "version": "4.60.2", + "resolved": "https://registry.npmmirror.com/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.60.2.tgz", + "integrity": "sha512-i16fokAGK46IVZuV8LIIwMdtqhin9hfYkCh8pf8iC3QU3LpwL+1FSFGej+O7l3E/AoknL6Dclh2oTdnRMpTzFQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.60.2", + "resolved": "https://registry.npmmirror.com/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.60.2.tgz", + "integrity": "sha512-49FkKS6RGQoriDSK/6E2GkAsAuU5kETFCh7pG4yD/ylj9rKhTmO3elsnmBvRD4PgJPds5W2PkhC82aVwmUcJ7A==", + "cpu": [ + "riscv64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-musl": { + "version": "4.60.2", + "resolved": "https://registry.npmmirror.com/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.60.2.tgz", + "integrity": "sha512-mjYNkHPfGpUR00DuM1ZZIgs64Hpf4bWcz9Z41+4Q+pgDx73UwWdAYyf6EG/lRFldmdHHzgrYyge5akFUW0D3mQ==", + "cpu": [ + "riscv64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-s390x-gnu": { + "version": "4.60.2", + "resolved": "https://registry.npmmirror.com/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.60.2.tgz", + "integrity": "sha512-ALyvJz965BQk8E9Al/JDKKDLH2kfKFLTGMlgkAbbYtZuJt9LU8DW3ZoDMCtQpXAltZxwBHevXz5u+gf0yA0YoA==", + "cpu": [ + "s390x" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.60.2", + "resolved": "https://registry.npmmirror.com/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.60.2.tgz", + "integrity": "sha512-UQjrkIdWrKI626Du8lCQ6MJp/6V1LAo2bOK9OTu4mSn8GGXIkPXk/Vsp4bLHCd9Z9Iz2OTEaokUE90VweJgIYQ==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.60.2", + "resolved": "https://registry.npmmirror.com/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.60.2.tgz", + "integrity": "sha512-bTsRGj6VlSdn/XD4CGyzMnzaBs9bsRxy79eTqTCBsA8TMIEky7qg48aPkvJvFe1HyzQ5oMZdg7AnVlWQSKLTnw==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-openbsd-x64": { + "version": "4.60.2", + "resolved": "https://registry.npmmirror.com/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.60.2.tgz", + "integrity": "sha512-6d4Z3534xitaA1FcMWP7mQPq5zGwBmGbhphh2DwaA1aNIXUu3KTOfwrWpbwI4/Gr0uANo7NTtaykFyO2hPuFLg==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "openbsd" + ] + }, + "node_modules/@rollup/rollup-openharmony-arm64": { + "version": "4.60.2", + "resolved": "https://registry.npmmirror.com/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.60.2.tgz", + "integrity": "sha512-NetAg5iO2uN7eB8zE5qrZ3CSil+7IJt4WDFLcC75Ymywq1VZVD6qJ6EvNLjZ3rEm6gB7XW5JdT60c6MN35Z85Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "openharmony" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.60.2", + "resolved": "https://registry.npmmirror.com/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.60.2.tgz", + "integrity": "sha512-NCYhOotpgWZ5kdxCZsv6Iudx0wX8980Q/oW4pNFNihpBKsDbEA1zpkfxJGC0yugsUuyDZ7gL37dbzwhR0VI7pQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.60.2", + "resolved": "https://registry.npmmirror.com/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.60.2.tgz", + "integrity": "sha512-RXsaOqXxfoUBQoOgvmmijVxJnW2IGB0eoMO7F8FAjaj0UTywUO/luSqimWBJn04WNgUkeNhh7fs7pESXajWmkg==", + "cpu": [ + "ia32" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-gnu": { + "version": "4.60.2", + "resolved": "https://registry.npmmirror.com/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.60.2.tgz", + "integrity": "sha512-qdAzEULD+/hzObedtmV6iBpdL5TIbKVztGiK7O3/KYSf+HIzU257+MX1EXJcyIiDbMAqmbwaufcYPvyRryeZtA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.60.2", + "resolved": "https://registry.npmmirror.com/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.60.2.tgz", + "integrity": "sha512-Nd/SgG27WoA9e+/TdK74KnHz852TLa94ovOYySo/yMPuTmpckK/jIF2jSwS3g7ELSKXK13/cVdmg1Z/DaCWKxA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@transloadit/prettier-bytes": { + "version": "0.0.7", + "resolved": "https://registry.npmmirror.com/@transloadit/prettier-bytes/-/prettier-bytes-0.0.7.tgz", + "integrity": "sha512-VeJbUb0wEKbcwaSlj5n+LscBl9IPgLPkHVGBkh00cztv6X4L/TJXK58LzFuBKX7/GAfiGhIwH67YTLTlzvIzBA==" + }, + "node_modules/@types/estree": { + "version": "1.0.8", + "resolved": "https://registry.npmmirror.com/@types/estree/-/estree-1.0.8.tgz", + "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==", + "dev": true + }, + "node_modules/@types/event-emitter": { + "version": "0.3.5", + "resolved": "https://registry.npmmirror.com/@types/event-emitter/-/event-emitter-0.3.5.tgz", + "integrity": "sha512-zx2/Gg0Eg7gwEiOIIh5w9TrhKKTeQh7CPCOPNc0el4pLSwzebA8SmnHwZs2dWlLONvyulykSwGSQxQHLhjGLvQ==" + }, + "node_modules/@types/lodash": { + "version": "4.17.24", + "resolved": "https://registry.npmmirror.com/@types/lodash/-/lodash-4.17.24.tgz", + "integrity": "sha512-gIW7lQLZbue7lRSWEFql49QJJWThrTFFeIMJdp3eH4tKoxm1OvEPg02rm4wCCSHS0cL3/Fizimb35b7k8atwsQ==" + }, + "node_modules/@types/lodash-es": { + "version": "4.17.12", + "resolved": "https://registry.npmmirror.com/@types/lodash-es/-/lodash-es-4.17.12.tgz", + "integrity": "sha512-0NgftHUcV4v34VhXm8QBSftKVXtbkBG3ViCjs6+eJ5a6y6Mi/jiFGPc1sC7QK+9BFhWrURE3EOggmWaSxL9OzQ==", + "dependencies": { + "@types/lodash": "*" + } + }, + "node_modules/@types/web-bluetooth": { + "version": "0.0.20", + "resolved": "https://registry.npmmirror.com/@types/web-bluetooth/-/web-bluetooth-0.0.20.tgz", + "integrity": "sha512-g9gZnnXVq7gM7v3tJCWV/qw7w+KeOlSHAhgF9RytFyifW6AF61hdT2ucrYhPq9hLs5JIryeupHV3qGk95dH9ow==" + }, + "node_modules/@uppy/companion-client": { + "version": "2.2.2", + "resolved": "https://registry.npmmirror.com/@uppy/companion-client/-/companion-client-2.2.2.tgz", + "integrity": "sha512-5mTp2iq97/mYSisMaBtFRry6PTgZA6SIL7LePteOV5x0/DxKfrZW3DEiQERJmYpHzy7k8johpm2gHnEKto56Og==", + "dependencies": { + "@uppy/utils": "^4.1.2", + "namespace-emitter": "^2.0.1" + } + }, + "node_modules/@uppy/core": { + "version": "2.3.4", + "resolved": "https://registry.npmmirror.com/@uppy/core/-/core-2.3.4.tgz", + "integrity": "sha512-iWAqppC8FD8mMVqewavCz+TNaet6HPXitmGXpGGREGrakZ4FeuWytVdrelydzTdXx6vVKkOmI2FLztGg73sENQ==", + "dependencies": { + "@transloadit/prettier-bytes": "0.0.7", + "@uppy/store-default": "^2.1.1", + "@uppy/utils": "^4.1.3", + "lodash.throttle": "^4.1.1", + "mime-match": "^1.0.2", + "namespace-emitter": "^2.0.1", + "nanoid": "^3.1.25", + "preact": "^10.5.13" + } + }, + "node_modules/@uppy/store-default": { + "version": "2.1.1", + "resolved": "https://registry.npmmirror.com/@uppy/store-default/-/store-default-2.1.1.tgz", + "integrity": "sha512-xnpTxvot2SeAwGwbvmJ899ASk5tYXhmZzD/aCFsXePh/v8rNvR2pKlcQUH7cF/y4baUGq3FHO/daKCok/mpKqQ==" + }, + "node_modules/@uppy/utils": { + "version": "4.1.3", + "resolved": "https://registry.npmmirror.com/@uppy/utils/-/utils-4.1.3.tgz", + "integrity": "sha512-nTuMvwWYobnJcytDO3t+D6IkVq/Qs4Xv3vyoEZ+Iaf8gegZP+rEyoaFT2CK5XLRMienPyqRqNbIfRuFaOWSIFw==", + "dependencies": { + "lodash.throttle": "^4.1.1" + } + }, + "node_modules/@uppy/xhr-upload": { + "version": "2.1.3", + "resolved": "https://registry.npmmirror.com/@uppy/xhr-upload/-/xhr-upload-2.1.3.tgz", + "integrity": "sha512-YWOQ6myBVPs+mhNjfdWsQyMRWUlrDLMoaG7nvf/G6Y3GKZf8AyjFDjvvJ49XWQ+DaZOftGkHmF1uh/DBeGivJQ==", + "dependencies": { + "@uppy/companion-client": "^2.2.2", + "@uppy/utils": "^4.1.2", + "nanoid": "^3.1.25" + }, + "peerDependencies": { + "@uppy/core": "^2.3.3" + } + }, + "node_modules/@vitejs/plugin-vue": { + "version": "5.2.4", + "resolved": "https://registry.npmmirror.com/@vitejs/plugin-vue/-/plugin-vue-5.2.4.tgz", + "integrity": "sha512-7Yx/SXSOcQq5HiiV3orevHUFn+pmMB4cgbEkDYgnkUWb0WfeQ/wa2yFv6D5ICiCQOVpjA7vYDXrC7AGO8yjDHA==", + "dev": true, + "engines": { + "node": "^18.0.0 || >=20.0.0" + }, + "peerDependencies": { + "vite": "^5.0.0 || ^6.0.0", + "vue": "^3.2.25" + } + }, + "node_modules/@vue/compiler-core": { + "version": "3.5.33", + "resolved": "https://registry.npmmirror.com/@vue/compiler-core/-/compiler-core-3.5.33.tgz", + "integrity": "sha512-3PZLQwFw4Za3TC8t0FvTy3wI16Kt+pmwcgNZca4Pj9iWL2E72a/gZlpBtAJvEdDMdCxdG/qq0C7PN0bsJuv0Rw==", + "dependencies": { + "@babel/parser": "^7.29.2", + "@vue/shared": "3.5.33", + "entities": "^7.0.1", + "estree-walker": "^2.0.2", + "source-map-js": "^1.2.1" + } + }, + "node_modules/@vue/compiler-dom": { + "version": "3.5.33", + "resolved": "https://registry.npmmirror.com/@vue/compiler-dom/-/compiler-dom-3.5.33.tgz", + "integrity": "sha512-PXq0yrfCLzzL07rbXO4awtXY1Z06LG2eu6Adg3RJFa/j3Cii217XxxLXG22N330gw7GmALCY0Z8RgXEviwgpjA==", + "dependencies": { + "@vue/compiler-core": "3.5.33", + "@vue/shared": "3.5.33" + } + }, + "node_modules/@vue/compiler-sfc": { + "version": "3.5.33", + "resolved": "https://registry.npmmirror.com/@vue/compiler-sfc/-/compiler-sfc-3.5.33.tgz", + "integrity": "sha512-UTUvRO9cY+rROrx/pvN9P5Z7FgA6QGfokUCfhQE4EnmUj3rVnK+CHI0LsEO1pg+I7//iRYMUfcNcCPe7tg0CoA==", + "dependencies": { + "@babel/parser": "^7.29.2", + "@vue/compiler-core": "3.5.33", + "@vue/compiler-dom": "3.5.33", + "@vue/compiler-ssr": "3.5.33", + "@vue/shared": "3.5.33", + "estree-walker": "^2.0.2", + "magic-string": "^0.30.21", + "postcss": "^8.5.10", + "source-map-js": "^1.2.1" + } + }, + "node_modules/@vue/compiler-ssr": { + "version": "3.5.33", + "resolved": "https://registry.npmmirror.com/@vue/compiler-ssr/-/compiler-ssr-3.5.33.tgz", + "integrity": "sha512-IErjYdnj1qIupG5xxiVIYiiRvDhGWV4zuh/RCrwfYpuL+HWQzeU6lCk/nF9r7olWMnjKxCAkOctT2qFWFkzb1A==", + "dependencies": { + "@vue/compiler-dom": "3.5.33", + "@vue/shared": "3.5.33" + } + }, + "node_modules/@vue/devtools-api": { + "version": "7.7.9", + "resolved": "https://registry.npmmirror.com/@vue/devtools-api/-/devtools-api-7.7.9.tgz", + "integrity": "sha512-kIE8wvwlcZ6TJTbNeU2HQNtaxLx3a84aotTITUuL/4bzfPxzajGBOoqjMhwZJ8L9qFYDU/lAYMEEm11dnZOD6g==", + "dependencies": { + "@vue/devtools-kit": "^7.7.9" + } + }, + "node_modules/@vue/devtools-kit": { + "version": "7.7.9", + "resolved": "https://registry.npmmirror.com/@vue/devtools-kit/-/devtools-kit-7.7.9.tgz", + "integrity": "sha512-PyQ6odHSgiDVd4hnTP+aDk2X4gl2HmLDfiyEnn3/oV+ckFDuswRs4IbBT7vacMuGdwY/XemxBoh302ctbsptuA==", + "dependencies": { + "@vue/devtools-shared": "^7.7.9", + "birpc": "^2.3.0", + "hookable": "^5.5.3", + "mitt": "^3.0.1", + "perfect-debounce": "^1.0.0", + "speakingurl": "^14.0.1", + "superjson": "^2.2.2" + } + }, + "node_modules/@vue/devtools-shared": { + "version": "7.7.9", + "resolved": "https://registry.npmmirror.com/@vue/devtools-shared/-/devtools-shared-7.7.9.tgz", + "integrity": "sha512-iWAb0v2WYf0QWmxCGy0seZNDPdO3Sp5+u78ORnyeonS6MT4PC7VPrryX2BpMJrwlDeaZ6BD4vP4XKjK0SZqaeA==", + "dependencies": { + "rfdc": "^1.4.1" + } + }, + "node_modules/@vue/reactivity": { + "version": "3.5.33", + "resolved": "https://registry.npmmirror.com/@vue/reactivity/-/reactivity-3.5.33.tgz", + "integrity": "sha512-p8UfIqyIhb0rYGlSgSBV+lPhF2iUSBcRy7enhTmPqKWadHy9kcOFYF1AejYBP9P+avnd3OBbD49DU4pLWX/94A==", + "dependencies": { + "@vue/shared": "3.5.33" + } + }, + "node_modules/@vue/runtime-core": { + "version": "3.5.33", + "resolved": "https://registry.npmmirror.com/@vue/runtime-core/-/runtime-core-3.5.33.tgz", + "integrity": "sha512-UpFF45RI9//a7rvq7RdOQblb4tup7hHG9QsmIrxkFQLzQ7R8/iNQ5LE15NhLZ1/WcHMU2b47u6P33CPUelHyIQ==", + "dependencies": { + "@vue/reactivity": "3.5.33", + "@vue/shared": "3.5.33" + } + }, + "node_modules/@vue/runtime-dom": { + "version": "3.5.33", + "resolved": "https://registry.npmmirror.com/@vue/runtime-dom/-/runtime-dom-3.5.33.tgz", + "integrity": "sha512-IOxMsAOwquhfITgmOgaPYl7/j8gKUxUFoflRc+u4LxyD3+783xne8vNta1PONVCvCV9A0w7hkyEepINDqfO0tw==", + "dependencies": { + "@vue/reactivity": "3.5.33", + "@vue/runtime-core": "3.5.33", + "@vue/shared": "3.5.33", + "csstype": "^3.2.3" + } + }, + "node_modules/@vue/server-renderer": { + "version": "3.5.33", + "resolved": "https://registry.npmmirror.com/@vue/server-renderer/-/server-renderer-3.5.33.tgz", + "integrity": "sha512-0xylq/8/h44lVG0pZFknv1XIdEgymq2E9n59uTWJBG+dIgiT0TMCSsxrN7nO16Z0MU0MPjFcguBbZV8Itk52Hw==", + "dependencies": { + "@vue/compiler-ssr": "3.5.33", + "@vue/shared": "3.5.33" + }, + "peerDependencies": { + "vue": "3.5.33" + } + }, + "node_modules/@vue/shared": { + "version": "3.5.33", + "resolved": "https://registry.npmmirror.com/@vue/shared/-/shared-3.5.33.tgz", + "integrity": "sha512-5vR2QIlmaLG77Ygd4pMP6+SGQ5yox9VhtnbDWTy9DzMzdmeLxZ1QqxrywEZ9sa1AVubfIJyaCG3ytyWU81ufcQ==" + }, + "node_modules/@vueuse/core": { + "version": "12.0.0", + "resolved": "https://registry.npmmirror.com/@vueuse/core/-/core-12.0.0.tgz", + "integrity": "sha512-C12RukhXiJCbx4MGhjmd/gH52TjJsc3G0E0kQj/kb19H3Nt6n1CA4DRWuTdWWcaFRdlTe0npWDS942mvacvNBw==", + "dependencies": { + "@types/web-bluetooth": "^0.0.20", + "@vueuse/metadata": "12.0.0", + "@vueuse/shared": "12.0.0", + "vue": "^3.5.13" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/@vueuse/metadata": { + "version": "12.0.0", + "resolved": "https://registry.npmmirror.com/@vueuse/metadata/-/metadata-12.0.0.tgz", + "integrity": "sha512-Yzimd1D3sjxTDOlF05HekU5aSGdKjxhuhRFHA7gDWLn57PRbBIh+SF5NmjhJ0WRgF3my7T8LBucyxdFJjIfRJQ==", + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/@vueuse/shared": { + "version": "12.0.0", + "resolved": "https://registry.npmmirror.com/@vueuse/shared/-/shared-12.0.0.tgz", + "integrity": "sha512-3i6qtcq2PIio5i/vVYidkkcgvmTjCqrf26u+Fd4LhnbBmIT6FN8y6q/GJERp8lfcB9zVEfjdV0Br0443qZuJpw==", + "dependencies": { + "vue": "^3.5.13" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/@wangeditor/basic-modules": { + "version": "1.1.7", + "resolved": "https://registry.npmmirror.com/@wangeditor/basic-modules/-/basic-modules-1.1.7.tgz", + "integrity": "sha512-cY9CPkLJaqF05STqfpZKWG4LpxTMeGSIIF1fHvfm/mz+JXatCagjdkbxdikOuKYlxDdeqvOeBmsUBItufDLXZg==", + "dependencies": { + "is-url": "^1.2.4" + }, + "peerDependencies": { + "@wangeditor/core": "1.x", + "dom7": "^3.0.0", + "lodash.throttle": "^4.1.1", + "nanoid": "^3.2.0", + "slate": "^0.72.0", + "snabbdom": "^3.1.0" + } + }, + "node_modules/@wangeditor/code-highlight": { + "version": "1.0.3", + "resolved": "https://registry.npmmirror.com/@wangeditor/code-highlight/-/code-highlight-1.0.3.tgz", + "integrity": "sha512-iazHwO14XpCuIWJNTQTikqUhGKyqj+dUNWJ9288Oym9M2xMVHvnsOmDU2sgUDWVy+pOLojReMPgXCsvvNlOOhw==", + "dependencies": { + "prismjs": "^1.23.0" + }, + "peerDependencies": { + "@wangeditor/core": "1.x", + "dom7": "^3.0.0", + "slate": "^0.72.0", + "snabbdom": "^3.1.0" + } + }, + "node_modules/@wangeditor/core": { + "version": "1.1.19", + "resolved": "https://registry.npmmirror.com/@wangeditor/core/-/core-1.1.19.tgz", + "integrity": "sha512-KevkB47+7GhVszyYF2pKGKtCSj/YzmClsD03C3zTt+9SR2XWT5T0e3yQqg8baZpcMvkjs1D8Dv4fk8ok/UaS2Q==", + "dependencies": { + "@types/event-emitter": "^0.3.3", + "event-emitter": "^0.3.5", + "html-void-elements": "^2.0.0", + "i18next": "^20.4.0", + "scroll-into-view-if-needed": "^2.2.28", + "slate-history": "^0.66.0" + }, + "peerDependencies": { + "@uppy/core": "^2.1.1", + "@uppy/xhr-upload": "^2.0.3", + "dom7": "^3.0.0", + "is-hotkey": "^0.2.0", + "lodash.camelcase": "^4.3.0", + "lodash.clonedeep": "^4.5.0", + "lodash.debounce": "^4.0.8", + "lodash.foreach": "^4.5.0", + "lodash.isequal": "^4.5.0", + "lodash.throttle": "^4.1.1", + "lodash.toarray": "^4.4.0", + "nanoid": "^3.2.0", + "slate": "^0.72.0", + "snabbdom": "^3.1.0" + } + }, + "node_modules/@wangeditor/editor": { + "version": "5.1.23", + "resolved": "https://registry.npmmirror.com/@wangeditor/editor/-/editor-5.1.23.tgz", + "integrity": "sha512-0RxfeVTuK1tktUaPROnCoFfaHVJpRAIE2zdS0mpP+vq1axVQpLjM8+fCvKzqYIkH0Pg+C+44hJpe3VVroSkEuQ==", + "dependencies": { + "@uppy/core": "^2.1.1", + "@uppy/xhr-upload": "^2.0.3", + "@wangeditor/basic-modules": "^1.1.7", + "@wangeditor/code-highlight": "^1.0.3", + "@wangeditor/core": "^1.1.19", + "@wangeditor/list-module": "^1.0.5", + "@wangeditor/table-module": "^1.1.4", + "@wangeditor/upload-image-module": "^1.0.2", + "@wangeditor/video-module": "^1.1.4", + "dom7": "^3.0.0", + "is-hotkey": "^0.2.0", + "lodash.camelcase": "^4.3.0", + "lodash.clonedeep": "^4.5.0", + "lodash.debounce": "^4.0.8", + "lodash.foreach": "^4.5.0", + "lodash.isequal": "^4.5.0", + "lodash.throttle": "^4.1.1", + "lodash.toarray": "^4.4.0", + "nanoid": "^3.2.0", + "slate": "^0.72.0", + "snabbdom": "^3.1.0" + } + }, + "node_modules/@wangeditor/editor-for-vue": { + "version": "5.1.12", + "resolved": "https://registry.npmmirror.com/@wangeditor/editor-for-vue/-/editor-for-vue-5.1.12.tgz", + "integrity": "sha512-0Ds3D8I+xnpNWezAeO7HmPRgTfUxHLMd9JKcIw+QzvSmhC5xUHbpCcLU+KLmeBKTR/zffnS5GQo6qi3GhTMJWQ==", + "peerDependencies": { + "@wangeditor/editor": ">=5.1.0", + "vue": "^3.0.5" + } + }, + "node_modules/@wangeditor/list-module": { + "version": "1.0.5", + "resolved": "https://registry.npmmirror.com/@wangeditor/list-module/-/list-module-1.0.5.tgz", + "integrity": "sha512-uDuYTP6DVhcYf7mF1pTlmNn5jOb4QtcVhYwSSAkyg09zqxI1qBqsfUnveeDeDqIuptSJhkh81cyxi+MF8sEPOQ==", + "peerDependencies": { + "@wangeditor/core": "1.x", + "dom7": "^3.0.0", + "slate": "^0.72.0", + "snabbdom": "^3.1.0" + } + }, + "node_modules/@wangeditor/table-module": { + "version": "1.1.4", + "resolved": "https://registry.npmmirror.com/@wangeditor/table-module/-/table-module-1.1.4.tgz", + "integrity": "sha512-5saanU9xuEocxaemGdNi9t8MCDSucnykEC6jtuiT72kt+/Hhh4nERYx1J20OPsTCCdVr7hIyQenFD1iSRkIQ6w==", + "peerDependencies": { + "@wangeditor/core": "1.x", + "dom7": "^3.0.0", + "lodash.isequal": "^4.5.0", + "lodash.throttle": "^4.1.1", + "nanoid": "^3.2.0", + "slate": "^0.72.0", + "snabbdom": "^3.1.0" + } + }, + "node_modules/@wangeditor/upload-image-module": { + "version": "1.0.2", + "resolved": "https://registry.npmmirror.com/@wangeditor/upload-image-module/-/upload-image-module-1.0.2.tgz", + "integrity": "sha512-z81lk/v71OwPDYeQDxj6cVr81aDP90aFuywb8nPD6eQeECtOymrqRODjpO6VGvCVxVck8nUxBHtbxKtjgcwyiA==", + "peerDependencies": { + "@uppy/core": "^2.0.3", + "@uppy/xhr-upload": "^2.0.3", + "@wangeditor/basic-modules": "1.x", + "@wangeditor/core": "1.x", + "dom7": "^3.0.0", + "lodash.foreach": "^4.5.0", + "slate": "^0.72.0", + "snabbdom": "^3.1.0" + } + }, + "node_modules/@wangeditor/video-module": { + "version": "1.1.4", + "resolved": "https://registry.npmmirror.com/@wangeditor/video-module/-/video-module-1.1.4.tgz", + "integrity": "sha512-ZdodDPqKQrgx3IwWu4ZiQmXI8EXZ3hm2/fM6E3t5dB8tCaIGWQZhmqd6P5knfkRAd3z2+YRSRbxOGfoRSp/rLg==", + "peerDependencies": { + "@uppy/core": "^2.1.4", + "@uppy/xhr-upload": "^2.0.7", + "@wangeditor/core": "1.x", + "dom7": "^3.0.0", + "nanoid": "^3.2.0", + "slate": "^0.72.0", + "snabbdom": "^3.1.0" + } + }, + "node_modules/acorn": { + "version": "8.16.0", + "resolved": "https://registry.npmmirror.com/acorn/-/acorn-8.16.0.tgz", + "integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==", + "dev": true, + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/anymatch": { + "version": "3.1.3", + "resolved": "https://registry.npmmirror.com/anymatch/-/anymatch-3.1.3.tgz", + "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", + "dev": true, + "dependencies": { + "normalize-path": "^3.0.0", + "picomatch": "^2.0.4" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/anymatch/node_modules/picomatch": { + "version": "2.3.2", + "resolved": "https://registry.npmmirror.com/picomatch/-/picomatch-2.3.2.tgz", + "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==", + "dev": true, + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/async-validator": { + "version": "4.2.5", + "resolved": "https://registry.npmmirror.com/async-validator/-/async-validator-4.2.5.tgz", + "integrity": "sha512-7HhHjtERjqlNbZtqNqy2rckN/SpOOlmDliet+lP7k+eKZEjPk3DgyeU9lIXLdeLz0uBbbVp+9Qdow9wJWgwwfg==" + }, + "node_modules/asynckit": { + "version": "0.4.0", + "resolved": "https://registry.npmmirror.com/asynckit/-/asynckit-0.4.0.tgz", + "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==" + }, + "node_modules/axios": { + "version": "1.16.0", + "resolved": "https://registry.npmmirror.com/axios/-/axios-1.16.0.tgz", + "integrity": "sha512-6hp5CwvTPlN2A31g5dxnwAX0orzM7pmCRDLnZSX772mv8WDqICwFjowHuPs04Mc8deIld1+ejhtaMn5vp6b+1w==", + "dependencies": { + "follow-redirects": "^1.16.0", + "form-data": "^4.0.5", + "proxy-from-env": "^2.1.0" + } + }, + "node_modules/balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmmirror.com/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", + "dev": true + }, + "node_modules/binary-extensions": { + "version": "2.3.0", + "resolved": "https://registry.npmmirror.com/binary-extensions/-/binary-extensions-2.3.0.tgz", + "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==", + "dev": true, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/birpc": { + "version": "2.9.0", + "resolved": "https://registry.npmmirror.com/birpc/-/birpc-2.9.0.tgz", + "integrity": "sha512-KrayHS5pBi69Xi9JmvoqrIgYGDkD6mcSe/i6YKi3w5kekCLzrX4+nawcXqrj2tIp50Kw/mT/s3p+GVK0A0sKxw==", + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/brace-expansion": { + "version": "2.1.0", + "resolved": "https://registry.npmmirror.com/brace-expansion/-/brace-expansion-2.1.0.tgz", + "integrity": "sha512-TN1kCZAgdgweJhWWpgKYrQaMNHcDULHkWwQIspdtjV4Y5aurRdZpjAqn6yX3FPqTA9ngHCc4hJxMAMgGfve85w==", + "dev": true, + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/braces": { + "version": "3.0.3", + "resolved": "https://registry.npmmirror.com/braces/-/braces-3.0.3.tgz", + "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==", + "dev": true, + "dependencies": { + "fill-range": "^7.1.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/call-bind-apply-helpers": { + "version": "1.0.2", + "resolved": "https://registry.npmmirror.com/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz", + "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==", + "dependencies": { + "es-errors": "^1.3.0", + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/china-area-data": { + "version": "5.0.1", + "resolved": "https://registry.npmmirror.com/china-area-data/-/china-area-data-5.0.1.tgz", + "integrity": "sha512-BQDPpiv5Nn+018ekcJK2oSD9PAD+E1bvXB0wgabc//dFVS/KvRqCgg0QOEUt3vBkx9XzB5a9BmkJCEZDBxVjVw==" + }, + "node_modules/china-division": { + "version": "2.7.0", + "resolved": "https://registry.npmmirror.com/china-division/-/china-division-2.7.0.tgz", + "integrity": "sha512-4uUPAT+1WfqDh5jytq7omdCmHNk3j+k76zEG/2IqaGcYB90c2SwcixttcypdsZ3T/9tN1TTpBDoeZn+Yw/qBEA==" + }, + "node_modules/chokidar": { + "version": "4.0.3", + "resolved": "https://registry.npmmirror.com/chokidar/-/chokidar-4.0.3.tgz", + "integrity": "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==", + "dev": true, + "dependencies": { + "readdirp": "^4.0.1" + }, + "engines": { + "node": ">= 14.16.0" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/combined-stream": { + "version": "1.0.8", + "resolved": "https://registry.npmmirror.com/combined-stream/-/combined-stream-1.0.8.tgz", + "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==", + "dependencies": { + "delayed-stream": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/compute-scroll-into-view": { + "version": "1.0.20", + "resolved": "https://registry.npmmirror.com/compute-scroll-into-view/-/compute-scroll-into-view-1.0.20.tgz", + "integrity": "sha512-UCB0ioiyj8CRjtrvaceBLqqhZCVP+1B8+NWQhmdsm0VXOJtobBCf1dBQmebCCo34qZmUwZfIH2MZLqNHazrfjg==" + }, + "node_modules/confbox": { + "version": "0.1.8", + "resolved": "https://registry.npmmirror.com/confbox/-/confbox-0.1.8.tgz", + "integrity": "sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==", + "dev": true + }, + "node_modules/copy-anything": { + "version": "4.0.5", + "resolved": "https://registry.npmmirror.com/copy-anything/-/copy-anything-4.0.5.tgz", + "integrity": "sha512-7Vv6asjS4gMOuILabD3l739tsaxFQmC+a7pLZm02zyvs8p977bL3zEgq3yDk5rn9B0PbYgIv++jmHcuUab4RhA==", + "dependencies": { + "is-what": "^5.2.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/mesqueeb" + } + }, + "node_modules/csstype": { + "version": "3.2.3", + "resolved": "https://registry.npmmirror.com/csstype/-/csstype-3.2.3.tgz", + "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==" + }, + "node_modules/d": { + "version": "1.0.2", + "resolved": "https://registry.npmmirror.com/d/-/d-1.0.2.tgz", + "integrity": "sha512-MOqHvMWF9/9MX6nza0KgvFH4HpMU0EF5uUDXqX/BtxtU8NfB0QzRtJ8Oe/6SuS4kbhyzVJwjd97EA4PKrzJ8bw==", + "dependencies": { + "es5-ext": "^0.10.64", + "type": "^2.7.2" + }, + "engines": { + "node": ">=0.12" + } + }, + "node_modules/dayjs": { + "version": "1.11.20", + "resolved": "https://registry.npmmirror.com/dayjs/-/dayjs-1.11.20.tgz", + "integrity": "sha512-YbwwqR/uYpeoP4pu043q+LTDLFBLApUP6VxRihdfNTqu4ubqMlGDLd6ErXhEgsyvY0K6nCs7nggYumAN+9uEuQ==" + }, + "node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmmirror.com/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/delayed-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmmirror.com/delayed-stream/-/delayed-stream-1.0.0.tgz", + "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==", + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/detect-libc": { + "version": "2.1.2", + "resolved": "https://registry.npmmirror.com/detect-libc/-/detect-libc-2.1.2.tgz", + "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==", + "dev": true, + "optional": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/dom7": { + "version": "3.0.0", + "resolved": "https://registry.npmmirror.com/dom7/-/dom7-3.0.0.tgz", + "integrity": "sha512-oNlcUdHsC4zb7Msx7JN3K0Nro1dzJ48knvBOnDPKJ2GV9wl1i5vydJZUSyOfrkKFDZEud/jBsTk92S/VGSAe/g==", + "dependencies": { + "ssr-window": "^3.0.0-alpha.1" + } + }, + "node_modules/dunder-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmmirror.com/dunder-proto/-/dunder-proto-1.0.1.tgz", + "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==", + "dependencies": { + "call-bind-apply-helpers": "^1.0.1", + "es-errors": "^1.3.0", + "gopd": "^1.2.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/echarts": { + "version": "5.6.0", + "resolved": "https://registry.npmmirror.com/echarts/-/echarts-5.6.0.tgz", + "integrity": "sha512-oTbVTsXfKuEhxftHqL5xprgLoc0k7uScAwtryCgWF6hPYFLRwOUHiFmHGCBKP5NPFNkDVopOieyUqYGH8Fa3kA==", + "dependencies": { + "tslib": "2.3.0", + "zrender": "5.6.1" + } + }, + "node_modules/element-china-area-data": { + "version": "6.1.0", + "resolved": "https://registry.npmmirror.com/element-china-area-data/-/element-china-area-data-6.1.0.tgz", + "integrity": "sha512-IkpcjwQv2A/2AxFiSoaISZ+oMw1rZCPUSOg5sOCwT5jKc96TaawmKZeY81xfxXsO0QbKxU5LLc6AirhG52hUmg==", + "dependencies": { + "china-division": "^2.7.0" + } + }, + "node_modules/element-plus": { + "version": "2.13.7", + "resolved": "https://registry.npmmirror.com/element-plus/-/element-plus-2.13.7.tgz", + "integrity": "sha512-XdHATFZOyzVFL1DaHQ90IOJQSg9UnSAV+bhDW+YB5UoZ0Hxs50mwqjqfwXkuwpSag+VXXizVcErBR6Movo5daw==", + "dependencies": { + "@ctrl/tinycolor": "^4.2.0", + "@element-plus/icons-vue": "^2.3.2", + "@floating-ui/dom": "^1.0.1", + "@popperjs/core": "npm:@sxzz/popperjs-es@^2.11.7", + "@types/lodash": "^4.17.20", + "@types/lodash-es": "^4.17.12", + "@vueuse/core": "12.0.0", + "async-validator": "^4.2.5", + "dayjs": "^1.11.19", + "lodash": "^4.17.23", + "lodash-es": "^4.17.23", + "lodash-unified": "^1.0.3", + "memoize-one": "^6.0.0", + "normalize-wheel-es": "^1.2.0", + "vue-component-type-helpers": "^3.2.4" + }, + "peerDependencies": { + "vue": "^3.3.0" + } + }, + "node_modules/entities": { + "version": "7.0.1", + "resolved": "https://registry.npmmirror.com/entities/-/entities-7.0.1.tgz", + "integrity": "sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA==", + "engines": { + "node": ">=0.12" + }, + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, + "node_modules/es-define-property": { + "version": "1.0.1", + "resolved": "https://registry.npmmirror.com/es-define-property/-/es-define-property-1.0.1.tgz", + "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-errors": { + "version": "1.3.0", + "resolved": "https://registry.npmmirror.com/es-errors/-/es-errors-1.3.0.tgz", + "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-module-lexer": { + "version": "1.7.0", + "resolved": "https://registry.npmmirror.com/es-module-lexer/-/es-module-lexer-1.7.0.tgz", + "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==", + "dev": true + }, + "node_modules/es-object-atoms": { + "version": "1.1.1", + "resolved": "https://registry.npmmirror.com/es-object-atoms/-/es-object-atoms-1.1.1.tgz", + "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==", + "dependencies": { + "es-errors": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-set-tostringtag": { + "version": "2.1.0", + "resolved": "https://registry.npmmirror.com/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz", + "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==", + "dependencies": { + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.6", + "has-tostringtag": "^1.0.2", + "hasown": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es5-ext": { + "version": "0.10.64", + "resolved": "https://registry.npmmirror.com/es5-ext/-/es5-ext-0.10.64.tgz", + "integrity": "sha512-p2snDhiLaXe6dahss1LddxqEm+SkuDvV8dnIQG0MWjyHpcMNfXKPE+/Cc0y+PhxJX3A4xGNeFCj5oc0BUh6deg==", + "hasInstallScript": true, + "dependencies": { + "es6-iterator": "^2.0.3", + "es6-symbol": "^3.1.3", + "esniff": "^2.0.1", + "next-tick": "^1.1.0" + }, + "engines": { + "node": ">=0.10" + } + }, + "node_modules/es6-iterator": { + "version": "2.0.3", + "resolved": "https://registry.npmmirror.com/es6-iterator/-/es6-iterator-2.0.3.tgz", + "integrity": "sha512-zw4SRzoUkd+cl+ZoE15A9o1oQd920Bb0iOJMQkQhl3jNc03YqVjAhG7scf9C5KWRU/R13Orf588uCC6525o02g==", + "dependencies": { + "d": "1", + "es5-ext": "^0.10.35", + "es6-symbol": "^3.1.1" + } + }, + "node_modules/es6-symbol": { + "version": "3.1.4", + "resolved": "https://registry.npmmirror.com/es6-symbol/-/es6-symbol-3.1.4.tgz", + "integrity": "sha512-U9bFFjX8tFiATgtkJ1zg25+KviIXpgRvRHS8sau3GfhVzThRQrOeksPeT0BWW2MNZs1OEWJ1DPXOQMn0KKRkvg==", + "dependencies": { + "d": "^1.0.2", + "ext": "^1.7.0" + }, + "engines": { + "node": ">=0.12" + } + }, + "node_modules/esbuild": { + "version": "0.21.5", + "resolved": "https://registry.npmmirror.com/esbuild/-/esbuild-0.21.5.tgz", + "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==", + "dev": true, + "hasInstallScript": true, + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=12" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.21.5", + "@esbuild/android-arm": "0.21.5", + "@esbuild/android-arm64": "0.21.5", + "@esbuild/android-x64": "0.21.5", + "@esbuild/darwin-arm64": "0.21.5", + "@esbuild/darwin-x64": "0.21.5", + "@esbuild/freebsd-arm64": "0.21.5", + "@esbuild/freebsd-x64": "0.21.5", + "@esbuild/linux-arm": "0.21.5", + "@esbuild/linux-arm64": "0.21.5", + "@esbuild/linux-ia32": "0.21.5", + "@esbuild/linux-loong64": "0.21.5", + "@esbuild/linux-mips64el": "0.21.5", + "@esbuild/linux-ppc64": "0.21.5", + "@esbuild/linux-riscv64": "0.21.5", + "@esbuild/linux-s390x": "0.21.5", + "@esbuild/linux-x64": "0.21.5", + "@esbuild/netbsd-x64": "0.21.5", + "@esbuild/openbsd-x64": "0.21.5", + "@esbuild/sunos-x64": "0.21.5", + "@esbuild/win32-arm64": "0.21.5", + "@esbuild/win32-ia32": "0.21.5", + "@esbuild/win32-x64": "0.21.5" + } + }, + "node_modules/escape-string-regexp": { + "version": "5.0.0", + "resolved": "https://registry.npmmirror.com/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz", + "integrity": "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==", + "dev": true, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/esniff": { + "version": "2.0.1", + "resolved": "https://registry.npmmirror.com/esniff/-/esniff-2.0.1.tgz", + "integrity": "sha512-kTUIGKQ/mDPFoJ0oVfcmyJn4iBDRptjNVIzwIFR7tqWXdVI9xfA2RMwY/gbSpJG3lkdWNEjLap/NqVHZiJsdfg==", + "dependencies": { + "d": "^1.0.1", + "es5-ext": "^0.10.62", + "event-emitter": "^0.3.5", + "type": "^2.7.2" + }, + "engines": { + "node": ">=0.10" + } + }, + "node_modules/estree-walker": { + "version": "2.0.2", + "resolved": "https://registry.npmmirror.com/estree-walker/-/estree-walker-2.0.2.tgz", + "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==" + }, + "node_modules/event-emitter": { + "version": "0.3.5", + "resolved": "https://registry.npmmirror.com/event-emitter/-/event-emitter-0.3.5.tgz", + "integrity": "sha512-D9rRn9y7kLPnJ+hMq7S/nhvoKwwvVJahBi2BPmx3bvbsEdK3W9ii8cBSGjP+72/LnM4n6fo3+dkCX5FeTQruXA==", + "dependencies": { + "d": "1", + "es5-ext": "~0.10.14" + } + }, + "node_modules/exsolve": { + "version": "1.0.8", + "resolved": "https://registry.npmmirror.com/exsolve/-/exsolve-1.0.8.tgz", + "integrity": "sha512-LmDxfWXwcTArk8fUEnOfSZpHOJ6zOMUJKOtFLFqJLoKJetuQG874Uc7/Kki7zFLzYybmZhp1M7+98pfMqeX8yA==", + "dev": true + }, + "node_modules/ext": { + "version": "1.7.0", + "resolved": "https://registry.npmmirror.com/ext/-/ext-1.7.0.tgz", + "integrity": "sha512-6hxeJYaL110a9b5TEJSj0gojyHQAmA2ch5Os+ySCiA1QGdS697XWY1pzsrSjqA9LDEEgdB/KypIlR59RcLuHYw==", + "dependencies": { + "type": "^2.7.2" + } + }, + "node_modules/fast-glob": { + "version": "3.3.3", + "resolved": "https://registry.npmmirror.com/fast-glob/-/fast-glob-3.3.3.tgz", + "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==", + "dev": true, + "dependencies": { + "@nodelib/fs.stat": "^2.0.2", + "@nodelib/fs.walk": "^1.2.3", + "glob-parent": "^5.1.2", + "merge2": "^1.3.0", + "micromatch": "^4.0.8" + }, + "engines": { + "node": ">=8.6.0" + } + }, + "node_modules/fastq": { + "version": "1.20.1", + "resolved": "https://registry.npmmirror.com/fastq/-/fastq-1.20.1.tgz", + "integrity": "sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==", + "dev": true, + "dependencies": { + "reusify": "^1.0.4" + } + }, + "node_modules/fill-range": { + "version": "7.1.1", + "resolved": "https://registry.npmmirror.com/fill-range/-/fill-range-7.1.1.tgz", + "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==", + "dev": true, + "dependencies": { + "to-regex-range": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/follow-redirects": { + "version": "1.16.0", + "resolved": "https://registry.npmmirror.com/follow-redirects/-/follow-redirects-1.16.0.tgz", + "integrity": "sha512-y5rN/uOsadFT/JfYwhxRS5R7Qce+g3zG97+JrtFZlC9klX/W5hD7iiLzScI4nZqUS7DNUdhPgw4xI8W2LuXlUw==", + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/RubenVerborgh" + } + ], + "engines": { + "node": ">=4.0" + }, + "peerDependenciesMeta": { + "debug": { + "optional": true + } + } + }, + "node_modules/form-data": { + "version": "4.0.5", + "resolved": "https://registry.npmmirror.com/form-data/-/form-data-4.0.5.tgz", + "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==", + "dependencies": { + "asynckit": "^0.4.0", + "combined-stream": "^1.0.8", + "es-set-tostringtag": "^2.1.0", + "hasown": "^2.0.2", + "mime-types": "^2.1.12" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmmirror.com/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/function-bind": { + "version": "1.1.2", + "resolved": "https://registry.npmmirror.com/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-intrinsic": { + "version": "1.3.0", + "resolved": "https://registry.npmmirror.com/get-intrinsic/-/get-intrinsic-1.3.0.tgz", + "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "es-define-property": "^1.0.1", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.1.1", + "function-bind": "^1.1.2", + "get-proto": "^1.0.1", + "gopd": "^1.2.0", + "has-symbols": "^1.1.0", + "hasown": "^2.0.2", + "math-intrinsics": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmmirror.com/get-proto/-/get-proto-1.0.1.tgz", + "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==", + "dependencies": { + "dunder-proto": "^1.0.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmmirror.com/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "dev": true, + "dependencies": { + "is-glob": "^4.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/gopd": { + "version": "1.2.0", + "resolved": "https://registry.npmmirror.com/gopd/-/gopd-1.2.0.tgz", + "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-symbols": { + "version": "1.1.0", + "resolved": "https://registry.npmmirror.com/has-symbols/-/has-symbols-1.1.0.tgz", + "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-tostringtag": { + "version": "1.0.2", + "resolved": "https://registry.npmmirror.com/has-tostringtag/-/has-tostringtag-1.0.2.tgz", + "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==", + "dependencies": { + "has-symbols": "^1.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/hasown": { + "version": "2.0.3", + "resolved": "https://registry.npmmirror.com/hasown/-/hasown-2.0.3.tgz", + "integrity": "sha512-ej4AhfhfL2Q2zpMmLo7U1Uv9+PyhIZpgQLGT1F9miIGmiCJIoCgSmczFdrc97mWT4kVY72KA+WnnhJ5pghSvSg==", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/hookable": { + "version": "5.5.3", + "resolved": "https://registry.npmmirror.com/hookable/-/hookable-5.5.3.tgz", + "integrity": "sha512-Yc+BQe8SvoXH1643Qez1zqLRmbA5rCL+sSmk6TVos0LWVfNIB7PGncdlId77WzLGSIB5KaWgTaNTs2lNVEI6VQ==" + }, + "node_modules/html-void-elements": { + "version": "2.0.1", + "resolved": "https://registry.npmmirror.com/html-void-elements/-/html-void-elements-2.0.1.tgz", + "integrity": "sha512-0quDb7s97CfemeJAnW9wC0hw78MtW7NU3hqtCD75g2vFlDLt36llsYD7uB7SUzojLMP24N5IatXf7ylGXiGG9A==", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/i18next": { + "version": "20.6.1", + "resolved": "https://registry.npmmirror.com/i18next/-/i18next-20.6.1.tgz", + "integrity": "sha512-yCMYTMEJ9ihCwEQQ3phLo7I/Pwycf8uAx+sRHwwk5U9Aui/IZYgQRyMqXafQOw5QQ7DM1Z+WyEXWIqSuJHhG2A==", + "dependencies": { + "@babel/runtime": "^7.12.0" + } + }, + "node_modules/immer": { + "version": "9.0.21", + "resolved": "https://registry.npmmirror.com/immer/-/immer-9.0.21.tgz", + "integrity": "sha512-bc4NBHqOqSfRW7POMkHd51LvClaeMXpm8dx0e8oE2GORbq5aRK7Bxl4FyzVLdGtLmvLKL7BTDBG5ACQm4HWjTA==", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/immer" + } + }, + "node_modules/immutable": { + "version": "5.1.5", + "resolved": "https://registry.npmmirror.com/immutable/-/immutable-5.1.5.tgz", + "integrity": "sha512-t7xcm2siw+hlUM68I+UEOK+z84RzmN59as9DZ7P1l0994DKUWV7UXBMQZVxaoMSRQ+PBZbHCOoBt7a2wxOMt+A==", + "dev": true + }, + "node_modules/is-binary-path": { + "version": "2.1.0", + "resolved": "https://registry.npmmirror.com/is-binary-path/-/is-binary-path-2.1.0.tgz", + "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", + "dev": true, + "dependencies": { + "binary-extensions": "^2.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/is-core-module": { + "version": "2.16.1", + "resolved": "https://registry.npmmirror.com/is-core-module/-/is-core-module-2.16.1.tgz", + "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==", + "dev": true, + "dependencies": { + "hasown": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmmirror.com/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmmirror.com/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "dev": true, + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-hotkey": { + "version": "0.2.0", + "resolved": "https://registry.npmmirror.com/is-hotkey/-/is-hotkey-0.2.0.tgz", + "integrity": "sha512-UknnZK4RakDmTgz4PI1wIph5yxSs/mvChWs9ifnlXsKuXgWmOkY/hAE0H/k2MIqH0RlRye0i1oC07MCRSD28Mw==" + }, + "node_modules/is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmmirror.com/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "dev": true, + "engines": { + "node": ">=0.12.0" + } + }, + "node_modules/is-plain-object": { + "version": "5.0.0", + "resolved": "https://registry.npmmirror.com/is-plain-object/-/is-plain-object-5.0.0.tgz", + "integrity": "sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-url": { + "version": "1.2.4", + "resolved": "https://registry.npmmirror.com/is-url/-/is-url-1.2.4.tgz", + "integrity": "sha512-ITvGim8FhRiYe4IQ5uHSkj7pVaPDrCTkNd3yq3cV7iZAcJdHTUMPMEHcqSOy9xZ9qFenQCvi+2wjH9a1nXqHww==" + }, + "node_modules/is-what": { + "version": "5.5.0", + "resolved": "https://registry.npmmirror.com/is-what/-/is-what-5.5.0.tgz", + "integrity": "sha512-oG7cgbmg5kLYae2N5IVd3jm2s+vldjxJzK1pcu9LfpGuQ93MQSzo0okvRna+7y5ifrD+20FE8FvjusyGaz14fw==", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/mesqueeb" + } + }, + "node_modules/js-tokens": { + "version": "9.0.1", + "resolved": "https://registry.npmmirror.com/js-tokens/-/js-tokens-9.0.1.tgz", + "integrity": "sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==", + "dev": true + }, + "node_modules/local-pkg": { + "version": "0.5.1", + "resolved": "https://registry.npmmirror.com/local-pkg/-/local-pkg-0.5.1.tgz", + "integrity": "sha512-9rrA30MRRP3gBD3HTGnC6cDFpaE1kVDWxWgqWJUN0RvDNAo+Nz/9GxB+nHOH0ifbVFy0hSA1V6vFDvnx54lTEQ==", + "dev": true, + "dependencies": { + "mlly": "^1.7.3", + "pkg-types": "^1.2.1" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/lodash": { + "version": "4.18.1", + "resolved": "https://registry.npmmirror.com/lodash/-/lodash-4.18.1.tgz", + "integrity": "sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q==" + }, + "node_modules/lodash-es": { + "version": "4.18.1", + "resolved": "https://registry.npmmirror.com/lodash-es/-/lodash-es-4.18.1.tgz", + "integrity": "sha512-J8xewKD/Gk22OZbhpOVSwcs60zhd95ESDwezOFuA3/099925PdHJ7OFHNTGtajL3AlZkykD32HykiMo+BIBI8A==" + }, + "node_modules/lodash-unified": { + "version": "1.0.3", + "resolved": "https://registry.npmmirror.com/lodash-unified/-/lodash-unified-1.0.3.tgz", + "integrity": "sha512-WK9qSozxXOD7ZJQlpSqOT+om2ZfcT4yO+03FuzAHD0wF6S0l0090LRPDx3vhTTLZ8cFKpBn+IOcVXK6qOcIlfQ==", + "peerDependencies": { + "@types/lodash-es": "*", + "lodash": "*", + "lodash-es": "*" + } + }, + "node_modules/lodash.camelcase": { + "version": "4.3.0", + "resolved": "https://registry.npmmirror.com/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz", + "integrity": "sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==" + }, + "node_modules/lodash.clonedeep": { + "version": "4.5.0", + "resolved": "https://registry.npmmirror.com/lodash.clonedeep/-/lodash.clonedeep-4.5.0.tgz", + "integrity": "sha512-H5ZhCF25riFd9uB5UCkVKo61m3S/xZk1x4wA6yp/L3RFP6Z/eHH1ymQcGLo7J3GMPfm0V/7m1tryHuGVxpqEBQ==" + }, + "node_modules/lodash.debounce": { + "version": "4.0.8", + "resolved": "https://registry.npmmirror.com/lodash.debounce/-/lodash.debounce-4.0.8.tgz", + "integrity": "sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==" + }, + "node_modules/lodash.foreach": { + "version": "4.5.0", + "resolved": "https://registry.npmmirror.com/lodash.foreach/-/lodash.foreach-4.5.0.tgz", + "integrity": "sha512-aEXTF4d+m05rVOAUG3z4vZZ4xVexLKZGF0lIxuHZ1Hplpk/3B6Z1+/ICICYRLm7c41Z2xiejbkCkJoTlypoXhQ==" + }, + "node_modules/lodash.isequal": { + "version": "4.5.0", + "resolved": "https://registry.npmmirror.com/lodash.isequal/-/lodash.isequal-4.5.0.tgz", + "integrity": "sha512-pDo3lu8Jhfjqls6GkMgpahsF9kCyayhgykjyLMNFTKWrpVdAQtYyB4muAMWozBB4ig/dtWAmsMxLEI8wuz+DYQ==", + "deprecated": "This package is deprecated. Use require('node:util').isDeepStrictEqual instead." + }, + "node_modules/lodash.throttle": { + "version": "4.1.1", + "resolved": "https://registry.npmmirror.com/lodash.throttle/-/lodash.throttle-4.1.1.tgz", + "integrity": "sha512-wIkUCfVKpVsWo3JSZlc+8MB5it+2AN5W8J7YVMST30UrvcQNZ1Okbj+rbVniijTWE6FGYy4XJq/rHkas8qJMLQ==" + }, + "node_modules/lodash.toarray": { + "version": "4.4.0", + "resolved": "https://registry.npmmirror.com/lodash.toarray/-/lodash.toarray-4.4.0.tgz", + "integrity": "sha512-QyffEA3i5dma5q2490+SgCvDN0pXLmRGSyAANuVi0HQ01Pkfr9fuoKQW8wm1wGBnJITs/mS7wQvS6VshUEBFCw==" + }, + "node_modules/magic-string": { + "version": "0.30.21", + "resolved": "https://registry.npmmirror.com/magic-string/-/magic-string-0.30.21.tgz", + "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.5" + } + }, + "node_modules/math-intrinsics": { + "version": "1.1.0", + "resolved": "https://registry.npmmirror.com/math-intrinsics/-/math-intrinsics-1.1.0.tgz", + "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/memoize-one": { + "version": "6.0.0", + "resolved": "https://registry.npmmirror.com/memoize-one/-/memoize-one-6.0.0.tgz", + "integrity": "sha512-rkpe71W0N0c0Xz6QD0eJETuWAJGnJ9afsl1srmwPrI+yBCkge5EycXXbYRyvL29zZVUWQCY7InPRCv3GDXuZNw==" + }, + "node_modules/merge2": { + "version": "1.4.1", + "resolved": "https://registry.npmmirror.com/merge2/-/merge2-1.4.1.tgz", + "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==", + "dev": true, + "engines": { + "node": ">= 8" + } + }, + "node_modules/micromatch": { + "version": "4.0.8", + "resolved": "https://registry.npmmirror.com/micromatch/-/micromatch-4.0.8.tgz", + "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==", + "dev": true, + "dependencies": { + "braces": "^3.0.3", + "picomatch": "^2.3.1" + }, + "engines": { + "node": ">=8.6" + } + }, + "node_modules/micromatch/node_modules/picomatch": { + "version": "2.3.2", + "resolved": "https://registry.npmmirror.com/picomatch/-/picomatch-2.3.2.tgz", + "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==", + "dev": true, + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/mime-db": { + "version": "1.52.0", + "resolved": "https://registry.npmmirror.com/mime-db/-/mime-db-1.52.0.tgz", + "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime-match": { + "version": "1.0.2", + "resolved": "https://registry.npmmirror.com/mime-match/-/mime-match-1.0.2.tgz", + "integrity": "sha512-VXp/ugGDVh3eCLOBCiHZMYWQaTNUHv2IJrut+yXA6+JbLPXHglHwfS/5A5L0ll+jkCY7fIzRJcH6OIunF+c6Cg==", + "dependencies": { + "wildcard": "^1.1.0" + } + }, + "node_modules/mime-types": { + "version": "2.1.35", + "resolved": "https://registry.npmmirror.com/mime-types/-/mime-types-2.1.35.tgz", + "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/minimatch": { + "version": "9.0.9", + "resolved": "https://registry.npmmirror.com/minimatch/-/minimatch-9.0.9.tgz", + "integrity": "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==", + "dev": true, + "dependencies": { + "brace-expansion": "^2.0.2" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/mitt": { + "version": "3.0.1", + "resolved": "https://registry.npmmirror.com/mitt/-/mitt-3.0.1.tgz", + "integrity": "sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==" + }, + "node_modules/mlly": { + "version": "1.8.2", + "resolved": "https://registry.npmmirror.com/mlly/-/mlly-1.8.2.tgz", + "integrity": "sha512-d+ObxMQFmbt10sretNDytwt85VrbkhhUA/JBGm1MPaWJ65Cl4wOgLaB1NYvJSZ0Ef03MMEU/0xpPMXUIQ29UfA==", + "dev": true, + "dependencies": { + "acorn": "^8.16.0", + "pathe": "^2.0.3", + "pkg-types": "^1.3.1", + "ufo": "^1.6.3" + } + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmmirror.com/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true + }, + "node_modules/namespace-emitter": { + "version": "2.0.1", + "resolved": "https://registry.npmmirror.com/namespace-emitter/-/namespace-emitter-2.0.1.tgz", + "integrity": "sha512-N/sMKHniSDJBjfrkbS/tpkPj4RAbvW3mr8UAzvlMHyun93XEm83IAvhWtJVHo+RHn/oO8Job5YN4b+wRjSVp5g==" + }, + "node_modules/nanoid": { + "version": "3.3.12", + "resolved": "https://registry.npmmirror.com/nanoid/-/nanoid-3.3.12.tgz", + "integrity": "sha512-ZB9RH/39qpq5Vu6Y+NmUaFhQR6pp+M2Xt76XBnEwDaGcVAqhlvxrl3B2bKS5D3NH3QR76v3aSrKaF/Kiy7lEtQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/next-tick": { + "version": "1.1.0", + "resolved": "https://registry.npmmirror.com/next-tick/-/next-tick-1.1.0.tgz", + "integrity": "sha512-CXdUiJembsNjuToQvxayPZF9Vqht7hewsvy2sOWafLvi2awflj9mOC6bHIg50orX8IJvWKY9wYQ/zB2kogPslQ==" + }, + "node_modules/node-addon-api": { + "version": "7.1.1", + "resolved": "https://registry.npmmirror.com/node-addon-api/-/node-addon-api-7.1.1.tgz", + "integrity": "sha512-5m3bsyrjFWE1xf7nz7YXdN4udnVtXK6/Yfgn5qnahL6bCkf2yKt4k3nuTKAtT4r3IG8JNR2ncsIMdZuAzJjHQQ==", + "dev": true, + "optional": true + }, + "node_modules/normalize-path": { + "version": "3.0.0", + "resolved": "https://registry.npmmirror.com/normalize-path/-/normalize-path-3.0.0.tgz", + "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/normalize-wheel-es": { + "version": "1.2.0", + "resolved": "https://registry.npmmirror.com/normalize-wheel-es/-/normalize-wheel-es-1.2.0.tgz", + "integrity": "sha512-Wj7+EJQ8mSuXr2iWfnujrimU35R2W4FAErEyTmJoJ7ucwTn2hOUSsRehMb5RSYkxXGTM7Y9QpvPmp++w5ftoJw==" + }, + "node_modules/path-parse": { + "version": "1.0.7", + "resolved": "https://registry.npmmirror.com/path-parse/-/path-parse-1.0.7.tgz", + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", + "dev": true + }, + "node_modules/pathe": { + "version": "2.0.3", + "resolved": "https://registry.npmmirror.com/pathe/-/pathe-2.0.3.tgz", + "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==", + "dev": true + }, + "node_modules/perfect-debounce": { + "version": "1.0.0", + "resolved": "https://registry.npmmirror.com/perfect-debounce/-/perfect-debounce-1.0.0.tgz", + "integrity": "sha512-xCy9V055GLEqoFaHoC1SoLIaLmWctgCUaBaWxDZ7/Zx4CTyX7cJQLJOok/orfjZAh9kEYpjJa4d0KcJmCbctZA==" + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmmirror.com/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==" + }, + "node_modules/picomatch": { + "version": "4.0.4", + "resolved": "https://registry.npmmirror.com/picomatch/-/picomatch-4.0.4.tgz", + "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==", + "dev": true, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/pinia": { + "version": "3.0.4", + "resolved": "https://registry.npmmirror.com/pinia/-/pinia-3.0.4.tgz", + "integrity": "sha512-l7pqLUFTI/+ESXn6k3nu30ZIzW5E2WZF/LaHJEpoq6ElcLD+wduZoB2kBN19du6K/4FDpPMazY2wJr+IndBtQw==", + "dependencies": { + "@vue/devtools-api": "^7.7.7" + }, + "funding": { + "url": "https://github.com/sponsors/posva" + }, + "peerDependencies": { + "typescript": ">=4.5.0", + "vue": "^3.5.11" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/pkg-types": { + "version": "1.3.1", + "resolved": "https://registry.npmmirror.com/pkg-types/-/pkg-types-1.3.1.tgz", + "integrity": "sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==", + "dev": true, + "dependencies": { + "confbox": "^0.1.8", + "mlly": "^1.7.4", + "pathe": "^2.0.1" + } + }, + "node_modules/postcss": { + "version": "8.5.13", + "resolved": "https://registry.npmmirror.com/postcss/-/postcss-8.5.13.tgz", + "integrity": "sha512-qif0+jGGZoLWdHey3UFHHWP0H7Gbmsk8T5VEqyYFbWqPr1XqvLGBbk/sl8V5exGmcYJklJOhOQq1pV9IcsiFag==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "dependencies": { + "nanoid": "^3.3.11", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/preact": { + "version": "10.29.1", + "resolved": "https://registry.npmmirror.com/preact/-/preact-10.29.1.tgz", + "integrity": "sha512-gQCLc/vWroE8lIpleXtdJhTFDogTdZG9AjMUpVkDf2iTCNwYNWA+u16dL41TqUDJO4gm2IgrcMv3uTpjd4Pwmg==", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/preact" + } + }, + "node_modules/prismjs": { + "version": "1.30.0", + "resolved": "https://registry.npmmirror.com/prismjs/-/prismjs-1.30.0.tgz", + "integrity": "sha512-DEvV2ZF2r2/63V+tK8hQvrR2ZGn10srHbXviTlcv7Kpzw8jWiNTqbVgjO3IY8RxrrOUF8VPMQQFysYYYv0YZxw==", + "engines": { + "node": ">=6" + } + }, + "node_modules/proxy-from-env": { + "version": "2.1.0", + "resolved": "https://registry.npmmirror.com/proxy-from-env/-/proxy-from-env-2.1.0.tgz", + "integrity": "sha512-cJ+oHTW1VAEa8cJslgmUZrc+sjRKgAKl3Zyse6+PV38hZe/V6Z14TbCuXcan9F9ghlz4QrFr2c92TNF82UkYHA==", + "engines": { + "node": ">=10" + } + }, + "node_modules/quansync": { + "version": "0.2.11", + "resolved": "https://registry.npmmirror.com/quansync/-/quansync-0.2.11.tgz", + "integrity": "sha512-AifT7QEbW9Nri4tAwR5M/uzpBuqfZf+zwaEM/QkzEjj7NBuFD2rBuy0K3dE+8wltbezDV7JMA0WfnCPYRSYbXA==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/antfu" + }, + { + "type": "individual", + "url": "https://github.com/sponsors/sxzz" + } + ] + }, + "node_modules/queue-microtask": { + "version": "1.2.3", + "resolved": "https://registry.npmmirror.com/queue-microtask/-/queue-microtask-1.2.3.tgz", + "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ] + }, + "node_modules/readdirp": { + "version": "4.1.2", + "resolved": "https://registry.npmmirror.com/readdirp/-/readdirp-4.1.2.tgz", + "integrity": "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==", + "dev": true, + "engines": { + "node": ">= 14.18.0" + }, + "funding": { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/resolve": { + "version": "1.22.12", + "resolved": "https://registry.npmmirror.com/resolve/-/resolve-1.22.12.tgz", + "integrity": "sha512-TyeJ1zif53BPfHootBGwPRYT1RUt6oGWsaQr8UyZW/eAm9bKoijtvruSDEmZHm92CwS9nj7/fWttqPCgzep8CA==", + "dev": true, + "dependencies": { + "es-errors": "^1.3.0", + "is-core-module": "^2.16.1", + "path-parse": "^1.0.7", + "supports-preserve-symlinks-flag": "^1.0.0" + }, + "bin": { + "resolve": "bin/resolve" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/reusify": { + "version": "1.1.0", + "resolved": "https://registry.npmmirror.com/reusify/-/reusify-1.1.0.tgz", + "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==", + "dev": true, + "engines": { + "iojs": ">=1.0.0", + "node": ">=0.10.0" + } + }, + "node_modules/rfdc": { + "version": "1.4.1", + "resolved": "https://registry.npmmirror.com/rfdc/-/rfdc-1.4.1.tgz", + "integrity": "sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==" + }, + "node_modules/rollup": { + "version": "4.60.2", + "resolved": "https://registry.npmmirror.com/rollup/-/rollup-4.60.2.tgz", + "integrity": "sha512-J9qZyW++QK/09NyN/zeO0dG/1GdGfyp9lV8ajHnRVLfo/uFsbji5mHnDgn/qYdUHyCkM2N+8VyspgZclfAh0eQ==", + "dev": true, + "dependencies": { + "@types/estree": "1.0.8" + }, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@rollup/rollup-android-arm-eabi": "4.60.2", + "@rollup/rollup-android-arm64": "4.60.2", + "@rollup/rollup-darwin-arm64": "4.60.2", + "@rollup/rollup-darwin-x64": "4.60.2", + "@rollup/rollup-freebsd-arm64": "4.60.2", + "@rollup/rollup-freebsd-x64": "4.60.2", + "@rollup/rollup-linux-arm-gnueabihf": "4.60.2", + "@rollup/rollup-linux-arm-musleabihf": "4.60.2", + "@rollup/rollup-linux-arm64-gnu": "4.60.2", + "@rollup/rollup-linux-arm64-musl": "4.60.2", + "@rollup/rollup-linux-loong64-gnu": "4.60.2", + "@rollup/rollup-linux-loong64-musl": "4.60.2", + "@rollup/rollup-linux-ppc64-gnu": "4.60.2", + "@rollup/rollup-linux-ppc64-musl": "4.60.2", + "@rollup/rollup-linux-riscv64-gnu": "4.60.2", + "@rollup/rollup-linux-riscv64-musl": "4.60.2", + "@rollup/rollup-linux-s390x-gnu": "4.60.2", + "@rollup/rollup-linux-x64-gnu": "4.60.2", + "@rollup/rollup-linux-x64-musl": "4.60.2", + "@rollup/rollup-openbsd-x64": "4.60.2", + "@rollup/rollup-openharmony-arm64": "4.60.2", + "@rollup/rollup-win32-arm64-msvc": "4.60.2", + "@rollup/rollup-win32-ia32-msvc": "4.60.2", + "@rollup/rollup-win32-x64-gnu": "4.60.2", + "@rollup/rollup-win32-x64-msvc": "4.60.2", + "fsevents": "~2.3.2" + } + }, + "node_modules/run-parallel": { + "version": "1.2.0", + "resolved": "https://registry.npmmirror.com/run-parallel/-/run-parallel-1.2.0.tgz", + "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "dependencies": { + "queue-microtask": "^1.2.2" + } + }, + "node_modules/sass": { + "version": "1.99.0", + "resolved": "https://registry.npmmirror.com/sass/-/sass-1.99.0.tgz", + "integrity": "sha512-kgW13M54DUB7IsIRM5LvJkNlpH+WhMpooUcaWGFARkF1Tc82v9mIWkCbCYf+MBvpIUBSeSOTilpZjEPr2VYE6Q==", + "dev": true, + "dependencies": { + "chokidar": "^4.0.0", + "immutable": "^5.1.5", + "source-map-js": ">=0.6.2 <2.0.0" + }, + "bin": { + "sass": "sass.js" + }, + "engines": { + "node": ">=14.0.0" + }, + "optionalDependencies": { + "@parcel/watcher": "^2.4.1" + } + }, + "node_modules/scroll-into-view-if-needed": { + "version": "2.2.31", + "resolved": "https://registry.npmmirror.com/scroll-into-view-if-needed/-/scroll-into-view-if-needed-2.2.31.tgz", + "integrity": "sha512-dGCXy99wZQivjmjIqihaBQNjryrz5rueJY7eHfTdyWEiR4ttYpsajb14rn9s5d4DY4EcY6+4+U/maARBXJedkA==", + "dependencies": { + "compute-scroll-into-view": "^1.0.20" + } + }, + "node_modules/scule": { + "version": "1.3.0", + "resolved": "https://registry.npmmirror.com/scule/-/scule-1.3.0.tgz", + "integrity": "sha512-6FtHJEvt+pVMIB9IBY+IcCJ6Z5f1iQnytgyfKMhDKgmzYG+TeH/wx1y3l27rshSbLiSanrR9ffZDrEsmjlQF2g==", + "dev": true + }, + "node_modules/slate": { + "version": "0.72.8", + "resolved": "https://registry.npmmirror.com/slate/-/slate-0.72.8.tgz", + "integrity": "sha512-/nJwTswQgnRurpK+bGJFH1oM7naD5qDmHd89JyiKNT2oOKD8marW0QSBtuFnwEbL5aGCS8AmrhXQgNOsn4osAw==", + "dependencies": { + "immer": "^9.0.6", + "is-plain-object": "^5.0.0", + "tiny-warning": "^1.0.3" + } + }, + "node_modules/slate-history": { + "version": "0.66.0", + "resolved": "https://registry.npmmirror.com/slate-history/-/slate-history-0.66.0.tgz", + "integrity": "sha512-6MWpxGQZiMvSINlCbMW43E2YBSVMCMCIwQfBzGssjWw4kb0qfvj0pIdblWNRQZD0hR6WHP+dHHgGSeVdMWzfng==", + "dependencies": { + "is-plain-object": "^5.0.0" + }, + "peerDependencies": { + "slate": ">=0.65.3" + } + }, + "node_modules/snabbdom": { + "version": "3.6.3", + "resolved": "https://registry.npmmirror.com/snabbdom/-/snabbdom-3.6.3.tgz", + "integrity": "sha512-W2lHLLw2qR2Vv0DcMmcxXqcfdBaIcoN+y/86SmHv8fn4DazEQSH6KN3TjZcWvwujW56OHiiirsbHWZb4vx/0fg==", + "engines": { + "node": ">=12.17.0" + } + }, + "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://registry.npmmirror.com/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/speakingurl": { + "version": "14.0.1", + "resolved": "https://registry.npmmirror.com/speakingurl/-/speakingurl-14.0.1.tgz", + "integrity": "sha512-1POYv7uv2gXoyGFpBCmpDVSNV74IfsWlDW216UPjbWufNf+bSU6GdbDsxdcxtfwb4xlI3yxzOTKClUosxARYrQ==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/ssr-window": { + "version": "3.0.0", + "resolved": "https://registry.npmmirror.com/ssr-window/-/ssr-window-3.0.0.tgz", + "integrity": "sha512-q+8UfWDg9Itrg0yWK7oe5p/XRCJpJF9OBtXfOPgSJl+u3Xd5KI328RUEvUqSMVM9CiQUEf1QdBzJMkYGErj9QA==" + }, + "node_modules/strip-literal": { + "version": "2.1.1", + "resolved": "https://registry.npmmirror.com/strip-literal/-/strip-literal-2.1.1.tgz", + "integrity": "sha512-631UJ6O00eNGfMiWG78ck80dfBab8X6IVFB51jZK5Icd7XAs60Z5y7QdSd/wGIklnWvRbUNloVzhOKKmutxQ6Q==", + "dev": true, + "dependencies": { + "js-tokens": "^9.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/superjson": { + "version": "2.2.6", + "resolved": "https://registry.npmmirror.com/superjson/-/superjson-2.2.6.tgz", + "integrity": "sha512-H+ue8Zo4vJmV2nRjpx86P35lzwDT3nItnIsocgumgr0hHMQ+ZGq5vrERg9kJBo5AWGmxZDhzDo+WVIJqkB0cGA==", + "dependencies": { + "copy-anything": "^4" + }, + "engines": { + "node": ">=16" + } + }, + "node_modules/supports-preserve-symlinks-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmmirror.com/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", + "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", + "dev": true, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/tiny-warning": { + "version": "1.0.3", + "resolved": "https://registry.npmmirror.com/tiny-warning/-/tiny-warning-1.0.3.tgz", + "integrity": "sha512-lBN9zLN/oAf68o3zNXYrdCt1kP8WsiGW8Oo2ka41b2IM5JL/S1CTyX1rW0mb/zSuJun0ZUrDxx4sqvYS2FWzPA==" + }, + "node_modules/to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmmirror.com/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "dev": true, + "dependencies": { + "is-number": "^7.0.0" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/tslib": { + "version": "2.3.0", + "resolved": "https://registry.npmmirror.com/tslib/-/tslib-2.3.0.tgz", + "integrity": "sha512-N82ooyxVNm6h1riLCoyS9e3fuJ3AMG2zIZs2Gd1ATcSFjSA23Q0fzjjZeh0jbJvWVDZ0cJT8yaNNaaXHzueNjg==" + }, + "node_modules/type": { + "version": "2.7.3", + "resolved": "https://registry.npmmirror.com/type/-/type-2.7.3.tgz", + "integrity": "sha512-8j+1QmAbPvLZow5Qpi6NCaN8FB60p/6x8/vfNqOk/hC+HuvFZhL4+WfekuhQLiqFZXOgQdrs3B+XxEmCc6b3FQ==" + }, + "node_modules/ufo": { + "version": "1.6.4", + "resolved": "https://registry.npmmirror.com/ufo/-/ufo-1.6.4.tgz", + "integrity": "sha512-JFNbkD1Svwe0KvGi8GOeLcP4kAWQ609twvCdcHxq1oSL8svv39ZuSvajcD8B+5D0eL4+s1Is2D/O6KN3qcTeRA==", + "dev": true + }, + "node_modules/unimport": { + "version": "3.14.6", + "resolved": "https://registry.npmmirror.com/unimport/-/unimport-3.14.6.tgz", + "integrity": "sha512-CYvbDaTT04Rh8bmD8jz3WPmHYZRG/NnvYVzwD6V1YAlvvKROlAeNDUBhkBGzNav2RKaeuXvlWYaa1V4Lfi/O0g==", + "dev": true, + "dependencies": { + "@rollup/pluginutils": "^5.1.4", + "acorn": "^8.14.0", + "escape-string-regexp": "^5.0.0", + "estree-walker": "^3.0.3", + "fast-glob": "^3.3.3", + "local-pkg": "^1.0.0", + "magic-string": "^0.30.17", + "mlly": "^1.7.4", + "pathe": "^2.0.1", + "picomatch": "^4.0.2", + "pkg-types": "^1.3.0", + "scule": "^1.3.0", + "strip-literal": "^2.1.1", + "unplugin": "^1.16.1" + } + }, + "node_modules/unimport/node_modules/confbox": { + "version": "0.2.4", + "resolved": "https://registry.npmmirror.com/confbox/-/confbox-0.2.4.tgz", + "integrity": "sha512-ysOGlgTFbN2/Y6Cg3Iye8YKulHw+R2fNXHrgSmXISQdMnomY6eNDprVdW9R5xBguEqI954+S6709UyiO7B+6OQ==", + "dev": true + }, + "node_modules/unimport/node_modules/estree-walker": { + "version": "3.0.3", + "resolved": "https://registry.npmmirror.com/estree-walker/-/estree-walker-3.0.3.tgz", + "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==", + "dev": true, + "dependencies": { + "@types/estree": "^1.0.0" + } + }, + "node_modules/unimport/node_modules/local-pkg": { + "version": "1.1.2", + "resolved": "https://registry.npmmirror.com/local-pkg/-/local-pkg-1.1.2.tgz", + "integrity": "sha512-arhlxbFRmoQHl33a0Zkle/YWlmNwoyt6QNZEIJcqNbdrsix5Lvc4HyyI3EnwxTYlZYc32EbYrQ8SzEZ7dqgg9A==", + "dev": true, + "dependencies": { + "mlly": "^1.7.4", + "pkg-types": "^2.3.0", + "quansync": "^0.2.11" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/unimport/node_modules/local-pkg/node_modules/pkg-types": { + "version": "2.3.1", + "resolved": "https://registry.npmmirror.com/pkg-types/-/pkg-types-2.3.1.tgz", + "integrity": "sha512-y+ichcgc2LrADuhLNAx8DFjVfgz91pRxfZdI3UDhxHvcVEZsenLO+7XaU5vOp0u/7V/wZ+plyuQxtrDlZJ+yeg==", + "dev": true, + "dependencies": { + "confbox": "^0.2.4", + "exsolve": "^1.0.8", + "pathe": "^2.0.3" + } + }, + "node_modules/unplugin": { + "version": "1.16.1", + "resolved": "https://registry.npmmirror.com/unplugin/-/unplugin-1.16.1.tgz", + "integrity": "sha512-4/u/j4FrCKdi17jaxuJA0jClGxB1AvU2hw/IuayPc4ay1XGaJs/rbb4v5WKwAjNifjmXK9PIFyuPiaK8azyR9w==", + "dev": true, + "dependencies": { + "acorn": "^8.14.0", + "webpack-virtual-modules": "^0.6.2" + }, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/unplugin-auto-import": { + "version": "0.17.8", + "resolved": "https://registry.npmmirror.com/unplugin-auto-import/-/unplugin-auto-import-0.17.8.tgz", + "integrity": "sha512-CHryj6HzJ+n4ASjzwHruD8arhbdl+UXvhuAIlHDs15Y/IMecG3wrf7FVg4pVH/DIysbq/n0phIjNHAjl7TG7Iw==", + "dev": true, + "dependencies": { + "@antfu/utils": "^0.7.10", + "@rollup/pluginutils": "^5.1.0", + "fast-glob": "^3.3.2", + "local-pkg": "^0.5.0", + "magic-string": "^0.30.10", + "minimatch": "^9.0.4", + "unimport": "^3.7.2", + "unplugin": "^1.11.0" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + }, + "peerDependencies": { + "@nuxt/kit": "^3.2.2", + "@vueuse/core": "*" + }, + "peerDependenciesMeta": { + "@nuxt/kit": { + "optional": true + }, + "@vueuse/core": { + "optional": true + } + } + }, + "node_modules/unplugin-element-plus": { + "version": "0.8.0", + "resolved": "https://registry.npmmirror.com/unplugin-element-plus/-/unplugin-element-plus-0.8.0.tgz", + "integrity": "sha512-jByUGY3FG2B8RJKFryqxx4eNtSTj+Hjlo8edcOdJymewndDQjThZ1pRUQHRjQsbKhTV2jEctJV7t7RJ405UL4g==", + "dev": true, + "dependencies": { + "@rollup/pluginutils": "^5.0.2", + "es-module-lexer": "^1.3.0", + "magic-string": "^0.30.1", + "unplugin": "^1.3.2" + }, + "engines": { + "node": ">=14.19.0" + } + }, + "node_modules/unplugin-vue-components": { + "version": "0.26.0", + "resolved": "https://registry.npmmirror.com/unplugin-vue-components/-/unplugin-vue-components-0.26.0.tgz", + "integrity": "sha512-s7IdPDlnOvPamjunVxw8kNgKNK8A5KM1YpK5j/p97jEKTjlPNrA0nZBiSfAKKlK1gWZuyWXlKL5dk3EDw874LQ==", + "dev": true, + "dependencies": { + "@antfu/utils": "^0.7.6", + "@rollup/pluginutils": "^5.0.4", + "chokidar": "^3.5.3", + "debug": "^4.3.4", + "fast-glob": "^3.3.1", + "local-pkg": "^0.4.3", + "magic-string": "^0.30.3", + "minimatch": "^9.0.3", + "resolve": "^1.22.4", + "unplugin": "^1.4.0" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + }, + "peerDependencies": { + "@babel/parser": "^7.15.8", + "@nuxt/kit": "^3.2.2", + "vue": "2 || 3" + }, + "peerDependenciesMeta": { + "@babel/parser": { + "optional": true + }, + "@nuxt/kit": { + "optional": true + } + } + }, + "node_modules/unplugin-vue-components/node_modules/chokidar": { + "version": "3.6.0", + "resolved": "https://registry.npmmirror.com/chokidar/-/chokidar-3.6.0.tgz", + "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==", + "dev": true, + "dependencies": { + "anymatch": "~3.1.2", + "braces": "~3.0.2", + "glob-parent": "~5.1.2", + "is-binary-path": "~2.1.0", + "is-glob": "~4.0.1", + "normalize-path": "~3.0.0", + "readdirp": "~3.6.0" + }, + "engines": { + "node": ">= 8.10.0" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + }, + "optionalDependencies": { + "fsevents": "~2.3.2" + } + }, + "node_modules/unplugin-vue-components/node_modules/local-pkg": { + "version": "0.4.3", + "resolved": "https://registry.npmmirror.com/local-pkg/-/local-pkg-0.4.3.tgz", + "integrity": "sha512-SFppqq5p42fe2qcZQqqEOiVRXl+WCP1MdT6k7BDEW1j++sp5fIY+/fdRQitvKgB5BrBcmrs5m/L0v2FrU5MY1g==", + "dev": true, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/unplugin-vue-components/node_modules/picomatch": { + "version": "2.3.2", + "resolved": "https://registry.npmmirror.com/picomatch/-/picomatch-2.3.2.tgz", + "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==", + "dev": true, + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/unplugin-vue-components/node_modules/readdirp": { + "version": "3.6.0", + "resolved": "https://registry.npmmirror.com/readdirp/-/readdirp-3.6.0.tgz", + "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==", + "dev": true, + "dependencies": { + "picomatch": "^2.2.1" + }, + "engines": { + "node": ">=8.10.0" + } + }, + "node_modules/vite": { + "version": "5.4.21", + "resolved": "https://registry.npmmirror.com/vite/-/vite-5.4.21.tgz", + "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==", + "dev": true, + "dependencies": { + "esbuild": "^0.21.3", + "postcss": "^8.4.43", + "rollup": "^4.20.0" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^18.0.0 || >=20.0.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^18.0.0 || >=20.0.0", + "less": "*", + "lightningcss": "^1.21.0", + "sass": "*", + "sass-embedded": "*", + "stylus": "*", + "sugarss": "*", + "terser": "^5.4.0" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + } + } + }, + "node_modules/vue": { + "version": "3.5.33", + "resolved": "https://registry.npmmirror.com/vue/-/vue-3.5.33.tgz", + "integrity": "sha512-1AgChhx5w3ALgT4oK3acm2Es/7jyZhWSVUfs3rOBlGQC0rjEDkS7G4lWlJJGGNQD+BV3reCwbQrOe1mPNwKHBQ==", + "dependencies": { + "@vue/compiler-dom": "3.5.33", + "@vue/compiler-sfc": "3.5.33", + "@vue/runtime-dom": "3.5.33", + "@vue/server-renderer": "3.5.33", + "@vue/shared": "3.5.33" + }, + "peerDependencies": { + "typescript": "*" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/vue-component-type-helpers": { + "version": "3.2.8", + "resolved": "https://registry.npmmirror.com/vue-component-type-helpers/-/vue-component-type-helpers-3.2.8.tgz", + "integrity": "sha512-9689efAXhN/EV86plgkL/XFiJSXhGtWPG6JDboZ+QnjlUWUUQrQ0ILKQtw4iQsuwIwu5k6Aw+JnehDe7161e7A==" + }, + "node_modules/vue-router": { + "version": "4.6.4", + "resolved": "https://registry.npmmirror.com/vue-router/-/vue-router-4.6.4.tgz", + "integrity": "sha512-Hz9q5sa33Yhduglwz6g9skT8OBPii+4bFn88w6J+J4MfEo4KRRpmiNG/hHHkdbRFlLBOqxN8y8gf2Fb0MTUgVg==", + "dependencies": { + "@vue/devtools-api": "^6.6.4" + }, + "funding": { + "url": "https://github.com/sponsors/posva" + }, + "peerDependencies": { + "vue": "^3.5.0" + } + }, + "node_modules/vue-router/node_modules/@vue/devtools-api": { + "version": "6.6.4", + "resolved": "https://registry.npmmirror.com/@vue/devtools-api/-/devtools-api-6.6.4.tgz", + "integrity": "sha512-sGhTPMuXqZ1rVOk32RylztWkfXTRhuS7vgAKv0zjqk8gbsHkJ7xfFf+jbySxt7tWObEJwyKaHMikV/WGDiQm8g==" + }, + "node_modules/webpack-virtual-modules": { + "version": "0.6.2", + "resolved": "https://registry.npmmirror.com/webpack-virtual-modules/-/webpack-virtual-modules-0.6.2.tgz", + "integrity": "sha512-66/V2i5hQanC51vBQKPH4aI8NMAcBW59FVBs+rC7eGHupMyfn34q7rZIE+ETlJ+XTevqfUhVVBgSUNSW2flEUQ==", + "dev": true + }, + "node_modules/wildcard": { + "version": "1.1.2", + "resolved": "https://registry.npmmirror.com/wildcard/-/wildcard-1.1.2.tgz", + "integrity": "sha512-DXukZJxpHA8LuotRwL0pP1+rS6CS7FF2qStDDE1C7DDg2rLud2PXRMuEDYIPhgEezwnlHNL4c+N6MfMTjCGTng==" + }, + "node_modules/zrender": { + "version": "5.6.1", + "resolved": "https://registry.npmmirror.com/zrender/-/zrender-5.6.1.tgz", + "integrity": "sha512-OFXkDJKcrlx5su2XbzJvj/34Q3m6PvyCZkVPHGYpcCJ52ek4U/ymZyfuV1nKE23AyBJ51E/6Yr0mhZ7xGTO4ag==", + "dependencies": { + "tslib": "2.3.0" + } + } + } +} diff --git a/vue/package.json b/vue/package.json new file mode 100644 index 0000000..da667a3 --- /dev/null +++ b/vue/package.json @@ -0,0 +1,32 @@ +{ + "name": "vue", + "version": "0.0.0", + "private": true, + "type": "module", + "scripts": { + "dev": "vite", + "build": "vite build", + "preview": "vite preview" + }, + "dependencies": { + "@element-plus/icons-vue": "^2.3.1", + "@wangeditor/editor": "^5.1.23", + "@wangeditor/editor-for-vue": "^5.1.12", + "axios": "^1.6.8", + "china-area-data": "^5.0.1", + "echarts": "^5.5.0", + "element-china-area-data": "^6.1.0", + "element-plus": "^2.7.2", + "pinia": "^3.0.1", + "vue": "^3.4.21", + "vue-router": "^4.3.0" + }, + "devDependencies": { + "@vitejs/plugin-vue": "^5.0.4", + "sass": "^1.71.1", + "unplugin-auto-import": "^0.17.5", + "unplugin-element-plus": "^0.8.0", + "unplugin-vue-components": "^0.26.0", + "vite": "^5.2.8" + } +} diff --git a/vue/src/App.vue b/vue/src/App.vue new file mode 100644 index 0000000..7c2aa3f --- /dev/null +++ b/vue/src/App.vue @@ -0,0 +1,3 @@ + diff --git a/vue/src/assets/css/global.css b/vue/src/assets/css/global.css new file mode 100644 index 0000000..ee8e02b --- /dev/null +++ b/vue/src/assets/css/global.css @@ -0,0 +1,21 @@ +* { + box-sizing: border-box; +} + +body { + margin: 0; + padding: 0; + color: #333; + font-size: 14px; +} + +a { + text-decoration: none; +} + +.card { + background-color: #fff; + border-radius: 5px; + padding: 10px; + box-shadow: 0 0 10px rgba(0,0,0,.1); +} \ No newline at end of file diff --git a/vue/src/assets/css/index.scss b/vue/src/assets/css/index.scss new file mode 100644 index 0000000..2c76031 --- /dev/null +++ b/vue/src/assets/css/index.scss @@ -0,0 +1,7 @@ +@forward "element-plus/theme-chalk/src/common/var.scss" with ($colors: ( + "primary": ("base": #009788), + "success": ("base": #3880ee), + "warning": ("base": #7d83d5), + "danger": ("base": #e35e5e), + "info": ("base": #F9B44C), +)); \ No newline at end of file diff --git a/vue/src/assets/css/manager.css b/vue/src/assets/css/manager.css new file mode 100644 index 0000000..c71e307 --- /dev/null +++ b/vue/src/assets/css/manager.css @@ -0,0 +1,108 @@ +.manager-container { + background-color: #f8f8ff; + min-height: 100vh; +} + +.manager-header { + height: 60px; + background-color: #2E8B57; /* 海洋绿 */ + display: flex; + align-items: center; + box-shadow: 0 1px 4px rgba(46, 139, 87, 0.3); +} + +.manager-header-left { + background-color: #2E8B57; /* 海洋绿 */ + width: 230px; + height: 100%; + padding-left: 10px; + display: flex; + align-items: center +} + +.manager-header-left img { + width: 30px; + height: 30px; +} + +.manager-header-left .title { + font-weight: bold; + font-size: 20px; + margin-left: 10px; + color: #fff; +} + +.manager-header-center { + flex: 1; + padding-left: 20px; +} + +.manager-main-left { + width: 200px; + background-color: #ffffff; /* 白色 */ + min-height: calc(100vh - 60px); + box-shadow: 0 0 6px rgba(0, 0, 0, 0.1); +} + +.manager-main-right { + flex: 1; + width: 0; + background-color: #f8f8ff; + padding: 10px; +} + + +/* ElementUI */ +.el-menu { + border: none; + background-color: #ffffff; /* 白色 */ +} + +.el-tooltip__trigger { + outline: none; +} + +:deep(.el-sub-menu__title) { + color: #333 !important; + height: 50px; + line-height: 50px; + background-color: #ffffff !important; /* 白色 */ +} + +.el-sub-menu__title:hover { + background-color: #2E8B57 !important; /* 海洋绿，悬停效果 */ + color: #fff !important; +} + +.el-menu-item { + color: #333; + height: 50px; + line-height: 50px; + background-color: #ffffff !important; /* 白色 */ +} + +.el-menu--inline .el-menu-item { + background-color: #f5f5f5 !important; /* 浅灰色，区分子菜单 */ +} + +.el-menu-item.is-active { + background-color: #2E8B57 !important; /* 海洋绿，活动状态 */ + color: #fff; +} + +.el-menu-item:not(.is-active):hover { + color: #fff; + background-color: #2E8B57 !important; /* 海洋绿，悬停效果 */ +} + +:deep(.el-breadcrumb__inner) { + color: #fff !important; +} + +:deep(.manager-header-right span) { + color: #ffffff; +} + +.notification-icon { + color: #ffffff !important; +} diff --git a/vue/src/assets/fonts/FontAwesome.otf b/vue/src/assets/fonts/FontAwesome.otf new file mode 100644 index 0000000000000000000000000000000000000000..401ec0f36e4f73b8efa40bd6f604fe80d286db70 GIT binary patch literal 134808 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 literal 0 HcmV?d00001 diff --git a/vue/src/assets/fonts/font-awesome.css b/vue/src/assets/fonts/font-awesome.css new file mode 100644 index 0000000..eab1cbb --- /dev/null +++ b/vue/src/assets/fonts/font-awesome.css @@ -0,0 +1,2337 @@ +/*! + * Font Awesome 4.7.0 by @davegandy - http://fontawesome.io - @fontawesome + * License - http://fontawesome.io/license (Font: SIL OFL 1.1, CSS: MIT License) + */ +/* FONT PATH + * -------------------------- */ +@font-face { + font-family: 'FontAwesome'; + src: url('fontawesome-webfont.eot?v=4.7.0'); + src: url('fontawesome-webfont.eot?#iefix&v=4.7.0') format('embedded-opentype'), url('fontawesome-webfont.woff2?v=4.7.0') format('woff2'), url('fontawesome-webfont.woff?v=4.7.0') format('woff'), url('fontawesome-webfont.ttf?v=4.7.0') format('truetype'), url('fontawesome-webfont.svg?v=4.7.0#fontawesomeregular') format('svg'); + font-weight: normal; + font-style: normal; +} +.fa { + display: inline-block; + font: normal normal normal 14px/1 FontAwesome; + font-size: inherit; + text-rendering: auto; + -webkit-font-smoothing: antialiased; + -moz-osx-font-smoothing: grayscale; +} +/* makes the font 33% larger relative to the icon container */ +.fa-lg { + font-size: 1.33333333em; + line-height: 0.75em; + vertical-align: -15%; +} +.fa-2x { + font-size: 2em; +} +.fa-3x { + font-size: 3em; +} +.fa-4x { + font-size: 4em; +} +.fa-5x { + font-size: 5em; +} +.fa-fw { + width: 1.28571429em; + text-align: center; +} +.fa-ul { + padding-left: 0; + margin-left: 2.14285714em; + list-style-type: none; +} +.fa-ul > li { + position: relative; +} +.fa-li { + position: absolute; + left: -2.14285714em; + width: 2.14285714em; + top: 0.14285714em; + text-align: center; +} +.fa-li.fa-lg { + left: -1.85714286em; +} +.fa-border { + padding: .2em .25em .15em; + border: solid 0.08em #eeeeee; + border-radius: .1em; +} +.fa-pull-left { + float: left; +} +.fa-pull-right { + float: right; +} +.fa.fa-pull-left { + margin-right: .3em; +} +.fa.fa-pull-right { + margin-left: .3em; +} +/* Deprecated as of 4.4.0 */ +.pull-right { + float: right; +} +.pull-left { + float: left; +} +.fa.pull-left { + margin-right: .3em; +} +.fa.pull-right { + margin-left: .3em; +} +.fa-spin { + -webkit-animation: fa-spin 2s infinite linear; + animation: fa-spin 2s infinite linear; +} +.fa-pulse { + -webkit-animation: fa-spin 1s infinite steps(8); + animation: fa-spin 1s infinite steps(8); +} +@-webkit-keyframes fa-spin { + 0% { + -webkit-transform: rotate(0deg); + transform: rotate(0deg); + } + 100% { + -webkit-transform: rotate(359deg); + transform: rotate(359deg); + } +} +@keyframes fa-spin { + 0% { + -webkit-transform: rotate(0deg); + transform: rotate(0deg); + } + 100% { + -webkit-transform: rotate(359deg); + transform: rotate(359deg); + } +} +.fa-rotate-90 { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=1)"; + -webkit-transform: rotate(90deg); + -ms-transform: rotate(90deg); + transform: rotate(90deg); +} +.fa-rotate-180 { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=2)"; + -webkit-transform: rotate(180deg); + -ms-transform: rotate(180deg); + transform: rotate(180deg); +} +.fa-rotate-270 { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=3)"; + -webkit-transform: rotate(270deg); + -ms-transform: rotate(270deg); + transform: rotate(270deg); +} +.fa-flip-horizontal { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1)"; + -webkit-transform: scale(-1, 1); + -ms-transform: scale(-1, 1); + transform: scale(-1, 1); +} +.fa-flip-vertical { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)"; + -webkit-transform: scale(1, -1); + -ms-transform: scale(1, -1); + transform: scale(1, -1); +} +:root .fa-rotate-90, +:root .fa-rotate-180, +:root .fa-rotate-270, +:root .fa-flip-horizontal, +:root .fa-flip-vertical { + filter: none; +} +.fa-stack { + position: relative; + display: inline-block; + width: 2em; + height: 2em; + line-height: 2em; + vertical-align: middle; +} +.fa-stack-1x, +.fa-stack-2x { + position: absolute; + left: 0; + width: 100%; + text-align: center; +} +.fa-stack-1x { + line-height: inherit; +} +.fa-stack-2x { + font-size: 2em; +} +.fa-inverse { + color: #ffffff; +} +/* Font Awesome uses the Unicode Private Use Area (PUA) to ensure screen + readers do not read off random characters that represent icons */ +.fa-glass:before { + content: "\f000"; +} +.fa-music:before { + content: "\f001"; +} +.fa-search:before { + content: "\f002"; +} +.fa-envelope-o:before { + content: "\f003"; +} +.fa-heart:before { + content: "\f004"; +} +.fa-star:before { + content: "\f005"; +} +.fa-star-o:before { + content: "\f006"; +} +.fa-user:before { + content: "\f007"; +} +.fa-film:before { + content: "\f008"; +} +.fa-th-large:before { + content: "\f009"; +} +.fa-th:before { + content: "\f00a"; +} +.fa-th-list:before { + content: "\f00b"; +} +.fa-check:before { + content: "\f00c"; +} +.fa-remove:before, +.fa-close:before, +.fa-times:before { + content: "\f00d"; +} +.fa-search-plus:before { + content: "\f00e"; +} +.fa-search-minus:before { + content: "\f010"; +} +.fa-power-off:before { + content: "\f011"; +} +.fa-signal:before { + content: "\f012"; +} +.fa-gear:before, +.fa-cog:before { + content: "\f013"; +} +.fa-trash-o:before { + content: "\f014"; +} +.fa-home:before { + content: "\f015"; +} +.fa-file-o:before { + content: "\f016"; +} +.fa-clock-o:before { + content: "\f017"; +} +.fa-road:before { + content: "\f018"; +} +.fa-download:before { + content: "\f019"; +} +.fa-arrow-circle-o-down:before { + content: "\f01a"; +} +.fa-arrow-circle-o-up:before { + content: "\f01b"; +} +.fa-inbox:before { + content: "\f01c"; +} +.fa-play-circle-o:before { + content: "\f01d"; +} +.fa-rotate-right:before, +.fa-repeat:before { + content: "\f01e"; +} +.fa-refresh:before { + content: "\f021"; +} +.fa-list-alt:before { + content: "\f022"; +} +.fa-lock:before { + content: "\f023"; +} +.fa-flag:before { + content: "\f024"; +} +.fa-headphones:before { + content: "\f025"; +} +.fa-volume-off:before { + content: "\f026"; +} +.fa-volume-down:before { + content: "\f027"; +} +.fa-volume-up:before { + content: "\f028"; +} +.fa-qrcode:before { + content: "\f029"; +} +.fa-barcode:before { + content: "\f02a"; +} +.fa-tag:before { + content: "\f02b"; +} +.fa-tags:before { + content: "\f02c"; +} +.fa-book:before { + content: "\f02d"; +} +.fa-bookmark:before { + content: "\f02e"; +} +.fa-print:before { + content: "\f02f"; +} +.fa-camera:before { + content: "\f030"; +} +.fa-font:before { + content: "\f031"; +} +.fa-bold:before { + content: "\f032"; +} +.fa-italic:before { + content: "\f033"; +} +.fa-text-height:before { + content: "\f034"; +} +.fa-text-width:before { + content: "\f035"; +} +.fa-align-left:before { + content: "\f036"; +} +.fa-align-center:before { + content: "\f037"; +} +.fa-align-right:before { + content: "\f038"; +} +.fa-align-justify:before { + content: "\f039"; +} +.fa-list:before { + content: "\f03a"; +} +.fa-dedent:before, +.fa-outdent:before { + content: "\f03b"; +} +.fa-indent:before { + content: "\f03c"; +} +.fa-video-camera:before { + content: "\f03d"; +} +.fa-photo:before, +.fa-image:before, +.fa-picture-o:before { + content: "\f03e"; +} +.fa-pencil:before { + content: "\f040"; +} +.fa-map-marker:before { + content: "\f041"; +} +.fa-adjust:before { + content: "\f042"; +} +.fa-tint:before { + content: "\f043"; +} +.fa-edit:before, +.fa-pencil-square-o:before { + content: "\f044"; +} +.fa-share-square-o:before { + content: "\f045"; +} +.fa-check-square-o:before { + content: "\f046"; +} +.fa-arrows:before { + content: "\f047"; +} +.fa-step-backward:before { + content: "\f048"; +} +.fa-fast-backward:before { + content: "\f049"; +} +.fa-backward:before { + content: "\f04a"; +} +.fa-play:before { + content: "\f04b"; +} +.fa-pause:before { + content: "\f04c"; +} +.fa-stop:before { + content: "\f04d"; +} +.fa-forward:before { + content: "\f04e"; +} +.fa-fast-forward:before { + content: "\f050"; +} +.fa-step-forward:before { + content: "\f051"; +} +.fa-eject:before { + content: "\f052"; +} +.fa-chevron-left:before { + content: "\f053"; +} +.fa-chevron-right:before { + content: "\f054"; +} +.fa-plus-circle:before { + content: "\f055"; +} +.fa-minus-circle:before { + content: "\f056"; +} +.fa-times-circle:before { + content: "\f057"; +} +.fa-check-circle:before { + content: "\f058"; +} +.fa-question-circle:before { + content: "\f059"; +} +.fa-info-circle:before { + content: "\f05a"; +} +.fa-crosshairs:before { + content: "\f05b"; +} +.fa-times-circle-o:before { + content: "\f05c"; +} +.fa-check-circle-o:before { + content: "\f05d"; +} +.fa-ban:before { + content: "\f05e"; +} +.fa-arrow-left:before { + content: "\f060"; +} +.fa-arrow-right:before { + content: "\f061"; +} +.fa-arrow-up:before { + content: "\f062"; +} +.fa-arrow-down:before { + content: "\f063"; +} +.fa-mail-forward:before, +.fa-share:before { + content: "\f064"; +} +.fa-expand:before { + content: "\f065"; +} +.fa-compress:before { + content: "\f066"; +} +.fa-plus:before { + content: "\f067"; +} +.fa-minus:before { + content: "\f068"; +} +.fa-asterisk:before { + content: "\f069"; +} +.fa-exclamation-circle:before { + content: "\f06a"; +} +.fa-gift:before { + content: "\f06b"; +} +.fa-leaf:before { + content: "\f06c"; +} +.fa-fire:before { + content: "\f06d"; +} +.fa-eye:before { + content: "\f06e"; +} +.fa-eye-slash:before { + content: "\f070"; +} +.fa-warning:before, +.fa-exclamation-triangle:before { + content: "\f071"; +} +.fa-plane:before { + content: "\f072"; +} +.fa-calendar:before { + content: "\f073"; +} +.fa-random:before { + content: "\f074"; +} +.fa-comment:before { + content: "\f075"; +} +.fa-magnet:before { + content: "\f076"; +} +.fa-chevron-up:before { + content: "\f077"; +} +.fa-chevron-down:before { + content: "\f078"; +} +.fa-retweet:before { + content: "\f079"; +} +.fa-shopping-cart:before { + content: "\f07a"; +} +.fa-folder:before { + content: "\f07b"; +} +.fa-folder-open:before { + content: "\f07c"; +} +.fa-arrows-v:before { + content: "\f07d"; +} +.fa-arrows-h:before { + content: "\f07e"; +} +.fa-bar-chart-o:before, +.fa-bar-chart:before { + content: "\f080"; +} +.fa-twitter-square:before { + content: "\f081"; +} +.fa-facebook-square:before { + content: "\f082"; +} +.fa-camera-retro:before { + content: "\f083"; +} +.fa-key:before { + content: "\f084"; +} +.fa-gears:before, +.fa-cogs:before { + content: "\f085"; +} +.fa-comments:before { + content: "\f086"; +} +.fa-thumbs-o-up:before { + content: "\f087"; +} +.fa-thumbs-o-down:before { + content: "\f088"; +} +.fa-star-half:before { + content: "\f089"; +} +.fa-heart-o:before { + content: "\f08a"; +} +.fa-sign-out:before { + content: "\f08b"; +} +.fa-linkedin-square:before { + content: "\f08c"; +} +.fa-thumb-tack:before { + content: "\f08d"; +} +.fa-external-link:before { + content: "\f08e"; +} +.fa-sign-in:before { + content: "\f090"; +} +.fa-trophy:before { + content: "\f091"; +} +.fa-github-square:before { + content: "\f092"; +} +.fa-upload:before { + content: "\f093"; +} +.fa-lemon-o:before { + content: "\f094"; +} +.fa-phone:before { + content: "\f095"; +} +.fa-square-o:before { + content: "\f096"; +} +.fa-bookmark-o:before { + content: "\f097"; +} +.fa-phone-square:before { + content: "\f098"; +} +.fa-twitter:before { + content: "\f099"; +} +.fa-facebook-f:before, +.fa-facebook:before { + content: "\f09a"; +} +.fa-github:before { + content: "\f09b"; +} +.fa-unlock:before { + content: "\f09c"; +} +.fa-credit-card:before { + content: "\f09d"; +} +.fa-feed:before, +.fa-rss:before { + content: "\f09e"; +} +.fa-hdd-o:before { + content: "\f0a0"; +} +.fa-bullhorn:before { + content: "\f0a1"; +} +.fa-bell:before { + content: "\f0f3"; +} +.fa-certificate:before { + content: "\f0a3"; +} +.fa-hand-o-right:before { + content: "\f0a4"; +} +.fa-hand-o-left:before { + content: "\f0a5"; +} +.fa-hand-o-up:before { + content: "\f0a6"; +} +.fa-hand-o-down:before { + content: "\f0a7"; +} +.fa-arrow-circle-left:before { + content: "\f0a8"; +} +.fa-arrow-circle-right:before { + content: "\f0a9"; +} +.fa-arrow-circle-up:before { + content: "\f0aa"; +} +.fa-arrow-circle-down:before { + content: "\f0ab"; +} +.fa-globe:before { + content: "\f0ac"; +} +.fa-wrench:before { + content: "\f0ad"; +} +.fa-tasks:before { + content: "\f0ae"; +} +.fa-filter:before { + content: "\f0b0"; +} +.fa-briefcase:before { + content: "\f0b1"; +} +.fa-arrows-alt:before { + content: "\f0b2"; +} +.fa-group:before, +.fa-users:before { + content: "\f0c0"; +} +.fa-chain:before, +.fa-link:before { + content: "\f0c1"; +} +.fa-cloud:before { + content: "\f0c2"; +} +.fa-flask:before { + content: "\f0c3"; +} +.fa-cut:before, +.fa-scissors:before { + content: "\f0c4"; +} +.fa-copy:before, +.fa-files-o:before { + content: "\f0c5"; +} +.fa-paperclip:before { + content: "\f0c6"; +} +.fa-save:before, +.fa-floppy-o:before { + content: "\f0c7"; +} +.fa-square:before { + content: "\f0c8"; +} +.fa-navicon:before, +.fa-reorder:before, +.fa-bars:before { + content: "\f0c9"; +} +.fa-list-ul:before { + content: "\f0ca"; +} +.fa-list-ol:before { + content: "\f0cb"; +} +.fa-strikethrough:before { + content: "\f0cc"; +} +.fa-underline:before { + content: "\f0cd"; +} +.fa-table:before { + content: "\f0ce"; +} +.fa-magic:before { + content: "\f0d0"; +} +.fa-truck:before { + content: "\f0d1"; +} +.fa-pinterest:before { + content: "\f0d2"; +} +.fa-pinterest-square:before { + content: "\f0d3"; +} +.fa-google-plus-square:before { + content: "\f0d4"; +} +.fa-google-plus:before { + content: "\f0d5"; +} +.fa-money:before { + content: "\f0d6"; +} +.fa-caret-down:before { + content: "\f0d7"; +} +.fa-caret-up:before { + content: "\f0d8"; +} +.fa-caret-left:before { + content: "\f0d9"; +} +.fa-caret-right:before { + content: "\f0da"; +} +.fa-columns:before { + content: "\f0db"; +} +.fa-unsorted:before, +.fa-sort:before { + content: "\f0dc"; +} +.fa-sort-down:before, +.fa-sort-desc:before { + content: "\f0dd"; +} +.fa-sort-up:before, +.fa-sort-asc:before { + content: "\f0de"; +} +.fa-envelope:before { + content: "\f0e0"; +} +.fa-linkedin:before { + content: "\f0e1"; +} +.fa-rotate-left:before, +.fa-undo:before { + content: "\f0e2"; +} +.fa-legal:before, +.fa-gavel:before { + content: "\f0e3"; +} +.fa-dashboard:before, +.fa-tachometer:before { + content: "\f0e4"; +} +.fa-comment-o:before { + content: "\f0e5"; +} +.fa-comments-o:before { + content: "\f0e6"; +} +.fa-flash:before, +.fa-bolt:before { + content: "\f0e7"; +} +.fa-sitemap:before { + content: "\f0e8"; +} +.fa-umbrella:before { + content: "\f0e9"; +} +.fa-paste:before, +.fa-clipboard:before { + content: "\f0ea"; +} +.fa-lightbulb-o:before { + content: "\f0eb"; +} +.fa-exchange:before { + content: "\f0ec"; +} +.fa-cloud-download:before { + content: "\f0ed"; +} +.fa-cloud-upload:before { + content: "\f0ee"; +} +.fa-user-md:before { + content: "\f0f0"; +} +.fa-stethoscope:before { + content: "\f0f1"; +} +.fa-suitcase:before { + content: "\f0f2"; +} +.fa-bell-o:before { + content: "\f0a2"; +} +.fa-coffee:before { + content: "\f0f4"; +} +.fa-cutlery:before { + content: "\f0f5"; +} +.fa-file-text-o:before { + content: "\f0f6"; +} +.fa-building-o:before { + content: "\f0f7"; +} +.fa-hospital-o:before { + content: "\f0f8"; +} +.fa-ambulance:before { + content: "\f0f9"; +} +.fa-medkit:before { + content: "\f0fa"; +} +.fa-fighter-jet:before { + content: "\f0fb"; +} +.fa-beer:before { + content: "\f0fc"; +} +.fa-h-square:before { + content: "\f0fd"; +} +.fa-plus-square:before { + content: "\f0fe"; +} +.fa-angle-double-left:before { + content: "\f100"; +} +.fa-angle-double-right:before { + content: "\f101"; +} +.fa-angle-double-up:before { + content: "\f102"; +} +.fa-angle-double-down:before { + content: "\f103"; +} +.fa-angle-left:before { + content: "\f104"; +} +.fa-angle-right:before { + content: "\f105"; +} +.fa-angle-up:before { + content: "\f106"; +} +.fa-angle-down:before { + content: "\f107"; +} +.fa-desktop:before { + content: "\f108"; +} +.fa-laptop:before { + content: "\f109"; +} +.fa-tablet:before { + content: "\f10a"; +} +.fa-mobile-phone:before, +.fa-mobile:before { + content: "\f10b"; +} +.fa-circle-o:before { + content: "\f10c"; +} +.fa-quote-left:before { + content: "\f10d"; +} +.fa-quote-right:before { + content: "\f10e"; +} +.fa-spinner:before { + content: "\f110"; +} +.fa-circle:before { + content: "\f111"; +} +.fa-mail-reply:before, +.fa-reply:before { + content: "\f112"; +} +.fa-github-alt:before { + content: "\f113"; +} +.fa-folder-o:before { + content: "\f114"; +} +.fa-folder-open-o:before { + content: "\f115"; +} +.fa-smile-o:before { + content: "\f118"; +} +.fa-frown-o:before { + content: "\f119"; +} +.fa-meh-o:before { + content: "\f11a"; +} +.fa-gamepad:before { + content: "\f11b"; +} +.fa-keyboard-o:before { + content: "\f11c"; +} +.fa-flag-o:before { + content: "\f11d"; +} +.fa-flag-checkered:before { + content: "\f11e"; +} +.fa-terminal:before { + content: "\f120"; +} +.fa-code:before { + content: "\f121"; +} +.fa-mail-reply-all:before, +.fa-reply-all:before { + content: "\f122"; +} +.fa-star-half-empty:before, +.fa-star-half-full:before, +.fa-star-half-o:before { + content: "\f123"; +} +.fa-location-arrow:before { + content: "\f124"; +} +.fa-crop:before { + content: "\f125"; +} +.fa-code-fork:before { + content: "\f126"; +} +.fa-unlink:before, +.fa-chain-broken:before { + content: "\f127"; +} +.fa-question:before { + content: "\f128"; +} +.fa-info:before { + content: "\f129"; +} +.fa-exclamation:before { + content: "\f12a"; +} +.fa-superscript:before { + content: "\f12b"; +} +.fa-subscript:before { + content: "\f12c"; +} +.fa-eraser:before { + content: "\f12d"; +} +.fa-puzzle-piece:before { + content: "\f12e"; +} +.fa-microphone:before { + content: "\f130"; +} +.fa-microphone-slash:before { + content: "\f131"; +} +.fa-shield:before { + content: "\f132"; +} +.fa-calendar-o:before { + content: "\f133"; +} +.fa-fire-extinguisher:before { + content: "\f134"; +} +.fa-rocket:before { + content: "\f135"; +} +.fa-maxcdn:before { + content: "\f136"; +} +.fa-chevron-circle-left:before { + content: "\f137"; +} +.fa-chevron-circle-right:before { + content: "\f138"; +} +.fa-chevron-circle-up:before { + content: "\f139"; +} +.fa-chevron-circle-down:before { + content: "\f13a"; +} +.fa-html5:before { + content: "\f13b"; +} +.fa-css3:before { + content: "\f13c"; +} +.fa-anchor:before { + content: "\f13d"; +} +.fa-unlock-alt:before { + content: "\f13e"; +} +.fa-bullseye:before { + content: "\f140"; +} +.fa-ellipsis-h:before { + content: "\f141"; +} +.fa-ellipsis-v:before { + content: "\f142"; +} +.fa-rss-square:before { + content: "\f143"; +} +.fa-play-circle:before { + content: "\f144"; +} +.fa-ticket:before { + content: "\f145"; +} +.fa-minus-square:before { + content: "\f146"; +} +.fa-minus-square-o:before { + content: "\f147"; +} +.fa-level-up:before { + content: "\f148"; +} +.fa-level-down:before { + content: "\f149"; +} +.fa-check-square:before { + content: "\f14a"; +} +.fa-pencil-square:before { + content: "\f14b"; +} +.fa-external-link-square:before { + content: "\f14c"; +} +.fa-share-square:before { + content: "\f14d"; +} +.fa-compass:before { + content: "\f14e"; +} +.fa-toggle-down:before, +.fa-caret-square-o-down:before { + content: "\f150"; +} +.fa-toggle-up:before, +.fa-caret-square-o-up:before { + content: "\f151"; +} +.fa-toggle-right:before, +.fa-caret-square-o-right:before { + content: "\f152"; +} +.fa-euro:before, +.fa-eur:before { + content: "\f153"; +} +.fa-gbp:before { + content: "\f154"; +} +.fa-dollar:before, +.fa-usd:before { + content: "\f155"; +} +.fa-rupee:before, +.fa-inr:before { + content: "\f156"; +} +.fa-cny:before, +.fa-rmb:before, +.fa-yen:before, +.fa-jpy:before { + content: "\f157"; +} +.fa-ruble:before, +.fa-rouble:before, +.fa-rub:before { + content: "\f158"; +} +.fa-won:before, +.fa-krw:before { + content: "\f159"; +} +.fa-bitcoin:before, +.fa-btc:before { + content: "\f15a"; +} +.fa-file:before { + content: "\f15b"; +} +.fa-file-text:before { + content: "\f15c"; +} +.fa-sort-alpha-asc:before { + content: "\f15d"; +} +.fa-sort-alpha-desc:before { + content: "\f15e"; +} +.fa-sort-amount-asc:before { + content: "\f160"; +} +.fa-sort-amount-desc:before { + content: "\f161"; +} +.fa-sort-numeric-asc:before { + content: "\f162"; +} +.fa-sort-numeric-desc:before { + content: "\f163"; +} +.fa-thumbs-up:before { + content: "\f164"; +} +.fa-thumbs-down:before { + content: "\f165"; +} +.fa-youtube-square:before { + content: "\f166"; +} +.fa-youtube:before { + content: "\f167"; +} +.fa-xing:before { + content: "\f168"; +} +.fa-xing-square:before { + content: "\f169"; +} +.fa-youtube-play:before { + content: "\f16a"; +} +.fa-dropbox:before { + content: "\f16b"; +} +.fa-stack-overflow:before { + content: "\f16c"; +} +.fa-instagram:before { + content: "\f16d"; +} +.fa-flickr:before { + content: "\f16e"; +} +.fa-adn:before { + content: "\f170"; +} +.fa-bitbucket:before { + content: "\f171"; +} +.fa-bitbucket-square:before { + content: "\f172"; +} +.fa-tumblr:before { + content: "\f173"; +} +.fa-tumblr-square:before { + content: "\f174"; +} +.fa-long-arrow-down:before { + content: "\f175"; +} +.fa-long-arrow-up:before { + content: "\f176"; +} +.fa-long-arrow-left:before { + content: "\f177"; +} +.fa-long-arrow-right:before { + content: "\f178"; +} +.fa-apple:before { + content: "\f179"; +} +.fa-windows:before { + content: "\f17a"; +} +.fa-android:before { + content: "\f17b"; +} +.fa-linux:before { + content: "\f17c"; +} +.fa-dribbble:before { + content: "\f17d"; +} +.fa-skype:before { + content: "\f17e"; +} +.fa-foursquare:before { + content: "\f180"; +} +.fa-trello:before { + content: "\f181"; +} +.fa-female:before { + content: "\f182"; +} +.fa-male:before { + content: "\f183"; +} +.fa-gittip:before, +.fa-gratipay:before { + content: "\f184"; +} +.fa-sun-o:before { + content: "\f185"; +} +.fa-moon-o:before { + content: "\f186"; +} +.fa-archive:before { + content: "\f187"; +} +.fa-bug:before { + content: "\f188"; +} +.fa-vk:before { + content: "\f189"; +} +.fa-weibo:before { + content: "\f18a"; +} +.fa-renren:before { + content: "\f18b"; +} +.fa-pagelines:before { + content: "\f18c"; +} +.fa-stack-exchange:before { + content: "\f18d"; +} +.fa-arrow-circle-o-right:before { + content: "\f18e"; +} +.fa-arrow-circle-o-left:before { + content: "\f190"; +} +.fa-toggle-left:before, +.fa-caret-square-o-left:before { + content: "\f191"; +} +.fa-dot-circle-o:before { + content: "\f192"; +} +.fa-wheelchair:before { + content: "\f193"; +} +.fa-vimeo-square:before { + content: "\f194"; +} +.fa-turkish-lira:before, +.fa-try:before { + content: "\f195"; +} +.fa-plus-square-o:before { + content: "\f196"; +} +.fa-space-shuttle:before { + content: "\f197"; +} +.fa-slack:before { + content: "\f198"; +} +.fa-envelope-square:before { + content: "\f199"; +} +.fa-wordpress:before { + content: "\f19a"; +} +.fa-openid:before { + content: "\f19b"; +} +.fa-institution:before, +.fa-bank:before, +.fa-university:before { + content: "\f19c"; +} +.fa-mortar-board:before, +.fa-graduation-cap:before { + content: "\f19d"; +} +.fa-yahoo:before { + content: "\f19e"; +} +.fa-google:before { + content: "\f1a0"; +} +.fa-reddit:before { + content: "\f1a1"; +} +.fa-reddit-square:before { + content: "\f1a2"; +} +.fa-stumbleupon-circle:before { + content: "\f1a3"; +} +.fa-stumbleupon:before { + content: "\f1a4"; +} +.fa-delicious:before { + content: "\f1a5"; +} +.fa-digg:before { + content: "\f1a6"; +} +.fa-pied-piper-pp:before { + content: "\f1a7"; +} +.fa-pied-piper-alt:before { + content: "\f1a8"; +} +.fa-drupal:before { + content: "\f1a9"; +} +.fa-joomla:before { + content: "\f1aa"; +} +.fa-language:before { + content: "\f1ab"; +} +.fa-fax:before { + content: "\f1ac"; +} +.fa-building:before { + content: "\f1ad"; +} +.fa-child:before { + content: "\f1ae"; +} +.fa-paw:before { + content: "\f1b0"; +} +.fa-spoon:before { + content: "\f1b1"; +} +.fa-cube:before { + content: "\f1b2"; +} +.fa-cubes:before { + content: "\f1b3"; +} +.fa-behance:before { + content: "\f1b4"; +} +.fa-behance-square:before { + content: "\f1b5"; +} +.fa-steam:before { + content: "\f1b6"; +} +.fa-steam-square:before { + content: "\f1b7"; +} +.fa-recycle:before { + content: "\f1b8"; +} +.fa-automobile:before, +.fa-car:before { + content: "\f1b9"; +} +.fa-cab:before, +.fa-taxi:before { + content: "\f1ba"; +} +.fa-tree:before { + content: "\f1bb"; +} +.fa-spotify:before { + content: "\f1bc"; +} +.fa-deviantart:before { + content: "\f1bd"; +} +.fa-soundcloud:before { + content: "\f1be"; +} +.fa-database:before { + content: "\f1c0"; +} +.fa-file-pdf-o:before { + content: "\f1c1"; +} +.fa-file-word-o:before { + content: "\f1c2"; +} +.fa-file-excel-o:before { + content: "\f1c3"; +} +.fa-file-powerpoint-o:before { + content: "\f1c4"; +} +.fa-file-photo-o:before, +.fa-file-picture-o:before, +.fa-file-image-o:before { + content: "\f1c5"; +} +.fa-file-zip-o:before, +.fa-file-archive-o:before { + content: "\f1c6"; +} +.fa-file-sound-o:before, +.fa-file-audio-o:before { + content: "\f1c7"; +} +.fa-file-movie-o:before, +.fa-file-video-o:before { + content: "\f1c8"; +} +.fa-file-code-o:before { + content: "\f1c9"; +} +.fa-vine:before { + content: "\f1ca"; +} +.fa-codepen:before { + content: "\f1cb"; +} +.fa-jsfiddle:before { + content: "\f1cc"; +} +.fa-life-bouy:before, +.fa-life-buoy:before, +.fa-life-saver:before, +.fa-support:before, +.fa-life-ring:before { + content: "\f1cd"; +} +.fa-circle-o-notch:before { + content: "\f1ce"; +} +.fa-ra:before, +.fa-resistance:before, +.fa-rebel:before { + content: "\f1d0"; +} +.fa-ge:before, +.fa-empire:before { + content: "\f1d1"; +} +.fa-git-square:before { + content: "\f1d2"; +} +.fa-git:before { + content: "\f1d3"; +} +.fa-y-combinator-square:before, +.fa-yc-square:before, +.fa-hacker-news:before { + content: "\f1d4"; +} +.fa-tencent-weibo:before { + content: "\f1d5"; +} +.fa-qq:before { + content: "\f1d6"; +} +.fa-wechat:before, +.fa-weixin:before { + content: "\f1d7"; +} +.fa-send:before, +.fa-paper-plane:before { + content: "\f1d8"; +} +.fa-send-o:before, +.fa-paper-plane-o:before { + content: "\f1d9"; +} +.fa-history:before { + content: "\f1da"; +} +.fa-circle-thin:before { + content: "\f1db"; +} +.fa-header:before { + content: "\f1dc"; +} +.fa-paragraph:before { + content: "\f1dd"; +} +.fa-sliders:before { + content: "\f1de"; +} +.fa-share-alt:before { + content: "\f1e0"; +} +.fa-share-alt-square:before { + content: "\f1e1"; +} +.fa-bomb:before { + content: "\f1e2"; +} +.fa-soccer-ball-o:before, +.fa-futbol-o:before { + content: "\f1e3"; +} +.fa-tty:before { + content: "\f1e4"; +} +.fa-binoculars:before { + content: "\f1e5"; +} +.fa-plug:before { + content: "\f1e6"; +} +.fa-slideshare:before { + content: "\f1e7"; +} +.fa-twitch:before { + content: "\f1e8"; +} +.fa-yelp:before { + content: "\f1e9"; +} +.fa-newspaper-o:before { + content: "\f1ea"; +} +.fa-wifi:before { + content: "\f1eb"; +} +.fa-calculator:before { + content: "\f1ec"; +} +.fa-paypal:before { + content: "\f1ed"; +} +.fa-google-wallet:before { + content: "\f1ee"; +} +.fa-cc-visa:before { + content: "\f1f0"; +} +.fa-cc-mastercard:before { + content: "\f1f1"; +} +.fa-cc-discover:before { + content: "\f1f2"; +} +.fa-cc-amex:before { + content: "\f1f3"; +} +.fa-cc-paypal:before { + content: "\f1f4"; +} +.fa-cc-stripe:before { + content: "\f1f5"; +} +.fa-bell-slash:before { + content: "\f1f6"; +} +.fa-bell-slash-o:before { + content: "\f1f7"; +} +.fa-trash:before { + content: "\f1f8"; +} +.fa-copyright:before { + content: "\f1f9"; +} +.fa-at:before { + content: "\f1fa"; +} +.fa-eyedropper:before { + content: "\f1fb"; +} +.fa-paint-brush:before { + content: "\f1fc"; +} +.fa-birthday-cake:before { + content: "\f1fd"; +} +.fa-area-chart:before { + content: "\f1fe"; +} +.fa-pie-chart:before { + content: "\f200"; +} +.fa-line-chart:before { + content: "\f201"; +} +.fa-lastfm:before { + content: "\f202"; +} +.fa-lastfm-square:before { + content: "\f203"; +} +.fa-toggle-off:before { + content: "\f204"; +} +.fa-toggle-on:before { + content: "\f205"; +} +.fa-bicycle:before { + content: "\f206"; +} +.fa-bus:before { + content: "\f207"; +} +.fa-ioxhost:before { + content: "\f208"; +} +.fa-angellist:before { + content: "\f209"; +} +.fa-cc:before { + content: "\f20a"; +} +.fa-shekel:before, +.fa-sheqel:before, +.fa-ils:before { + content: "\f20b"; +} +.fa-meanpath:before { + content: "\f20c"; +} +.fa-buysellads:before { + content: "\f20d"; +} +.fa-connectdevelop:before { + content: "\f20e"; +} +.fa-dashcube:before { + content: "\f210"; +} +.fa-forumbee:before { + content: "\f211"; +} +.fa-leanpub:before { + content: "\f212"; +} +.fa-sellsy:before { + content: "\f213"; +} +.fa-shirtsinbulk:before { + content: "\f214"; +} +.fa-simplybuilt:before { + content: "\f215"; +} +.fa-skyatlas:before { + content: "\f216"; +} +.fa-cart-plus:before { + content: "\f217"; +} +.fa-cart-arrow-down:before { + content: "\f218"; +} +.fa-diamond:before { + content: "\f219"; +} +.fa-ship:before { + content: "\f21a"; +} +.fa-user-secret:before { + content: "\f21b"; +} +.fa-motorcycle:before { + content: "\f21c"; +} +.fa-street-view:before { + content: "\f21d"; +} +.fa-heartbeat:before { + content: "\f21e"; +} +.fa-venus:before { + content: "\f221"; +} +.fa-mars:before { + content: "\f222"; +} +.fa-mercury:before { + content: "\f223"; +} +.fa-intersex:before, +.fa-transgender:before { + content: "\f224"; +} +.fa-transgender-alt:before { + content: "\f225"; +} +.fa-venus-double:before { + content: "\f226"; +} +.fa-mars-double:before { + content: "\f227"; +} +.fa-venus-mars:before { + content: "\f228"; +} +.fa-mars-stroke:before { + content: "\f229"; +} +.fa-mars-stroke-v:before { + content: "\f22a"; +} +.fa-mars-stroke-h:before { + content: "\f22b"; +} +.fa-neuter:before { + content: "\f22c"; +} +.fa-genderless:before { + content: "\f22d"; +} +.fa-facebook-official:before { + content: "\f230"; +} +.fa-pinterest-p:before { + content: "\f231"; +} +.fa-whatsapp:before { + content: "\f232"; +} +.fa-server:before { + content: "\f233"; +} +.fa-user-plus:before { + content: "\f234"; +} +.fa-user-times:before { + content: "\f235"; +} +.fa-hotel:before, +.fa-bed:before { + content: "\f236"; +} +.fa-viacoin:before { + content: "\f237"; +} +.fa-train:before { + content: "\f238"; +} +.fa-subway:before { + content: "\f239"; +} +.fa-medium:before { + content: "\f23a"; +} +.fa-yc:before, +.fa-y-combinator:before { + content: "\f23b"; +} +.fa-optin-monster:before { + content: "\f23c"; +} +.fa-opencart:before { + content: "\f23d"; +} +.fa-expeditedssl:before { + content: "\f23e"; +} +.fa-battery-4:before, +.fa-battery:before, +.fa-battery-full:before { + content: "\f240"; +} +.fa-battery-3:before, +.fa-battery-three-quarters:before { + content: "\f241"; +} +.fa-battery-2:before, +.fa-battery-half:before { + content: "\f242"; +} +.fa-battery-1:before, +.fa-battery-quarter:before { + content: "\f243"; +} +.fa-battery-0:before, +.fa-battery-empty:before { + content: "\f244"; +} +.fa-mouse-pointer:before { + content: "\f245"; +} +.fa-i-cursor:before { + content: "\f246"; +} +.fa-object-group:before { + content: "\f247"; +} +.fa-object-ungroup:before { + content: "\f248"; +} +.fa-sticky-note:before { + content: "\f249"; +} +.fa-sticky-note-o:before { + content: "\f24a"; +} +.fa-cc-jcb:before { + content: "\f24b"; +} +.fa-cc-diners-club:before { + content: "\f24c"; +} +.fa-clone:before { + content: "\f24d"; +} +.fa-balance-scale:before { + content: "\f24e"; +} +.fa-hourglass-o:before { + content: "\f250"; +} +.fa-hourglass-1:before, +.fa-hourglass-start:before { + content: "\f251"; +} +.fa-hourglass-2:before, +.fa-hourglass-half:before { + content: "\f252"; +} +.fa-hourglass-3:before, +.fa-hourglass-end:before { + content: "\f253"; +} +.fa-hourglass:before { + content: "\f254"; +} +.fa-hand-grab-o:before, +.fa-hand-rock-o:before { + content: "\f255"; +} +.fa-hand-stop-o:before, +.fa-hand-paper-o:before { + content: "\f256"; +} +.fa-hand-scissors-o:before { + content: "\f257"; +} +.fa-hand-lizard-o:before { + content: "\f258"; +} +.fa-hand-spock-o:before { + content: "\f259"; +} +.fa-hand-pointer-o:before { + content: "\f25a"; +} +.fa-hand-peace-o:before { + content: "\f25b"; +} +.fa-trademark:before { + content: "\f25c"; +} +.fa-registered:before { + content: "\f25d"; +} +.fa-creative-commons:before { + content: "\f25e"; +} +.fa-gg:before { + content: "\f260"; +} +.fa-gg-circle:before { + content: "\f261"; +} +.fa-tripadvisor:before { + content: "\f262"; +} +.fa-odnoklassniki:before { + content: "\f263"; +} +.fa-odnoklassniki-square:before { + content: "\f264"; +} +.fa-get-pocket:before { + content: "\f265"; +} +.fa-wikipedia-w:before { + content: "\f266"; +} +.fa-safari:before { + content: "\f267"; +} +.fa-chrome:before { + content: "\f268"; +} +.fa-firefox:before { + content: "\f269"; +} +.fa-opera:before { + content: "\f26a"; +} +.fa-internet-explorer:before { + content: "\f26b"; +} +.fa-tv:before, +.fa-television:before { + content: "\f26c"; +} +.fa-contao:before { + content: "\f26d"; +} +.fa-500px:before { + content: "\f26e"; +} +.fa-amazon:before { + content: "\f270"; +} +.fa-calendar-plus-o:before { + content: "\f271"; +} +.fa-calendar-minus-o:before { + content: "\f272"; +} +.fa-calendar-times-o:before { + content: "\f273"; +} +.fa-calendar-check-o:before { + content: "\f274"; +} +.fa-industry:before { + content: "\f275"; +} +.fa-map-pin:before { + content: "\f276"; +} +.fa-map-signs:before { + content: "\f277"; +} +.fa-map-o:before { + content: "\f278"; +} +.fa-map:before { + content: "\f279"; +} +.fa-commenting:before { + content: "\f27a"; +} +.fa-commenting-o:before { + content: "\f27b"; +} +.fa-houzz:before { + content: "\f27c"; +} +.fa-vimeo:before { + content: "\f27d"; +} +.fa-black-tie:before { + content: "\f27e"; +} +.fa-fonticons:before { + content: "\f280"; +} +.fa-reddit-alien:before { + content: "\f281"; +} +.fa-edge:before { + content: "\f282"; +} +.fa-credit-card-alt:before { + content: "\f283"; +} +.fa-codiepie:before { + content: "\f284"; +} +.fa-modx:before { + content: "\f285"; +} +.fa-fort-awesome:before { + content: "\f286"; +} +.fa-usb:before { + content: "\f287"; +} +.fa-product-hunt:before { + content: "\f288"; +} +.fa-mixcloud:before { + content: "\f289"; +} +.fa-scribd:before { + content: "\f28a"; +} +.fa-pause-circle:before { + content: "\f28b"; +} +.fa-pause-circle-o:before { + content: "\f28c"; +} +.fa-stop-circle:before { + content: "\f28d"; +} +.fa-stop-circle-o:before { + content: "\f28e"; +} +.fa-shopping-bag:before { + content: "\f290"; +} +.fa-shopping-basket:before { + content: "\f291"; +} +.fa-hashtag:before { + content: "\f292"; +} +.fa-bluetooth:before { + content: "\f293"; +} +.fa-bluetooth-b:before { + content: "\f294"; +} +.fa-percent:before { + content: "\f295"; +} +.fa-gitlab:before { + content: "\f296"; +} +.fa-wpbeginner:before { + content: "\f297"; +} +.fa-wpforms:before { + content: "\f298"; +} +.fa-envira:before { + content: "\f299"; +} +.fa-universal-access:before { + content: "\f29a"; +} +.fa-wheelchair-alt:before { + content: "\f29b"; +} +.fa-question-circle-o:before { + content: "\f29c"; +} +.fa-blind:before { + content: "\f29d"; +} +.fa-audio-description:before { + content: "\f29e"; +} +.fa-volume-control-phone:before { + content: "\f2a0"; +} +.fa-braille:before { + content: "\f2a1"; +} +.fa-assistive-listening-systems:before { + content: "\f2a2"; +} +.fa-asl-interpreting:before, +.fa-american-sign-language-interpreting:before { + content: "\f2a3"; +} +.fa-deafness:before, +.fa-hard-of-hearing:before, +.fa-deaf:before { + content: "\f2a4"; +} +.fa-glide:before { + content: "\f2a5"; +} +.fa-glide-g:before { + content: "\f2a6"; +} +.fa-signing:before, +.fa-sign-language:before { + content: "\f2a7"; +} +.fa-low-vision:before { + content: "\f2a8"; +} +.fa-viadeo:before { + content: "\f2a9"; +} +.fa-viadeo-square:before { + content: "\f2aa"; +} +.fa-snapchat:before { + content: "\f2ab"; +} +.fa-snapchat-ghost:before { + content: "\f2ac"; +} +.fa-snapchat-square:before { + content: "\f2ad"; +} +.fa-pied-piper:before { + content: "\f2ae"; +} +.fa-first-order:before { + content: "\f2b0"; +} +.fa-yoast:before { + content: "\f2b1"; +} +.fa-themeisle:before { + content: "\f2b2"; +} +.fa-google-plus-circle:before, +.fa-google-plus-official:before { + content: "\f2b3"; +} +.fa-fa:before, +.fa-font-awesome:before { + content: "\f2b4"; +} +.fa-handshake-o:before { + content: "\f2b5"; +} +.fa-envelope-open:before { + content: "\f2b6"; +} +.fa-envelope-open-o:before { + content: "\f2b7"; +} +.fa-linode:before { + content: "\f2b8"; +} +.fa-address-book:before { + content: "\f2b9"; +} +.fa-address-book-o:before { + content: "\f2ba"; +} +.fa-vcard:before, +.fa-address-card:before { + content: "\f2bb"; +} +.fa-vcard-o:before, +.fa-address-card-o:before { + content: "\f2bc"; +} +.fa-user-circle:before { + content: "\f2bd"; +} +.fa-user-circle-o:before { + content: "\f2be"; +} +.fa-user-o:before { + content: "\f2c0"; +} +.fa-id-badge:before { + content: "\f2c1"; +} +.fa-drivers-license:before, +.fa-id-card:before { + content: "\f2c2"; +} +.fa-drivers-license-o:before, +.fa-id-card-o:before { + content: "\f2c3"; +} +.fa-quora:before { + content: "\f2c4"; +} +.fa-free-code-camp:before { + content: "\f2c5"; +} +.fa-telegram:before { + content: "\f2c6"; +} +.fa-thermometer-4:before, +.fa-thermometer:before, +.fa-thermometer-full:before { + content: "\f2c7"; +} +.fa-thermometer-3:before, +.fa-thermometer-three-quarters:before { + content: "\f2c8"; +} +.fa-thermometer-2:before, +.fa-thermometer-half:before { + content: "\f2c9"; +} +.fa-thermometer-1:before, +.fa-thermometer-quarter:before { + content: "\f2ca"; +} +.fa-thermometer-0:before, +.fa-thermometer-empty:before { + content: "\f2cb"; +} +.fa-shower:before { + content: "\f2cc"; +} +.fa-bathtub:before, +.fa-s15:before, +.fa-bath:before { + content: "\f2cd"; +} +.fa-podcast:before { + content: "\f2ce"; +} +.fa-window-maximize:before { + content: "\f2d0"; +} +.fa-window-minimize:before { + content: "\f2d1"; +} +.fa-window-restore:before { + content: "\f2d2"; +} +.fa-times-rectangle:before, +.fa-window-close:before { + content: "\f2d3"; +} +.fa-times-rectangle-o:before, +.fa-window-close-o:before { + content: "\f2d4"; +} +.fa-bandcamp:before { + content: "\f2d5"; +} +.fa-grav:before { + content: "\f2d6"; +} +.fa-etsy:before { + content: "\f2d7"; +} +.fa-imdb:before { + content: "\f2d8"; +} +.fa-ravelry:before { + content: "\f2d9"; +} +.fa-eercast:before { + content: "\f2da"; +} +.fa-microchip:before { + content: "\f2db"; +} +.fa-snowflake-o:before { + content: "\f2dc"; +} +.fa-superpowers:before { + content: "\f2dd"; +} +.fa-wpexplorer:before { + content: "\f2de"; +} +.fa-meetup:before { + content: "\f2e0"; +} +.sr-only { + position: absolute; + width: 1px; + height: 1px; + padding: 0; + margin: -1px; + overflow: hidden; + clip: rect(0, 0, 0, 0); + border: 0; +} +.sr-only-focusable:active, +.sr-only-focusable:focus { + position: static; + width: auto; + height: auto; + margin: 0; + overflow: visible; + clip: auto; +} diff --git a/vue/src/assets/fonts/fontawesome-webfont.eot b/vue/src/assets/fonts/fontawesome-webfont.eot new file mode 100644 index 0000000000000000000000000000000000000000..e9f60ca953f93e35eab4108bd414bc02ddcf3928 GIT binary patch literal 165742 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 G*yFsbY~cLNXLP73aA74Mq6M9f^&YV`isWW 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

5q!RY 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 + + + +Created by FontForge 20120731 at Mon Oct 24 17:37:40 2016 + By ,,, +Copyright Dave Gandy 2016. All rights reserved. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/vue/src/assets/fonts/fontawesome-webfont.ttf b/vue/src/assets/fonts/fontawesome-webfont.ttf new file mode 100644 index 0000000000000000000000000000000000000000..35acda2fa1196aad98c2adf4378a7611dd713aa3 GIT binary patch literal 165548 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 z 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 d0mRO}xo^G_%I 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 SdSQM28?+M|D(2r_;{O0|uQ74} literal 0 HcmV?d00001 diff --git a/vue/src/assets/fonts/fontawesome-webfont.woff2 b/vue/src/assets/fonts/fontawesome-webfont.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..4d13fc60404b91e398a37200c4a77b645cfd9586 GIT binary patch literal 77160 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 literal 0 HcmV?d00001 diff --git a/vue/src/assets/imgs/404.jpg b/vue/src/assets/imgs/404.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7ce045c163246a2740a86dbfc1135d456adfaede GIT binary patch literal 156674 zcmdSAcTiK&*Y6zxrKl)~C>^9GH0d1$rG*|skkAyVfrJiHRiudY5_%^ggetv*3P=|S z2}lAcU8)KMl_J;QbDw$Mciw;QANQ|!pP4hWW}maqclMmU&RTnY&iUu_uYl`dT?1Xf zg$n?{g?|U&oC0|8&-%Y>{~6@}ZiIh#pT7gJFwi>F%+X%B1E68KK+AIBydS{#ACVU? z{yY6oyFf$B$V7MX62oQse-{K^2V9`JNJD#(j)9hz{^BJX@qhh*f88wf0t~D&j5oB* zpWN|znaad=v!wq0)DL#qrCWm9w>gC5R3Ja)9etm*2#bhDrZsRXDm~D#u#C+rZ52~c z*42Z#xcd1AzKX&16NnG>A3b#nO3y4SZ*2O|H!w5%@43AHnL_%1y8lPlKOMA}=ouI< z(lPz(w`Kv*T%e_)qq)RD`%euMiz&*gk z^7Sa7zV>yj0E2c$lmHXt|Ig;_rNGIfU(yZR7Ki5mt;3ZEo16<(O6WIy`J0t>`#ZCH#I@gn zPlP!xQ0gEqV9Ql#T)S`J<_;j__@TZa$Io5x#6HW$Q5|;nWAUIgW4>Zx`#GSKoEz4) z%}D*5igO@*U$GVhF5QcH7lwutNv=FWH~XKi9PsjEHh6EJy4$}@N!EOS*sVOrU$k$$ zgrluHBNKN{6T@_qo^D3`Y#Rcd1B41Wp{a>I6e6*(Gd1@QkGeiTO9J2RL#5$AfB3Fc zO-8Udnhe;J-_Rq@YAQ0gl8xb03&B(CZUL8P2<4XRC@$TvEhzeOCw!}O2`oQ7wJ6JD zR|QxZ?)arr@sz}|Ha#<7QYWo0!qGFuPh+ape)c*OeOp(7r=dt+wqUNRstLvA|6JF- zW2xplxhaqEGi0;f6&cU_uFO_EM{!rvSw0u3UGFoGcDDw;$s_&=`qq$92^|L^=Qdki z6RH$V`3$QP12AIV1$`d2@AweS_*&oeuRd_E>}OX83;%+wiq!=t-a8nUB>@<@#ea;b zzpOw+COfc7`MXXyC4{VqWFOn*dts7LHs)2<>&QrM)E3UZ1fzDG8pB_&g2OH;hPhz{kqs&D)0Mw_@8RnWr%G;Xgq)Vco3hhGn0O3^NyU%E2UYPlK*z*#-Lm;CBJ=1T)LVw{rkt zd&S*Z*Cy&Or?p9V%I;H(FJ`G9r4&S0^r(W=m%GeHqvRlLy*u`6#+p{N-7w@WE6*pW z2-9F##GTR$8dZvJI_sJiPCFcKeax6M?F&x_S!9;n= z<1F^&$m=gspry^?jQWgpY5IUGhY8PqA08XzU-=RGsAh9L_a1b)_mSK8u^|%*+`=p+ z^R1hLfpd_T#U2t?h(big#RbXE6Kl!@f+vPG(W6jjAzOnx{5L+|_`!j7(uUGoB!}Iv z5%eudzIUxi|Dc%k9qUTgdrowD-k_nfwDO>as<}bLE;dW?n6&3)-P`KleeYwNQOQkt zFDef0M&EhSv?j*?LiMNgVakc)T#nJytg%dvn=&^v;bY|H5SoF96O@S?HO>$}wQbZ7 zdMA;eombNRd|O98ai{q2DRJD^mu5;5~@IdKW3R|ywie9t{JqH-J zCJylJDVr{p6zL(33y(CeNq+eF`{x(U2bhPEYJ_guCEl<%$97%*v_<=tOR-skUbS0s znr$Mxrhie3x+)5n|G8@q@w@Na+hix<{l##j5w{@fIRIq@tUfVt{`1G9q-9=^yUMl- zPhW+29WCl}K>1ZX|8m3n_=C*Nr7xR)-n}7~n}?dhZ9yaxzW$Z*yVNBQ7!W?-GJP_R zma}ltEpWFt0vGQ^j5KdgGZ>7J*T6Hf!IR9w{(Ntcs^y5@Yq?df2+}J{;T9<_%}SC^ zj(flG<&Yd$dS3u1kE5ly-mDlkM};##$Lxk|;*INq^p{Gt=r8rGFuV}B&oa5En%wrC z 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�%aieDJ)~gxR*8x0q=eR(G}pvJ%WQd{Hxuz5;#u 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

  • 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 interface \ No newline at end of file diff --git a/vue/src/assets/imgs/logo.png b/vue/src/assets/imgs/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..f3d2503fc2a44b5053b0837ebea6e87a2d339a43 GIT binary patch literal 6849 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 in \ No newline at end of file diff --git a/vue/src/assets/logo.png b/vue/src/assets/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..f3d2503fc2a44b5053b0837ebea6e87a2d339a43 GIT binary patch literal 6849 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 import('@/views/Manager.vue'), + redirect: '/manager/login', + children: [ + { path: 'password', meta: { name: '修改密码' }, component: () => import('@/views/manager/Password.vue') }, + { path: 'home', meta: { name: '系统首页' }, component: () => import('@/views/manager/Home.vue') }, + { path: 'admin', meta: { name: '管理员' }, component: () => import("@/views/manager/Admin.vue") }, + { path: 'patient', meta: { name: '患者' }, component: () => import("@/views/manager/Patient.vue") }, + { path: 'doctor', meta: { name: '医生' }, component: () => import("@/views/manager/Doctor.vue") }, + { path: 'pAdmin', meta: { name: '个人信息', roles: ['admin'] }, component: () => import("@/views/manager/pAdmin.vue") }, + { path: 'pPatient', meta: { name: '个人信息', roles: ['patient'] }, component: () => import("@/views/manager/pPatient.vue") }, + { path: 'pDoctor', meta: { name: '个人信息', roles: ['doctor'] }, component: () => import("@/views/manager/pDoctor.vue") }, + { path: 'symptomRecord', meta: { name: '症状记录' }, component: () => import("@/views/manager/SymptomRecord.vue") }, + { path: 'resourceCategory', meta: { name: '资源分类管理' }, component: () => import("@/views/manager/ResourceCategory.vue") }, + { path: 'treatmentResource', meta: { name: '心理资源管理' }, component: () => import("@/views/manager/TreatmentResource.vue") }, + { path: 'resourceRecommendation', meta: { name: '心理资源推荐', roles: ['patient'] }, component: () => import("@/views/manager/ResourceRecommendation.vue") }, + { path: 'myResources', meta: { name: '我的资源' }, component: () => import("@/views/manager/MyResources.vue") }, + { path: 'aiChat', meta: { name: '智能问答' }, component: () => import("@/views/manager/AIChat.vue") }, + { path: 'symptomStatistics', meta: { name: '症状统计', roles: ['admin', 'doctor', 'patient'] }, component: () => import('@/views/manager/SymptomStatistics.vue') }, + { path: 'assessmentReports', meta: { name: '评估报告管理', roles: ['admin'] }, component: () => import('@/views/manager/AssessmentReports.vue') }, + { path: 'patientReports', meta: { name: '患者评估报告', roles: ['doctor'] }, component: () => import('@/views/manager/PatientReports.vue') }, + { path: 'myReports', meta: { name: '我的评估报告', roles: ['patient'] }, component: () => import('@/views/manager/MyReports.vue') }, + { path: 'generateReport', meta: { name: '生成评估报告', roles: ['admin', 'doctor'] }, component: () => import('@/views/manager/GenerateReport.vue') }, + { path: 'reportDetail/:id', meta: { name: '报告详情', roles: ['admin', 'doctor', 'patient'] }, component: () => import('@/views/manager/ReportDetail.vue') }, + { path: 'announcement', meta: { name: '公告管理' }, component: () => import('@/views/manager/Announcement.vue') }, + { path: 'announcementList', meta: { name: '公告列表' }, component: () => import('@/views/manager/AnnouncementList.vue') }, + ] + }, + { path: '/login', component: () => import('@/views/Login.vue') }, + { path: '/register', component: () => import("@/views/Register.vue") }, + { path: '/404', component: () => import('@/views/404.vue') }, + { path: '/manager/chat', name: 'Chat', component: Chat }, + { path: '/:pathMatch(.*)', redirect: '/404', hidden: true } + ] +}) + +export default router diff --git a/vue/src/utils/request.js b/vue/src/utils/request.js new file mode 100644 index 0000000..87a6fd9 --- /dev/null +++ b/vue/src/utils/request.js @@ -0,0 +1,54 @@ +import router from '../router' +import axios from "axios"; +import {ElMessage} from "element-plus"; + +const request = axios.create({ + baseURL: import.meta.env.VITE_BASE_URL, + timeout: 30000 // 后台接口超时时间设置 +}) + +// request 拦截器 +// 可以自请求发送前对请求做一些处理 +request.interceptors.request.use(config => { + config.headers['Content-Type'] = 'application/json;charset=utf-8'; + const user = JSON.parse(localStorage.getItem('xm-user') || '{}') + // console.log(user) + config.headers['token'] = user.token || '' + return config +}, error => { + return Promise.reject(error) +}); + +// response 拦截器 +// 可以在接口响应后统一处理结果 +request.interceptors.response.use( + response => { + let res = response.data; + // 如果是返回的文件 + if (response.config.responseType === 'blob') { + return res + } + // 兼容服务端返回的字符串数据 + if (typeof res === 'string') { + res = res ? JSON.parse(res) : res + } + // 当权限验证不通过的时候给出提示 + if (res.code === '401') { + router.push("/login") + } + return res; + }, + error => { + if (error.response.status === 404) { + ElMessage.error('未找到请求接口') + } else if (error.response.status === 500) { + ElMessage.error('系统异常，请查看后端控制台报错') + } else { + console.error(error.message) + } + return Promise.reject(error) + } +) + + +export default request diff --git a/vue/src/views/404.vue b/vue/src/views/404.vue new file mode 100644 index 0000000..f920543 --- /dev/null +++ b/vue/src/views/404.vue @@ -0,0 +1,28 @@ + + + + + \ No newline at end of file diff --git a/vue/src/views/Login.vue b/vue/src/views/Login.vue new file mode 100644 index 0000000..a8005a9 --- /dev/null +++ b/vue/src/views/Login.vue @@ -0,0 +1,339 @@ + + + + + \ No newline at end of file diff --git a/vue/src/views/Manager.vue b/vue/src/views/Manager.vue new file mode 100644 index 0000000..60ac8a5 --- /dev/null +++ b/vue/src/views/Manager.vue @@ -0,0 +1,408 @@ + + + + + diff --git a/vue/src/views/Register.vue b/vue/src/views/Register.vue new file mode 100644 index 0000000..225270a --- /dev/null +++ b/vue/src/views/Register.vue @@ -0,0 +1,394 @@ + + + + + \ No newline at end of file diff --git a/vue/src/views/manager/AIChat.vue b/vue/src/views/manager/AIChat.vue new file mode 100644 index 0000000..9fa5c97 --- /dev/null +++ b/vue/src/views/manager/AIChat.vue @@ -0,0 +1,430 @@ + + + + + \ No newline at end of file diff --git a/vue/src/views/manager/Admin.vue b/vue/src/views/manager/Admin.vue new file mode 100644 index 0000000..a611861 --- /dev/null +++ b/vue/src/views/manager/Admin.vue @@ -0,0 +1,159 @@ + + + diff --git a/vue/src/views/manager/Announcement.vue b/vue/src/views/manager/Announcement.vue new file mode 100644 index 0000000..7261d23 --- /dev/null +++ b/vue/src/views/manager/Announcement.vue @@ -0,0 +1,248 @@ + + + + + \ No newline at end of file diff --git a/vue/src/views/manager/AnnouncementList.vue b/vue/src/views/manager/AnnouncementList.vue new file mode 100644 index 0000000..138f1e7 --- /dev/null +++ b/vue/src/views/manager/AnnouncementList.vue @@ -0,0 +1,252 @@ + + + + + \ No newline at end of file diff --git a/vue/src/views/manager/AssessmentReports.vue b/vue/src/views/manager/AssessmentReports.vue new file mode 100644 index 0000000..13c2b69 --- /dev/null +++ b/vue/src/views/manager/AssessmentReports.vue @@ -0,0 +1,446 @@ + + + + + \ No newline at end of file diff --git a/vue/src/views/manager/Chat.vue b/vue/src/views/manager/Chat.vue new file mode 100644 index 0000000..144b5ed --- /dev/null +++ b/vue/src/views/manager/Chat.vue @@ -0,0 +1,733 @@ + + + + + \ No newline at end of file diff --git a/vue/src/views/manager/Doctor.vue b/vue/src/views/manager/Doctor.vue new file mode 100644 index 0000000..d08d322 --- /dev/null +++ b/vue/src/views/manager/Doctor.vue @@ -0,0 +1,195 @@ + + + + + \ No newline at end of file diff --git a/vue/src/views/manager/GenerateReport.vue b/vue/src/views/manager/GenerateReport.vue new file mode 100644 index 0000000..e1778d4 --- /dev/null +++ b/vue/src/views/manager/GenerateReport.vue @@ -0,0 +1,232 @@ + + + + + \ No newline at end of file diff --git a/vue/src/views/manager/Home.vue b/vue/src/views/manager/Home.vue new file mode 100644 index 0000000..34f1b36 --- /dev/null +++ b/vue/src/views/manager/Home.vue @@ -0,0 +1,692 @@ + + + + + + diff --git a/vue/src/views/manager/MyReports.vue b/vue/src/views/manager/MyReports.vue new file mode 100644 index 0000000..6bccaa0 --- /dev/null +++ b/vue/src/views/manager/MyReports.vue @@ -0,0 +1,239 @@ + + + + + \ No newline at end of file diff --git a/vue/src/views/manager/MyResources.vue b/vue/src/views/manager/MyResources.vue new file mode 100644 index 0000000..27b474a --- /dev/null +++ b/vue/src/views/manager/MyResources.vue @@ -0,0 +1,438 @@ + + + + + \ No newline at end of file diff --git a/vue/src/views/manager/Password.vue b/vue/src/views/manager/Password.vue new file mode 100644 index 0000000..98d1f49 --- /dev/null +++ b/vue/src/views/manager/Password.vue @@ -0,0 +1,74 @@ + + + diff --git a/vue/src/views/manager/Patient.vue b/vue/src/views/manager/Patient.vue new file mode 100644 index 0000000..45dd667 --- /dev/null +++ b/vue/src/views/manager/Patient.vue @@ -0,0 +1,230 @@ + + + + + \ No newline at end of file diff --git a/vue/src/views/manager/PatientReports.vue b/vue/src/views/manager/PatientReports.vue new file mode 100644 index 0000000..e042b42 --- /dev/null +++ b/vue/src/views/manager/PatientReports.vue @@ -0,0 +1,253 @@ + + + + + \ No newline at end of file diff --git a/vue/src/views/manager/ReportDetail.vue b/vue/src/views/manager/ReportDetail.vue new file mode 100644 index 0000000..67f9165 --- /dev/null +++ b/vue/src/views/manager/ReportDetail.vue @@ -0,0 +1,366 @@ + + + + + \ No newline at end of file diff --git a/vue/src/views/manager/ResourceCategory.vue b/vue/src/views/manager/ResourceCategory.vue new file mode 100644 index 0000000..43fe2b4 --- /dev/null +++ b/vue/src/views/manager/ResourceCategory.vue @@ -0,0 +1,245 @@ + + + + + \ No newline at end of file diff --git a/vue/src/views/manager/ResourceRecommendation.vue b/vue/src/views/manager/ResourceRecommendation.vue new file mode 100644 index 0000000..62d9fd7 --- /dev/null +++ b/vue/src/views/manager/ResourceRecommendation.vue @@ -0,0 +1,496 @@ + + + + + \ No newline at end of file diff --git a/vue/src/views/manager/SymptomRecord.vue b/vue/src/views/manager/SymptomRecord.vue new file mode 100644 index 0000000..3bfd2c4 --- /dev/null +++ b/vue/src/views/manager/SymptomRecord.vue @@ -0,0 +1,490 @@ + + + + + \ No newline at end of file diff --git a/vue/src/views/manager/SymptomStatistics.vue b/vue/src/views/manager/SymptomStatistics.vue new file mode 100644 index 0000000..db9c77e --- /dev/null +++ b/vue/src/views/manager/SymptomStatistics.vue @@ -0,0 +1,641 @@ + + + + + \ No newline at end of file diff --git a/vue/src/views/manager/TreatmentResource.vue b/vue/src/views/manager/TreatmentResource.vue new file mode 100644 index 0000000..670b140 --- /dev/null +++ b/vue/src/views/manager/TreatmentResource.vue @@ -0,0 +1,791 @@ + + + + + \ No newline at end of file diff --git a/vue/src/views/manager/User.vue b/vue/src/views/manager/User.vue new file mode 100644 index 0000000..a2c9fe7 --- /dev/null +++ b/vue/src/views/manager/User.vue @@ -0,0 +1,167 @@ + + + diff --git a/vue/src/views/manager/pAdmin.vue b/vue/src/views/manager/pAdmin.vue new file mode 100644 index 0000000..d7fd47a --- /dev/null +++ b/vue/src/views/manager/pAdmin.vue @@ -0,0 +1,110 @@ + + + + + + + diff --git a/vue/src/views/manager/pDoctor.vue b/vue/src/views/manager/pDoctor.vue new file mode 100644 index 0000000..c343ac3 --- /dev/null +++ b/vue/src/views/manager/pDoctor.vue @@ -0,0 +1,171 @@ + + + + + + + \ No newline at end of file diff --git a/vue/src/views/manager/pPatient.vue b/vue/src/views/manager/pPatient.vue new file mode 100644 index 0000000..b555bc7 --- /dev/null +++ b/vue/src/views/manager/pPatient.vue @@ -0,0 +1,156 @@ + + + + + + + \ No newline at end of file diff --git a/vue/vite.config.js b/vue/vite.config.js new file mode 100644 index 0000000..86023f8 --- /dev/null +++ b/vue/vite.config.js @@ -0,0 +1,103 @@ +import { fileURLToPath, URL } from 'node:url' +import { defineConfig } from 'vite' +import vue from '@vitejs/plugin-vue' +import AutoImport from 'unplugin-auto-import/vite' +import Components from 'unplugin-vue-components/vite' +import { ElementPlusResolver } from 'unplugin-vue-components/resolvers' +import ElementPlus from 'unplugin-element-plus/vite' + +// https://vitejs.dev/config/ +export default defineConfig({ + plugins: [ + vue(), + // 按需定制主题配置 + ElementPlus({ + useSource: true, + }), + AutoImport({ + resolvers: [ElementPlusResolver()], + }), + Components({ + resolvers: [ElementPlusResolver()], + }), + ], + // 预加载项目必需的组件 + optimizeDeps: { + include: [ + "vue", + "vue-router", + "axios", + "path-browserify", + "element-plus/es/components/base/style/css", + "element-plus/es/components/message/style/css", + "element-plus/es/components/message-box/style/css", + "element-plus/es/components/form/style/css", + "element-plus/es/components/form-item/style/css", + "element-plus/es/components/button/style/css", + "element-plus/es/components/input/style/css", + "element-plus/es/components/input-number/style/css", + "element-plus/es/components/switch/style/css", + "element-plus/es/components/upload/style/css", + "element-plus/es/components/menu/style/css", + "element-plus/es/components/col/style/css", + "element-plus/es/components/icon/style/css", + "element-plus/es/components/row/style/css", + "element-plus/es/components/tag/style/css", + "element-plus/es/components/dialog/style/css", + "element-plus/es/components/loading/style/css", + "element-plus/es/components/radio/style/css", + "element-plus/es/components/radio-group/style/css", + "element-plus/es/components/popover/style/css", + "element-plus/es/components/scrollbar/style/css", + "element-plus/es/components/tooltip/style/css", + "element-plus/es/components/dropdown/style/css", + "element-plus/es/components/dropdown-menu/style/css", + "element-plus/es/components/dropdown-item/style/css", + "element-plus/es/components/sub-menu/style/css", + "element-plus/es/components/menu-item/style/css", + "element-plus/es/components/divider/style/css", + "element-plus/es/components/card/style/css", + "element-plus/es/components/link/style/css", + "element-plus/es/components/breadcrumb/style/css", + "element-plus/es/components/breadcrumb-item/style/css", + "element-plus/es/components/table/style/css", + "element-plus/es/components/tree-select/style/css", + "element-plus/es/components/table-column/style/css", + "element-plus/es/components/select/style/css", + "element-plus/es/components/option/style/css", + "element-plus/es/components/pagination/style/css", + "element-plus/es/components/tree/style/css", + "element-plus/es/components/alert/style/css", + "element-plus/es/components/radio-button/style/css", + "element-plus/es/components/checkbox-group/style/css", + "element-plus/es/components/checkbox/style/css", + "element-plus/es/components/tabs/style/css", + "element-plus/es/components/tab-pane/style/css", + "element-plus/es/components/rate/style/css", + "element-plus/es/components/date-picker/style/css", + "element-plus/es/components/notification/style/css", + "element-plus/es/components/image/style/css", + "element-plus/es/components/statistic/style/css", + "element-plus/es/components/watermark/style/css", + "element-plus/es/components/config-provider/style/css", + "element-plus/es/components/text/style/css", + "element-plus/es/components/drawer/style/css", + "element-plus/es/components/color-picker/style/css", + ], + }, + resolve: { + alias: { + '@': fileURLToPath(new URL('./src', import.meta.url)) + } + }, + css: { + preprocessorOptions: { + scss: { + // 自动导入定制化样式文件进行样式覆盖 + additionalData: ` + @use "@/assets/css/index.scss" as *; + `, + } + } + }, +})