From 37052ed4fa6750b842969830c37993d01bdd4c59 Mon Sep 17 00:00:00 2001 From: cjy <2436221054@qq.com> Date: Tue, 29 Apr 2025 23:09:15 +0800 Subject: [PATCH 1/7] =?UTF-8?q?=E2=80=9C1.2=E2=80=9D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- client/src/apis/accident.ts | 42 +++- client/src/apis/depositRecharge.ts | 55 ++++- client/src/apis/elderRecord.ts | 73 +++++- client/src/apis/nurseGrade.ts | 91 ++++++-- client/src/apis/nurseReserve.ts | 86 ++++++- client/src/apis/outward.ts | 88 +++++++- client/src/apis/retreatApply.ts | 36 ++- client/src/apis/service.ts | 107 +++++++-- client/src/apis/staff.ts | 75 ++++++- client/src/apis/visit.ts | 86 ++++++- .../controller/AccidentController.java | 172 ++++++++++++-- .../controller/ActiveController.java | 154 +++++++++++-- .../controller/ActiveTypeController.java | 120 +++++++++- .../controller/ElderRecordController.java | 152 +++++++++++-- .../controller/NurseGradeController.java | 167 ++++++++++++-- .../controller/NurseReserveController.java | 139 ++++++++++-- .../controller/OutwardController.java | 212 ++++++++++++++++-- .../controller/ReserveController.java | 147 ++++++++++-- .../controller/RetreatApplyController.java | 77 ++++++- .../controller/ServiceProjectController.java | 194 ++++++++++++++-- .../controller/StaffController.java | 123 ++++++++-- .../controller/VisitController.java | 144 ++++++++++-- 22 files changed, 2259 insertions(+), 281 deletions(-) diff --git a/client/src/apis/accident.ts b/client/src/apis/accident.ts index 8e87112..1b446d9 100644 --- a/client/src/apis/accident.ts +++ b/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 diff --git a/client/src/apis/depositRecharge.ts b/client/src/apis/depositRecharge.ts index 4bb2d1d..ed6ef32 100644 --- a/client/src/apis/depositRecharge.ts +++ b/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; + // 身份证号码，用于筛选预存充值记录，类型为字符串 + 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); } diff --git a/client/src/apis/elderRecord.ts b/client/src/apis/elderRecord.ts index 6ae94ae..ead9262 100644 --- a/client/src/apis/elderRecord.ts +++ b/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不一样，但是组件封装是需要一样的，所以请求前增加一些这两个字段 - Reflect.has(data, "sex") ? (data.elderSex = data.sex) : ""; - Reflect.has(data, "name") ? (data.elderName = data.name) : ""; + // 因为后台返回的字段与前端表单数据的 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 diff --git a/client/src/apis/nurseGrade.ts b/client/src/apis/nurseGrade.ts index b215ea8..0bd92a7 100644 --- a/client/src/apis/nurseGrade.ts +++ b/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; + // 名称，用于筛选护理等级，类型为字符串 + name: string; + // 护理等级名称，用于筛选护理等级，类型为字符串 gradeName: string; - type:string; + // 类型，用于筛选护理等级，类型为字符串 + type: string; + // 护理类型，用于筛选护理等级，类型为字符串 nurseType: string; } +// 定义一个接口 IAddNurseGrade，用于描述新增护理等级时的数据结构 interface IAddNurseGrade { + // 护理等级的 ID，类型为数字 id: number; + // 护理等级的名称，类型为字符串 name: string; + // 护理等级的类型，类型为字符串 type: string; + // 护理等级的月价格，类型为数字 monthPrice: number; - serviceIdList: any ; + // 服务 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 diff --git a/client/src/apis/nurseReserve.ts b/client/src/apis/nurseReserve.ts index 93337fa..bb31b28 100644 --- a/client/src/apis/nurseReserve.ts +++ b/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; + // 老人姓名，用于筛选护理预定记录，类型为字符串 + 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不一样，但是组件封装是需要一样的，所以请求前增加一些这两个字段 - // Reflect.has(data, 'name') ? (data.gradeName = data.name) : '' - // Reflect.has(data, 'type') ? (data.nurseType = data.type) : '' + // 因为后台返回的字段与前端表单数据的 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); } diff --git a/client/src/apis/outward.ts b/client/src/apis/outward.ts index 066b898..1d4e858 100644 --- a/client/src/apis/outward.ts +++ b/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 diff --git a/client/src/apis/retreatApply.ts b/client/src/apis/retreatApply.ts index 5aed87a..ed1724a 100644 --- a/client/src/apis/retreatApply.ts +++ b/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); } diff --git a/client/src/apis/service.ts b/client/src/apis/service.ts index 067a33c..a115761 100644 --- a/client/src/apis/service.ts +++ b/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) : '' + // 因为后台返回的字段与前端表单数据的 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 diff --git a/client/src/apis/staff.ts b/client/src/apis/staff.ts index 347b5ff..0dedaa6 100644 --- a/client/src/apis/staff.ts +++ b/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 可能有误，通常角色名称应该是字符串类型，用于筛选员工 + 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 diff --git a/client/src/apis/visit.ts b/client/src/apis/visit.ts index 3300427..5cb5e96 100644 --- a/client/src/apis/visit.ts +++ b/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 diff --git a/server/src/main/java/com/ew/gerocomium/controller/AccidentController.java b/server/src/main/java/com/ew/gerocomium/controller/AccidentController.java index 5452571..3d0457a 100644 --- a/server/src/main/java/com/ew/gerocomium/controller/AccidentController.java +++ b/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); } -} +} \ No newline at end of file diff --git a/server/src/main/java/com/ew/gerocomium/controller/ActiveController.java b/server/src/main/java/com/ew/gerocomium/controller/ActiveController.java index df8702f..6e5e35b 100644 --- a/server/src/main/java/com/ew/gerocomium/controller/ActiveController.java +++ b/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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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); } -} +} \ No newline at end of file diff --git a/server/src/main/java/com/ew/gerocomium/controller/ActiveTypeController.java b/server/src/main/java/com/ew/gerocomium/controller/ActiveTypeController.java index 00d747a..f648ddb 100644 --- a/server/src/main/java/com/ew/gerocomium/controller/ActiveTypeController.java +++ b/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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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); } -} +} \ No newline at end of file diff --git a/server/src/main/java/com/ew/gerocomium/controller/ElderRecordController.java b/server/src/main/java/com/ew/gerocomium/controller/ElderRecordController.java index facb0f0..673669a 100644 --- a/server/src/main/java/com/ew/gerocomium/controller/ElderRecordController.java +++ b/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); } -} +} \ No newline at end of file diff --git a/server/src/main/java/com/ew/gerocomium/controller/NurseGradeController.java b/server/src/main/java/com/ew/gerocomium/controller/NurseGradeController.java index d5caafd..4ce58ab 100644 --- a/server/src/main/java/com/ew/gerocomium/controller/NurseGradeController.java +++ b/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); } -} +} \ No newline at end of file diff --git a/server/src/main/java/com/ew/gerocomium/controller/NurseReserveController.java b/server/src/main/java/com/ew/gerocomium/controller/NurseReserveController.java index ae2800b..1aae105 100644 --- a/server/src/main/java/com/ew/gerocomium/controller/NurseReserveController.java +++ b/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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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); } -} +} \ No newline at end of file diff --git a/server/src/main/java/com/ew/gerocomium/controller/OutwardController.java b/server/src/main/java/com/ew/gerocomium/controller/OutwardController.java index c95f2bb..38a4cc2 100644 --- a/server/src/main/java/com/ew/gerocomium/controller/OutwardController.java +++ b/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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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); } -} +} \ No newline at end of file diff --git a/server/src/main/java/com/ew/gerocomium/controller/ReserveController.java b/server/src/main/java/com/ew/gerocomium/controller/ReserveController.java index 4da77d7..9a7bf68 100644 --- a/server/src/main/java/com/ew/gerocomium/controller/ReserveController.java +++ b/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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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()); } -} +} \ No newline at end of file diff --git a/server/src/main/java/com/ew/gerocomium/controller/RetreatApplyController.java b/server/src/main/java/com/ew/gerocomium/controller/RetreatApplyController.java index 5e9fb98..5232173 100644 --- a/server/src/main/java/com/ew/gerocomium/controller/RetreatApplyController.java +++ b/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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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()); } -} +} \ No newline at end of file diff --git a/server/src/main/java/com/ew/gerocomium/controller/ServiceProjectController.java b/server/src/main/java/com/ew/gerocomium/controller/ServiceProjectController.java index 84aafbf..1e6d483 100644 --- a/server/src/main/java/com/ew/gerocomium/controller/ServiceProjectController.java +++ b/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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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); } -} +} \ No newline at end of file diff --git a/server/src/main/java/com/ew/gerocomium/controller/StaffController.java b/server/src/main/java/com/ew/gerocomium/controller/StaffController.java index 9e6aa1a..82becc8 100644 --- a/server/src/main/java/com/ew/gerocomium/controller/StaffController.java +++ b/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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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); } -} +} \ No newline at end of file diff --git a/server/src/main/java/com/ew/gerocomium/controller/VisitController.java b/server/src/main/java/com/ew/gerocomium/controller/VisitController.java index d628a9a..2c3ed93 100644 --- a/server/src/main/java/com/ew/gerocomium/controller/VisitController.java +++ b/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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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, - @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) { + 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); } } From ea50457f515dd5c4b4f75497ec35fed6a79a01eb Mon Sep 17 00:00:00 2001 From: zgj <2913248995@qq.com> Date: Wed, 30 Apr 2025 00:35:57 +0800 Subject: [PATCH 2/7] v1.5 --- .../components/Grid/components/GridItem.vue | 51 ++- client/src/components/Grid/index.vue | 77 +++- client/src/components/Grid/interface/index.ts | 14 +- client/src/components/IconPark/index.vue | 22 +- .../ProTable/Grid/components/GridItem.vue | 109 +++++ client/src/components/ProTable/Grid/index.vue | 207 +++++++++ .../ProTable/Grid/interface/index.ts | 12 + .../components/ProTable/IconPark/index.vue | 45 ++ .../ProTable/components/ColSetting.vue | 88 ++++ .../ProTable/components/Pagination.vue | 47 +++ .../ProTable/components/TableColumn.vue | 103 +++++ .../src/components/ProTable/ProTable/index.md | 87 ++++ .../components/ProTable/ProTable/index.vue | 397 ++++++++++++++++++ .../ProTable/ProTable/interface/index.ts | 84 ++++ .../ProTable/ReImageVerify/index.ts | 12 + .../ProTable/ReImageVerify/src/hooks.ts | 133 ++++++ .../ProTable/ReImageVerify/src/index.vue | 55 +++ .../SearchForm/components/SearchFormItem.vue | 117 ++++++ .../components/ProTable/SearchForm/index.vue | 142 +++++++ .../src/components/ProTable/SvgIcon/index.vue | 49 +++ .../ProTable/components/ColSetting.vue | 32 +- .../ProTable/components/Pagination.vue | 20 +- .../ProTable/components/TableColumn.vue | 45 +- .../ProTable/elderListDialog/index.vue | 118 ++++++ client/src/components/ProTable/index.vue | 182 +++++--- .../components/ProTable/interface/index.ts | 83 ++-- .../components/ProTable/my-card/my-card.vue | 30 ++ .../components/ProTable/treeDialog/index.vue | 90 ++++ .../ProTable/upload/image/index.vue | 189 +++++++++ .../wen-test/DynamicAdditionComponent.vue | 47 +++ client/src/components/ReImageVerify/index.ts | 6 + .../src/components/ReImageVerify/src/hooks.ts | 48 +++ .../components/ReImageVerify/src/index.vue | 19 +- .../SearchForm/components/SearchFormItem.vue | 92 ++-- client/src/components/SearchForm/index.vue | 73 +++- client/src/components/SvgIcon/index.vue | 13 + .../src/components/elderListDialog/index.vue | 50 ++- client/src/components/my-card/my-card.vue | 10 + client/src/components/treeDialog/index.vue | 38 +- client/src/components/upload/image/index.vue | 77 +++- .../wen-test/DynamicAdditionComponent.vue | 19 +- client/src/mock/getters.ts | 15 +- client/src/mock/index.ts | 4 + client/src/mock/routes.ts | 87 +++- client/src/mock/users.ts | 7 + .../controller/CateringSetController.java | 172 +++++++- .../controller/ConsumeController.java | 42 +- .../controller/DepositRechargeController.java | 80 +++- .../controller/DishesController.java | 232 +++++++++- .../controller/OrderController.java | 173 +++++++- .../controller/RetreatAuditController.java | 75 +++- 51 files changed, 3692 insertions(+), 327 deletions(-) create mode 100644 client/src/components/ProTable/Grid/components/GridItem.vue create mode 100644 client/src/components/ProTable/Grid/index.vue create mode 100644 client/src/components/ProTable/Grid/interface/index.ts create mode 100644 client/src/components/ProTable/IconPark/index.vue create mode 100644 client/src/components/ProTable/ProTable/components/ColSetting.vue create mode 100644 client/src/components/ProTable/ProTable/components/Pagination.vue create mode 100644 client/src/components/ProTable/ProTable/components/TableColumn.vue create mode 100644 client/src/components/ProTable/ProTable/index.md create mode 100644 client/src/components/ProTable/ProTable/index.vue create mode 100644 client/src/components/ProTable/ProTable/interface/index.ts create mode 100644 client/src/components/ProTable/ReImageVerify/index.ts create mode 100644 client/src/components/ProTable/ReImageVerify/src/hooks.ts create mode 100644 client/src/components/ProTable/ReImageVerify/src/index.vue create mode 100644 client/src/components/ProTable/SearchForm/components/SearchFormItem.vue create mode 100644 client/src/components/ProTable/SearchForm/index.vue create mode 100644 client/src/components/ProTable/SvgIcon/index.vue create mode 100644 client/src/components/ProTable/elderListDialog/index.vue create mode 100644 client/src/components/ProTable/my-card/my-card.vue create mode 100644 client/src/components/ProTable/treeDialog/index.vue create mode 100644 client/src/components/ProTable/upload/image/index.vue create mode 100644 client/src/components/ProTable/wen-test/DynamicAdditionComponent.vue diff --git a/client/src/components/Grid/components/GridItem.vue b/client/src/components/Grid/components/GridItem.vue index 6492076..7e5389e 100644 --- a/client/src/components/Grid/components/GridItem.vue +++ b/client/src/components/Grid/components/GridItem.vue @@ -1,23 +1,38 @@ + diff --git a/client/src/components/Grid/interface/index.ts b/client/src/components/Grid/interface/index.ts index b062bef..a3ff77d 100644 --- a/client/src/components/Grid/interface/index.ts +++ b/client/src/components/Grid/interface/index.ts @@ -1,6 +1,12 @@ -export type BreakPoint = 'xs' | 'sm' | 'md' | 'lg' | 'xl' +// 定义一个类型别名 BreakPoint，它的值只能是 'xs'、'sm'、'md'、'lg' 或 'xl' 中的一个， +// 通常用于表示响应式布局中的不同屏幕断点 +export type BreakPoint = 'xs' |'sm' |'md' | 'lg' | 'xl'; +// 定义一个类型别名 Responsive，它是一个对象类型，包含两个可选属性 span 和 offset。 +// span 用于表示在响应式布局中元素所占的列数，类型为 number 类型的可选值。 +// offset 用于表示在响应式布局中元素的偏移量，类型为 number 类型的可选值。 +// 这个类型通常用于描述在不同屏幕断点下元素的布局属性 export type Responsive = { - span?: number - offset?: number -} + span?: number; + offset?: number; +}; diff --git a/client/src/components/IconPark/index.vue b/client/src/components/IconPark/index.vue index 59e6480..9ca92a5 100644 --- a/client/src/components/IconPark/index.vue +++ b/client/src/components/IconPark/index.vue @@ -1,4 +1,12 @@