“1.2”

client/src/apis/accident.ts

@@ -1,35 +1,57 @@
+// 从 "@/utils" 模块中导入 http 对象，用于发起 HTTP 请求
 import { http } from "@/utils";
+// 从 "@/apis/bookManage" 模块中导入 IPageSearchElderByKey 接口
 import { IPageSearchElderByKey } from "@/apis/bookManage";
 
+// 定义一个名为 IPageAccidentByKey 的接口，用于分页查询事故登记时的数据结构
 interface IPageAccidentByKey {
+  // 老人姓名
   elderName: string;
+  // 护工姓名
   staffName: string;
 }
 
+// 定义一个名为 IAddAccident 的接口，用于新增事故登记时的数据结构
 interface IAddAccident {
+  // 事故登记的 ID
   id: number;
+  // 老人的 ID
   elderId: number;
+  // 护工的 ID
   staffId: number;
+  // 事故发生日期
   occurDate: string;
+  // 事故描述
   description: string;
+  // 事故相关图片
   picture: string;
 }
 
+// 定义一个名为 IGetAccidentById 的接口，用于根据编号获取事故登记时的数据结构
 interface IGetAccidentById {
+  // 事故登记的 ID
   accidentId: string;
 }
 
+// 定义一个名为 IEditAccident 的接口，用于编辑事故登记时的数据结构
 interface IEditAccident {
+  // 事故登记的 ID
   id: number;
+  // 姓名
   name: string;
+  // 电话号码
   phone: string;
+  // 关系
   relation: string;
+  // 事故日期字符串
   accidentDateStr: string;
+  // 事故编号
   accidentNum: number;
 }
 
-// 分页查询事故登记
+// 定义一个异步函数 pageAccidentByKey，用于分页查询事故登记
 export async function pageAccidentByKey(data: IPageAccidentByKey) {
+  // 使用 http 对象发起 GET 请求，请求路径为 "/api/accident/pageAccidentByKey"，并将 data 对象展开作为请求参数
   return http.get("/api/accident/pageAccidentByKey", {
     params: {
       ...data
@@ -37,8 +59,9 @@ export async function pageAccidentByKey(data: IPageAccidentByKey) {
   });
 }
 
-// 分页搜索老人
+// 定义一个异步函数 pageSearchElderByKey，用于分页搜索老人
 export async function pageSearchElderByKey(data: IPageSearchElderByKey) {
+  // 使用 http 对象发起 GET 请求，请求路径为 "/api/accident/pageSearchElderByKey"，并将 data 对象展开作为请求参数
   return http.get("/api/accident/pageSearchElderByKey", {
     params: {
       ...data
@@ -46,18 +69,21 @@ export async function pageSearchElderByKey(data: IPageSearchElderByKey) {
   });
 }
 
-// 获取护工列表
+// 定义一个异步函数 listAccidentStaff，用于获取护工列表
 export async function listAccidentStaff() {
+  // 使用 http 对象发起 GET 请求，请求路径为 "/api/accident/listAccidentStaff"
   return http.get("/api/accident/listAccidentStaff");
 }
 
-// 新增事故登记
+// 定义一个函数 addAccident，用于新增事故登记
 export function addAccident(data: IAddAccident) {
+  // 使用 http 对象发起 POST 请求，请求路径为 "/api/accident/addAccident"，并将 data 对象作为请求体
   return http.post("/api/accident/addAccident", data);
 }
 
-// 根据编号获取事故登记
+// 定义一个异步函数 getAccidentById，用于根据编号获取事故登记
 export async function getAccidentById(data: IGetAccidentById) {
+  // 使用 http 对象发起 GET 请求，请求路径为 "/api/accident/getAccidentById"，并将 data 对象展开作为请求参数
   return http.get("/api/accident/getAccidentById", {
     params: {
       ...data
@@ -65,13 +91,15 @@ export async function getAccidentById(data: IGetAccidentById) {
   });
 }
 
-// 编辑事故登记
+// 定义一个函数 editAccident，用于编辑事故登记
 export function editAccident(data: IEditAccident) {
+  // 使用 http 对象发起 PUT 请求，请求路径为 "/api/accident/editAccident"，并将 data 对象作为请求体
   return http.put("/api/accident/editAccident", data);
 }
 
-// 删除事故登记
+// 定义一个异步函数 deleteAccident，用于删除事故登记
 export async function deleteAccident(data: IGetAccidentById) {
+  // 使用 http 对象发起 DELETE 请求，请求路径为 "/api/accident/deleteAccident"，并将 data 对象展开作为请求参数
   return http.delete("/api/accident/deleteAccident", {
     params: {
       ...data

client/src/apis/depositRecharge.ts

@@ -1,24 +1,47 @@
+// 从 "@/utils" 模块导入名为 http 的对象，
+// 推测该对象是用于发起 HTTP 请求的工具，可能是对 axios 等请求库的封装
 import { http } from "@/utils";
+
+// 从 "@/apis/bookManage" 模块导入 IPageSearchElderByKey 接口，
+// 用于描述分页搜索老人时的请求参数结构
 import { IPageSearchElderByKey } from "@/apis/bookManage";
 
+// 定义一个接口 IPageDepositRechargeByKey，用于描述分页查询预存充值时的请求参数结构
 interface IPageDepositRechargeByKey {
+  // 身份证号码，用于筛选预存充值记录，类型为字符串
   idNum: string;
+  // 姓名，用于筛选预存充值记录，类型为字符串
   name: string;
+  // 老人姓名，用于筛选预存充值记录，类型为字符串
   elderName: string;
+  // 电话，用于筛选预存充值记录，类型为字符串
   phone: string;
+  // 老人电话，用于筛选预存充值记录，类型为字符串
   elderPhone: string;
 }
 
+// 定义一个接口 IRecharge，用于描述入住老人账户充值时的请求参数结构
 interface IRecharge {
+  // 老人 ID，用于指定要充值的老人账户，类型为字符串
   elderId: string;
+  // 充值金额，用于指定充值的金额，类型为字符串
   amount: string;
 }
 
-// 分页查询预存充值
+/**
+ * 定义一个异步函数 pageDepositRechargeByKey，用于分页查询预存充值记录
+ * @param data - 一个符合 IPageDepositRechargeByKey 接口的对象，包含查询所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是分页查询预存充值记录的响应结果
+ */
 export async function pageDepositRechargeByKey(data: IPageDepositRechargeByKey) {
-  // 因为后台返回的字段与前端表单数据的prop不一样，但是组件封装是需要一样的，所以请求前增加一些这两个字段
-  Reflect.has(data, 'elderName') ? (data.name = data.elderName) : ''
-  Reflect.has(data, 'elderPhone') ? (data.phone = data.elderPhone) : ''
+  // 因为后台返回的字段与前端表单数据的 prop 不一样，
+  // 但是组件封装需要一样，所以请求前增加一些这两个字段
+  // 如果 data 对象中有 'elderName' 字段，则将其值赋给 'name' 字段
+  Reflect.has(data, 'elderName')? (data.name = data.elderName) : '';
+  // 如果 data 对象中有 'elderPhone' 字段，则将其值赋给 'phone' 字段
+  Reflect.has(data, 'elderPhone')? (data.phone = data.elderPhone) : '';
+  // 使用导入的 http 对象发起 GET 请求，请求地址为 "/api/depositRecharge/pageDepositRechargeByKey"
+  // 将处理后的 data 对象展开作为请求的参数
   return http.get("/api/depositRecharge/pageDepositRechargeByKey", {
     params: {
       ...data
@@ -26,16 +49,28 @@ export async function pageDepositRechargeByKey(data: IPageDepositRechargeByKey)
   });
 }
 
-// 分页搜索老人
+/**
+ * 定义一个函数 pageSearchElderByKey，用于分页搜索老人
+ * @param data - 一个符合 IPageSearchElderByKey 接口的对象，包含搜索所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是分页搜索老人的响应结果
+ */
 export function pageSearchElderByKey(data: IPageSearchElderByKey) {
+  // 使用导入的 http 对象发起 GET 请求，请求地址为 "/api/depositRecharge/pageSearchElderByKey"
+  // 将 data 对象展开作为请求的参数
   return http.get('/api/depositRecharge/pageSearchElderByKey', {
     params: {
       ...data
     }
-  })
+  });
 }
 
-// 入住老人账户充值
+/**
+ * 定义一个函数 recharge，用于入住老人账户充值
+ * @param data - 一个符合 IRecharge 接口的对象，包含充值所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是入住老人账户充值操作的响应结果
+ */
 export function recharge(data: IRecharge) {
+  // 使用导入的 http 对象发起 PUT 请求，请求地址为 "/api/depositRecharge/recharge"
+  // 将 data 对象作为请求的主体
   return http.put("/api/depositRecharge/recharge", data);
 }

client/src/apis/elderRecord.ts

@@ -1,43 +1,72 @@
+// 从 "@/utils" 模块导入名为 http 的对象，该对象可能是对 HTTP 请求库（如 axios）的封装，用于发起各种 HTTP 请求
 import { http } from "@/utils";
 
+// 定义一个接口 IPageElderByKey，用于描述分页查询员工（这里可能是长者相关，名称可能有误）时的请求参数结构
 interface IPageElderByKey {
+  // 姓名，用于筛选，类型为字符串
   name: string;
+  // 长者姓名，用于筛选，类型为字符串
   elderName: string;
+  // 身份证号码，用于筛选，类型为字符串
   idNum: string;
+  // 性别，用于筛选，类型为字符串
   sex: string;
+  // 长者性别，用于筛选，类型为字符串
   elderSex: string;
 }
 
+// 定义一个接口 IGetElderById，用于描述根据编号获取长者信息时的请求参数结构
 interface IGetElderById {
+  // 长者 ID，类型为字符串
   elderId: string;
 }
 
+// 定义一个接口 IEditElder，用于描述编辑长者信息时的数据结构
 interface IEditElder {
+  // 长者 ID，类型为数字
   id: number;
+  // 姓名，类型为字符串
   name: string;
+  // 身份证号码，类型为字符串
   idNum: string;
+  // 年龄，类型为数字
   age: number;
+  // 性别，类型为字符串
   sex: string;
+  // 电话号码，类型为字符串
   phone: string;
+  // 地址，类型为字符串
   address: string;
 }
 
-// 性别
+// 定义一个名为 sexList 的常量，是一个包含性别选项的数组，每个选项有标签和对应的值
 export const sexList = [
   { label: "男", value: "男" },
   { label: "女", value: "女" }
 ];
 
-// 导出excel
+/**
+ * 定义一个函数 exportExcel，用于导出 Excel 文件
+ * @returns 一个 Promise 对象，解析后得到的是导出 Excel 文件操作的响应结果
+ */
 export function exportExcel() {
+  // 使用导入的 http 对象发起 GET 请求，请求地址为 "/api/elderRecord/exportExcel"
   return http.get("/api/elderRecord/exportExcel");
 }
 
-// 分页查询员工
+/**
+ * 定义一个异步函数 pageElderByKey，用于分页查询员工（长者）
+ * @param data - 一个符合 IPageElderByKey 接口的对象，包含分页查询所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是分页查询的响应结果
+ */
 export async function pageElderByKey(data: IPageElderByKey) {
   // 因为后台返回的字段与前端表单数据的 prop 不一样，但是组件封装是需要一样的，所以请求前增加一些这两个字段
+  // 如果 data 对象中有 "sex" 字段，则将其值赋给 "elderSex" 字段
   Reflect.has(data, "sex")? (data.elderSex = data.sex) : "";
+  // 如果 data 对象中有 "name" 字段，则将其值赋给 "elderName" 字段
   Reflect.has(data, "name")? (data.elderName = data.name) : "";
+  // 使用导入的 http 对象发起 GET 请求，请求地址为 "/api/elderRecord/pageElderByKey"
+  // 将处理后的 data 对象展开作为请求的参数
   return http.get("/api/elderRecord/pageElderByKey", {
     params: {
       ...data
@@ -45,8 +74,14 @@ export async function pageElderByKey(data: IPageElderByKey) {
   });
 }
 
-// 根据编号获取长者信息
+/**
+ * 定义一个异步函数 getElderById，用于根据编号获取长者信息
+ * @param data - 一个符合 IGetElderById 接口的对象，包含根据编号获取长者信息所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是根据编号获取长者信息的响应结果
+ */
 export async function getElderById(data: IGetElderById) {
+  // 使用导入的 http 对象发起 GET 请求，请求地址为 "/api/elderRecord/getElderById"
+  // 将 data 对象展开作为请求的参数
   return http.get("/api/elderRecord/getElderById", {
     params: {
       ...data
@@ -54,8 +89,14 @@ export async function getElderById(data: IGetElderById) {
   });
 }
 
-// 根据编号获取长者档案
+/**
+ * 定义一个异步函数 getElderRecordById，用于根据编号获取长者档案
+ * @param data - 一个符合 IGetElderById 接口的对象，包含根据编号获取长者档案所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是根据编号获取长者档案的响应结果
+ */
 export async function getElderRecordById(data: IGetElderById) {
+  // 使用导入的 http 对象发起 GET 请求，请求地址为 "/api/elderRecord/getElderRecordById"
+  // 将 data 对象展开作为请求的参数
   return http.get("/api/elderRecord/getElderRecordById", {
     params: {
       ...data
@@ -63,13 +104,25 @@ export async function getElderRecordById(data: IGetElderById) {
   });
 }
 
-// 编辑长者
+/**
+ * 定义一个函数 editElder，用于编辑长者信息
+ * @param data - 一个符合 IEditElder 接口的对象，包含编辑长者信息所需的数据
+ * @returns 一个 Promise 对象，解析后得到的是编辑长者信息操作的响应结果
+ */
 export function editElder(data: IEditElder) {
+  // 使用导入的 http 对象发起 PUT 请求，请求地址为 "/api/elderRecord/editElder"
+  // 将 data 对象作为请求的主体
   return http.put("/api/elderRecord/editElder", data);
 }
 
-// 删除长者
+/**
+ * 定义一个异步函数 deleteElder，用于删除长者
+ * @param data - 一个符合 IGetElderById 接口的对象，包含删除长者所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是删除长者操作的响应结果
+ */
 export async function deleteElder(data: IGetElderById) {
+  // 使用导入的 http 对象发起 DELETE 请求，请求地址为 "/api/elderRecord/deleteElder"
+  // 将 data 对象展开作为请求的参数
   return http.delete("/api/elderRecord/deleteElder", {
     params: {
       ...data

client/src/apis/nurseGrade.ts

@@ -1,37 +1,64 @@
+// 从 "@/utils" 模块导入名为 http 的对象，
+// 推测该对象是用于发起 HTTP 请求的工具，可能是对 axios 等请求库的封装
 import { http } from "@/utils";
+
+// 从 "@/apis/service" 模块导入 IPageServiceByKey 接口，
+// 用于描述分页查询服务时的请求参数结构
 import { IPageServiceByKey } from "@/apis/service";
 
+// 定义一个接口 IPageNurseGradeByKey，用于描述分页查询护理等级时的请求参数结构
 interface IPageNurseGradeByKey {
+  // 名称，用于筛选护理等级，类型为字符串
   name: string;
+  // 护理等级名称，用于筛选护理等级，类型为字符串
   gradeName: string;
+  // 类型，用于筛选护理等级，类型为字符串
   type: string;
+  // 护理类型，用于筛选护理等级，类型为字符串
   nurseType: string;
 }
 
+// 定义一个接口 IAddNurseGrade，用于描述新增护理等级时的数据结构
 interface IAddNurseGrade {
+  // 护理等级的 ID，类型为数字
   id: number;
+  // 护理等级的名称，类型为字符串
   name: string;
+  // 护理等级的类型，类型为字符串
   type: string;
+  // 护理等级的月价格，类型为数字
   monthPrice: number;
+  // 服务 ID 列表，类型为 any，需根据实际情况调整
   serviceIdList: any;
 }
 
+// 定义一个接口 IGetNurseGradeById，用于描述根据编号查询护理等级时的请求参数结构
 interface IGetNurseGradeById {
-  nurseGradeId: string
+  // 护理等级 ID，类型为字符串
+  nurseGradeId: string;
 }
 
-// 护理类型
+// 定义一个名为 INurseTypeList 的常量，是一个包含护理类型选项的数组，每个选项有标签和对应的值
 export const INurseTypeList = [
   { label: "自理", value: "自理" },
   { label: "介护", value: "介护" },
   { label: "全护", value: "全护" }
 ];
 
-// 分页查询护理等级
+/**
+ * 定义一个异步函数 pageNurseGradeByKey，用于分页查询护理等级
+ * @param data - 一个符合 IPageNurseGradeByKey 接口的对象，包含分页查询所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是分页查询护理等级的响应结果
+ */
 export async function pageNurseGradeByKey(data: IPageNurseGradeByKey) {
-  // 因为后台返回的字段与前端表单数据的prop不一样，但是组件封装是需要一样的，所以请求前增加一些这两个字段
-  Reflect.has(data, 'name') ? (data.gradeName = data.name) : ''
-  Reflect.has(data, 'type') ? (data.nurseType = data.type) : ''
+  // 因为后台返回的字段与前端表单数据的 prop 不一样，
+  // 但是组件封装需要一样，所以请求前增加一些这两个字段
+  // 如果 data 对象中有 'name' 字段，则将其值赋给 'gradeName' 字段
+  Reflect.has(data, 'name')? (data.gradeName = data.name) : '';
+  // 如果 data 对象中有 'type' 字段，则将其值赋给 'nurseType' 字段
+  Reflect.has(data, 'type')? (data.nurseType = data.type) : '';
+  // 使用导入的 http 对象发起 GET 请求，请求地址为 "/api/nurseGrade/pageNurseGradeByKey"
+  // 将处理后的 data 对象展开作为请求的参数
   return http.get("/api/nurseGrade/pageNurseGradeByKey", {
     params: {
       ...data
@@ -39,13 +66,23 @@ export async function pageNurseGradeByKey(data: IPageNurseGradeByKey) {
   });
 }
 
-// 获取服务类型
+/**
+ * 定义一个函数 listServiceType，用于获取服务类型
+ * @returns 一个 Promise 对象，解析后得到的是获取服务类型的响应结果
+ */
 export function listServiceType() {
+  // 使用导入的 http 对象发起 POST 请求，请求地址为 "/api/nurseGrade/listServiceType"
   return http.post("/api/nurseGrade/listServiceType");
 }
 
-// 分页查询服务
+/**
+ * 定义一个异步函数 pageServiceByKey，用于分页查询服务
+ * @param data - 一个符合 IPageServiceByKey 接口的对象，包含分页查询所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是分页查询服务的响应结果
+ */
 export async function pageServiceByKey(data: IPageServiceByKey) {
+  // 使用导入的 http 对象发起 GET 请求，请求地址为 "/api/nurseGrade/pageServiceByKey"
+  // 将 data 对象展开作为请求的参数
   return http.get("/api/nurseGrade/pageServiceByKey", {
     params: {
       ...data
@@ -53,13 +90,25 @@ export async function pageServiceByKey(data: IPageServiceByKey) {
   });
 }
 
-// 新增护理等级
+/**
+ * 定义一个函数 addNurseGrade，用于新增护理等级
+ * @param data - 一个符合 IAddNurseGrade 接口的对象，包含新增护理等级所需的数据
+ * @returns 一个 Promise 对象，解析后得到的是新增护理等级操作的响应结果
+ */
 export function addNurseGrade(data: IAddNurseGrade) {
+  // 使用导入的 http 对象发起 POST 请求，请求地址为 "/api/nurseGrade/addNurseGrade"
+  // 将 data 对象作为请求的主体
   return http.post("/api/nurseGrade/addNurseGrade", data);
 }
 
-// 根据编号查询护理等级
+/**
+ * 定义一个异步函数 getNurseGradeById，用于根据编号查询护理等级
+ * @param data - 一个符合 IGetNurseGradeById 接口的对象，包含根据编号查询护理等级所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是根据编号查询护理等级的响应结果
+ */
 export async function getNurseGradeById(data: IGetNurseGradeById) {
+  // 使用导入的 http 对象发起 GET 请求，请求地址为 "/api/nurseGrade/getNurseGradeById"
+  // 将 data 对象展开作为请求的参数
   return http.get("/api/nurseGrade/getNurseGradeById", {
     params: {
       ...data
@@ -67,13 +116,25 @@ export async function getNurseGradeById(data: IGetNurseGradeById) {
   });
 }
 
-// 编辑护理等级
+/**
+ * 定义一个函数 editNurseGrade，用于编辑护理等级
+ * @param data - 一个符合 IAddNurseGrade 接口的对象，包含编辑护理等级所需的数据
+ * @returns 一个 Promise 对象，解析后得到的是编辑护理等级操作的响应结果
+ */
 export function editNurseGrade(data: IAddNurseGrade) {
+  // 使用导入的 http 对象发起 PUT 请求，请求地址为 "/api/nurseGrade/editNurseGrade"
+  // 将 data 对象作为请求的主体
   return http.put("/api/nurseGrade/editNurseGrade", data);
 }
 
-// 删除护理等级
+/**
+ * 定义一个异步函数 deleteNurseGrade，用于删除护理等级
+ * @param data - 一个符合 IGetNurseGradeById 接口的对象，包含删除护理等级所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是删除护理等级操作的响应结果
+ */
 export async function deleteNurseGrade(data: IGetNurseGradeById) {
+  // 使用导入的 http 对象发起 DELETE 请求，请求地址为 "/api/nurseGrade/deleteNurseGrade"
+  // 将 data 对象展开作为请求的参数
   return http.delete("/api/nurseGrade/deleteNurseGrade", {
     params: {
       ...data

client/src/apis/nurseReserve.ts

@@ -1,34 +1,64 @@
+// 从 "@/utils" 模块导入名为 http 的对象，
+// 推测该对象是用于发起 HTTP 请求的工具，可能是对 axios 等请求库的封装
 import { http } from "@/utils";
+// 从 "@/apis/bookManage" 模块导入 IPageSearchElderByKey 接口，
+// 用于描述分页搜索老人时的请求参数结构
 import { IPageSearchElderByKey } from "@/apis/bookManage";
+// 从 "@/apis/service" 模块导入 IGetServiceById 接口，
+// 用于描述根据编号查询服务时的请求参数结构
 import { IGetServiceById } from "@/apis/service";
 
+// 定义一个接口 IPageNurseReserveByKey，用于描述分页查询护理预定时的请求参数结构
 interface IPageNurseReserveByKey {
+  // 床位名称，用于筛选护理预定记录，类型为字符串
   bedName: string;
+  // 老人姓名，用于筛选护理预定记录，类型为字符串
   elderName: string;
+  // 服务名称，用于筛选护理预定记录，类型为字符串
   serviceName: string;
 }
 
+// 定义一个接口 IAddNurseReserve，用于描述新增护理预定时的数据结构
 interface IAddNurseReserve {
+  // 老人 ID，类型为数字
   elderId: number;
+  // 服务名称，类型为字符串
   serviceName: string;
+  // 需要服务的日期（这里推测为时间戳等能表示日期的值，类型为数字）
   needDate: number;
+  // 服务价格，类型为数字
   servicePrice: number;
+  // 收费方式，类型为字符串
   chargeMethod: string;
+  // 频率，类型为数字
   frequency: number;
+  // 支付金额，类型为数字
   payAmount: number;
 }
 
+// 定义一个接口 IExecuteNurseReserve，用于描述执行护理预定时的数据结构
 interface IExecuteNurseReserve {
+  // 护理预定的 ID，类型为数字
   id: number;
+  // 护理日期，类型为字符串
   nurseDate: string;
+  // 护理人员 ID，类型为字符串
   staffId: string;
 }
 
-// 分页查询护理预定
+/**
+ * 定义一个异步函数 pageNurseReserveByKey，用于分页查询护理预定
+ * @param data - 一个符合 IPageNurseReserveByKey 接口的对象，包含分页查询所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是分页查询护理预定的响应结果
+ */
 export async function pageNurseReserveByKey(data: IPageNurseReserveByKey) {
-  // 因为后台返回的字段与前端表单数据的prop不一样，但是组件封装是需要一样的，所以请求前增加一些这两个字段
+  // 因为后台返回的字段与前端表单数据的 prop 不一样，
+  // 但是组件封装需要一样，所以原本计划请求前处理某些字段，
+  // 但这里代码被注释掉了，可能是暂不处理或有其他调整
   // Reflect.has(data, 'name')? (data.gradeName = data.name) : ''
   // Reflect.has(data, 'type')? (data.nurseType = data.type) : ''
+  // 使用导入的 http 对象发起 GET 请求，请求地址为 "/api/nurseReserve/pageNurseReserveByKey"
+  // 将 data 对象展开作为请求的参数
   return http.get("/api/nurseReserve/pageNurseReserveByKey", {
     params: {
       ...data
@@ -36,27 +66,49 @@ export async function pageNurseReserveByKey(data: IPageNurseReserveByKey) {
   });
 }
 
-// 分页搜索老人
+/**
+ * 定义一个函数 pageSearchElderByKey，用于分页搜索老人
+ * @param data - 一个符合 IPageSearchElderByKey 接口的对象，包含搜索所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是分页搜索老人的响应结果
+ */
 export function pageSearchElderByKey(data: IPageSearchElderByKey) {
+  // 使用导入的 http 对象发起 GET 请求，请求地址为 "/api/nurseReserve/pageSearchElderByKey"
+  // 将 data 对象展开作为请求的参数
   return http.get('/api/nurseReserve/pageSearchElderByKey', {
     params: {
       ...data
     }
-  })
+  });
 }
 
-// 获取服务项目
+/**
+ * 定义一个异步函数 listService，用于获取服务项目
+ * @returns 一个 Promise 对象，解析后得到的是获取服务项目的响应结果
+ */
 export async function listService() {
+  // 使用导入的 http 对象发起 GET 请求，请求地址为 "/api/nurseReserve/listService"
   return http.get("/api/nurseReserve/listService");
 }
 
-// 新增护理预定
+/**
+ * 定义一个函数 addNurseReserve，用于新增护理预定
+ * @param data - 一个符合 IAddNurseReserve 接口的对象，包含新增护理预定所需的数据
+ * @returns 一个 Promise 对象，解析后得到的是新增护理预定操作的响应结果
+ */
 export function addNurseReserve(data: IAddNurseReserve) {
+  // 使用导入的 http 对象发起 POST 请求，请求地址为 "/api/nurseReserve/addNurseReserve"
+  // 将 data 对象作为请求的主体
   return http.post("/api/nurseReserve/addNurseReserve", data);
 }
 
-// 根据编号查询护理预定
+/**
+ * 定义一个异步函数 getServiceById，用于根据编号查询服务（这里实际是护理预定相关服务）
+ * @param data - 一个符合 IGetServiceById 接口的对象，包含根据编号查询服务所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是根据编号查询服务的响应结果
+ */
 export async function getServiceById(data: IGetServiceById) {
+  // 使用导入的 http 对象发起 GET 请求，请求地址为 "/api/nurseReserve/getServiceById"
+  // 将 data 对象展开作为请求的参数
   return http.get("/api/nurseReserve/getServiceById", {
     params: {
       ...data
@@ -64,12 +116,22 @@ export async function getServiceById(data: IGetServiceById) {
   });
 }
 
-// 护理人员
+/**
+ * 定义一个异步函数 listNurseStaff，用于获取护理人员列表
+ * @returns 一个 Promise 对象，解析后得到的是获取护理人员列表的响应结果
+ */
 export async function listNurseStaff() {
+  // 使用导入的 http 对象发起 GET 请求，请求地址为 "/api/nurseReserve/listNurseStaff"
   return http.get("/api/nurseReserve/listNurseStaff");
 }
 
-// 执行护理预定
+/**
+ * 定义一个函数 executeNurseReserve，用于执行护理预定
+ * @param data - 一个符合 IExecuteNurseReserve 接口的对象，包含执行护理预定所需的数据
+ * @returns 一个 Promise 对象，解析后得到的是执行护理预定操作的响应结果
+ */
 export function executeNurseReserve(data: IExecuteNurseReserve) {
+  // 使用导入的 http 对象发起 PUT 请求，请求地址为 "/api/nurseReserve/executeNurseReserve"
+  // 将 data 对象作为请求的主体
   return http.put("/api/nurseReserve/executeNurseReserve", data);
 }

client/src/apis/outward.ts

@@ -1,48 +1,77 @@
+// 从 "@/utils" 模块导入名为 http 的对象，该对象可用于发起 HTTP 请求，可能是对 axios 等请求库的封装
 import { http } from "@/utils";
+// 从 "@/apis/bookManage" 模块导入 IPageSearchElderByKey 接口，此接口用于定义分页搜索老人时的请求参数结构
 import { IPageSearchElderByKey } from "@/apis/bookManage";
 
+// 定义 IPageOutwardByKey 接口，用于描述分页查询外出登记时的请求参数结构
 interface IPageOutwardByKey {
+  // 老人姓名，用于筛选外出登记记录，类型为字符串
   elderName: string;
+  // 陪同人类型，用于筛选外出登记记录，类型为字符串
   chaperoneType: string;
+  // 外出开始时间，用于筛选外出登记记录，类型为字符串
   startTime: string;
+  // 外出结束时间，用于筛选外出登记记录，类型为字符串
   endTime: string;
 }
 
+// 定义 IListContactByElderId 接口，用于描述根据老人 ID 获取紧急联系人列表时的请求参数结构
 interface IListContactByElderId {
+  // 老人 ID，类型为字符串
   elderId: string;
 }
 
+// 定义 IAddOutward 接口，用于描述新增外出登记时的数据结构
 interface IAddOutward {
+  // 老人 ID，类型为数字
   elderId: number;
+  // 陪同人姓名，类型为字符串
   chaperoneName: string;
+  // 陪同人电话，类型为字符串
   chaperonePhone: string;
+  // 陪同人类型，类型为字符串
   chaperoneType: string;
+  // 外出日期，类型为字符串
   outwardDate: string;
+  // 计划返回日期，类型为字符串
   planReturnDate: string;
 }
 
+// 定义 IGetOutwardById 接口，用于描述根据编号获取外出登记时的请求参数结构
 interface IGetOutwardById {
+  // 外出登记 ID，类型为字符串
   outwardId: string;
 }
 
+// 定义 IDelayReturn 接口，用于描述延期返回操作时的数据结构
 interface IDelayReturn {
+  // 外出登记 ID，类型为字符串
   id: string;
+  // 新的计划返回日期，类型为字符串
   planReturnDate: string;
 }
 
+// 定义 IRecordReturn 接口，用于描述登记返回操作时的数据结构
 interface IRecordReturn {
+  // 外出登记 ID，类型为字符串
   id: string;
+  // 实际返回日期，类型为 any，具体类型需根据实际情况确定
   realReturnDate: any;
 }
 
-// 陪同人类型
+// 定义一个常量 typeList，包含陪同人类型的选项，每个选项有标签和对应的值
 export const typeList = [
   { label: "护工", value: "护工" },
   { label: "家属", value: "家属" }
 ];
 
-// 分页查询外出登记
+/**
+ * 定义一个异步函数 pageOutwardByKey，用于分页查询外出登记
+ * @param data - 一个符合 IPageOutwardByKey 接口的对象，包含分页查询所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是分页查询外出登记的响应结果
+ */
 export async function pageOutwardByKey(data: IPageOutwardByKey) {
+  // 使用 http 对象发起 GET 请求，请求地址为 "/api/outward/pageOutwardByKey"，并将 data 对象展开作为请求参数
   return http.get("/api/outward/pageOutwardByKey", {
     params: {
       ...data
@@ -50,8 +79,13 @@ export async function pageOutwardByKey(data: IPageOutwardByKey) {
   });
 }
 
-// 分页搜索老人
+/**
+ * 定义一个异步函数 pageSearchElderByKey，用于分页搜索老人
+ * @param data - 一个符合 IPageSearchElderByKey 接口的对象，包含搜索所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是分页搜索老人的响应结果
+ */
 export async function pageSearchElderByKey(data: IPageSearchElderByKey) {
+  // 使用 http 对象发起 GET 请求，请求地址为 "/api/outward/pageSearchElderByKey"，并将 data 对象展开作为请求参数
   return http.get("/api/outward/pageSearchElderByKey", {
     params: {
       ...data
@@ -59,13 +93,22 @@ export async function pageSearchElderByKey(data: IPageSearchElderByKey) {
   });
 }
 
-// 获取护工列表
+/**
+ * 定义一个异步函数 listOutwardStaff，用于获取护工列表
+ * @returns 一个 Promise 对象，解析后得到的是获取护工列表的响应结果
+ */
 export async function listOutwardStaff() {
+  // 使用 http 对象发起 GET 请求，请求地址为 "/api/outward/listOutwardStaff"
   return http.get("/api/outward/listOutwardStaff");
 }
 
-// 获取紧急联系人列表
+/**
+ * 定义一个异步函数 listContactByElderId，用于根据老人 ID 获取紧急联系人列表
+ * @param data - 一个符合 IListContactByElderId 接口的对象，包含所需的老人 ID
+ * @returns 一个 Promise 对象，解析后得到的是获取紧急联系人列表的响应结果
+ */
 export async function listContactByElderId(data: IListContactByElderId) {
+  // 使用 http 对象发起 GET 请求，请求地址为 "/api/outward/listContactByElderId"，并将 data 对象展开作为请求参数
   return http.get("/api/outward/listContactByElderId", {
     params: {
       ...data
@@ -73,13 +116,23 @@ export async function listContactByElderId(data: IListContactByElderId) {
   });
 }
 
-// 新增外出登记
+/**
+ * 定义一个函数 addOutward，用于新增外出登记
+ * @param data - 一个符合 IAddOutward 接口的对象，包含新增外出登记所需的数据
+ * @returns 一个 Promise 对象，解析后得到的是新增外出登记操作的响应结果
+ */
 export function addOutward(data: IAddOutward) {
+  // 使用 http 对象发起 POST 请求，请求地址为 "/api/outward/addOutward"，并将 data 对象作为请求体
   return http.post("/api/outward/addOutward", data);
 }
 
-// 根据编号获取外出登记
+/**
+ * 定义一个异步函数 getOutwardById，用于根据编号获取外出登记
+ * @param data - 一个符合 IGetOutwardById 接口的对象，包含所需的外出登记 ID
+ * @returns 一个 Promise 对象，解析后得到的是根据编号获取外出登记的响应结果
+ */
 export async function getOutwardById(data: IGetOutwardById) {
+  // 使用 http 对象发起 GET 请求，请求地址为 "/api/outward/getOutwardById"，并将 data 对象展开作为请求参数
   return http.get("/api/outward/getOutwardById", {
     params: {
       ...data
@@ -87,18 +140,33 @@ export async function getOutwardById(data: IGetOutwardById) {
   });
 }
 
-// 延期返回
+/**
+ * 定义一个函数 delayReturn，用于处理延期返回操作
+ * @param data - 一个符合 IDelayReturn 接口的对象，包含延期返回所需的数据
+ * @returns 一个 Promise 对象，解析后得到的是延期返回操作的响应结果
+ */
 export function delayReturn(data: IDelayReturn) {
+  // 使用 http 对象发起 PUT 请求，请求地址为 "/api/outward/delayReturn"，并将 data 对象作为请求体
   return http.put("/api/outward/delayReturn", data);
 }
 
-// 登记返回
+/**
+ * 定义一个函数 recordReturn，用于处理登记返回操作
+ * @param data - 一个符合 IRecordReturn 接口的对象，包含登记返回所需的数据
+ * @returns 一个 Promise 对象，解析后得到的是登记返回操作的响应结果
+ */
 export function recordReturn(data: IRecordReturn) {
+  // 使用 http 对象发起 PUT 请求，请求地址为 "/api/outward/recordReturn"，并将 data 对象作为请求体
   return http.put("/api/outward/recordReturn", data);
 }
 
-// 删除外出登记
+/**
+ * 定义一个异步函数 deleteOutward，用于删除外出登记
+ * @param data - 一个符合 IGetOutwardById 接口的对象，包含要删除的外出登记 ID
+ * @returns 一个 Promise 对象，解析后得到的是删除外出登记操作的响应结果
+ */
 export async function deleteOutward(data: IGetOutwardById) {
+  // 使用 http 对象发起 DELETE 请求，请求地址为 "/api/outward/deleteOutward"，并将 data 对象展开作为请求参数
   return http.delete("/api/outward/deleteOutward", {
     params: {
       ...data

client/src/apis/retreatApply.ts

@@ -1,19 +1,37 @@
+// 从 "@/utils" 模块导入名为 http 的对象，
+// 推测该对象是用于发起 HTTP 请求的工具，可能是对 axios 等请求库的封装
 import { http } from "@/utils";
+
+// 从 "@/apis/bookManage" 模块导入 IPageSearchElderByKey 接口，
+// 用于描述分页搜索老人时的请求参数结构
 import { IPageSearchElderByKey } from "@/apis/bookManage";
 
+// 定义一个接口 IPageRetreatApplyByKey，用于描述分页查询退住申请时的请求参数结构
 interface IPageRetreatApplyByKey {
+  // 床位名称，用于筛选退住申请记录，类型为字符串
   bedName: string;
+  // 老人姓名，用于筛选退住申请记录，类型为字符串
   elderName: string;
+  // 老人性别，用于筛选退住申请记录，类型为字符串
   elderSex: string;
+  // 身份证号码，用于筛选退住申请记录，类型为字符串
   idNum: string;
 }
 
+// 定义一个接口 IAddRetreatApply，用于描述新增退住申请时的数据结构
 interface IAddRetreatApply {
+  // 老人 ID，类型为数字，用于标识发起退住申请的老人
   elderId: number;
 }
 
-// 分页查询退住申请
+/**
+ * 定义一个异步函数 pageRetreatApplyByKey，用于分页查询退住申请
+ * @param data - 一个符合 IPageRetreatApplyByKey 接口的对象，包含分页查询所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是分页查询退住申请的响应结果
+ */
 export async function pageRetreatApplyByKey(data: IPageRetreatApplyByKey) {
+  // 使用导入的 http 对象发起 GET 请求，请求地址为 "/api/retreatApply/pageRetreatApplyByKey"
+  // 将 data 对象展开作为请求的参数
   return http.get("/api/retreatApply/pageRetreatApplyByKey", {
     params: {
       ...data
@@ -21,8 +39,14 @@ export async function pageRetreatApplyByKey(data: IPageRetreatApplyByKey) {
   });
 }
 
-// 分页搜索老人
+/**
+ * 定义一个异步函数 pageSearchElderByKey，用于分页搜索老人
+ * @param data - 一个符合 IPageSearchElderByKey 接口的对象，包含搜索所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是分页搜索老人的响应结果
+ */
 export async function pageSearchElderByKey(data: IPageSearchElderByKey) {
+  // 使用导入的 http 对象发起 GET 请求，请求地址为 "/api/retreatApply/pageSearchElderByKey"
+  // 将 data 对象展开作为请求的参数
   return http.get("/api/retreatApply/pageSearchElderByKey", {
     params: {
       ...data
@@ -30,7 +54,13 @@ export async function pageSearchElderByKey(data: IPageSearchElderByKey) {
   });
 }
 
-// 新增退住申请
+/**
+ * 定义一个函数 addRetreatApply，用于新增退住申请
+ * @param data - 一个符合 IAddRetreatApply 接口的对象，包含新增退住申请所需的数据
+ * @returns 一个 Promise 对象，解析后得到的是新增退住申请操作的响应结果
+ */
 export function addRetreatApply(data: IAddRetreatApply) {
+  // 使用导入的 http 对象发起 POST 请求，请求地址为 "/api/retreatApply/addRetreatApply"
+  // 将 data 对象作为请求的主体
   return http.post("/api/retreatApply/addRetreatApply", data);
 }

client/src/apis/service.ts

@@ -1,44 +1,70 @@
+// 从 "@/utils" 模块导入名为 http 的对象，推测该对象是用于发起 HTTP 请求的工具，可能是对 axios 等请求库的封装
 import { http } from "@/utils";
 
+// 定义一个接口 IGetServiceType，用于描述获取服务类型时的请求参数结构
 interface IGetServiceType {
+  // 服务类型名称，用于筛选服务类型，类型为字符串
   serviceTypeName: string;
 }
 
+// 导出一个接口 IPageServiceByKey，用于描述分页查询服务时的请求参数结构
 export interface IPageServiceByKey {
+  // 名称，用于筛选服务，类型为字符串
   name: string;
+  // 服务类型 ID，用于筛选属于特定类型的服务，类型为数字
   typeId: number;
 }
 
+// 定义一个接口 IAddServiceType，用于描述新增服务类型时的数据结构
 interface IAddServiceType {
+  // 服务类型的 ID，类型为数字
   id: number;
+  // 服务类型的名称，类型为字符串
   name: string;
 }
 
+// 定义一个接口 IGetServiceTypeById，用于描述根据编号获取服务类型时的请求参数结构
 interface IGetServiceTypeById {
+  // 服务类型 ID，类型为字符串
   serviceTypeId: string;
 }
 
+// 定义一个接口 IAddService，用于描述新增服务时的数据结构
 interface IAddService {
+  // 服务的 ID，类型为数字
   id: number;
+  // 服务的名称，类型为字符串
   name: string;
+  // 服务所需日期，类型为字符串
   needDate: string;
+  // 服务价格，类型为字符串
   price: string;
+  // 服务所属类型的 ID，类型为数字
   typeId: number;
+  // 收费方式，类型为字符串
   chargeMethod: string;
 }
 
+// 导出一个接口 IGetServiceById，用于描述根据编号获取服务时的请求参数结构
 export interface IGetServiceById {
+  // 服务 ID，类型为字符串
   serviceId: string;
 }
 
-// 收费方式
+// 定义一个名为 IChargeMethodList 的常量，是一个包含收费方式选项的数组，每个选项有标签和对应的值
 export const IChargeMethodList = [
   { label: "按次", value: "按次" },
   { label: "按月", value: "按月" }
 ];
 
-// 获取服务类型列表
+/**
+ * 定义一个异步函数 getServiceType，用于获取服务类型列表
+ * @param data - 一个符合 IGetServiceType 接口的对象，包含获取服务类型列表所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是获取服务类型列表的响应结果
+ */
 export async function getServiceType(data: IGetServiceType) {
+  // 使用导入的 http 对象发起 GET 请求，请求地址为 "/api/service/getServiceType"
+  // 将 data 对象展开作为请求的参数
   return http.get("/api/service/getServiceType", {
     params: {
       ...data
@@ -46,10 +72,17 @@ export async function getServiceType(data: IGetServiceType) {
   });
 }
 
-// 分页查询服务
+/**
+ * 定义一个异步函数 pageServiceByKey，用于分页查询服务
+ * @param data - 一个符合 IPageServiceByKey 接口的对象，包含分页查询所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是分页查询服务的响应结果
+ */
 export async function pageServiceByKey(data: IPageServiceByKey) {
   // 因为后台返回的字段与前端表单数据的 prop 不一样，但是组件封装是需要一样的，所以请求前增加一些这两个字段
+  // 这里注释掉的代码可能是原本用于处理字段的逻辑，但当前未启用
   // Reflect.has(data, 'roleName')? (data.roleId = data.roleName) : ''
+  // 使用导入的 http 对象发起 GET 请求，请求地址为 "/api/service/pageServiceByKey"
+  // 将 data 对象展开作为请求的参数
   return http.get("/api/service/pageServiceByKey", {
     params: {
       ...data
@@ -57,13 +90,25 @@ export async function pageServiceByKey(data: IPageServiceByKey) {
   });
 }
 
-// 新增服务类型
+/**
+ * 定义一个函数 addServiceType，用于新增服务类型
+ * @param data - 一个符合 IAddServiceType 接口的对象，包含新增服务类型所需的数据
+ * @returns 一个 Promise 对象，解析后得到的是新增服务类型操作的响应结果
+ */
 export function addServiceType(data: IAddServiceType) {
+  // 使用导入的 http 对象发起 POST 请求，请求地址为 "/api/service/addServiceType"
+  // 将 data 对象作为请求的主体
   return http.post("/api/service/addServiceType", data);
 }
 
-// 根据编号获取服务类型
+/**
+ * 定义一个异步函数 getServiceTypeById，用于根据编号获取服务类型
+ * @param data - 一个符合 IGetServiceTypeById 接口的对象，包含根据编号获取服务类型所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是根据编号获取服务类型的响应结果
+ */
 export async function getServiceTypeById(data: IGetServiceTypeById) {
+  // 使用导入的 http 对象发起 GET 请求，请求地址为 "/api/service/getServiceTypeById"
+  // 将 data 对象展开作为请求的参数
   return http.get("/api/service/getServiceTypeById", {
     params: {
       ...data
@@ -71,13 +116,25 @@ export async function getServiceTypeById(data: IGetServiceTypeById) {
   });
 }
 
-// 编辑服务类型
+/**
+ * 定义一个函数 editServiceType，用于编辑服务类型
+ * @param data - 一个符合 IAddServiceType 接口的对象，包含编辑服务类型所需的数据
+ * @returns 一个 Promise 对象，解析后得到的是编辑服务类型操作的响应结果
+ */
 export function editServiceType(data: IAddServiceType) {
+  // 使用导入的 http 对象发起 PUT 请求，请求地址为 "/api/service/editServiceType"
+  // 将 data 对象作为请求的主体
   return http.put("/api/service/editServiceType", data);
 }
 
-// 删除服务类型
+/**
+ * 定义一个异步函数 deleteServiceType，用于删除服务类型
+ * @param data - 一个符合 IGetServiceTypeById 接口的对象，包含删除服务类型所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是删除服务类型操作的响应结果
+ */
 export async function deleteServiceType(data: IGetServiceTypeById) {
+  // 使用导入的 http 对象发起 DELETE 请求，请求地址为 "/api/service/deleteServiceType"
+  // 将 data 对象展开作为请求的参数
   return http.delete("/api/service/deleteServiceType", {
     params: {
       ...data
@@ -85,13 +142,25 @@ export async function deleteServiceType(data: IGetServiceTypeById) {
   });
 }
 
-// 新增服务
+/**
+ * 定义一个函数 addService，用于新增服务
+ * @param data - 一个符合 IAddService 接口的对象，包含新增服务所需的数据
+ * @returns 一个 Promise 对象，解析后得到的是新增服务操作的响应结果
+ */
 export function addService(data: IAddService) {
+  // 使用导入的 http 对象发起 POST 请求，请求地址为 "/api/service/addService"
+  // 将 data 对象作为请求的主体
   return http.post("/api/service/addService", data);
 }
 
-// 根据编号获取服务
+/**
+ * 定义一个异步函数 getServiceById，用于根据编号获取服务
+ * @param data - 一个符合 IGetServiceById 接口的对象，包含根据编号获取服务所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是根据编号获取服务的响应结果
+ */
 export async function getServiceById(data: IGetServiceById) {
+  // 使用导入的 http 对象发起 GET 请求，请求地址为 "/api/service/getServiceById"
+  // 将 data 对象展开作为请求的参数
   return http.get("/api/service/getServiceById", {
     params: {
       ...data
@@ -99,13 +168,25 @@ export async function getServiceById(data: IGetServiceById) {
   });
 }
 
-// 编辑服务
+/**
+ * 定义一个函数 editService，用于编辑服务
+ * @param data - 一个符合 IAddService 接口的对象，包含编辑服务所需的数据
+ * @returns 一个 Promise 对象，解析后得到的是编辑服务操作的响应结果
+ */
 export function editService(data: IAddService) {
+  // 使用导入的 http 对象发起 PUT 请求，请求地址为 "/api/service/editService"
+  // 将 data 对象作为请求的主体
   return http.put("/api/service/editService", data);
 }
 
-// 删除服务
+/**
+ * 定义一个异步函数 deleteService，用于删除服务
+ * @param data - 一个符合 IGetServiceById 接口的对象，包含删除服务所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是删除服务操作的响应结果
+ */
 export async function deleteService(data: IGetServiceById) {
+  // 使用导入的 http 对象发起 DELETE 请求，请求地址为 "/api/service/deleteService"
+  // 将 data 对象展开作为请求的参数
   return http.delete("/api/service/deleteService", {
     params: {
       ...data

client/src/apis/staff.ts

@@ -1,38 +1,69 @@
+// 从 "@/utils" 模块导入名为 http 的对象，推测该对象是用于发起 HTTP 请求的工具，可能是对 axios 等请求库的封装
 import { http } from "@/utils";
 
+// 定义一个接口 IPageStaffByKey，用于描述分页查询员工时的请求参数结构
 interface IPageStaffByKey {
+  // 角色 ID，用于筛选员工，类型为数字
   roleId: number;
+  // 这里 roleName 的类型标注为 number 可能有误，通常角色名称应该是字符串类型，用于筛选员工
   roleName: number;
+  // 员工姓名，用于筛选员工，类型为字符串
   name: string;
+  // 员工电话，用于筛选员工，类型为字符串
   phone: string;
 }
 
+// 定义一个接口 IAddStaff，用于描述新增员工时的数据结构
 interface IAddStaff {
+  // 员工 ID，类型为数字
   id: number;
+  // 员工角色 ID，类型为数字
   roleId: number;
+  // 员工姓名，类型为字符串
   name: string;
+  // 员工身份证号码，类型为字符串
   idNum: string;
+  // 员工年龄，类型为数字
   age: number;
+  // 员工性别，类型为字符串
   sex: string;
+  // 员工电话，类型为字符串
   phone: string;
+  // 员工邮箱，类型为字符串
   email: string;
+  // 员工地址，类型为字符串
   address: string;
+  // 员工头像地址，类型为字符串
   avator: string;
 }
 
+// 定义一个接口 IGetStaffById，用于描述根据员工编号查询员工时的请求参数结构
 interface IGetStaffById {
-  staffId: string
+  // 员工 ID，类型为字符串
+  staffId: string;
 }
 
-// 获取角色列表
+/**
+ * 定义一个异步函数 getRole，用于获取角色列表
+ * @returns 一个 Promise 对象，解析后得到的是获取角色列表的响应结果
+ */
 export async function getRole() {
+  // 使用导入的 http 对象发起 GET 请求，请求地址为 "/api/staff/getRole"
   return http.get("/api/staff/getRole");
 }
 
-// 分页查询员工
+/**
+ * 定义一个异步函数 pageStaffByKey，用于分页查询员工
+ * @param data - 一个符合 IPageStaffByKey 接口的对象，包含分页查询所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是分页查询员工的响应结果
+ */
 export async function pageStaffByKey(data: IPageStaffByKey) {
-  // 因为后台返回的字段与前端表单数据的prop不一样，但是组件封装是需要一样的，所以请求前增加一些这两个字段
-  Reflect.has(data, 'roleName') ? (data.roleId = data.roleName) : ''
+  // 因为后台返回的字段与前端表单数据的 prop 不一样，
+  // 但是组件封装需要一样，所以请求前增加一些这两个字段
+  // 如果 data 对象中有 'roleName' 字段，则将其值赋给 'roleId' 字段，这里逻辑可能需要进一步确认合理性
+  Reflect.has(data, 'roleName')? (data.roleId = data.roleName) : '';
+  // 使用导入的 http 对象发起 GET 请求，请求地址为 "/api/staff/pageStaffByKey"
+  // 将 data 对象展开作为请求的参数
   return http.get("/api/staff/pageStaffByKey", {
     params: {
       ...data
@@ -40,13 +71,25 @@ export async function pageStaffByKey(data: IPageStaffByKey) {
   });
 }
 
-// 新增员工
+/**
+ * 定义一个函数 addStaff，用于新增员工
+ * @param data - 一个符合 IAddStaff 接口的对象，包含新增员工所需的数据
+ * @returns 一个 Promise 对象，解析后得到的是新增员工操作的响应结果
+ */
 export function addStaff(data: IAddStaff) {
+  // 使用导入的 http 对象发起 POST 请求，请求地址为 "/api/staff/addStaff"
+  // 将 data 对象作为请求的主体
   return http.post("/api/staff/addStaff", data);
 }
 
-// 根据老人编号查询员工
+/**
+ * 定义一个异步函数 getStaffById，用于根据员工编号查询员工
+ * @param data - 一个符合 IGetStaffById 接口的对象，包含根据员工编号查询员工所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是根据员工编号查询员工的响应结果
+ */
 export async function getStaffById(data: IGetStaffById) {
+  // 使用导入的 http 对象发起 GET 请求，请求地址为 "/api/staff/getStaffById"
+  // 将 data 对象展开作为请求的参数
   return http.get("/api/staff/getStaffById", {
     params: {
       ...data
@@ -54,13 +97,25 @@ export async function getStaffById(data: IGetStaffById) {
   });
 }
 
-// 编辑员工
+/**
+ * 定义一个函数 editStaff，用于编辑员工信息
+ * @param data - 一个符合 IAddStaff 接口的对象，包含编辑员工所需的数据
+ * @returns 一个 Promise 对象，解析后得到的是编辑员工操作的响应结果
+ */
 export function editStaff(data: IAddStaff) {
+  // 使用导入的 http 对象发起 PUT 请求，请求地址为 "/api/staff/editStaff"
+  // 将 data 对象作为请求的主体
   return http.put("/api/staff/editStaff", data);
 }
 
-// 删除员工
+/**
+ * 定义一个异步函数 leaveStaff，用于删除员工
+ * @param data - 一个符合 IGetStaffById 接口的对象，包含删除员工所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是删除员工操作的响应结果
+ */
 export async function leaveStaff(data: IGetStaffById) {
+  // 使用导入的 http 对象发起 DELETE 请求，请求地址为 "/api/staff/leaveStaff"
+  // 将 data 对象展开作为请求的参数
   return http.delete("/api/staff/leaveStaff", {
     params: {
       ...data

client/src/apis/visit.ts

@@ -1,49 +1,83 @@
+// 从 "@/utils" 模块导入名为 http 的对象，推测该对象是用于发起 HTTP 请求的工具，可能是对 axios 等请求库的封装
 import { http } from "@/utils";
+// 从 "@/apis/bookManage" 模块导入 IPageSearchElderByKey 接口，
+// 用于描述分页搜索老人时的请求参数结构
 import { IPageSearchElderByKey } from "@/apis/bookManage";
 
+// 定义一个接口 IPageVisitByKey，用于描述分页查询来访登记时的请求参数结构
 interface IPageVisitByKey {
+  // 老人姓名，用于筛选来访登记记录，类型为字符串
   elderName: string;
+  // 来访人姓名，用于筛选来访登记记录，类型为字符串
   visitName: string;
+  // 来访人电话，用于筛选来访登记记录，类型为字符串
   visitPhone: string;
+  // 来访状态标识，用于筛选来访登记记录，类型为字符串
   visitFlag: string;
 }
 
+// 定义一个接口 IAddVisit，用于描述新增来访登记时的数据结构
 interface IAddVisit {
+  // 来访登记的 ID，类型为数字
   id: number;
+  // 老人 ID，类型为数字
   elderId: number;
+  // 来访人姓名，类型为字符串
   name: string;
+  // 来访人电话，类型为字符串
   phone: string;
+  // 与老人的关系，类型为字符串
   relation: string;
+  // 来访日期，类型为字符串
   visitDate: string;
+  // 来访次数，类型为数字
   visitNum: number;
 }
 
+// 定义一个接口 IGetVisitById，用于描述根据编号获取来访登记时的请求参数结构
 interface IGetVisitById {
+  // 来访登记 ID，类型为字符串
   visitId: string;
 }
 
+// 定义一个接口 IEditVisit，用于描述编辑来访登记时的数据结构
 interface IEditVisit {
+  // 来访登记的 ID，类型为数字
   id: number;
+  // 来访人姓名，类型为字符串
   name: string;
+  // 来访人电话，类型为字符串
   phone: string;
+  // 与老人的关系，类型为字符串
   relation: string;
+  // 来访日期字符串，类型为字符串
   visitDateStr: string;
+  // 来访次数，类型为数字
   visitNum: number;
 }
 
+// 定义一个接口 IRecordLeave，用于描述登记离开时的数据结构
 interface IRecordLeave {
+  // 来访登记 ID，类型为字符串
   id: string;
+  // 离开日期，类型为 any（具体类型需根据实际情况确定）
   leaveDate: any;
 }
 
-// 来访状态
+// 定义一个名为 typeList 的常量，是一个包含来访状态选项的数组，每个选项有标签和对应的值
 export const typeList = [
   { label: "待离开", value: "待离开" },
   { label: "已离开", value: "已离开" }
 ];
 
-// 分页查询来访登记
+/**
+ * 定义一个异步函数 pageVisitByKey，用于分页查询来访登记
+ * @param data - 一个符合 IPageVisitByKey 接口的对象，包含分页查询所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是分页查询来访登记的响应结果
+ */
 export async function pageVisitByKey(data: IPageVisitByKey) {
+  // 使用导入的 http 对象发起 GET 请求，请求地址为 "/api/visit/pageVisitByKey"
+  // 将 data 对象展开作为请求的参数
   return http.get("/api/visit/pageVisitByKey", {
     params: {
       ...data
@@ -51,8 +85,14 @@ export async function pageVisitByKey(data: IPageVisitByKey) {
   });
 }
 
-// 分页搜索老人
+/**
+ * 定义一个异步函数 pageSearchElderByKey，用于分页搜索老人
+ * @param data - 一个符合 IPageSearchElderByKey 接口的对象，包含搜索所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是分页搜索老人的响应结果
+ */
 export async function pageSearchElderByKey(data: IPageSearchElderByKey) {
+  // 使用导入的 http 对象发起 GET 请求，请求地址为 "/api/visit/pageSearchElderByKey"
+  // 将 data 对象展开作为请求的参数
   return http.get("/api/visit/pageSearchElderByKey", {
     params: {
       ...data
@@ -60,13 +100,25 @@ export async function pageSearchElderByKey(data: IPageSearchElderByKey) {
   });
 }
 
-// 新增来访登记
+/**
+ * 定义一个函数 addVisit，用于新增来访登记
+ * @param data - 一个符合 IAddVisit 接口的对象，包含新增来访登记所需的数据
+ * @returns 一个 Promise 对象，解析后得到的是新增来访登记操作的响应结果
+ */
 export function addVisit(data: IAddVisit) {
+  // 使用导入的 http 对象发起 POST 请求，请求地址为 "/api/visit/addVisit"
+  // 将 data 对象作为请求的主体
   return http.post("/api/visit/addVisit", data);
 }
 
-// 根据编号获取来访登记
+/**
+ * 定义一个异步函数 getVisitById，用于根据编号获取来访登记
+ * @param data - 一个符合 IGetVisitById 接口的对象，包含根据编号获取来访登记所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是根据编号获取来访登记的响应结果
+ */
 export async function getVisitById(data: IGetVisitById) {
+  // 使用导入的 http 对象发起 GET 请求，请求地址为 "/api/visit/getVisitById"
+  // 将 data 对象展开作为请求的参数
   return http.get("/api/visit/getVisitById", {
     params: {
       ...data
@@ -74,18 +126,36 @@ export async function getVisitById(data: IGetVisitById) {
   });
 }
 
-// 编辑来访登记
+/**
+ * 定义一个函数 editVisit，用于编辑来访登记
+ * @param data - 一个符合 IEditVisit 接口的对象，包含编辑来访登记所需的数据
+ * @returns 一个 Promise 对象，解析后得到的是编辑来访登记操作的响应结果
+ */
 export function editVisit(data: IEditVisit) {
+  // 使用导入的 http 对象发起 PUT 请求，请求地址为 "/api/visit/editVisit"
+  // 将 data 对象作为请求的主体
   return http.put("/api/visit/editVisit", data);
 }
 
-// 登记离开
+/**
+ * 定义一个函数 recordLeave，用于登记离开
+ * @param data - 一个符合 IRecordLeave 接口的对象，包含登记离开所需的数据
+ * @returns 一个 Promise 对象，解析后得到的是登记离开操作的响应结果
+ */
 export function recordLeave(data: IRecordLeave) {
+  // 使用导入的 http 对象发起 PUT 请求，请求地址为 "/api/visit/recordLeave"
+  // 将 data 对象作为请求的主体
   return http.put("/api/visit/recordLeave", data);
 }
 
-// 删除来访登记
+/**
+ * 定义一个异步函数 deleteVisit，用于删除来访登记
+ * @param data - 一个符合 IGetVisitById 接口的对象，包含删除来访登记所需的参数
+ * @returns 一个 Promise 对象，解析后得到的是删除来访登记操作的响应结果
+ */
 export async function deleteVisit(data: IGetVisitById) {
+  // 使用导入的 http 对象发起 DELETE 请求，请求地址为 "/api/visit/deleteVisit"
+  // 将 data 对象展开作为请求的参数
   return http.delete("/api/visit/deleteVisit", {
     params: {
       ...data

server/src/main/java/com/ew/gerocomium/controller/AccidentController.java

@@ -1,83 +1,221 @@
+// 声明该类所在的包名
 package com.ew.gerocomium.controller;
 
+// 导入项目中自定义的常量类
 import com.ew.gerocomium.common.constant.Constant;
+// 导入项目中自定义的统一结果返回类
 import com.ew.gerocomium.dao.base.Result;
+// 导入项目中自定义的各种查询实体类
 import com.ew.gerocomium.dao.query.*;
+// 导入项目中自定义的各种服务接口类
 import com.ew.gerocomium.service.*;
+// 导入 Swagger 用于标记 API 相关信息的注解
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
 import io.swagger.annotations.ApiParam;
+// 导入 Spring Security 用于权限控制的注解
 import org.springframework.security.access.prepost.PreAuthorize;
+// 导入 Spring MVC 相关注解，用于处理 HTTP 请求
 import org.springframework.web.bind.annotation.*;
-
+// 导入 Spring 用于资源注入的注解
 import javax.annotation.Resource;
 
+/**
+ * 事故登记控制器类，处理与事故登记相关的 HTTP 请求
+ * 用于实现对事故登记的增删改查以及相关的搜索和获取列表等操作
+ */
+// 使用 Swagger 注解，标记该控制器的标签为“事故登记”
 @Api(tags = "事故登记")
+// 标记该类为 RESTful 风格的控制器，处理 HTTP 请求并返回 JSON 等格式的响应
 @RestController
+// 定义该控制器的基础请求路径为 /accident
 @RequestMapping("/accident")
+// 权限控制注解，检查用户是否具有指定权限
 @PreAuthorize("@AuthorityAssert.hasAuthority('/check-in/accident')")
 public class AccidentController {
+
+    // 注入事故登记相关的业务逻辑服务类
     @Resource
     private AccidentService accidentService;
+    // 注入押金充值相关的业务逻辑服务类
     @Resource
     private DepositRechargeService depositRechargeService;
+    // 注入护工预约相关的业务逻辑服务类
     @Resource
     private NurseReserveService nurseReserveService;
+    // 注入外出相关的业务逻辑服务类
     @Resource
     private OutwardService outwardService;
 
+    /**
+     * 分页查询事故登记的方法
+     *
+     * @param pageAccidentByKeyQuery 分页查询事故登记的请求实体，包含查询条件和分页信息
+     * @param token 接口访问请求头中的令牌，用于身份验证和权限检查
+     * @return 包含查询结果的 Result 对象，封装了操作结果和数据
+     */
+    // 处理 HTTP GET 请求，请求路径为 /accident/pageAccidentByKey
     @GetMapping("/pageAccidentByKey")
+    // 使用 Swagger 注解，描述该接口的功能和开发者信息
     @ApiOperation(value = "分页查询事故登记", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result pageAccidentByKey(@ApiParam(value = "分页查询事故登记请求实体", required = true) PageAccidentByKeyQuery pageAccidentByKeyQuery,
-                                    @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+    public Result pageAccidentByKey(
+            // 使用 Swagger 注解，描述该参数的作用并标记为必需
+            @ApiParam(value = "分页查询事故登记请求实体", required = true)
+            PageAccidentByKeyQuery pageAccidentByKeyQuery,
+            // 使用 Swagger 注解，描述该参数的作用并标记为必需，同时从请求头中获取该参数
+            @ApiParam(value = "接口访问请求头", required = true)
+            @RequestHeader String token) {
+        // 调用事故登记服务类的分页查询方法，并返回结果
         return accidentService.pageAccidentByKey(pageAccidentByKeyQuery);
     }
 
+    /**
+     * 分页搜索老人的方法
+     *
+     * @param pageSearchElderByKeyQuery 分页搜索老人的请求实体，包含搜索条件和分页信息
+     * @param token 接口访问请求头中的令牌，用于身份验证和权限检查
+     * @return 包含查询结果的 Result 对象，封装了操作结果和数据
+     */
+    // 处理 HTTP GET 请求，请求路径为 /accident/pageSearchElderByKey
     @GetMapping("/pageSearchElderByKey")
+    // 使用 Swagger 注解，描述该接口的功能和开发者信息
     @ApiOperation(value = "分页搜索老人", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result pageSearchElderByKey(@ApiParam(value = "分页搜索老人请求实体", required = true) PageSearchElderByKeyQuery pageSearchElderByKeyQuery,
-                                       @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+    public Result pageSearchElderByKey(
+            // 使用 Swagger 注解，描述该参数的作用并标记为必需
+            @ApiParam(value = "分页搜索老人请求实体", required = true)
+            PageSearchElderByKeyQuery pageSearchElderByKeyQuery,
+            // 使用 Swagger 注解，描述该参数的作用并标记为必需，同时从请求头中获取该参数
+            @ApiParam(value = "接口访问请求头", required = true)
+            @RequestHeader String token) {
+        // 调用押金充值服务类的分页搜索老人方法，并返回结果
         return depositRechargeService.pageSearchElderByKey(pageSearchElderByKeyQuery);
     }
 
+    /**
+     * 分页搜索护工的方法
+     *
+     * @param pageSearchStaffByKeyQuery 分页搜索护工的请求实体，包含搜索条件和分页信息
+     * @param token 接口访问请求头中的令牌，用于身份验证和权限检查
+     * @return 包含查询结果的 Result 对象，封装了操作结果和数据
+     */
+    // 处理 HTTP GET 请求，请求路径为 /accident/pageSearchStaffByKey
     @GetMapping("/pageSearchStaffByKey")
+    // 使用 Swagger 注解，描述该接口的功能和开发者信息
     @ApiOperation(value = "分页搜索护工", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result pageSearchStaffByKey(@ApiParam(value = "分页搜索护工请求实体", required = true) PageSearchStaffByKeyQuery pageSearchStaffByKeyQuery,
-                                       @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+    public Result pageSearchStaffByKey(
+            // 使用 Swagger 注解，描述该参数的作用并标记为必需
+            @ApiParam(value = "分页搜索护工请求实体", required = true)
+            PageSearchStaffByKeyQuery pageSearchStaffByKeyQuery,
+            // 使用 Swagger 注解，描述该参数的作用并标记为必需，同时从请求头中获取该参数
+            @ApiParam(value = "接口访问请求头", required = true)
+            @RequestHeader String token) {
+        // 调用外出服务类的分页搜索护工方法，并返回结果
         return outwardService.pageSearchStaffByKey(pageSearchStaffByKeyQuery);
     }
 
+    /**
+     * 获取护工列表的方法
+     *
+     * @param token 接口访问请求头中的令牌，用于身份验证和权限检查
+     * @return 包含护工列表的 Result 对象，封装了操作结果和数据
+     */
+    // 处理 HTTP GET 请求，请求路径为 /accident/listAccidentStaff
     @GetMapping("/listAccidentStaff")
+    // 使用 Swagger 注解，描述该接口的功能和开发者信息
     @ApiOperation(value = "获取护工列表", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result listOutwardStaff(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+    public Result listOutwardStaff(
+            // 使用 Swagger 注解，描述该参数的作用并标记为必需，同时从请求头中获取该参数
+            @ApiParam(value = "接口访问请求头", required = true)
+            @RequestHeader String token) {
+        // 调用护工预约服务类的获取护工列表方法，并返回结果
         return nurseReserveService.listNurseStaff();
     }
 
+    /**
+     * 新增事故登记的方法
+     *
+     * @param addAccidentQuery 新增事故登记的请求实体，包含要新增的事故登记信息
+     * @param token 接口访问请求头中的令牌，用于身份验证和权限检查
+     * @return 包含操作结果的 Result 对象，封装了操作是否成功等信息
+     */
+    // 处理 HTTP POST 请求，请求路径为 /accident/addAccident
     @PostMapping("/addAccident")
+    // 使用 Swagger 注解，描述该接口的功能和开发者信息
     @ApiOperation(value = "新增事故登记", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result addOutward(@ApiParam(value = "新增事故登记请求实体", required = true) @RequestBody AddAccidentQuery addAccidentQuery,
-                             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+    public Result addOutward(
+            // 使用 Swagger 注解，描述该参数的作用并标记为必需，同时从请求体中获取该参数
+            @ApiParam(value = "新增事故登记请求实体", required = true)
+            @RequestBody AddAccidentQuery addAccidentQuery,
+            // 使用 Swagger 注解，描述该参数的作用并标记为必需，同时从请求头中获取该参数
+            @ApiParam(value = "接口访问请求头", required = true)
+            @RequestHeader String token) {
+        // 调用事故登记服务类的新增事故登记方法，并返回结果
         return accidentService.addAccident(addAccidentQuery);
     }
 
+    /**
+     * 根据编号获取事故登记的方法
+     *
+     * @param accidentId 要获取的事故登记的编号
+     * @param token 接口访问请求头中的令牌，用于身份验证和权限检查
+     * @return 包含指定事故登记信息的 Result 对象，封装了操作结果和数据
+     */
+    // 处理 HTTP GET 请求，请求路径为 /accident/getAccidentById
     @GetMapping("/getAccidentById")
+    // 使用 Swagger 注解，描述该接口的功能和开发者信息
     @ApiOperation(value = "根据编号获取事故登记", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result getAccidentById(@ApiParam(value = "根据编号获取事故登记请求参数", required = true) @RequestParam Long accidentId,
-                                  @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+    public Result getAccidentById(
+            // 使用 Swagger 注解，描述该参数的作用并标记为必需，同时从请求参数中获取该参数
+            @ApiParam(value = "根据编号获取事故登记请求参数", required = true)
+            @RequestParam Long accidentId,
+            // 使用 Swagger 注解，描述该参数的作用并标记为必需，同时从请求头中获取该参数
+            @ApiParam(value = "接口访问请求头", required = true)
+            @RequestHeader String token) {
+        // 调用事故登记服务类的根据编号获取事故登记方法，并返回结果
         return accidentService.getAccidentById(accidentId);
     }
 
+    /**
+     * 编辑事故登记的方法
+     *
+     * @param editAccidentQuery 编辑事故登记的请求实体，包含要修改的事故登记信息
+     * @param token 接口访问请求头中的令牌，用于身份验证和权限检查
+     * @return 包含操作结果的 Result 对象，封装了操作是否成功等信息
+     */
+    // 处理 HTTP PUT 请求，请求路径为 /accident/editAccident
     @PutMapping("/editAccident")
+    // 使用 Swagger 注解，描述该接口的功能和开发者信息
     @ApiOperation(value = "编辑事故登记", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result editAccident(@ApiParam(value = "编辑事故登记请求实体", required = true) @RequestBody EditAccidentQuery editAccidentQuery,
-                               @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+    public Result editAccident(
+            // 使用 Swagger 注解，描述该参数的作用并标记为必需，同时从请求体中获取该参数
+            @ApiParam(value = "编辑事故登记请求实体", required = true)
+            @RequestBody EditAccidentQuery editAccidentQuery,
+            // 使用 Swagger 注解，描述该参数的作用并标记为必需，同时从请求头中获取该参数
+            @ApiParam(value = "接口访问请求头", required = true)
+            @RequestHeader String token) {
+        // 调用事故登记服务类的编辑事故登记方法，并返回结果
         return accidentService.editAccident(editAccidentQuery);
     }
 
+    /**
+     * 删除事故登记的方法
+     *
+     * @param accidentId 要删除的事故登记的编号
+     * @param token 接口访问请求头中的令牌，用于身份验证和权限检查
+     * @return 包含操作结果的 Result 对象，封装了操作是否成功等信息
+     */
+    // 处理 HTTP DELETE 请求，请求路径为 /accident/deleteAccident
     @DeleteMapping("/deleteAccident")
+    // 使用 Swagger 注解，描述该接口的功能和开发者信息
     @ApiOperation(value = "删除事故登记", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result deleteAccident(@ApiParam(value = "删除事故登记请求参数", required = true) @RequestParam Long accidentId,
-                                 @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+    public Result deleteAccident(
+            // 使用 Swagger 注解，描述该参数的作用并标记为必需，同时从请求参数中获取该参数
+            @ApiParam(value = "删除事故登记请求参数", required = true)
+            @RequestParam Long accidentId,
+            // 使用 Swagger 注解，描述该参数的作用并标记为必需，同时从请求头中获取该参数
+            @ApiParam(value = "接口访问请求头", required = true)
+            @RequestHeader String token) {
+        // 调用事故登记服务类的删除事故登记方法，并返回结果
         return accidentService.deleteAccident(accidentId);
     }
 }

server/src/main/java/com/ew/gerocomium/controller/ActiveController.java

@@ -1,70 +1,194 @@
+// 声明该类所在的包名，用于组织代码结构
 package com.ew.gerocomium.controller;
 
+// 导入自定义的常量类，通常包含一些通用的常量信息，如开发者信息等
 import com.ew.gerocomium.common.constant.Constant;
+// 导入自定义的结果封装类，用于统一封装接口的返回结果，包含操作结果状态、消息和数据等
 import com.ew.gerocomium.dao.base.Result;
+// 导入自定义的查询类，用于封装不同业务操作的请求参数
 import com.ew.gerocomium.dao.query.*;
+// 导入活动管理业务逻辑的服务接口
 import com.ew.gerocomium.service.ActiveService;
+// 导入 Swagger 相关注解，用于生成接口文档，方便前后端开发人员进行对接
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
 import io.swagger.annotations.ApiParam;
+// 导入 Spring Security 用于权限控制的注解
 import org.springframework.security.access.prepost.PreAuthorize;
+// 导入 Spring MVC 相关注解，用于处理 HTTP 请求和映射路由
 import org.springframework.web.bind.annotation.*;
-
+// 导入 Spring 的资源注入注解，用于依赖注入
 import javax.annotation.Resource;
 
+/**
+ * 活动管理控制器类，用于处理与活动相关的各种操作请求，如获取活动类型、分页查询活动、新增活动等。
+ */
+// 使用 Swagger 的 @Api 注解，标记该控制器的标签为“活动管理”，在生成的 API 文档中会以该标签分类展示接口
 @Api(tags = "活动管理")
+// 使用 Spring 的 @RestController 注解，标记该类为 RESTful 风格的控制器，会自动将返回结果转换为 JSON 格式
 @RestController
+// 使用 @RequestMapping 注解，定义该控制器的基础请求路径为 /active，所有该控制器下的接口请求路径都会以 /active 开头
 @RequestMapping("/active")
+// 使用 Spring Security 的 @PreAuthorize 注解进行权限控制，只有拥有 '/people/activity' 权限的用户才能访问该控制器的方法
 @PreAuthorize("@AuthorityAssert.hasAuthority('/people/activity')")
 public class ActiveController {
+
+    // 使用 @Resource 注解进行依赖注入，将 ActiveService 接口的实现类实例注入到当前控制器中
     @Resource
     private ActiveService activeService;
 
+    /**
+     * 获取活动类型的方法。
+     *
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含获取活动类型操作结果的 Result 对象，封装了操作是否成功以及获取到的活动类型数据等信息。
+     */
+    // 使用 @GetMapping 注解，指定该方法处理 HTTP GET 请求，请求路径为 /active/getActiveType
     @GetMapping("/getActiveType")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该接口的功能为“获取活动类型”，并添加备注信息，备注信息包含开发者信息
     @ApiOperation(value = "获取活动类型", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result getActiveType(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+    public Result getActiveType(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数为“接口访问请求头”，并标记为必需参数
+            // 使用 @RequestHeader 注解，从 HTTP 请求头中获取名为 token 的值
+            @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用 ActiveService 中的 getActiveType 方法处理获取活动类型的逻辑
+        // 返回处理结果，结果会被封装在 Result 对象中
         return activeService.getActiveType();
     }
 
+    /**
+     * 分页查询活动的方法。
+     *
+     * @param pageActiveByKeyQuery 分页查询活动的请求实体，包含查询条件（如活动名称等）和分页信息（如页码、每页数量等）。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含分页查询活动操作结果的 Result 对象，封装了操作是否成功以及查询到的活动数据列表等信息。
+     */
+    // 使用 @GetMapping 注解，指定该方法处理 HTTP GET 请求，请求路径为 /active/pageActiveByKey
     @GetMapping("/pageActiveByKey")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该接口的功能为“分页查询活动”，并添加备注信息
     @ApiOperation(value = "分页查询活动", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result pageActiveByKey(@ApiParam(value = "分页查询活动请求实体", required = true) PageActiveByKeyQuery pageActiveByKeyQuery,
+    public Result pageActiveByKey(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数为“分页查询活动请求实体”，并标记为必需参数
+            @ApiParam(value = "分页查询活动请求实体", required = true) PageActiveByKeyQuery pageActiveByKeyQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数为“接口访问请求头”，并标记为必需参数
+            // 使用 @RequestHeader 注解，从 HTTP 请求头中获取名为 token 的值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用 ActiveService 中的 pageActiveByKey 方法处理分页查询活动的逻辑，并将 PageActiveByKeyQuery 对象作为参数传入
+        // 返回处理结果，结果会被封装在 Result 对象中
         return activeService.pageActiveByKey(pageActiveByKeyQuery);
     }
 
+    /**
+     * 分页搜索老人的方法。
+     *
+     * @param pageSearchElderByKeyQuery 分页搜索老人的请求实体，包含搜索条件（如老人姓名等）和分页信息（如页码、每页数量等）。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含分页搜索老人操作结果的 Result 对象，封装了操作是否成功以及搜索到的老人数据列表等信息。
+     */
+    // 使用 @GetMapping 注解，指定该方法处理 HTTP GET 请求，请求路径为 /active/pageSearchElderByKey
     @GetMapping("/pageSearchElderByKey")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该接口的功能为“分页搜索老人”，并添加备注信息
     @ApiOperation(value = "分页搜索老人", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result pageSearchElderByKey(@ApiParam(value = "分页搜索老人请求实体", required = true) PageSearchElderByKeyQuery pageSearchElderByKeyQuery,
+    public Result pageSearchElderByKey(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数为“分页搜索老人请求实体”，并标记为必需参数
+            @ApiParam(value = "分页搜索老人请求实体", required = true) PageSearchElderByKeyQuery pageSearchElderByKeyQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数为“接口访问请求头”，并标记为必需参数
+            // 使用 @RequestHeader 注解，从 HTTP 请求头中获取名为 token 的值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用 ActiveService 中的 pageSearchElderByKey 方法处理分页搜索老人的逻辑，并将 PageSearchElderByKeyQuery 对象作为参数传入
+        // 返回处理结果，结果会被封装在 Result 对象中
         return activeService.pageSearchElderByKey(pageSearchElderByKeyQuery);
     }
 
+    /**
+     * 新增活动的方法。
+     *
+     * @param operateActiveQuery 新增活动的请求实体，包含要新增的活动的详细信息，如活动名称、时间、地点等。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含新增活动操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+     */
+    // 使用 @PostMapping 注解，指定该方法处理 HTTP POST 请求，请求路径为 /active/addActive
     @PostMapping("/addActive")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该接口的功能为“新增活动”，并添加备注信息
     @ApiOperation(value = "新增活动", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result addActive(@ApiParam(value = "新增活动请求实体", required = true) @RequestBody OperateActiveQuery operateActiveQuery,
+    public Result addActive(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数为“新增活动请求实体”，并标记为必需参数
+            // 使用 @RequestBody 注解，将 HTTP 请求体中的 JSON 数据映射到 OperateActiveQuery 对象中
+            @ApiParam(value = "新增活动请求实体", required = true) @RequestBody OperateActiveQuery operateActiveQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数为“接口访问请求头”，并标记为必需参数
+            // 使用 @RequestHeader 注解，从 HTTP 请求头中获取名为 token 的值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用 ActiveService 中的 addActive 方法处理新增活动的逻辑，并将 OperateActiveQuery 对象作为参数传入
+        // 返回处理结果，结果会被封装在 Result 对象中
         return activeService.addActive(operateActiveQuery);
     }
 
+    /**
+     * 根据编号查询活动的方法。
+     *
+     * @param activeId 要查询的活动的编号。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含根据编号查询活动操作结果的 Result 对象，封装了操作是否成功以及查询到的活动详细信息等。
+     */
+    // 使用 @GetMapping 注解，指定该方法处理 HTTP GET 请求，请求路径为 /active/getActiveById
     @GetMapping("/getActiveById")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该接口的功能为“根据编号查询活动”，并添加备注信息
     @ApiOperation(value = "根据编号查询活动", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result getActiveById(@ApiParam(value = "根据编号查询活动请求参数", required = true) @RequestParam Long activeId,
+    public Result getActiveById(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数为“根据编号查询活动请求参数”，并标记为必需参数
+            // 使用 @RequestParam 注解，从 HTTP 请求参数中获取名为 activeId 的值
+            @ApiParam(value = "根据编号查询活动请求参数", required = true) @RequestParam Long activeId,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数为“接口访问请求头”，并标记为必需参数
+            // 使用 @RequestHeader 注解，从 HTTP 请求头中获取名为 token 的值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用 ActiveService 中的 getActiveById 方法处理根据编号查询活动的逻辑，并将 activeId 作为参数传入
+        // 返回处理结果，结果会被封装在 Result 对象中
         return activeService.getActiveById(activeId);
     }
 
+    /**
+     * 编辑活动的方法。
+     *
+     * @param operateActiveQuery 编辑活动的请求实体，包含要修改的活动的详细信息，如活动名称、时间、地点等。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含编辑活动操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+     */
+    // 使用 @PutMapping 注解，指定该方法处理 HTTP PUT 请求，请求路径为 /active/editActive
     @PutMapping("/editActive")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该接口的功能为“编辑活动”，并添加备注信息
     @ApiOperation(value = "编辑活动", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result editActive(@ApiParam(value = "编辑活动请求实体", required = true) @RequestBody OperateActiveQuery operateActiveQuery,
+    public Result editActive(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数为“编辑活动请求实体”，并标记为必需参数
+            // 使用 @RequestBody 注解，将 HTTP 请求体中的 JSON 数据映射到 OperateActiveQuery 对象中
+            @ApiParam(value = "编辑活动请求实体", required = true) @RequestBody OperateActiveQuery operateActiveQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数为“接口访问请求头”，并标记为必需参数
+            // 使用 @RequestHeader 注解，从 HTTP 请求头中获取名为 token 的值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用 ActiveService 中的 editActive 方法处理编辑活动的逻辑，并将 OperateActiveQuery 对象作为参数传入
+        // 返回处理结果，结果会被封装在 Result 对象中
         return activeService.editActive(operateActiveQuery);
     }
 
+    /**
+     * 删除活动的方法。
+     *
+     * @param activeId 要删除的活动的编号。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含删除活动操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+     */
+    // 使用 @DeleteMapping 注解，指定该方法处理 HTTP DELETE 请求，请求路径为 /active/deleteActive
     @DeleteMapping("/deleteActive")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该接口的功能为“删除活动”，并添加备注信息
     @ApiOperation(value = "删除活动", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result deleteActive(@ApiParam(value = "删除活动请求参数", required = true) @RequestParam Long activeId,
+    public Result deleteActive(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数为“删除活动请求参数”，并标记为必需参数
+            // 使用 @RequestParam 注解，从 HTTP 请求参数中获取名为 activeId 的值
+            @ApiParam(value = "删除活动请求参数", required = true) @RequestParam Long activeId,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数为“接口访问请求头”，并标记为必需参数
+            // 使用 @RequestHeader 注解，从 HTTP 请求头中获取名为 token 的值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用 ActiveService 中的 deleteActive 方法处理删除活动的逻辑，并将 activeId 作为参数传入
+        // 返回处理结果，结果会被封装在 Result 对象中
         return activeService.deleteActive(activeId);
     }
 }

server/src/main/java/com/ew/gerocomium/controller/ActiveTypeController.java

@@ -1,58 +1,154 @@
+// 声明该类所在的包路径，用于组织和管理代码结构
 package com.ew.gerocomium.controller;
 
+// 导入自定义的常量类，可能包含项目中通用的常量信息，如开发者标识等
 import com.ew.gerocomium.common.constant.Constant;
+// 导入自定义的结果封装类，用于统一处理接口返回结果，包含操作状态、消息和数据等
 import com.ew.gerocomium.dao.base.Result;
+// 导入自定义的查询实体类，用于封装与活动分类相关的操作请求参数
 import com.ew.gerocomium.dao.query.OperateActiveTypeQuery;
 import com.ew.gerocomium.dao.query.PageActiveTypeByKeyQuery;
+// 导入活动分类业务逻辑的服务接口
 import com.ew.gerocomium.service.ActiveTypeService;
+// 导入 Swagger 相关注解，用于生成接口文档，方便前后端开发人员理解和使用接口
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
 import io.swagger.annotations.ApiParam;
+// 导入 Spring Security 用于权限控制的注解
 import org.springframework.security.access.prepost.PreAuthorize;
+// 导入 Spring MVC 相关注解，用于处理 HTTP 请求和路由映射
 import org.springframework.web.bind.annotation.*;
-
+// 导入 Spring 用于依赖注入的注解
 import javax.annotation.Resource;
 
+/**
+ * 活动分类控制器类，用于处理与活动分类相关的各种操作请求，如分页查询、新增、编辑、删除等。
+ */
+// 使用 Swagger 的 @Api 注解，标记该控制器的标签为“活动分类”，在生成 API 文档时会以此标签分类展示接口
 @Api(tags = "活动分类")
+// 使用 Spring 的 @RestController 注解，标记该类为 RESTful 风格的控制器，自动将返回结果转换为 JSON 格式
 @RestController
+// 使用 @RequestMapping 注解，定义该控制器的基础请求路径为 /activeType，后续该控制器下的所有请求路径都基于此路径
 @RequestMapping("/activeType")
+// 使用 Spring Security 的 @PreAuthorize 注解进行权限控制，只有拥有 '/base/activity' 权限的用户才能访问该控制器的方法
 @PreAuthorize("@AuthorityAssert.hasAuthority('/base/activity')")
 public class ActiveTypeController {
+
+    // 使用 @Resource 注解进行依赖注入，将 ActiveTypeService 接口的实现类实例注入到当前控制器中
     @Resource
     private ActiveTypeService activeTypeService;
 
+    /**
+     * 分页查询活动分类的方法。
+     *
+     * @param pageActiveTypeByKeyQuery 分页查询活动分类的请求实体，包含查询条件（如分类名称等）和分页信息（如页码、每页数量等）。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含分页查询活动分类操作结果的 Result 对象，封装了操作是否成功以及查询到的活动分类数据列表等信息。
+     */
+    // 使用 @GetMapping 注解，指定该方法处理 HTTP GET 请求，请求路径为 /activeType/pageActiveTypeByKey
     @GetMapping("/pageActiveTypeByKey")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该接口的功能为“分页查询活动分类”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "分页查询活动分类", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result pageActiveTypeByKey(@ApiParam(value = "分页查询活动分类请求实体", required = true) PageActiveTypeByKeyQuery pageActiveTypeByKeyQuery,
+    public Result pageActiveTypeByKey(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数为“分页查询活动分类请求实体”，并标记为必需参数
+            @ApiParam(value = "分页查询活动分类请求实体", required = true) PageActiveTypeByKeyQuery pageActiveTypeByKeyQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数为“接口访问请求头”，并标记为必需参数
+            // 使用 @RequestHeader 注解，从 HTTP 请求头中获取名为 token 的值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用 ActiveTypeService 中的 pageActiveTypeByKey 方法处理分页查询逻辑，并传入请求实体参数
+        // 返回处理结果，结果封装在 Result 对象中
         return activeTypeService.pageActiveTypeByKey(pageActiveTypeByKeyQuery);
     }
 
+    /**
+     * 新增活动分类的方法。
+     *
+     * @param activeTypeName 要新增的活动分类名称。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含新增活动分类操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+     */
+    // 使用 @PostMapping 注解，指定该方法处理 HTTP POST 请求，请求路径为 /activeType/addActiveType
     @PostMapping("/addActiveType")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该接口的功能为“新增活动分类”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "新增活动分类", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result addActiveType(@ApiParam(value = "新增活动分类请求参数", required = true) @RequestParam String activeTypeName,
+    public Result addActiveType(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数为“新增活动分类请求参数”，并标记为必需参数
+            // 使用 @RequestParam 注解，从 HTTP 请求参数中获取名为 activeTypeName 的值
+            @ApiParam(value = "新增活动分类请求参数", required = true) @RequestParam String activeTypeName,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数为“接口访问请求头”，并标记为必需参数
+            // 使用 @RequestHeader 注解，从 HTTP 请求头中获取名为 token 的值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用 ActiveTypeService 中的 addActiveType 方法处理新增逻辑，并传入活动分类名称参数
+        // 返回处理结果，结果封装在 Result 对象中
         return activeTypeService.addActiveType(activeTypeName);
     }
 
+    /**
+     * 根据编号获取活动分类的方法。
+     *
+     * @param activeTypeId 要获取的活动分类的编号。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含根据编号获取活动分类操作结果的 Result 对象，封装了操作是否成功以及获取到的活动分类详细信息等。
+     */
+    // 使用 @GetMapping 注解，指定该方法处理 HTTP GET 请求，请求路径为 /activeType/getActiveTypeById
     @GetMapping("/getActiveTypeById")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该接口的功能为“根据编号获取活动分类”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "根据编号获取活动分类", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result getActiveTypeById(@ApiParam(value = "根据编号获取活动分类请求参数", required = true) @RequestParam Long activeTypeId,
+    public Result getActiveTypeById(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数为“根据编号获取活动分类请求参数”，并标记为必需参数
+            // 使用 @RequestParam 注解，从 HTTP 请求参数中获取名为 activeTypeId 的值
+            @ApiParam(value = "根据编号获取活动分类请求参数", required = true) @RequestParam Long activeTypeId,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数为“接口访问请求头”，并标记为必需参数
+            // 使用 @RequestHeader 注解，从 HTTP 请求头中获取名为 token 的值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用 ActiveTypeService 中的 getActiveTypeById 方法处理获取逻辑，并传入活动分类编号参数
+        // 返回处理结果，结果封装在 Result 对象中
         return activeTypeService.getActiveTypeById(activeTypeId);
     }
 
+    /**
+     * 编辑活动分类的方法。
+     *
+     * @param operateActiveTypeQuery 编辑活动分类的请求实体，包含要修改的活动分类的详细信息（如分类名称等）。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含编辑活动分类操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+     */
+    // 使用 @PutMapping 注解，指定该方法处理 HTTP PUT 请求，请求路径为 /activeType/editActiveType
     @PutMapping("/editActiveType")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该接口的功能为“编辑活动分类”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "编辑活动分类", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result editActiveType(@ApiParam(value = "编辑活动分类请求实体", required = true) @RequestBody OperateActiveTypeQuery operateActiveTypeQuery,
+    public Result editActiveType(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数为“编辑活动分类请求实体”，并标记为必需参数
+            // 使用 @RequestBody 注解，将 HTTP 请求体中的 JSON 数据映射到 OperateActiveTypeQuery 对象中
+            @ApiParam(value = "编辑活动分类请求实体", required = true) @RequestBody OperateActiveTypeQuery operateActiveTypeQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数为“接口访问请求头”，并标记为必需参数
+            // 使用 @RequestHeader 注解，从 HTTP 请求头中获取名为 token 的值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用 ActiveTypeService 中的 editActiveType 方法处理编辑逻辑，并传入请求实体参数
+        // 返回处理结果，结果封装在 Result 对象中
         return activeTypeService.editActiveType(operateActiveTypeQuery);
     }
 
+    /**
+     * 删除活动分类的方法。
+     *
+     * @param activeTypeId 要删除的活动分类的编号。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含删除活动分类操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+     */
+    // 使用 @DeleteMapping 注解，指定该方法处理 HTTP DELETE 请求，请求路径为 /activeType/deleteActiveType
     @DeleteMapping("/deleteActiveType")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该接口的功能为“删除活动分类”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "删除活动分类", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result deleteActiveType(@ApiParam(value = "删除活动分类请求参数", required = true) @RequestParam Long activeTypeId,
+    public Result deleteActiveType(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数为“删除活动分类请求参数”，并标记为必需参数
+            // 使用 @RequestParam 注解，从 HTTP 请求参数中获取名为 activeTypeId 的值
+            @ApiParam(value = "删除活动分类请求参数", required = true) @RequestParam Long activeTypeId,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数为“接口访问请求头”，并标记为必需参数
+            // 使用 @RequestHeader 注解，从 HTTP 请求头中获取名为 token 的值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用 ActiveTypeService 中的 deleteActiveType 方法处理删除逻辑，并传入活动分类编号参数
+        // 返回处理结果，结果封装在 Result 对象中
         return activeTypeService.deleteActiveType(activeTypeId);
     }
 }

server/src/main/java/com/ew/gerocomium/controller/ElderRecordController.java

@@ -1,71 +1,195 @@
+// 声明该类所属的包，表明该类在 com.ew.gerocomium.controller 包下
 package com.ew.gerocomium.controller;
 
+// 导入自定义的常量类，可能包含项目中固定不变的一些值，如开发者信息等
 import com.ew.gerocomium.common.constant.Constant;
+// 导入自定义的基础结果类，用于封装接口操作的结果，如操作是否成功、数据等
 import com.ew.gerocomium.dao.base.Result;
+// 导入操作意向的查询实体类，用于封装与意向操作相关的数据
 import com.ew.gerocomium.dao.query.OperateIntentionQuery;
+// 导入分页查询长者的请求实体类，用于封装分页查询长者时的查询条件和分页信息
 import com.ew.gerocomium.dao.query.PageElderByKeyQuery;
-import com.ew.gerocomium.service.CheckContractService;
+// 导入长者档案业务逻辑服务类，用于处理与长者档案相关的业务操作
 import com.ew.gerocomium.service.ElderRecordService;
+// 导入意向业务逻辑服务类，用于处理与意向相关的业务操作
 import com.ew.gerocomium.service.IntentionService;
+// 导入入住签约业务逻辑服务类，用于处理与入住签约相关的业务操作
+import com.ew.gerocomium.service.CheckContractService;
+// 导入 Swagger 相关注解，用于生成 API 文档，对接口进行描述和分类
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
 import io.swagger.annotations.ApiParam;
+// 导入 Spring Security 的权限控制注解，用于对接口进行权限管理
 import org.springframework.security.access.prepost.PreAuthorize;
+// 导入 Spring MVC 相关注解，用于处理 HTTP 请求
 import org.springframework.web.bind.annotation.*;
-
+// 导入 Spring 的资源注入注解，用于实现依赖注入
 import javax.annotation.Resource;
+// 导入 IOException 异常类，用于处理可能的 I/O 异常情况
 import java.io.IOException;
 
+/**
+ * 长者档案控制器类，用于处理与长者档案相关的各种操作请求，如导出长者档案 Excel、分页查询长者、获取长者档案和信息、编辑和删除长者等。
+ */
+// 使用 Swagger 注解，标记该控制器的标签为“长者档案”，方便在生成 API 文档时进行分类展示
 @Api(tags = "长者档案")
+// 标记该类为 RESTful 风格的控制器，用于处理 HTTP 请求并返回 JSON 等格式的响应
 @RestController
+// 定义该控制器的基础请求路径为 /elderRecord，该控制器下的所有请求都以此为前缀
 @RequestMapping("/elderRecord")
+// 权限控制注解，只有拥有指定权限（'/people/old' 对应的权限）的用户才能访问该控制器的方法
 @PreAuthorize("@AuthorityAssert.hasAuthority('/people/old')")
 public class ElderRecordController {
+
+    // 注入长者档案相关的业务逻辑服务类，通过依赖注入获取 ElderRecordService 的实例，以便调用其方法处理长者档案业务
     @Resource
     private ElderRecordService elderRecordService;
+
+    // 注入意向相关的业务逻辑服务类，通过依赖注入获取 IntentionService 的实例，用于处理与意向相关的业务
     @Resource
     private IntentionService intentionService;
+
+    // 注入入住签约相关的业务逻辑服务类，通过依赖注入获取 CheckContractService 的实例，用于处理入住签约相关业务
     @Resource
     private CheckContractService checkContractService;
 
+    /**
+     * 导出长者档案 Excel 的方法。
+     *
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含导出 Excel 操作结果的 Result 对象，封装了操作是否成功以及可能的文件流等信息（如果成功）。
+     * @throws IOException 如果在导出 Excel 过程中出现 I/O 错误（如文件写入失败等），则抛出该异常。
+     */
+    // 处理 HTTP GET 请求，路径为 /elderRecord/exportExcel，用于导出长者档案 Excel
     @GetMapping("/exportExcel")
+    // 使用 Swagger 注解描述该接口的功能和开发者信息
     @ApiOperation(value = "导出excel", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result exportExcel(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) throws IOException {
+    public Result exportExcel(
+            // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数是接口访问请求头中的令牌
+            @ApiParam(value = "接口访问请求头", required = true)
+            // 从请求头中获取令牌
+            @RequestHeader String token) throws IOException {
+        // 调用长者档案服务类的导出 Excel 方法，并返回操作结果
         return elderRecordService.exportExcel();
     }
 
+    /**
+     * 分页查询长者信息的方法。
+     *
+     * @param pageElderByKeyQuery 分页查询长者的请求实体，包含查询条件（如长者姓名、年龄范围等）和分页信息（如页码、每页数量等）。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含分页查询长者操作结果的 Result 对象，封装了操作是否成功以及查询到的长者数据列表等信息。
+     */
+    // 处理 HTTP GET 请求，路径为 /elderRecord/pageElderByKey，用于分页查询长者信息
     @GetMapping("/pageElderByKey")
+    // 使用 Swagger 注解描述该接口的功能和开发者信息
     @ApiOperation(value = "分页查询长者", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result pageElderByKey(@ApiParam(value = "分页查询长者请求实体", required = true) PageElderByKeyQuery pageElderByKeyQuery,
-                                 @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+    public Result pageElderByKey(
+            // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数是分页查询长者的请求实体
+            @ApiParam(value = "分页查询长者请求实体", required = true)
+            // 接收分页查询长者的请求实体
+            PageElderByKeyQuery pageElderByKeyQuery,
+            // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数是接口访问请求头中的令牌
+            @ApiParam(value = "接口访问请求头", required = true)
+            // 从请求头中获取令牌
+            @RequestHeader String token) {
+        // 调用长者档案服务类的分页查询长者方法，并返回操作结果
         return elderRecordService.pageElderByKey(pageElderByKeyQuery);
     }
 
+    /**
+     * 根据编号获取长者档案信息的方法。
+     *
+     * @param elderId 要获取档案的长者的编号。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含根据编号获取长者档案操作结果的 Result 对象，封装了操作是否成功以及查询到的长者档案详细信息等。
+     */
+    // 处理 HTTP GET 请求，路径为 /elderRecord/getElderRecordById，用于根据编号获取长者档案信息
     @GetMapping("/getElderRecordById")
+    // 使用 Swagger 注解描述该接口的功能和开发者信息
     @ApiOperation(value = "根据编号获取长者档案", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result getElderRecordById(@ApiParam(value = "根据编号获取长者档案请求参数", required = true) @RequestParam Long elderId,
-                                     @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+    public Result getElderRecordById(
+            // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数是要获取档案的长者编号
+            @ApiParam(value = "根据编号获取长者档案请求参数", required = true)
+            // 从请求参数中获取长者编号
+            @RequestParam Long elderId,
+            // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数是接口访问请求头中的令牌
+            @ApiParam(value = "接口访问请求头", required = true)
+            // 从请求头中获取令牌
+            @RequestHeader String token) {
+        // 调用长者档案服务类的根据编号获取长者档案方法，并返回操作结果
         return elderRecordService.getElderRecordById(elderId);
     }
 
+    /**
+     * 根据编号获取长者信息的方法（这里由意向服务类处理，可能是获取与意向相关的长者信息）。
+     *
+     * @param elderId 要获取信息的长者的编号。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含根据编号获取长者信息操作结果的 Result 对象，封装了操作是否成功以及查询到的长者相关信息等。
+     */
+    // 处理 HTTP GET 请求，路径为 /elderRecord/getElderById，用于根据编号获取长者信息
     @GetMapping("/getElderById")
+    // 使用 Swagger 注解描述该接口的功能和开发者信息
     @ApiOperation(value = "根据编号获取长者信息", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result getElderById(@ApiParam(value = "根据编号获取长者信息请求参数", required = true) @RequestParam Long elderId,
-                               @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+    public Result getElderById(
+            // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数是要获取信息的长者编号
+            @ApiParam(value = "根据编号获取长者信息请求参数", required = true)
+            // 从请求参数中获取长者编号
+            @RequestParam Long elderId,
+            // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数是接口访问请求头中的令牌
+            @ApiParam(value = "接口访问请求头", required = true)
+            // 从请求头中获取令牌
+            @RequestHeader String token) {
+        // 调用意向服务类的根据编号获取意向（这里可能关联到长者信息）的方法，并返回操作结果
         return intentionService.getIntentById(elderId);
     }
 
+    /**
+     * 编辑长者信息的方法（这里由意向服务类处理，可能是编辑与意向相关的长者信息）。
+     *
+     * @param operateIntentionQuery 编辑长者的请求实体，包含要修改的长者的详细信息（与意向相关）。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含编辑长者操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+     */
+    // 处理 HTTP PUT 请求，路径为 /elderRecord/editElder，用于编辑长者信息
     @PutMapping("/editElder")
+    // 使用 Swagger 注解描述该接口的功能和开发者信息
     @ApiOperation(value = "编辑长者", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result editElder(@ApiParam(value = "编辑长者请求实体", required = true) @RequestBody OperateIntentionQuery operateIntentionQuery,
-                            @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+    public Result editElder(
+            // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数是编辑长者的请求实体
+            @ApiParam(value = "编辑长者请求实体", required = true)
+            // 从请求体中接收编辑长者的请求实体
+            @RequestBody OperateIntentionQuery operateIntentionQuery,
+            // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数是接口访问请求头中的令牌
+            @ApiParam(value = "接口访问请求头", required = true)
+            // 从请求头中获取令牌
+            @RequestHeader String token) {
+        // 调用意向服务类的编辑意向（这里可能关联到长者信息编辑）的方法，并返回操作结果
         return intentionService.editIntention(operateIntentionQuery);
     }
 
+    /**
+     * 删除长者（这里通过入住签约服务类处理，可能是删除与入住签约相关的长者信息）的方法。
+     *
+     * @param elderId 要删除的长者的编号。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含删除长者操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+     */
+    // 处理 HTTP DELETE 请求，路径为 /elderRecord/deleteElder，用于删除长者
     @DeleteMapping("/deleteElder")
+    // 使用 Swagger 注解描述该接口的功能和开发者信息
     @ApiOperation(value = "删除长者", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result deleteCheckContract(@ApiParam(value = "删除长者请求参数", required = true) @RequestParam Long elderId,
-                                      @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+    public Result deleteCheckContract(
+            // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数是要删除的长者编号
+            @ApiParam(value = "删除长者请求参数", required = true)
+            // 从请求参数中获取长者编号
+            @RequestParam Long elderId,
+            // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数是接口访问请求头中的令牌
+            @ApiParam(value = "接口访问请求头", required = true)
+            // 从请求头中获取令牌
+            @RequestHeader String token) {
+        // 调用入住签约服务类的删除入住签约（这里可能关联到删除长者相关信息）的方法，并返回操作结果
         return checkContractService.deleteCheckContract(elderId);
     }
 }

server/src/main/java/com/ew/gerocomium/controller/NurseGradeController.java

@@ -1,73 +1,210 @@
+// 声明该类所在的包名
 package com.ew.gerocomium.controller;
 
+// 导入自定义常量类
 import com.ew.gerocomium.common.constant.Constant;
+// 导入自定义基础结果类
 import com.ew.gerocomium.dao.base.Result;
+// 导入分页查询护理等级的请求实体类
 import com.ew.gerocomium.dao.query.*;
+// 导入护理等级业务逻辑服务类
 import com.ew.gerocomium.service.NurseGradeService;
+// 导入服务项目业务逻辑服务类
 import com.ew.gerocomium.service.ServiceProjectService;
+// 导入 Swagger 注解，用于生成 API 文档时对接口进行描述
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
 import io.swagger.annotations.ApiParam;
+// 导入 Spring Security 权限控制注解
 import org.springframework.security.access.prepost.PreAuthorize;
+// 导入 Spring MVC 注解，用于处理 HTTP 请求
 import org.springframework.web.bind.annotation.*;
-
+// 导入 Spring 资源注入注解
 import javax.annotation.Resource;
 
+/**
+ * 护理等级控制器类，用于处理与护理等级相关的各种操作请求，
+ * 包括分页查询护理等级、获取服务类型、分页查询服务以及护理等级的增删改查等功能。
+ */
+// 使用 Swagger 注解，标记该控制器的标签为“护理等级”，方便在生成 API 文档时进行分类展示
 @Api(tags = "护理等级")
+// 标记该类为 RESTful 风格的控制器，用于处理 HTTP 请求并返回 JSON 等格式的响应
 @RestController
+// 定义该控制器的基础请求路径为 /nurseGrade，该控制器下的所有请求都以此为前缀
 @RequestMapping("/nurseGrade")
+// 权限控制注解，只有拥有指定权限的用户才能访问该控制器的方法
 @PreAuthorize("@AuthorityAssert.hasAuthority('/service/level')")
 public class NurseGradeController {
+
+    // 注入护理等级相关的业务逻辑服务类，通过依赖注入的方式获取 NurseGradeService 的实例
     @Resource
     private NurseGradeService nurseGradeService;
+
+    // 注入服务项目相关的业务逻辑服务类，通过依赖注入的方式获取 ServiceProjectService 的实例
     @Resource
     private ServiceProjectService serviceProjectService;
 
+    /**
+     * 分页查询护理等级信息的方法。
+     *
+     * @param pageNurseGradeByKeyQuery 分页查询护理等级的请求实体，包含查询条件（如护理等级名称、等级描述等）和分页信息（如页码、每页数量等）。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含分页查询护理等级操作结果的 Result 对象，封装了操作是否成功以及查询到的护理等级数据列表等信息。
+     */
+    // 处理 HTTP GET 请求，请求路径为 /nurseGrade/pageNurseGradeByKey
     @GetMapping("/pageNurseGradeByKey")
+    // 使用 Swagger 注解描述该接口的功能和开发者信息
     @ApiOperation(value = "分页查询护理等级", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result pageNurseGradeByKey(@ApiParam(value = "分页查询护理等级请求实体", required = true) PageNurseGradeByKeyQuery pageNurseGradeByKeyQuery,
-                                      @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+    public Result pageNurseGradeByKey(
+            // 使用 Swagger 注解描述该参数的作用，并标记为必需参数
+            @ApiParam(value = "分页查询护理等级请求实体", required = true)
+            // 接收分页查询护理等级的请求实体
+            PageNurseGradeByKeyQuery pageNurseGradeByKeyQuery,
+            // 使用 Swagger 注解描述该参数的作用，并标记为必需参数
+            @ApiParam(value = "接口访问请求头", required = true)
+            // 从请求头中获取令牌
+            @RequestHeader String token) {
+        // 调用护理等级服务类的分页查询方法
         return nurseGradeService.pageNurseGradeByKey(pageNurseGradeByKeyQuery);
     }
 
+    /**
+     * 获取服务类型的方法。
+     *
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含获取服务类型操作结果的 Result 对象，封装了操作是否成功以及获取到的服务类型数据列表等信息。
+     *         这里调用 serviceProjectService.listServiceType(null) 方法，参数为 null 可能表示获取所有服务类型。
+     */
+    // 处理 HTTP GET 请求，请求路径为 /nurseGrade/listServiceType
     @GetMapping("/listServiceType")
+    // 使用 Swagger 注解描述该接口的功能和开发者信息
     @ApiOperation(value = "获取服务类型", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result listServiceType(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+    public Result listServiceType(
+            // 使用 Swagger 注解描述该参数的作用，并标记为必需参数
+            @ApiParam(value = "接口访问请求头", required = true)
+            // 从请求头中获取令牌
+            @RequestHeader String token) {
+        // 调用服务项目服务类的获取服务类型方法，参数为 null 表示获取所有服务类型
         return serviceProjectService.listServiceType(null);
     }
 
+    /**
+     * 分页查询服务信息的方法。
+     *
+     * @param pageServiceByKeyQuery 分页查询服务的请求实体，包含查询条件（如服务名称、服务类型等）和分页信息（如页码、每页数量等）。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含分页查询服务操作结果的 Result 对象，封装了操作是否成功以及查询到的服务数据列表等信息。
+     */
+    // 处理 HTTP GET 请求，请求路径为 /nurseGrade/pageServiceByKey
     @GetMapping("/pageServiceByKey")
+    // 使用 Swagger 注解描述该接口的功能和开发者信息
     @ApiOperation(value = "分页查询服务", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result pageServiceByKey(@ApiParam(value = "分页查询服务请求实体", required = true) PageServiceByKeyQuery pageServiceByKeyQuery,
-                                   @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+    public Result pageServiceByKey(
+            // 使用 Swagger 注解描述该参数的作用，并标记为必需参数
+            @ApiParam(value = "分页查询服务请求实体", required = true)
+            // 接收分页查询服务的请求实体
+            PageServiceByKeyQuery pageServiceByKeyQuery,
+            // 使用 Swagger 注解描述该参数的作用，并标记为必需参数
+            @ApiParam(value = "接口访问请求头", required = true)
+            // 从请求头中获取令牌
+            @RequestHeader String token) {
+        // 调用护理等级服务类的分页查询服务方法
         return nurseGradeService.pageServiceByKey(pageServiceByKeyQuery);
     }
 
+    /**
+     * 新增护理等级的方法。
+     *
+     * @param operateNurseGradeQuery 新增护理等级的请求实体，包含要新增的护理等级的详细信息，如等级名称、等级描述、服务项目等。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含新增护理等级操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+     */
+    // 处理 HTTP POST 请求，请求路径为 /nurseGrade/addNurseGrade
     @PostMapping("/addNurseGrade")
+    // 使用 Swagger 注解描述该接口的功能和开发者信息
     @ApiOperation(value = "新增护理等级", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result addNurseGrade(@ApiParam(value = "新增护理等级请求实体", required = true) @RequestBody OperateNurseGradeQuery operateNurseGradeQuery,
-                                @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+    public Result addNurseGrade(
+            // 使用 Swagger 注解描述该参数的作用，并标记为必需参数
+            @ApiParam(value = "新增护理等级请求实体", required = true)
+            // 从请求体中接收新增护理等级的请求实体
+            @RequestBody OperateNurseGradeQuery operateNurseGradeQuery,
+            // 使用 Swagger 注解描述该参数的作用，并标记为必需参数
+            @ApiParam(value = "接口访问请求头", required = true)
+            // 从请求头中获取令牌
+            @RequestHeader String token) {
+        // 调用护理等级服务类的新增护理等级方法
         return nurseGradeService.addNurseGrade(operateNurseGradeQuery);
     }
 
+    /**
+     * 根据编号查询护理等级信息的方法。
+     *
+     * @param nurseGradeId 要查询的护理等级的编号。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含根据编号查询护理等级操作结果的 Result 对象，封装了操作是否成功以及获取到的护理等级详细信息等。
+     */
+    // 处理 HTTP GET 请求，请求路径为 /nurseGrade/getNurseGradeById
     @GetMapping("/getNurseGradeById")
+    // 使用 Swagger 注解描述该接口的功能和开发者信息
     @ApiOperation(value = "根据编号查询护理等级", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result getNurseGradeById(@ApiParam(value = "根据编号查询护理等级请求参数", required = true) @RequestParam Long nurseGradeId,
-                                    @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+    public Result getNurseGradeById(
+            // 使用 Swagger 注解描述该参数的作用，并标记为必需参数
+            @ApiParam(value = "根据编号查询护理等级请求参数", required = true)
+            // 从请求参数中获取护理等级编号
+            @RequestParam Long nurseGradeId,
+            // 使用 Swagger 注解描述该参数的作用，并标记为必需参数
+            @ApiParam(value = "接口访问请求头", required = true)
+            // 从请求头中获取令牌
+            @RequestHeader String token) {
+        // 调用护理等级服务类的根据编号查询护理等级方法
         return nurseGradeService.getNurseGradeById(nurseGradeId);
     }
 
+    /**
+     * 编辑护理等级信息的方法。
+     *
+     * @param operateNurseGradeQuery 编辑护理等级的请求实体，包含要修改的护理等级的详细信息。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含编辑护理等级操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+     */
+    // 处理 HTTP PUT 请求，请求路径为 /nurseGrade/editNurseGrade
     @PutMapping("/editNurseGrade")
+    // 使用 Swagger 注解描述该接口的功能和开发者信息
     @ApiOperation(value = "编辑护理等级", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result editNurseGrade(@ApiParam(value = "编辑护理等级请求实体", required = true) @RequestBody OperateNurseGradeQuery operateNurseGradeQuery,
-                                 @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+    public Result editNurseGrade(
+            // 使用 Swagger 注解描述该参数的作用，并标记为必需参数
+            @ApiParam(value = "编辑护理等级请求实体", required = true)
+            // 从请求体中接收编辑护理等级的请求实体
+            @RequestBody OperateNurseGradeQuery operateNurseGradeQuery,
+            // 使用 Swagger 注解描述该参数的作用，并标记为必需参数
+            @ApiParam(value = "接口访问请求头", required = true)
+            // 从请求头中获取令牌
+            @RequestHeader String token) {
+        // 调用护理等级服务类的编辑护理等级方法
         return nurseGradeService.editNurseGrade(operateNurseGradeQuery);
     }
 
+    /**
+     * 删除护理等级的方法。
+     *
+     * @param nurseGradeId 要删除的护理等级的编号。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含删除护理等级操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+     */
+    // 处理 HTTP DELETE 请求，请求路径为 /nurseGrade/deleteNurseGrade
     @DeleteMapping("/deleteNurseGrade")
+    // 使用 Swagger 注解描述该接口的功能和开发者信息
     @ApiOperation(value = "删除护理等级", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result deleteNurseGrade(@ApiParam(value = "删除护理等级请求参数", required = true) @RequestParam Long nurseGradeId,
-                                   @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+    public Result deleteNurseGrade(
+            // 使用 Swagger 注解描述该参数的作用，并标记为必需参数
+            @ApiParam(value = "删除护理等级请求参数", required = true)
+            // 从请求参数中获取要删除的护理等级编号
+            @RequestParam Long nurseGradeId,
+            // 使用 Swagger 注解描述该参数的作用，并标记为必需参数
+            @ApiParam(value = "接口访问请求头", required = true)
+            // 从请求头中获取令牌
+            @RequestHeader String token) {
+        // 调用护理等级服务类的删除护理等级方法
         return nurseGradeService.deleteNurseGrade(nurseGradeId);
     }
 }

server/src/main/java/com/ew/gerocomium/controller/NurseReserveController.java

@@ -1,75 +1,186 @@
+// 声明该类所属的包，方便代码的组织和管理，通常按功能模块划分包名
 package com.ew.gerocomium.controller;
 
+// 导入自定义的常量类，该类可能包含一些通用的、不可变的信息，如开发者信息、默认值等
 import com.ew.gerocomium.common.constant.Constant;
+// 导入自定义的基础结果类，用于封装接口返回的结果，一般包含状态码、消息和数据等，方便统一处理接口响应
 import com.ew.gerocomium.dao.base.Result;
+// 导入多个查询类，这些类通常用于封装不同业务操作的查询条件和参数，方便传递和处理
 import com.ew.gerocomium.dao.query.*;
+// 导入押金充值服务类，该类提供了与押金充值相关的业务逻辑，如查询老人信息可能会与押金充值业务有一定关联
 import com.ew.gerocomium.service.DepositRechargeService;
+// 导入护理预定服务类，该类处理与护理预定相关的核心业务逻辑，如查询预定信息、新增预定等
 import com.ew.gerocomium.service.NurseReserveService;
+// 导入服务项目服务类，该类负责与服务项目相关的业务逻辑，如查询服务项目信息等
 import com.ew.gerocomium.service.ServiceProjectService;
+// 导入 Swagger 的 @Api 注解，用于在生成 API 文档时对控制器进行分类和说明，方便开发者和使用者查看接口所属的功能模块
 import io.swagger.annotations.Api;
+// 导入 Swagger 的 @ApiOperation 注解，用于描述 API 操作的详细信息，如操作名称、备注等，有助于生成清晰的 API 文档
 import io.swagger.annotations.ApiOperation;
+// 导入 Swagger 的 @ApiParam 注解，用于描述 API 参数的详细信息，如参数名称、是否必填、参数描述等，方便在文档中展示参数的使用方法
 import io.swagger.annotations.ApiParam;
+// 导入 Spring Security 的 @PreAuthorize 注解，用于在方法执行前进行权限验证，确保只有具有指定权限的用户才能访问该接口
 import org.springframework.security.access.prepost.PreAuthorize;
+// 导入 Spring MVC 的注解，用于处理 HTTP 请求，@GetMapping 处理 GET 请求，@PostMapping 处理 POST 请求，@PutMapping 处理 PUT 请求
 import org.springframework.web.bind.annotation.*;
-
+// 导入 Spring 的 @Resource 注解，用于实现依赖注入，将所需的服务类实例注入到当前类中，方便调用其方法
 import javax.annotation.Resource;
 
+// 使用 Swagger 的 @Api 注解，标记该控制器的标签为“服务预定”，这样在生成的 API 文档中，该控制器下的所有接口都会归类到“服务预定”模块下
 @Api(tags = "服务预定")
+// 使用 Spring MVC 的 @RestController 注解，将该类标记为 RESTful 风格的控制器，它会自动将方法的返回值转换为 JSON 等格式的响应，方便前后端交互
 @RestController
+// 使用 Spring MVC 的 @RequestMapping 注解，定义该控制器处理的请求的基础路径为 /nurseReserve，该控制器下的所有接口路径都会基于此路径
 @RequestMapping("/nurseReserve")
+// 使用 Spring Security 的 @PreAuthorize 注解，进行权限验证，只有拥有 /service/book 权限的用户才能访问该控制器下的接口，确保系统的安全性
 @PreAuthorize("@AuthorityAssert.hasAuthority('/service/book')")
 public class NurseReserveController {
+    // 使用 @Resource 注解，将 NurseReserveService 类型的实例注入到当前类中，用于调用该服务类的方法处理护理预定相关的业务逻辑
     @Resource
     private NurseReserveService nurseReserveService;
+    // 使用 @Resource 注解，将 DepositRechargeService 类型的实例注入到当前类中，用于调用该服务类的方法处理押金充值和老人搜索等相关业务逻辑
     @Resource
     private DepositRechargeService depositRechargeService;
+    // 使用 @Resource 注解，将 ServiceProjectService 类型的实例注入到当前类中，用于调用该服务类的方法处理服务项目相关的业务逻辑
     @Resource
     private ServiceProjectService serviceProjectService;
 
+    /**
+     * 分页查询护理预定信息
+     *
+     * @param PageNurseReserveByKeyQuery 分页查询护理预定的请求实体，包含查询条件（如预定时间范围、老人姓名等）和分页信息（如页码、每页数量）
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口
+     * @return 包含分页查询结果的 Result 对象，封装了查询操作的状态（成功或失败）、消息和查询到的护理预定数据列表
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，处理 HTTP GET 请求，路径为 /nurseReserve/pageNurseReserveByKey
     @GetMapping("/pageNurseReserveByKey")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“分页查询护理预定”，并添加备注信息，通常包含开发者等相关信息
     @ApiOperation(value = "分页查询护理预定", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result pageNurseReserveByKey(@ApiParam(value = "分页查询护理预定请求实体", required = true) PageNurseReserveByKeyQuery PageNurseReserveByKeyQuery,
+    public Result pageNurseReserveByKey(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“分页查询护理预定请求实体”，并标记为必需参数
+            @ApiParam(value = "分页查询护理预定请求实体", required = true)
+            PageNurseReserveByKeyQuery PageNurseReserveByKeyQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用 NurseReserveService 的 pageNurseReserveByKey 方法，传入分页查询请求实体，执行分页查询操作，并返回结果
         return nurseReserveService.pageNurseReserveByKey(PageNurseReserveByKeyQuery);
     }
 
+    /**
+     * 分页搜索老人信息
+     *
+     * @param pageSearchElderByKeyQuery 分页搜索老人的请求实体，包含搜索条件（如老人姓名、身份证号等）和分页信息（如页码、每页数量）
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口
+     * @return 包含分页搜索结果的 Result 对象，封装了搜索操作的状态（成功或失败）、消息和搜索到的老人数据列表
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，处理 HTTP GET 请求，路径为 /nurseReserve/pageSearchElderByKey
     @GetMapping("/pageSearchElderByKey")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“分页搜索老人”，并添加备注信息
     @ApiOperation(value = "分页搜索老人", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result pageSearchElderByKey(@ApiParam(value = "分页搜索老人请求实体", required = true) PageSearchElderByKeyQuery pageSearchElderByKeyQuery,
+    public Result pageSearchElderByKey(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“分页搜索老人请求实体”，并标记为必需参数
+            @ApiParam(value = "分页搜索老人请求实体", required = true)
+            PageSearchElderByKeyQuery pageSearchElderByKeyQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用 DepositRechargeService 的 pageSearchElderByKey 方法，传入分页搜索请求实体，执行分页搜索操作，并返回结果
         return depositRechargeService.pageSearchElderByKey(pageSearchElderByKeyQuery);
     }
 
+    /**
+     * 获取服务项目列表
+     *
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口
+     * @return 包含服务项目列表的 Result 对象，封装了获取操作的状态（成功或失败）、消息和获取到的服务项目数据列表
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，处理 HTTP GET 请求，路径为 /nurseReserve/listService
     @GetMapping("/listService")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“获取服务项目”，并添加备注信息
     @ApiOperation(value = "获取服务项目", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result listService(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+    public Result listService(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+            @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用 NurseReserveService 的 listService 方法，执行获取服务项目列表的操作，并返回结果
         return nurseReserveService.listService();
     }
 
+    /**
+     * 根据编号查询服务信息
+     *
+     * @param serviceId 服务的编号，用于唯一标识一个服务项目
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口
+     * @return 包含服务详细信息的 Result 对象，封装了查询操作的状态（成功或失败）、消息和查询到的服务详细数据
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，处理 HTTP GET 请求，路径为 /nurseReserve/getServiceById
     @GetMapping("/getServiceById")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“根据编号查询服务”，并添加备注信息
     @ApiOperation(value = "根据编号查询服务", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result getServiceById(@ApiParam(value = "根据编号查询服务请求参数", required = true) @RequestParam Long serviceId,
+    public Result getServiceById(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“根据编号查询服务请求参数”，并标记为必需参数，同时使用 @RequestParam 注解从请求参数中获取该参数值
+            @ApiParam(value = "根据编号查询服务请求参数", required = true) @RequestParam
+            Long serviceId,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用 ServiceProjectService 的 getServiceById 方法，传入服务编号，执行查询服务信息的操作，并返回结果
         return serviceProjectService.getServiceById(serviceId);
     }
 
+    /**
+     * 新增护理预定
+     *
+     * @param addNurseReserveQuery 新增护理预定的请求实体，包含预定的详细信息，如老人信息、服务项目、预定时间等
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口
+     * @return 包含新增操作结果的 Result 对象，封装了新增操作的状态（成功或失败）、消息和可能的新增记录信息
+     */
+    // 使用 Spring MVC 的 @PostMapping 注解，处理 HTTP POST 请求，路径为 /nurseReserve/addNurseReserve
     @PostMapping("/addNurseReserve")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“新增护理预定”，并添加备注信息
     @ApiOperation(value = "新增护理预定", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result addNurseReserve(@ApiParam(value = "新增护理预定请求实体", required = true) @RequestBody AddNurseReserveQuery addNurseReserveQuery,
+    public Result addNurseReserve(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“新增护理预定请求实体”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+            @ApiParam(value = "新增护理预定请求实体", required = true) @RequestBody
+            AddNurseReserveQuery addNurseReserveQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用 NurseReserveService 的 addNurseReserve 方法，传入新增护理预定请求实体，执行新增操作，并返回结果
         return nurseReserveService.addNurseReserve(addNurseReserveQuery);
     }
 
+    /**
+     * 获取护理人员列表
+     *
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口
+     * @return 包含护理人员列表的 Result 对象，封装了获取操作的状态（成功或失败）、消息和获取到的护理人员数据列表
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，处理 HTTP GET 请求，路径为 /nurseReserve/listNurseStaff
     @GetMapping("/listNurseStaff")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“护理人员”，并添加备注信息
     @ApiOperation(value = "护理人员", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result listNurseStaff(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+    public Result listNurseStaff(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+            @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用 NurseReserveService 的 listNurseStaff 方法，执行获取护理人员列表的操作，并返回结果
         return nurseReserveService.listNurseStaff();
     }
 
+    /**
+     * 执行护理预定
+     *
+     * @param executeNurseReserve 执行护理预定的请求实体，包含执行预定所需的信息，如预定编号、执行时间等
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口
+     * @return 包含执行操作结果的 Result 对象，封装了执行操作的状态（成功或失败）、消息和可能的执行结果信息
+     */
+    // 使用 Spring MVC 的 @PutMapping 注解，处理 HTTP PUT 请求，路径为 /nurseReserve/executeNurseReserve
     @PutMapping("/executeNurseReserve")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“执行护理预定”，并添加备注信息
     @ApiOperation(value = "执行护理预定", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result executeNurseReserve(@ApiParam(value = "执行护理预定请求实体", required = true) @RequestBody ExecuteNurseReserveQuery executeNurseReserve,
+    public Result executeNurseReserve(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“执行护理预定请求实体”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+            @ApiParam(value = "执行护理预定请求实体", required = true) @RequestBody
+            ExecuteNurseReserveQuery executeNurseReserve,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用 NurseReserveService 的 executeNurseReserve 方法，传入执行护理预定请求实体，执行预定操作，并返回结果
         return nurseReserveService.executeNurseReserve(executeNurseReserve);
     }
 }

server/src/main/java/com/ew/gerocomium/controller/OutwardController.java

@@ -1,99 +1,265 @@
+// 声明该类所在的包，包名遵循命名规范，用于组织和管理代码
 package com.ew.gerocomium.controller;
 
+// 导入自定义的常量类，该类可能包含一些全局通用的常量，如开发者信息等
 import com.ew.gerocomium.common.constant.Constant;
+// 导入自定义的基础结果类，用于封装接口返回的数据，通常包含状态码、消息和具体数据
 import com.ew.gerocomium.dao.base.Result;
+// 导入多个查询实体类，这些类用于封装不同业务操作的查询条件和参数
 import com.ew.gerocomium.dao.query.*;
+// 导入外出登记服务类，该类包含处理外出登记相关业务逻辑的方法
 import com.ew.gerocomium.service.OutwardService;
+// 导入退住申请服务类，虽然当前代码未直接使用该类，但可能在后续扩展或某些业务场景中会用到
 import com.ew.gerocomium.service.RetreatApplyService;
+// 导入 Swagger 注解，用于标记该控制器的 API 分组，方便在生成 API 文档时对接口进行分类展示
 import io.swagger.annotations.Api;
+// 导入 Swagger 注解，用于描述 API 操作的详细信息，如操作名称和备注
 import io.swagger.annotations.ApiOperation;
+// 导入 Swagger 注解，用于描述 API 参数的详细信息，如参数名称、是否必填等
 import io.swagger.annotations.ApiParam;
+// 导入 Spring Security 注解，用于在方法执行前进行权限验证，确保只有具有指定权限的用户才能访问接口
 import org.springframework.security.access.prepost.PreAuthorize;
+// 导入 Spring MVC 注解，用于处理 HTTP 请求，将类标记为 RESTful 风格的控制器
 import org.springframework.web.bind.annotation.*;
-
+// 导入 Spring 注解，用于实现依赖注入，将所需的服务类实例注入到当前类中
 import javax.annotation.Resource;
 
+/**
+ * 外出登记控制器类，负责处理与老人或护工外出登记相关的各种操作请求，
+ * 涵盖了外出登记的增删改查、搜索老人和护工、获取护工列表、紧急联系人相关操作等功能。
+ */
+// 使用 Swagger 的 @Api 注解，标记该控制器的 API 分组为“外出登记”，方便在 API 文档中展示
 @Api(tags = "外出登记")
+// 使用 Spring MVC 的 @RestController 注解，将该类标记为 RESTful 风格的控制器，用于处理 HTTP 请求并返回 JSON 格式的数据
 @RestController
+// 使用 Spring MVC 的 @RequestMapping 注解，指定该控制器处理的请求的基础路径为 "/outward"
 @RequestMapping("/outward")
+// 使用 Spring Security 的 @PreAuthorize 注解，进行权限验证，只有拥有 '/check-in/leave' 权限的用户才能访问该控制器的方法
 @PreAuthorize("@AuthorityAssert.hasAuthority('/check-in/leave')")
 public class OutwardController {
+
+    // 使用 @Resource 注解，将 OutwardService 类型的实例注入到当前类中，以便调用其方法处理外出登记相关业务逻辑
     @Resource
     private OutwardService outwardService;
 
+    /**
+     * 分页查询外出登记记录的方法。
+     *
+     * @param pageOutwardByKeyQuery 分页查询外出登记的请求实体，包含查询条件（如外出时间、外出人员等）和分页信息（如页码、每页数量等）。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含分页查询外出登记操作结果的 Result 对象，封装了操作是否成功以及查询到的外出登记数据列表等信息。
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/outward/pageOutwardByKey"
     @GetMapping("/pageOutwardByKey")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“分页查询外出登记”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "分页查询外出登记", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result pageOutwardByKey(@ApiParam(value = "分页查询外出登记请求实体", required = true) PageOutwardByKeyQuery pageOutwardByKeyQuery,
+    public Result pageOutwardByKey(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“分页查询外出登记请求实体”，并标记为必需参数
+            @ApiParam(value = "分页查询外出登记请求实体", required = true)
+            PageOutwardByKeyQuery pageOutwardByKeyQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用外出登记服务类的 pageOutwardByKey 方法，传入分页查询请求实体，获取分页查询结果并以 Result 对象形式返回
         return outwardService.pageOutwardByKey(pageOutwardByKeyQuery);
     }
 
+    /**
+     * 分页搜索老人信息的方法。
+     *
+     * @param pageSearchElderByKeyQuery 分页搜索老人的请求实体，包含搜索条件（如老人姓名、身份证号等）和分页信息（如页码、每页数量等）。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含分页搜索老人操作结果的 Result 对象，封装了操作是否成功以及搜索到的老人数据列表等信息。
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/outward/pageSearchElderByKey"
     @GetMapping("/pageSearchElderByKey")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“分页搜索老人”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "分页搜索老人", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result pageSearchElderByKey(@ApiParam(value = "分页搜索老人请求实体", required = true) PageSearchElderByKeyQuery pageSearchElderByKeyQuery,
+    public Result pageSearchElderByKey(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“分页搜索老人请求实体”，并标记为必需参数
+            @ApiParam(value = "分页搜索老人请求实体", required = true)
+            PageSearchElderByKeyQuery pageSearchElderByKeyQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用外出登记服务类的 pageSearchElderByKey 方法，传入分页搜索请求实体，获取分页搜索结果并以 Result 对象形式返回
         return outwardService.pageSearchElderByKey(pageSearchElderByKeyQuery);
     }
 
+    /**
+     * 分页搜索护工信息的方法。
+     *
+     * @param pageSearchStaffByKeyQuery 分页搜索护工的请求实体，包含搜索条件（如护工姓名、工号等）和分页信息（如页码、每页数量等）。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含分页搜索护工操作结果的 Result 对象，封装了操作是否成功以及搜索到的护工数据列表等信息。
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/outward/pageSearchStaffByKey"
     @GetMapping("/pageSearchStaffByKey")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“分页搜索护工”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "分页搜索护工", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result pageSearchStaffByKey(@ApiParam(value = "分页搜索护工请求实体", required = true) PageSearchStaffByKeyQuery pageSearchStaffByKeyQuery,
+    public Result pageSearchStaffByKey(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“分页搜索护工请求实体”，并标记为必需参数
+            @ApiParam(value = "分页搜索护工请求实体", required = true)
+            PageSearchStaffByKeyQuery pageSearchStaffByKeyQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用外出登记服务类的 pageSearchStaffByKey 方法，传入分页搜索请求实体，获取分页搜索结果并以 Result 对象形式返回
         return outwardService.pageSearchStaffByKey(pageSearchStaffByKeyQuery);
     }
 
+    /**
+     * 获取护工列表的方法。
+     *
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含获取护工列表操作结果的 Result 对象，封装了操作是否成功以及获取到的护工数据列表等信息。
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/outward/listOutwardStaff"
     @GetMapping("/listOutwardStaff")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“获取护工列表”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "获取护工列表", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result listOutwardStaff(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+    public Result listOutwardStaff(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+            @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用外出登记服务类的 listOutwardStaff 方法获取护工列表，并以 Result 对象形式返回结果
         return outwardService.listOutwardStaff();
     }
 
+    /**
+     * 分页获取紧急联系人信息的方法。
+     *
+     * @param pageSearchEmergencyContactQuery 分页获取紧急联系人的请求实体，包含查询条件（如联系人姓名、联系方式等）和分页信息（如页码、每页数量等）。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含分页获取紧急联系人操作结果的 Result 对象，封装了操作是否成功以及获取到的紧急联系人数据列表等信息。
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/outward/pageEmergencyContact"
     @GetMapping("/pageEmergencyContact")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“分页获取紧急联系人”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "分页获取紧急联系人", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result pageEmergencyContact(@ApiParam(value = "分页获取紧急联系人请求实体", required = true) PageSearchEmergencyContactQuery pageSearchEmergencyContactQuery,
+    public Result pageEmergencyContact(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“分页获取紧急联系人请求实体”，并标记为必需参数
+            @ApiParam(value = "分页获取紧急联系人请求实体", required = true)
+            PageSearchEmergencyContactQuery pageSearchEmergencyContactQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用外出登记服务类的 pageEmergencyContact 方法，传入分页获取请求实体，获取分页查询结果并以 Result 对象形式返回
         return outwardService.pageEmergencyContact(pageSearchEmergencyContactQuery);
     }
 
+    /**
+     * 根据老人编号获取紧急联系人列表的方法。
+     *
+     * @param elderId 要获取紧急联系人列表的老人的编号。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含根据老人编号获取紧急联系人列表操作结果的 Result 对象，封装了操作是否成功以及获取到的紧急联系人数据列表等信息。
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/outward/listContactByElderId"
     @GetMapping("/listContactByElderId")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“获取紧急联系人列表”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "获取紧急联系人列表", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result listContact(@ApiParam(value = "根据编号获取外出登记请求参数", required = true) @RequestParam Long elderId,
+    public Result listContact(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“根据编号获取外出登记请求参数”，并标记为必需参数，同时使用 @RequestParam 注解从请求参数中获取该参数值
+            @ApiParam(value = "根据编号获取外出登记请求参数", required = true) @RequestParam Long elderId,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用外出登记服务类的 listContactByElderId 方法，传入老人编号，获取紧急联系人列表并以 Result 对象形式返回
         return outwardService.listContactByElderId(elderId);
     }
 
+    /**
+     * 新增外出登记记录的方法。
+     *
+     * @param addOutwardQuery 新增外出登记的请求实体，包含要新增的外出登记的详细信息，如外出人员、外出时间、返回时间等。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含新增外出登记操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+     */
+    // 使用 Spring MVC 的 @PostMapping 注解，指定该方法处理 HTTP POST 请求，路径为 "/outward/addOutward"
     @PostMapping("/addOutward")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“新增外出登记”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "新增外出登记", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result addOutward(@ApiParam(value = "新增外出登记请求实体", required = true) @RequestBody AddOutwardQuery addOutwardQuery,
+    public Result addOutward(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“新增外出登记请求实体”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+            @ApiParam(value = "新增外出登记请求实体", required = true) @RequestBody AddOutwardQuery addOutwardQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用外出登记服务类的 addOutward 方法，传入新增外出登记请求实体，执行新增操作并以 Result 对象形式返回
         return outwardService.addOutward(addOutwardQuery);
     }
 
+    /**
+     * 根据编号获取外出登记记录信息的方法。
+     *
+     * @param outwardId 要获取信息的外出登记记录的编号。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含根据编号获取外出登记记录操作结果的 Result 对象，封装了操作是否成功以及获取到的外出登记记录详细信息等。
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/outward/getOutwardById"
     @GetMapping("/getOutwardById")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“根据编号获取外出登记”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "根据编号获取外出登记", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result getOutwardById(@ApiParam(value = "根据编号获取外出登记请求参数", required = true) @RequestParam Long outwardId,
+    public Result getOutwardById(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“根据编号获取外出登记请求参数”，并标记为必需参数，同时使用 @RequestParam 注解从请求参数中获取该参数值
+            @ApiParam(value = "根据编号获取外出登记请求参数", required = true) @RequestParam Long outwardId,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用外出登记服务类的 getOutwardById 方法，传入外出登记记录编号，获取外出登记记录信息并以 Result 对象形式返回
         return outwardService.getOutwardById(outwardId);
     }
 
+    /**
+     * 处理外出人员延期返回的方法。
+     *
+     * @param delayReturnQuery 延期返回的请求实体，包含延期的相关信息，如延期原因、新的返回时间等。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含处理延期返回操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+     */
+    // 使用 Spring MVC 的 @PutMapping 注解，指定该方法处理 HTTP PUT 请求，路径为 "/outward/delayReturn"
     @PutMapping("/delayReturn")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“延期返回”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "延期返回", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result delayReturn(@ApiParam(value = "延期返回请求实体", required = true) @RequestBody DelayReturnQuery delayReturnQuery,
+    public Result delayReturn(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“延期返回请求实体”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+            @ApiParam(value = "延期返回请求实体", required = true) @RequestBody DelayReturnQuery delayReturnQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用外出登记服务类的 delayReturn 方法，传入延期返回请求实体，执行延期返回操作并以 Result 对象形式返回
         return outwardService.delayReturn(delayReturnQuery);
     }
 
+    /**
+     * 登记外出人员返回的方法。
+     *
+     * @param recordReturnQuery 登记返回的请求实体，包含返回的相关信息，如实际返回时间、返回状态等。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含登记返回操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+     */
+    // 使用 Spring MVC 的 @PutMapping 注解，指定该方法处理 HTTP PUT 请求，路径为 "/outward/recordReturn"
     @PutMapping("/recordReturn")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“登记返回”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "登记返回", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result recordReturn(@ApiParam(value = "登记返回请求实体", required = true) @RequestBody RecordReturnQuery recordReturnQuery,
+    public Result recordReturn(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“登记返回请求实体”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+            @ApiParam(value = "登记返回请求实体", required = true) @RequestBody RecordReturnQuery recordReturnQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用外出登记服务类的 recordReturn 方法，传入登记返回请求实体，执行登记返回操作并以 Result 对象形式返回
         return outwardService.recordReturn(recordReturnQuery);
     }
 
+    /**
+     * 删除外出登记记录的方法。
+     *
+     * @param outwardId 要删除的外出登记记录的编号。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含删除外出登记记录操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+     */
+    // 使用 Spring MVC 的 @DeleteMapping 注解，指定该方法处理 HTTP DELETE 请求，路径为 "/outward/deleteOutward"
     @DeleteMapping("/deleteOutward")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“删除外出登记”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "删除外出登记", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result deleteOutward(@ApiParam(value = "删除外出登记请求参数", required = true) @RequestParam Long outwardId,
+    public Result deleteOutward(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“删除外出登记请求参数”，并标记为必需参数，同时使用 @RequestParam 注解从请求参数中获取该参数值
+            @ApiParam(value = "删除外出登记请求参数", required = true) @RequestParam Long outwardId,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用外出登记服务类的 deleteOutward 方法，传入外出登记记录编号，执行删除操作并以 Result 对象形式返回
         return outwardService.deleteOutward(outwardId);
     }
 }

server/src/main/java/com/ew/gerocomium/controller/ReserveController.java

@@ -1,72 +1,189 @@
+// 声明该类所在的包，用于组织项目中的类，这里表示是预定管理相关控制器类的包
 package com.ew.gerocomium.controller;
 
+// 导入项目自定义的常量类，可能包含项目通用的一些常量信息，如开发者标识等
 import com.ew.gerocomium.common.constant.Constant;
+// 导入项目自定义的基础结果类，用于封装接口返回的数据，通常包含状态码、消息和具体数据内容
 import com.ew.gerocomium.dao.base.Result;
+// 导入多个查询实体类，这些类用于封装不同业务操作的查询条件和参数
 import com.ew.gerocomium.dao.query.*;
-import com.ew.gerocomium.service.ConsultService;
+// 导入预定服务类，该类包含处理预定相关业务逻辑的方法
 import com.ew.gerocomium.service.ReserveService;
+// 导入咨询服务类，该类包含处理咨询相关业务逻辑的方法
+import com.ew.gerocomium.service.ConsultService;
+// 导入 Swagger 注解，用于标记 API 分组，方便在生成 API 文档时对接口进行分类展示
 import io.swagger.annotations.Api;
+// 导入 Swagger 注解，用于描述 API 操作的详细信息，如操作名称和备注
 import io.swagger.annotations.ApiOperation;
+// 导入 Swagger 注解，用于描述 API 参数的详细信息，如参数名称、是否必填等
 import io.swagger.annotations.ApiParam;
+// 导入 Spring Security 注解，用于在方法执行前进行权限验证，确保只有具有指定权限的用户才能访问接口
 import org.springframework.security.access.prepost.PreAuthorize;
+// 导入 Spring MVC 注解，用于处理 HTTP 请求，将类标记为 RESTful 风格的控制器
 import org.springframework.web.bind.annotation.*;
-
+// 导入 Spring 注解，用于实现依赖注入，将所需的服务类实例注入到当前类中
 import javax.annotation.Resource;
 
+/**
+ * 预定管理控制器类，用于处理与预定相关的各种操作请求，
+ * 包括获取营销人员列表、分页查询预定信息、搜索老人、获取楼栋树、
+ * 新增预定、根据预定编号和老人编号获取预定信息以及退款等功能。
+ */
+// 使用 Swagger 的 @Api 注解，标记该控制器的 API 分组为“预定管理”，方便在 API 文档中展示
 @Api(tags = "预定管理")
+// 使用 Spring MVC 的 @RestController 注解，将该类标记为 RESTful 风格的控制器，用于处理 HTTP 请求并返回 JSON 格式的数据
 @RestController
+// 使用 Spring MVC 的 @RequestMapping 注解，指定该控制器处理的请求的基础路径为 "/reserve"
 @RequestMapping("/reserve")
+// 使用 Spring Security 的 @PreAuthorize 注解，进行权限验证，只有拥有 '/soles/booking' 权限的用户才能访问该控制器的方法
 @PreAuthorize("@AuthorityAssert.hasAuthority('/soles/booking')")
 public class ReserveController {
+
+    // 使用 @Resource 注解，将 ReserveService 类型的实例注入到当前类中，以便调用其方法处理预定相关业务逻辑
     @Resource
     private ReserveService reserveService;
+
+    // 使用 @Resource 注解，将 ConsultService 类型的实例注入到当前类中，以便调用其方法处理咨询相关业务逻辑
     @Resource
     private ConsultService consultService;
 
+    /**
+     * 获取营销人员列表的方法。
+     * 这里调用了 consultService 的 listConsultStaff 方法，可能是因为营销人员与咨询人员相关。
+     *
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含获取营销人员列表操作结果的 Result 对象，封装了操作是否成功以及获取到的营销人员数据列表等信息。
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/reserve/listReserveStaff"
     @GetMapping("/listReserveStaff")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“获取营销人员”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "获取营销人员", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result listReserveStaff(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+    public Result listReserveStaff(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+            @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用咨询服务类的 listConsultStaff 方法获取营销人员列表，并以 Result 对象形式返回结果
         return consultService.listConsultStaff();
     }
 
+    /**
+     * 分页查询预定信息的方法。
+     *
+     * @param pageReserveByKeyQuery 分页查询预定的请求实体，包含查询条件（如预定时间、预定人员等）和分页信息（如页码、每页数量等）。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含分页查询预定操作结果的 Result 对象，封装了操作是否成功以及查询到的预定数据列表等信息。
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/reserve/pageReserveByKey"
     @GetMapping("/pageReserveByKey")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“分页查询预定”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "分页查询预定", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result pageReserveByKey(@ApiParam(value = "分页查询预定请求实体", required = true) PageReserveByKeyQuery pageReserveByKeyQuery,
+    public Result pageReserveByKey(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“分页查询预定请求实体”，并标记为必需参数
+            @ApiParam(value = "分页查询预定请求实体", required = true)
+            PageReserveByKeyQuery pageReserveByKeyQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用预定服务类的 pageReserveByKey 方法，传入分页查询请求实体，获取分页查询结果并以 Result 对象形式返回
         return reserveService.pageReserveByKey(pageReserveByKeyQuery);
     }
 
+    /**
+     * 分页搜索老人信息的方法。
+     *
+     * @param pageSearchElderByKeyQuery 分页搜索老人的请求实体，包含搜索条件（如老人姓名、身份证号等）和分页信息（如页码、每页数量等）。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含分页搜索老人操作结果的 Result 对象，封装了操作是否成功以及搜索到的老人数据列表等信息。
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/reserve/pageSearchElderByKey"
     @GetMapping("/pageSearchElderByKey")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“分页搜索老人”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "分页搜索老人", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result pageSearchElderByKey(@ApiParam(value = "分页搜索老人请求实体", required = true) PageSearchElderByKeyQuery pageSearchElderByKeyQuery,
+    public Result pageSearchElderByKey(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“分页搜索老人请求实体”，并标记为必需参数
+            @ApiParam(value = "分页搜索老人请求实体", required = true)
+            PageSearchElderByKeyQuery pageSearchElderByKeyQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用预定服务类的 pageSearchElderByKey 方法，传入分页搜索请求实体，获取分页搜索结果并以 Result 对象形式返回
         return reserveService.pageSearchElderByKey(pageSearchElderByKeyQuery);
     }
 
+    /**
+     * 获取楼栋树信息的方法。
+     *
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含获取楼栋树操作结果的 Result 对象，封装了操作是否成功以及获取到的楼栋树相关数据等信息。
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/reserve/getBuildTree"
     @GetMapping("/getBuildTree")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“获取楼栋树”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "获取楼栋树", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result getBuildTree(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+    public Result getBuildTree(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+            @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用预定服务类的 getBuildTree 方法获取楼栋树信息，并以 Result 对象形式返回结果
         return reserveService.getBuildTree();
     }
 
+    /**
+     * 新增预定记录的方法。
+     *
+     * @param addReserveQuery 新增预定的请求实体，包含要新增的预定的详细信息，如预定人员、预定时间、预定房间等。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含新增预定操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+     */
+    // 使用 Spring MVC 的 @PostMapping 注解，指定该方法处理 HTTP POST 请求，路径为 "/reserve/addReserve"
     @PostMapping("/addReserve")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“新增预定”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "新增预定", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result addReserve(@ApiParam(value = "新增预定请求实体", required = true) @RequestBody AddReserveQuery addReserveQuery,
+    public Result addReserve(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“新增预定请求实体”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+            @ApiParam(value = "新增预定请求实体", required = true) @RequestBody AddReserveQuery addReserveQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用预定服务类的 addReserve 方法，传入新增预定请求实体，执行新增预定操作并以 Result 对象形式返回
         return reserveService.addReserve(addReserveQuery);
     }
 
+    /**
+     * 根据预定编号和老人编号获取预定信息的方法。
+     *
+     * @param getReserveByReserveIdAndElderIdQuery 包含预定编号和老人编号的请求实体。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含根据预定编号和老人编号获取预定信息操作结果的 Result 对象，
+     *         封装了操作是否成功以及获取到的预定详细信息等。
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/reserve/getReserveByReserveIdAndElderId"
     @GetMapping("/getReserveByReserveIdAndElderId")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“根据预定编号和老人编号获取预定信息”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "根据预定编号和老人编号获取预定信息", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result getReserveByReserveIdAndElderId(@ApiParam(value = "根据预定编号和老人编号获取预定信息请求实体", required = true) GetReserveByReserveIdAndElderIdQuery getReserveByReserveIdAndElderIdQuery,
+    public Result getReserveByReserveIdAndElderId(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“根据预定编号和老人编号获取预定信息请求实体”，并标记为必需参数
+            @ApiParam(value = "根据预定编号和老人编号获取预定信息请求实体", required = true)
+            GetReserveByReserveIdAndElderIdQuery getReserveByReserveIdAndElderIdQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用预定服务类的 getReserveByReserveIdAndElderId 方法，传入请求实体，获取预定信息并以 Result 对象形式返回
         return reserveService.getReserveByReserveIdAndElderId(getReserveByReserveIdAndElderIdQuery);
     }
 
+    /**
+     * 处理退款操作的方法。
+     * 从请求实体中获取预定编号，调用 reserveService 的 refund 方法进行退款操作。
+     *
+     * @param getReserveByReserveIdAndElderIdQuery 包含预定编号的请求实体（这里可能只用到预定编号进行退款）。
+     * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+     * @return 包含退款操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+     */
+    // 使用 Spring MVC 的 @PutMapping 注解，指定该方法处理 HTTP PUT 请求，路径为 "/reserve/refund"
     @PutMapping("/refund")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“退款”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "退款", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result refund(@ApiParam(value = "退款请求参数", required = true) @RequestBody GetReserveByReserveIdAndElderIdQuery getReserveByReserveIdAndElderIdQuery,
+    public Result refund(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“退款请求参数”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+            @ApiParam(value = "退款请求参数", required = true) @RequestBody GetReserveByReserveIdAndElderIdQuery getReserveByReserveIdAndElderIdQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 从请求实体中获取预定编号，调用预定服务类的 refund 方法进行退款操作，并以 Result 对象形式返回结果
         return reserveService.refund(getReserveByReserveIdAndElderIdQuery.getReserveId());
     }
 }

server/src/main/java/com/ew/gerocomium/controller/RetreatApplyController.java

@@ -1,45 +1,106 @@
+// 声明该类所在的包，用于组织和管理代码，这里表示该类属于 com.ew.gerocomium.controller 包
 package com.ew.gerocomium.controller;
 
+// 导入项目自定义的常量类，可能包含一些通用的常量信息，如开发者信息等
 import com.ew.gerocomium.common.constant.Constant;
+// 导入项目自定义的基础结果类，用于封装接口返回的数据，一般包含状态码、消息和具体数据
 import com.ew.gerocomium.dao.base.Result;
+// 导入根据预订 ID 和老人 ID 获取预订信息的查询实体类，这里用于新增退住申请时获取相关信息
 import com.ew.gerocomium.dao.query.GetReserveByReserveIdAndElderIdQuery;
+// 导入分页查询退住申请的查询实体类，用于封装分页查询退住申请的条件和分页信息
 import com.ew.gerocomium.dao.query.PageRetreatApplyQuery;
+// 导入分页搜索老人的查询实体类，用于封装分页搜索老人的条件和分页信息
 import com.ew.gerocomium.dao.query.PageSearchElderByKeyQuery;
+// 导入退住申请服务类，该类包含处理退住申请相关业务逻辑的方法
 import com.ew.gerocomium.service.RetreatApplyService;
+// 导入 Swagger 注解，用于标记 API 分组，方便在生成 API 文档时对接口进行分类展示
 import io.swagger.annotations.Api;
+// 导入 Swagger 注解，用于描述 API 操作的详细信息，如操作名称和备注
 import io.swagger.annotations.ApiOperation;
+// 导入 Swagger 注解，用于描述 API 参数的详细信息，如参数名称、是否必填等
 import io.swagger.annotations.ApiParam;
+// 导入 Spring Security 注解，用于在方法执行前进行权限验证，确保只有具有指定权限的用户才能访问接口
 import org.springframework.security.access.prepost.PreAuthorize;
+// 导入 Spring MVC 注解，用于处理 HTTP 请求，将类标记为 RESTful 风格的控制器
 import org.springframework.web.bind.annotation.*;
-
+// 导入 Spring 注解，用于实现依赖注入，将所需的服务类实例注入到当前类中
 import javax.annotation.Resource;
 
+/**
+ * 退住申请控制器，处理与退住申请相关的 HTTP 请求。
+ */
+// 使用 Swagger 的 @Api 注解，标记该控制器的 API 分组为“退住申请”，方便在 API 文档中展示
 @Api(tags = "退住申请")
+// 使用 Spring MVC 的 @RestController 注解，将该类标记为 RESTful 风格的控制器，用于处理 HTTP 请求并返回 JSON 格式的数据
 @RestController
+// 使用 Spring MVC 的 @RequestMapping 注解，指定该控制器处理的请求的基础路径为 "/retreatApply"
 @RequestMapping("/retreatApply")
+// 使用 Spring Security 的 @PreAuthorize 注解，进行权限验证，只有拥有 '/check-in/check-out' 权限的用户才能访问该控制器的方法
 @PreAuthorize("@AuthorityAssert.hasAuthority('/check-in/check-out')")
 public class RetreatApplyController {
+    // 使用 @Resource 注解，将 RetreatApplyService 类型的实例注入到当前类中，以便调用其方法处理业务逻辑
     @Resource
     private RetreatApplyService retreatApplyService;
 
+    /**
+     * 分页查询退住申请。
+     *
+     * @param pageRetreatApplyQuery 分页查询退住申请的请求实体，包含查询条件和分页信息
+     * @param token 接口访问请求头中的令牌，用于身份验证
+     * @return 包含分页查询结果的 Result 对象
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/retreatApply/pageRetreatApplyByKey"
     @GetMapping("/pageRetreatApplyByKey")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“分页查询退住申请”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "分页查询退住申请", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result pageRetreatApplyByKey(@ApiParam(value = "分页查询退住申请请求实体", required = true) PageRetreatApplyQuery pageRetreatApplyQuery,
+    public Result pageRetreatApplyByKey(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“分页查询退住申请请求实体”，并标记为必需参数
+            @ApiParam(value = "分页查询退住申请请求实体", required = true)
+            PageRetreatApplyQuery pageRetreatApplyQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用退住申请服务类的 pageRetreatApplyByKey 方法，传入分页查询请求实体，获取分页查询结果并以 Result 对象形式返回
         return retreatApplyService.pageRetreatApplyByKey(pageRetreatApplyQuery);
     }
 
+    /**
+     * 分页搜索老人信息。
+     *
+     * @param pageSearchElderByKeyQuery 分页搜索老人的请求实体，包含搜索条件和分页信息
+     * @param token 接口访问请求头中的令牌，用于身份验证
+     * @return 包含分页搜索结果的 Result 对象
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/retreatApply/pageSearchElderByKey"
     @GetMapping("/pageSearchElderByKey")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“分页搜索老人”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "分页搜索老人", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result pageSearchElderByKey(@ApiParam(value = "分页搜索老人请求实体", required = true) PageSearchElderByKeyQuery pageSearchElderByKeyQuery,
+    public Result pageSearchElderByKey(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“分页搜索老人请求实体”，并标记为必需参数
+            @ApiParam(value = "分页搜索老人请求实体", required = true)
+            PageSearchElderByKeyQuery pageSearchElderByKeyQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用退住申请服务类的 pageSearchElderByKey 方法，传入分页搜索请求实体，获取分页搜索结果并以 Result 对象形式返回
         return retreatApplyService.pageSearchElderByKey(pageSearchElderByKeyQuery);
     }
 
+    /**
+     * 新增退住申请。
+     *
+     * @param getReserveByReserveIdAndElderIdQuery 新增退住申请的请求参数，包含老人编号等信息
+     * @param token 接口访问请求头中的令牌，用于身份验证
+     * @return 包含新增操作结果的 Result 对象
+     */
+    // 使用 Spring MVC 的 @PostMapping 注解，指定该方法处理 HTTP POST 请求，路径为 "/retreatApply/addRetreatApply"
     @PostMapping("/addRetreatApply")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“新增退住申请”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "新增退住申请", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result addRetreatApply(@ApiParam(value = "新增退住申请请求参数", required = true) @RequestBody GetReserveByReserveIdAndElderIdQuery getReserveByReserveIdAndElderIdQuery,
+    public Result addRetreatApply(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“新增退住申请请求参数”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+            @ApiParam(value = "新增退住申请请求参数", required = true) @RequestBody GetReserveByReserveIdAndElderIdQuery getReserveByReserveIdAndElderIdQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 从请求参数中获取老人编号，并调用退住申请服务类的 addRetreatApply 方法，传入老人编号，执行新增退住申请操作并以 Result 对象形式返回
         return retreatApplyService.addRetreatApply(getReserveByReserveIdAndElderIdQuery.getElderId());
     }
 }

server/src/main/java/com/ew/gerocomium/controller/ServiceProjectController.java

@@ -1,92 +1,242 @@
+// 声明该类所在的包，用于组织和管理项目中的类，这里表明该类是控制器相关的类
 package com.ew.gerocomium.controller;
 
+// 导入项目自定义的常量类，通常包含一些通用的常量信息，如开发者信息等
 import com.ew.gerocomium.common.constant.Constant;
+// 导入项目自定义的基础结果类，用于封装接口返回的数据，一般包含状态码、消息和具体的数据内容
 import com.ew.gerocomium.dao.base.Result;
+// 导入多个查询实体类，这些类用于封装不同业务操作的查询条件和参数
 import com.ew.gerocomium.dao.query.*;
+// 导入服务项目的服务类，该类包含了处理服务项目和服务类型相关业务逻辑的方法
 import com.ew.gerocomium.service.ServiceProjectService;
+// 导入 Swagger 注解，用于标记 API 分组，方便在生成 API 文档时对接口进行分类展示
 import io.swagger.annotations.Api;
+// 导入 Swagger 注解，用于描述 API 操作的详细信息，如操作名称和备注
 import io.swagger.annotations.ApiOperation;
+// 导入 Swagger 注解，用于描述 API 参数的详细信息，如参数名称、是否必填等
 import io.swagger.annotations.ApiParam;
+// 导入 Spring Security 注解，用于在方法执行前进行权限验证，确保只有具有指定权限的用户才能访问接口
 import org.springframework.security.access.prepost.PreAuthorize;
+// 导入 Spring MVC 注解，用于处理 HTTP 请求，将类标记为 RESTful 风格的控制器
 import org.springframework.web.bind.annotation.*;
-
+// 导入 Spring 注解，用于实现依赖注入，将所需的服务类实例注入到当前类中
 import javax.annotation.Resource;
 
+/**
+ * 服务项目控制器，处理与服务项目和服务类型相关的 HTTP 请求。
+ */
+// 使用 Swagger 的 @Api 注解，标记该控制器的 API 分组为“服务项目”，方便在 API 文档中展示
 @Api(tags = "服务项目")
+// 使用 Spring MVC 的 @RestController 注解，将该类标记为 RESTful 风格的控制器，用于处理 HTTP 请求并返回 JSON 格式的数据
 @RestController
+// 使用 Spring MVC 的 @RequestMapping 注解，指定该控制器处理的请求的基础路径为 "/service"
 @RequestMapping("/service")
+// 使用 Spring Security 的 @PreAuthorize 注解，进行权限验证，只有拥有 '/service/project' 权限的用户才能访问该控制器的方法
 @PreAuthorize("@AuthorityAssert.hasAuthority('/service/project')")
 public class ServiceProjectController {
+    // 使用 @Resource 注解，将 ServiceProjectService 类型的实例注入到当前类中，以便调用其方法处理业务逻辑
     @Resource
     private ServiceProjectService serviceProjectService;
 
+    /**
+     * 获取服务类型列表。
+     *
+     * @param serviceTypeName 可选的服务类型名称，用于过滤服务类型列表
+     * @param token 接口访问请求头中的令牌，用于身份验证
+     * @return 包含服务类型列表的 Result 对象
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/service/getServiceType"
     @GetMapping("/getServiceType")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“获取服务类型”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "获取服务类型", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result getServiceType(@ApiParam(value = "获取服务类型请求参数", required = false) String serviceTypeName,
+    public Result getServiceType(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“获取服务类型请求参数”，并标记为非必需参数
+            @ApiParam(value = "获取服务类型请求参数", required = false)
+            String serviceTypeName,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用服务项目服务类的 listServiceType 方法，传入服务类型名称，获取服务类型列表并以 Result 对象形式返回
         return serviceProjectService.listServiceType(serviceTypeName);
     }
 
+    /**
+     * 分页查询服务信息。
+     *
+     * @param pageServiceByKeyQuery 分页查询服务的请求实体，包含查询条件和分页信息
+     * @param token 接口访问请求头中的令牌，用于身份验证
+     * @return 包含分页查询结果的 Result 对象
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/service/pageServiceByKey"
     @GetMapping("/pageServiceByKey")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“分页查询服务”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "分页查询服务", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result pageServiceByKey(@ApiParam(value = "分页查询服务请求实体", required = true) PageServiceByKeyQuery pageServiceByKeyQuery,
+    public Result pageServiceByKey(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“分页查询服务请求实体”，并标记为必需参数
+            @ApiParam(value = "分页查询服务请求实体", required = true)
+            PageServiceByKeyQuery pageServiceByKeyQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用服务项目服务类的 pageServiceByKey 方法，传入分页查询请求实体，获取分页查询结果并以 Result 对象形式返回
         return serviceProjectService.pageServiceByKey(pageServiceByKeyQuery);
     }
 
+    /**
+     * 新增服务类型。
+     *
+     * @param operateServiceTypeQuery 新增服务类型的请求实体，包含服务类型的详细信息
+     * @param token 接口访问请求头中的令牌，用于身份验证
+     * @return 包含新增操作结果的 Result 对象
+     */
+    // 使用 Spring MVC 的 @PostMapping 注解，指定该方法处理 HTTP POST 请求，路径为 "/service/addServiceType"
     @PostMapping("/addServiceType")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“新增服务类型”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "新增服务类型", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result addServiceType(@ApiParam(value = "新增服务类型请求实体", required = true) @RequestBody OperateServiceTypeQuery operateServiceTypeQuery,
+    public Result addServiceType(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“新增服务类型请求实体”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+            @ApiParam(value = "新增服务类型请求实体", required = true) @RequestBody OperateServiceTypeQuery operateServiceTypeQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用服务项目服务类的 addServiceType 方法，传入新增服务类型请求实体，执行新增操作并将结果以 Result 对象形式返回
         return serviceProjectService.addServiceType(operateServiceTypeQuery);
     }
 
+    /**
+     * 根据编号查询服务类型。
+     *
+     * @param serviceTypeId 服务类型的编号
+     * @param token 接口访问请求头中的令牌，用于身份验证
+     * @return 包含服务类型详细信息的 Result 对象
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/service/getServiceTypeById"
     @GetMapping("/getServiceTypeById")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“根据编号查询服务类型”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "根据编号查询服务类型", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result getServiceTypeById(@ApiParam(value = "根据编号查询服务类型请求参数", required = true) @RequestParam Long serviceTypeId,
+    public Result getServiceTypeById(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“根据编号查询服务类型请求参数”，并标记为必需参数，同时使用 @RequestParam 注解从请求参数中获取该参数值
+            @ApiParam(value = "根据编号查询服务类型请求参数", required = true) @RequestParam Long serviceTypeId,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用服务项目服务类的 getServiceTypeById 方法，传入服务类型编号，获取指定编号的服务类型详细信息并以 Result 对象形式返回
         return serviceProjectService.getServiceTypeById(serviceTypeId);
     }
 
+    /**
+     * 编辑服务类型。
+     *
+     * @param operateServiceTypeQuery 编辑服务类型的请求实体，包含要更新的服务类型信息
+     * @param token 接口访问请求头中的令牌，用于身份验证
+     * @return 包含编辑操作结果的 Result 对象
+     */
+    // 使用 Spring MVC 的 @PutMapping 注解，指定该方法处理 HTTP PUT 请求，路径为 "/service/editServiceType"
     @PutMapping("/editServiceType")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“编辑服务类型”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "编辑服务类型", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result editServiceType(@ApiParam(value = "编辑服务类型请求实体", required = true) @RequestBody OperateServiceTypeQuery operateServiceTypeQuery,
+    public Result editServiceType(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“编辑服务类型请求实体”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+            @ApiParam(value = "编辑服务类型请求实体", required = true) @RequestBody OperateServiceTypeQuery operateServiceTypeQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用服务项目服务类的 editServiceType 方法，传入编辑服务类型请求实体，执行编辑操作并将结果以 Result 对象形式返回
         return serviceProjectService.editServiceType(operateServiceTypeQuery);
     }
 
+    /**
+     * 删除服务类型。
+     *
+     * @param serviceTypeId 要删除的服务类型的编号
+     * @param token 接口访问请求头中的令牌，用于身份验证
+     * @return 包含删除操作结果的 Result 对象
+     */
+    // 使用 Spring MVC 的 @DeleteMapping 注解，指定该方法处理 HTTP DELETE 请求，路径为 "/service/deleteServiceType"
     @DeleteMapping("/deleteServiceType")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“删除服务类型”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "删除服务类型", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result deleteServiceType(@ApiParam(value = "删除服务类型请求参数", required = true) @RequestParam Long serviceTypeId,
+    public Result deleteServiceType(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“删除服务类型请求参数”，并标记为必需参数，同时使用 @RequestParam 注解从请求参数中获取该参数值
+            @ApiParam(value = "删除服务类型请求参数", required = true) @RequestParam Long serviceTypeId,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用服务项目服务类的 deleteServiceType 方法，传入服务类型编号，执行删除操作并将结果以 Result 对象形式返回
         return serviceProjectService.deleteServiceType(serviceTypeId);
     }
 
+    /**
+     * 新增服务。
+     *
+     * @param operateServiceQuery 新增服务的请求实体，包含服务的详细信息
+     * @param token 接口访问请求头中的令牌，用于身份验证
+     * @return 包含新增操作结果的 Result 对象
+     */
+    // 使用 Spring MVC 的 @PostMapping 注解，指定该方法处理 HTTP POST 请求，路径为 "/service/addService"
     @PostMapping("/addService")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“新增服务”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "新增服务", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result addService(@ApiParam(value = "新增服务请求实体", required = true) @RequestBody OperateServiceQuery operateServiceQuery,
+    public Result addService(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“新增服务请求实体”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+            @ApiParam(value = "新增服务请求实体", required = true) @RequestBody OperateServiceQuery operateServiceQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用服务项目服务类的 addService 方法，传入新增服务请求实体，执行新增操作并将结果以 Result 对象形式返回
         return serviceProjectService.addService(operateServiceQuery);
     }
 
+    /**
+     * 根据编号查询服务。
+     *
+     * @param serviceId 服务的编号
+     * @param token 接口访问请求头中的令牌，用于身份验证
+     * @return 包含服务详细信息的 Result 对象
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/service/getServiceById"
     @GetMapping("/getServiceById")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“根据编号查询服务”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "根据编号查询服务", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result getServiceById(@ApiParam(value = "根据编号查询服务请求参数", required = true) @RequestParam Long serviceId,
+    public Result getServiceById(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“根据编号查询服务请求参数”，并标记为必需参数，同时使用 @RequestParam 注解从请求参数中获取该参数值
+            @ApiParam(value = "根据编号查询服务请求参数", required = true) @RequestParam Long serviceId,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用服务项目服务类的 getServiceById 方法，传入服务编号，获取指定编号的服务详细信息并以 Result 对象形式返回
         return serviceProjectService.getServiceById(serviceId);
     }
 
+    /**
+     * 编辑服务。
+     *
+     * @param operateServiceQuery 编辑服务的请求实体，包含要更新的服务信息
+     * @param token 接口访问请求头中的令牌，用于身份验证
+     * @return 包含编辑操作结果的 Result 对象
+     */
+    // 使用 Spring MVC 的 @PutMapping 注解，指定该方法处理 HTTP PUT 请求，路径为 "/service/editService"
     @PutMapping("/editService")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“编辑服务”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "编辑服务", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result editService(@ApiParam(value = "编辑服务请求实体", required = true) @RequestBody OperateServiceQuery operateServiceQuery,
+    public Result editService(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“编辑服务请求实体”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+            @ApiParam(value = "编辑服务请求实体", required = true) @RequestBody OperateServiceQuery operateServiceQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用服务项目服务类的 editService 方法，传入编辑服务请求实体，执行编辑操作并将结果以 Result 对象形式返回
         return serviceProjectService.editService(operateServiceQuery);
     }
 
+    /**
+     * 删除服务。
+     *
+     * @param serviceId 要删除的服务的编号
+     * @param token 接口访问请求头中的令牌，用于身份验证
+     * @return 包含删除操作结果的 Result 对象
+     */
+    // 使用 Spring MVC 的 @DeleteMapping 注解，指定该方法处理 HTTP DELETE 请求，路径为 "/service/deleteService"
     @DeleteMapping("/deleteService")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“删除服务”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "删除服务", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result deleteService(@ApiParam(value = "删除服务请求参数", required = true) @RequestParam Long serviceId,
+    public Result deleteService(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“删除服务请求参数”，并标记为必需参数，同时使用 @RequestParam 注解从请求参数中获取该参数值
+            @ApiParam(value = "删除服务请求参数", required = true) @RequestParam Long serviceId,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用服务项目服务类的 deleteService 方法，传入服务编号，执行删除操作并将结果以 Result 对象形式返回
         return serviceProjectService.deleteService(serviceId);
     }
 }

server/src/main/java/com/ew/gerocomium/controller/StaffController.java

@@ -1,65 +1,162 @@
+// 声明当前类所在的包，表明这是员工管理相关控制器类所在的包
 package com.ew.gerocomium.controller;
 
+// 导入项目自定义的常量类，可能包含一些通用的开发相关常量等信息
 import com.ew.gerocomium.common.constant.Constant;
+// 导入项目自定义的基础结果类，用于封装接口返回的各种数据结果，一般包含状态码、消息和具体数据等
 import com.ew.gerocomium.dao.base.Result;
+// 导入操作员工的查询实体类，用于封装新增、编辑员工等操作时的相关数据
 import com.ew.gerocomium.dao.query.OperateStaffQuery;
+// 导入分页查询员工离职申请的查询实体类，这里在当前代码中暂未使用到
 import com.ew.gerocomium.dao.query.PageRetreatApplyQuery;
+// 导入分页查询员工的查询实体类，用于封装分页和查询条件等相关数据
 import com.ew.gerocomium.dao.query.PageStaffByKeyQuery;
+// 导入员工服务类，该类包含了处理员工相关业务逻辑的具体方法
 import com.ew.gerocomium.service.StaffService;
+// 导入 Swagger 的注解，用于标记 API 的分组，方便在生成 API 文档时分类展示
 import io.swagger.annotations.Api;
+// 导入 Swagger 的注解，用于描述 API 操作的具体信息，如操作名称和备注等
 import io.swagger.annotations.ApiOperation;
+// 导入 Swagger 的注解，用于描述 API 参数的相关信息，如参数名称、是否必填等
 import io.swagger.annotations.ApiParam;
+// 导入 Spring Security 的注解，用于在方法执行前进行权限验证，确保只有具备相应权限的用户才能访问接口
 import org.springframework.security.access.prepost.PreAuthorize;
+// 导入 Spring MVC 的注解，用于处理 HTTP 请求，将类标记为 RESTful 风格的控制器
 import org.springframework.web.bind.annotation.*;
-
+// 导入 Spring 的注解，用于实现依赖注入，将所需的服务类实例注入到当前类中
 import javax.annotation.Resource;
 
+/**
+ * 员工管理相关的控制器类，处理与员工管理相关的 HTTP 请求
+ */
+// 使用 Swagger 的 @Api 注解，标记该控制器所属的 API 分组为“员工管理”
 @Api(tags = "员工管理")
+// 使用 Spring MVC 的 @RestController 注解，将该类标记为 RESTful 风格的控制器，用于处理 HTTP 请求并返回 JSON 格式的数据
 @RestController
+// 使用 Spring MVC 的 @RequestMapping 注解，指定该控制器处理的请求路径前缀为 "/staff"
 @RequestMapping("/staff")
+// 使用 Spring Security 的 @PreAuthorize 注解，进行权限验证，只有拥有 '/people/staff' 权限的用户才能访问该控制器中的接口
 @PreAuthorize("@AuthorityAssert.hasAuthority('/people/staff')")
 public class StaffController {
+    // 使用 @Resource 注解，将 StaffService 类型的实例注入到当前类中，以便在当前类中调用员工服务类的方法处理业务逻辑
     @Resource
     private StaffService staffService;
 
+    /**
+     * 获取角色的接口
+     *
+     * @param token 接口访问请求头，用于身份验证等
+     * @return 返回包含角色信息的结果对象
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/staff/getRole"
     @GetMapping("/getRole")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“获取角色”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "获取角色", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result getRole(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+    public Result getRole(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+            @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用员工服务类的 getRole 方法，获取角色信息，并将结果以 Result 对象形式返回
         return staffService.getRole();
     }
 
+    /**
+     * 分页查询员工的接口
+     *
+     * @param pageStaffByKeyQuery 分页查询员工请求实体，包含分页和查询条件等信息
+     * @param token               接口访问请求头，用于身份验证等
+     * @return 返回包含分页查询员工结果的结果对象
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/staff/pageStaffByKey"
     @GetMapping("/pageStaffByKey")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“分页查询员工”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "分页查询员工", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result pageStaffByKey(@ApiParam(value = "分页查询员工请求实体", required = true) PageStaffByKeyQuery pageStaffByKeyQuery,
+    public Result pageStaffByKey(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“分页查询员工请求实体”，并标记为必需参数
+            @ApiParam(value = "分页查询员工请求实体", required = true)
+            PageStaffByKeyQuery pageStaffByKeyQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用员工服务类的 pageStaffByKey 方法，传入分页查询员工请求实体，获取分页查询员工的结果，并以 Result 对象形式返回
         return staffService.pageStaffByKey(pageStaffByKeyQuery);
     }
 
+    /**
+     * 新增员工的接口
+     *
+     * @param operateStaffQuery 新增员工请求实体，包含员工的相关信息
+     * @param token             接口访问请求头，用于身份验证等
+     * @return 返回包含新增员工操作结果的结果对象
+     */
+    // 使用 Spring MVC 的 @PostMapping 注解，指定该方法处理 HTTP POST 请求，路径为 "/staff/addStaff"
     @PostMapping("/addStaff")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“新增员工”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "新增员工", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result addStaff(@ApiParam(value = "新增员工请求实体", required = true) @RequestBody OperateStaffQuery operateStaffQuery,
+    public Result addStaff(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“新增员工请求实体”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+            @ApiParam(value = "新增员工请求实体", required = true) @RequestBody OperateStaffQuery operateStaffQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用员工服务类的 addStaff 方法，传入新增员工请求实体，执行新增员工操作，并将操作结果以 Result 对象形式返回
         return staffService.addStaff(operateStaffQuery);
     }
 
+    /**
+     * 根据编号查询员工的接口
+     *
+     * @param staffId 员工编号，用于指定要查询的员工
+     * @param token   接口访问请求头，用于身份验证等
+     * @return 返回包含指定编号员工信息的结果对象
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/staff/getStaffById"
     @GetMapping("/getStaffById")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“根据编号查询员工”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "根据编号查询员工", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result getStaffById(@ApiParam(value = "根据编号查询员工请求参数", required = true) @RequestParam Long staffId,
+    public Result getStaffById(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“根据编号查询员工请求参数”，并标记为必需参数，同时使用 @RequestParam 注解从请求参数中获取该参数值
+            @ApiParam(value = "根据编号查询员工请求参数", required = true) @RequestParam Long staffId,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用员工服务类的 getStaffById 方法，传入员工编号，查询指定编号的员工信息，并将结果以 Result 对象形式返回
         return staffService.getStaffById(staffId);
     }
 
+    /**
+     * 编辑员工的接口
+     *
+     * @param operateStaffQuery 编辑员工请求实体，包含要编辑的员工的相关信息
+     * @param token             接口访问请求头，用于身份验证等
+     * @return 返回包含编辑员工操作结果的结果对象
+     */
+    // 使用 Spring MVC 的 @PutMapping 注解，指定该方法处理 HTTP PUT 请求，路径为 "/staff/editStaff"
     @PutMapping("/editStaff")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“编辑员工”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "编辑员工", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result editStaff(@ApiParam(value = "编辑员工请求实体", required = true) @RequestBody OperateStaffQuery operateStaffQuery,
+    public Result editStaff(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“编辑员工请求实体”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+            @ApiParam(value = "编辑员工请求实体", required = true) @RequestBody OperateStaffQuery operateStaffQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用员工服务类的 editStaff 方法，传入编辑员工请求实体，执行编辑员工操作，并将操作结果以 Result 对象形式返回
         return staffService.editStaff(operateStaffQuery);
     }
 
+    /**
+     * 离职员工的接口
+     *
+     * @param staffId 员工编号，用于指定要处理离职的员工
+     * @param token   接口访问请求头，用于身份验证等
+     * @return 返回包含员工离职操作结果的结果对象
+     */
+    // 使用 Spring MVC 的 @DeleteMapping 注解，指定该方法处理 HTTP DELETE 请求，路径为 "/staff/leaveStaff"
     @DeleteMapping("/leaveStaff")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“离职员工”，并添加备注信息（包含开发者信息）
     @ApiOperation(value = "离职员工", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result leaveStaff(@ApiParam(value = "离职员工请求参数", required = true) @RequestParam Long staffId,
+    public Result leaveStaff(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“离职员工请求参数”，并标记为必需参数，同时使用 @RequestParam 注解从请求参数中获取该参数值
+            @ApiParam(value = "离职员工请求参数", required = true) @RequestParam Long staffId,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用员工服务类的 leaveStaff 方法，传入员工编号，执行员工离职操作，并将操作结果以 Result 对象形式返回
         return staffService.leaveStaff(staffId);
     }
 }

server/src/main/java/com/ew/gerocomium/controller/VisitController.java

@@ -1,74 +1,188 @@
+// 声明该类所在的包，用于组织和管理代码
 package com.ew.gerocomium.controller;
 
+// 导入项目中自定义的常量类，可能包含一些通用的常量值，如开发者信息等
 import com.ew.gerocomium.common.constant.Constant;
+// 导入项目中自定义的通用结果类，用于封装接口返回的数据，一般包含状态码、消息和数据等信息
 import com.ew.gerocomium.dao.base.Result;
+// 导入多个查询相关的实体类，这些类用于封装不同业务的查询参数和条件
 import com.ew.gerocomium.dao.query.*;
+// 导入押金充值服务类，用于处理与押金充值相关的业务逻辑
 import com.ew.gerocomium.service.DepositRechargeService;
+// 导入来访服务类，用于处理来访登记相关的业务逻辑
 import com.ew.gerocomium.service.VisitService;
+// 导入 Swagger 注解，用于标记 API 分组，方便在生成的 API 文档中分类展示
 import io.swagger.annotations.Api;
+// 导入 Swagger 注解，用于描述 API 操作的详细信息，如操作名称、备注等
 import io.swagger.annotations.ApiOperation;
+// 导入 Swagger 注解，用于描述 API 参数的详细信息，如参数名称、是否必填等
 import io.swagger.annotations.ApiParam;
+// 导入 Spring Security 注解，用于在方法执行前进行权限检查，确保用户具有相应权限才能访问接口
 import org.springframework.security.access.prepost.PreAuthorize;
+// 导入 Spring MVC 注解，用于处理 HTTP 请求，将类标记为 RESTful 风格的控制器
 import org.springframework.web.bind.annotation.*;
-
+// 导入 Spring 注解，用于实现依赖注入，将所需的服务类实例注入到当前类中
 import javax.annotation.Resource;
 
+/**
+ * 来访登记相关的控制器类，负责处理与来访登记业务相关的 HTTP 请求。
+ * 该控制器需要用户具有 '/check-in/visit' 权限才能访问其接口。
+ */
+// 使用 Swagger 的 @Api 注解，标记该控制器的 API 分组为“来访登记”
 @Api(tags = "来访登记")
+// 使用 Spring MVC 的 @RestController 注解，将该类标记为 RESTful 风格的控制器，用于处理 HTTP 请求并返回 JSON 格式的数据
 @RestController
+// 使用 Spring MVC 的 @RequestMapping 注解，指定该控制器处理的请求路径前缀为 "/visit"
 @RequestMapping("/visit")
+// 使用 Spring Security 的 @PreAuthorize 注解，要求用户具有 '/check-in/visit' 权限才能访问该控制器的接口
 @PreAuthorize("@AuthorityAssert.hasAuthority('/check-in/visit')")
 public class VisitController {
+    // 使用 @Resource 注解，将 VisitService 类型的实例注入到当前类中，用于处理来访登记的核心业务逻辑
     @Resource
     private VisitService visitService;
+    // 使用 @Resource 注解，将 DepositRechargeService 类型的实例注入到当前类中，虽然注释说用于处理与老人搜索相关业务逻辑，但从方法名看可能存在一些不一致，这里按代码注释理解
     @Resource
     private DepositRechargeService depositRechargeService;
 
+    /**
+     * 分页查询来访登记信息
+     *
+     * @param pageVisitByKeyQuery 分页查询来访登记的请求实体，包含分页和查询条件等信息
+     * @param token               接口访问请求头，用于身份验证等操作
+     * @return 返回包含分页查询结果的 Result 对象
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/visit/pageVisitByKey"
     @GetMapping("/pageVisitByKey")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“分页查询来访登记”，并添加备注信息
     @ApiOperation(value = "分页查询来访登记", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result pageVisitByKey(@ApiParam(value = "分页查询来访登记请求实体", required = true) PageVisitByKeyQuery pageVisitByKeyQuery,
+    public Result pageVisitByKey(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“分页查询来访登记请求实体”，并标记为必需参数
+            @ApiParam(value = "分页查询来访登记请求实体", required = true)
+            PageVisitByKeyQuery pageVisitByKeyQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用来访服务类的 pageVisitByKey 方法，传入请求实体，获取分页查询结果并返回
         return visitService.pageVisitByKey(pageVisitByKeyQuery);
     }
 
+    /**
+     * 分页搜索老人信息
+     *
+     * @param pageSearchElderByKeyQuery 分页搜索老人的请求实体，包含分页和搜索条件等信息
+     * @param token                     接口访问请求头，用于身份验证等操作
+     * @return 返回包含分页搜索结果的 Result 对象
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/visit/pageSearchElderByKey"
     @GetMapping("/pageSearchElderByKey")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“分页搜索老人”，并添加备注信息
     @ApiOperation(value = "分页搜索老人", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result pageSearchElderByKey(@ApiParam(value = "分页搜索老人请求实体", required = true) PageSearchElderByKeyQuery pageSearchElderByKeyQuery,
+    public Result pageSearchElderByKey(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“分页搜索老人请求实体”，并标记为必需参数
+            @ApiParam(value = "分页搜索老人请求实体", required = true)
+            PageSearchElderByKeyQuery pageSearchElderByKeyQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用押金充值服务类的 pageSearchElderByKey 方法，传入请求实体，获取分页搜索结果并返回
         return depositRechargeService.pageSearchElderByKey(pageSearchElderByKeyQuery);
     }
 
+    /**
+     * 新增来访登记信息
+     *
+     * @param addVisitQuery 新增来访登记的请求实体，包含来访登记的详细信息
+     * @param token         接口访问请求头，用于身份验证等操作
+     * @return 返回包含新增操作结果的 Result 对象
+     */
+    // 使用 Spring MVC 的 @PostMapping 注解，指定该方法处理 HTTP POST 请求，路径为 "/visit/addVisit"
     @PostMapping("/addVisit")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“新增来访登记”，并添加备注信息
     @ApiOperation(value = "新增来访登记", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result addOutward(@ApiParam(value = "新增来访登记请求实体", required = true) @RequestBody AddVisitQuery addVisitQuery,
+    public Result addOutward(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“新增来访登记请求实体”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+            @ApiParam(value = "新增来访登记请求实体", required = true) @RequestBody AddVisitQuery addVisitQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用来访服务类的 addVisit 方法，传入请求实体，获取新增操作结果并返回
         return visitService.addVisit(addVisitQuery);
     }
 
+    /**
+     * 根据编号获取来访登记信息
+     *
+     * @param visitId 来访登记的编号，用于唯一标识一条来访登记记录
+     * @param token   接口访问请求头，用于身份验证等操作
+     * @return 返回包含指定编号来访登记信息的 Result 对象
+     */
+    // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/visit/getVisitById"
     @GetMapping("/getVisitById")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“根据编号获取来访登记”，并添加备注信息
     @ApiOperation(value = "根据编号获取来访登记", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result getVisitById(@ApiParam(value = "根据编号获取来访登记请求参数", required = true) @RequestParam Long visitId,
+    public Result getVisitById(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“根据编号获取来访登记请求参数”，并标记为必需参数，同时使用 @RequestParam 注解从请求参数中获取该参数值
+            @ApiParam(value = "根据编号获取来访登记请求参数", required = true) @RequestParam Long visitId,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用来访服务类的 getVisitById 方法，传入来访登记编号，获取指定编号的来访登记信息并返回
         return visitService.getVisitById(visitId);
     }
 
+    /**
+     * 编辑来访登记信息
+     *
+     * @param editVisitQuery 编辑来访登记的请求实体，包含要修改的来访登记详细信息
+     * @param token          接口访问请求头，用于身份验证等操作
+     * @return 返回包含编辑操作结果的 Result 对象
+     */
+    // 使用 Spring MVC 的 @PutMapping 注解，指定该方法处理 HTTP PUT 请求，路径为 "/visit/editVisit"
     @PutMapping("/editVisit")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“编辑来访登记”，并添加备注信息
     @ApiOperation(value = "编辑来访登记", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result editVisit(@ApiParam(value = "编辑来访登记请求实体", required = true) @RequestBody EditVisitQuery editVisitQuery,
+    public Result editVisit(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“编辑来访登记请求实体”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+            @ApiParam(value = "编辑来访登记请求实体", required = true) @RequestBody EditVisitQuery editVisitQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用来访服务类的 editVisit 方法，传入请求实体，获取编辑操作结果并返回
         return visitService.editVisit(editVisitQuery);
     }
 
+    /**
+     * 登记来访人员离开信息
+     *
+     * @param recordLeaveQuery 登记离开的请求实体，包含离开登记的相关信息
+     * @param token            接口访问请求头，用于身份验证等操作
+     * @return 返回包含登记离开操作结果的 Result 对象
+     */
+    // 使用 Spring MVC 的 @PutMapping 注解，指定该方法处理 HTTP PUT 请求，路径为 "/visit/recordLeave"
     @PutMapping("/recordLeave")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“登记离开”，并添加备注信息
     @ApiOperation(value = "登记离开", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result recordLeave(@ApiParam(value = "登记离开请求实体", required = true) @RequestBody RecordLeaveQuery recordLeaveQuery,
+    public Result recordLeave(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“登记离开请求实体”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+            @ApiParam(value = "登记离开请求实体", required = true) @RequestBody RecordLeaveQuery recordLeaveQuery,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用来访服务类的 recordLeave 方法，传入请求实体，获取登记离开操作结果并返回
         return visitService.recordLeave(recordLeaveQuery);
     }
 
+    /**
+     * 删除来访登记信息
+     *
+     * @param visitId 要删除的来访登记的编号
+     * @param token   接口访问请求头，用于身份验证等操作
+     * @return 返回包含删除操作结果的 Result 对象
+     */
+    // 使用 Spring MVC 的 @DeleteMapping 注解，指定该方法处理 HTTP DELETE 请求，路径为 "/visit/deleteVisit"
     @DeleteMapping("/deleteVisit")
+    // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“删除来访登记”，并添加备注信息
     @ApiOperation(value = "删除来访登记", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
-    public Result deleteVisit(@ApiParam(value = "删除来访登记请求参数", required = true) @RequestParam Long visitId,
+    public Result deleteVisit(
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“删除来访登记请求参数”，并标记为必需参数，同时使用 @RequestParam 注解从请求参数中获取该参数值
+            @ApiParam(value = "删除来访登记请求参数", required = true) @RequestParam Long visitId,
+            // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
             @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+        // 调用来访服务类的 deleteVisit 方法，传入来访登记编号，获取删除操作结果并返回
         return visitService.deleteVisit(visitId);
     }
 }