+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
暂无可配置列
@@ -37,23 +59,29 @@
diff --git a/client/src/components/elderListDialog/index.vue b/client/src/components/elderListDialog/index.vue
index d5a8ee0..172f22c 100644
--- a/client/src/components/elderListDialog/index.vue
+++ b/client/src/components/elderListDialog/index.vue
@@ -1,26 +1,47 @@
+
+
+
+
+
+
+
+
+
+
-
+
+
+
+
+
+
- 选择
+
+
+
+
+
+ 选择
@@ -30,27 +51,36 @@
diff --git a/client/src/layout/components/NavBar/index.vue b/client/src/layout/components/NavBar/index.vue
index fdccd75..4e8f846 100644
--- a/client/src/layout/components/NavBar/index.vue
+++ b/client/src/layout/components/NavBar/index.vue
@@ -1,32 +1,50 @@
+
diff --git a/client/src/layout/components/SideBar/components/MenuItem.vue b/client/src/layout/components/SideBar/components/MenuItem.vue
index 3b2b0d4..e1a2de2 100644
--- a/client/src/layout/components/SideBar/components/MenuItem.vue
+++ b/client/src/layout/components/SideBar/components/MenuItem.vue
@@ -1,15 +1,28 @@
+
+
+
+
+
+
+
+
+
+
{{
- menu.meta.title
- }}
+ menu.meta.title
+ }}
+
+
+
+
+
+
+
+
+
{{
- menu.meta.title
- }}
+ menu.meta.title
+ }}
@@ -52,26 +84,35 @@
diff --git a/client/src/layout/components/SideBar/index.vue b/client/src/layout/components/SideBar/index.vue
index 70cccae..547e1aa 100644
--- a/client/src/layout/components/SideBar/index.vue
+++ b/client/src/layout/components/SideBar/index.vue
@@ -1,12 +1,25 @@
+
-
+
+
+
+
+
+
+
+
+
+
+
+
@@ -24,10 +37,14 @@
diff --git a/client/src/mock/getters.ts b/client/src/mock/getters.ts
index 256c799..bbf9ef5 100644
--- a/client/src/mock/getters.ts
+++ b/client/src/mock/getters.ts
@@ -1,15 +1,23 @@
+// 从当前目录的 index 文件中导入 routes、users、IRoute 和 IUser
import { routes, users, IRoute, IUser } from './index'
+// 导入项目的 Vuex 存储实例
import store from '@/store'
-// 获取路由列表
+// 获取路由列表的函数，接受一个用户 ID（uid）作为参数
export const getRouterList = (uid: number) => {
+ // 从 Vuex 存储中获取当前用户的权限 ID 列表
const authIdList: number[] = store.state.app.userPeofile.authIdList
+ // 过滤出当前用户有权限访问的路由列表
const routeList: any[] = routes.filter(route => authIdList.includes(route.id))
+
+ // 如果传入了用户 ID（uid）
if (uid) {
- // userInfo 有可能是 undefined
+ // 查找具有指定 ID 的用户信息，userInfo 有可能是 undefined
const userInfo: IUser | undefined = users.find(user => user.id === uid)
+ // 如果找到了用户信息
if (userInfo) {
+ // 以下是一段被注释掉的代码，功能可能是进一步筛选用户的授权路由列表
// const authRouteList: IRoute[] = []
// rid = router id
// userInfo.auth.map(rid => {
@@ -19,12 +27,14 @@ export const getRouterList = (uid: number) => {
// }
// })
// })
+ // 返回成功响应，包含状态码、消息和筛选后的路由列表
return {
code: 0,
msg: 'ok',
data: routeList
}
} else {
+ // 如果没有找到用户信息，返回错误响应
return {
code: 1001,
msg: 'No userInfo for this UID',
@@ -32,6 +42,7 @@ export const getRouterList = (uid: number) => {
}
}
} else {
+ // 如果没有传入用户 ID，返回错误响应
return {
code: 1002,
msg: 'No UID received',
diff --git a/client/src/mock/index.ts b/client/src/mock/index.ts
index 8bed4b6..4a645d7 100644
--- a/client/src/mock/index.ts
+++ b/client/src/mock/index.ts
@@ -1,5 +1,9 @@
+// 从当前目录下的 routes 文件中导入 routes 变量和 IRoute 类型
import routes, { IRoute } from './routes'
+// 从当前目录下的 users 文件中导入 users 变量和 IUser 类型
import users, { IUser } from './users'
+// 导出 routes 变量，这样在其他文件中可以导入使用该变量
export { routes, users }
+// 导出 IRoute 和 IUser 类型，方便其他文件导入使用这些类型定义
export type { IRoute, IUser }
diff --git a/client/src/mock/routes.ts b/client/src/mock/routes.ts
index a46c70a..e547280 100644
--- a/client/src/mock/routes.ts
+++ b/client/src/mock/routes.ts
@@ -1,17 +1,29 @@
+// 定义一个接口 IRoute，用于描述路由的结构
export interface IRoute {
+ // 路由的唯一标识 ID，类型为数字
id: number
+ // 父路由的 ID，类型为数字
pid: number
+ // 路由的名称，类型为字符串
name: string
+ // 路由的路径，类型为字符串
path: string
+ // 重定向的路径，是一个可选属性，类型为字符串
redirect?: string
+ // 路由对应的组件路径，类型为字符串
component: string
+ // 路由的元数据，是一个对象
meta: {
+ // 路由的标题，类型为字符串
title: string
+ // 路由的图标名称，是一个可选属性，类型为字符串
icon?: string
}
}
+// 定义一个名为 routes 的数组，元素类型为 IRoute，存储路由信息
const routes: IRoute[] = [
+ // 第一个路由对象
{
id: 1,
pid: 0,
@@ -23,6 +35,7 @@ const routes: IRoute[] = [
icon: 'home'
}
},
+ // 第二个路由对象
{
id: 2,
pid: 0,
@@ -35,39 +48,43 @@ const routes: IRoute[] = [
icon: 'sale'
}
},
+ // 第三个路由对象
{
id: 3,
pid: 2,
path: 'counsel',
name: 'CounselSale',
- component: 'sale/counsel/index.vue',
+ component:'sale/counsel/index.vue',
meta: {
title: '咨询管理',
icon: ''
}
},
+ // 以下是一些被注释掉的路由对象，可根据需求启用
// {
// id: 4,
// pid: 2,
// path: 'intention',
// name: 'IntentionSale',
- // component: 'sale/intention/index.vue',
+ // component:'sale/intention/index.vue',
// meta: {
// title: '意向客户',
// icon: ''
// }
// },
+ // 第五个路由对象
{
id: 5,
pid: 2,
path: 'book',
name: 'BookSale',
- component: 'sale/book/index.vue',
+ component:'sale/book/index.vue',
meta: {
title: '预定管理',
icon: ''
}
},
+ // 第六个路由对象
{
id: 6,
pid: 0,
@@ -80,6 +97,7 @@ const routes: IRoute[] = [
icon: 'live'
}
},
+ // 第七个路由对象
{
id: 7,
pid: 6,
@@ -91,6 +109,7 @@ const routes: IRoute[] = [
icon: ''
}
},
+ // 第八个路由对象
{
id: 8,
pid: 6,
@@ -102,6 +121,7 @@ const routes: IRoute[] = [
icon: ''
}
},
+ // 第九个路由对象
{
id: 9,
pid: 6,
@@ -113,6 +133,7 @@ const routes: IRoute[] = [
icon: ''
}
},
+ // 第十个路由对象
{
id: 10,
pid: 6,
@@ -124,6 +145,7 @@ const routes: IRoute[] = [
icon: ''
}
},
+ // 第十一个路由对象
{
id: 11,
pid: 6,
@@ -135,6 +157,7 @@ const routes: IRoute[] = [
icon: ''
}
},
+ // 第十二个路由对象
{
id: 12,
pid: 6,
@@ -146,6 +169,7 @@ const routes: IRoute[] = [
icon: ''
}
},
+ // 第十三个路由对象
{
id: 13,
pid: 0,
@@ -158,6 +182,7 @@ const routes: IRoute[] = [
icon: 'people'
}
},
+ // 第十四个路由对象
{
id: 14,
pid: 13,
@@ -169,10 +194,11 @@ const routes: IRoute[] = [
icon: ''
}
},
+ // 第十五个路由对象
{
id: 15,
pid: 13,
- path: 'staff',
+ path:'staff',
name: 'StaffPeople',
component: 'people/staff/index.vue',
meta: {
@@ -180,6 +206,7 @@ const routes: IRoute[] = [
icon: ''
}
},
+ // 以下是一些被注释掉的路由对象，可根据需求启用
// {
// id: 16,
// pid: 13,
@@ -191,61 +218,66 @@ const routes: IRoute[] = [
// icon: ''
// }
// },
+ // 第十七个路由对象
{
id: 17,
pid: 0,
path: '/serve',
name: 'Serve',
redirect: '/serve/project',
- component: 'serve/index.vue',
+ component:'serve/index.vue',
meta: {
title: '服务管理',
- icon: 'serve'
+ icon:'serve'
}
},
+ // 第十八个路由对象
{
id: 18,
pid: 17,
path: 'project',
name: 'ProjectServe',
- component: 'serve/project/index.vue',
+ component:'serve/project/index.vue',
meta: {
title: '服务项目',
icon: ''
}
},
+ // 第十九个路由对象
{
id: 19,
pid: 17,
path: 'level',
name: 'LevelServe',
- component: 'serve/level/index.vue',
+ component:'serve/level/index.vue',
meta: {
title: '护理等级',
icon: ''
}
},
+ // 第二十个路由对象
{
id: 20,
pid: 17,
path: 'book',
name: 'BookServe',
- component: 'serve/book/index.vue',
+ component:'serve/book/index.vue',
meta: {
title: '服务预定',
icon: ''
}
},
+ // 以下是一些被注释掉的路由对象，可根据需求启用
// {
// id: 21,
// pid: 0,
// path: '/resource',
// name: 'Resource',
// redirect: '/resource/info',
- // component: 'resource/index.vue',
+ // component:'resource/index.vue',
// meta: {
// title: '物资管理',
- // icon: 'resource'
+ // icon:'resource'
// }
// },
// {
@@ -253,7 +285,7 @@ const routes: IRoute[] = [
// pid: 21,
// path: 'info',
// name: 'InfoResource',
- // component: 'resource/info/index.vue',
+ // component:'resource/info/index.vue',
// meta: {
// title: '物资信息',
// icon: ''
@@ -264,7 +296,7 @@ const routes: IRoute[] = [
// pid: 21,
// path: 'Storage',
// name: 'StorageResource',
- // component: 'resource/storage/index.vue',
+ // component:'resource/storage/index.vue',
// meta: {
// title: '仓库设置',
// icon: ''
@@ -275,7 +307,7 @@ const routes: IRoute[] = [
// pid: 21,
// path: 'enter',
// name: 'EnterResource',
- // component: 'resource/enter/index.vue',
+ // component:'resource/enter/index.vue',
// meta: {
// title: '入库管理',
// icon: ''
@@ -286,7 +318,7 @@ const routes: IRoute[] = [
// pid: 21,
// path: 'leave',
// name: 'LeaveResource',
- // component: 'resource/leave/index.vue',
+ // component:'resource/leave/index.vue',
// meta: {
// title: '出库管理',
// icon: ''
@@ -295,14 +327,15 @@ const routes: IRoute[] = [
// {
// id: 26,
// pid: 21,
- // path: 'search',
+ // path:'search',
// name: 'SearchResource',
- // component: 'resource/search/index.vue',
+ // component:'resource/search/index.vue',
// meta: {
// title: '库存查询',
// icon: ''
// }
// },
+ // 第二十七个路由对象
{
id: 27,
pid: 0,
@@ -315,6 +348,7 @@ const routes: IRoute[] = [
icon: 'diet'
}
},
+ // 第二十八个路由对象
{
id: 28,
pid: 27,
@@ -326,6 +360,7 @@ const routes: IRoute[] = [
icon: ''
}
},
+ // 第二十九个路由对象
{
id: 29,
pid: 27,
@@ -337,6 +372,7 @@ const routes: IRoute[] = [
icon: ''
}
},
+ // 第三十个路由对象
{
id: 30,
pid: 27,
@@ -348,6 +384,7 @@ const routes: IRoute[] = [
icon: ''
}
},
+ // 第三十一个路由对象
{
id: 31,
pid: 0,
@@ -360,6 +397,7 @@ const routes: IRoute[] = [
icon: 'charge'
}
},
+ // 第三十二个路由对象
{
id: 32,
pid: 31,
@@ -371,10 +409,11 @@ const routes: IRoute[] = [
icon: ''
}
},
+ // 第三十三个路由对象
{
id: 33,
pid: 31,
- path: 'record',
+ path:'record',
name: 'RecordCharge',
component: 'charge/record/index.vue',
meta: {
@@ -382,6 +421,7 @@ const routes: IRoute[] = [
icon: ''
}
},
+ // 第三十四个路由对象
{
id: 34,
pid: 31,
@@ -393,6 +433,7 @@ const routes: IRoute[] = [
icon: ''
}
},
+ // 第三十五个路由对象
{
id: 35,
pid: 0,
@@ -405,10 +446,11 @@ const routes: IRoute[] = [
icon: 'base'
}
},
+ // 第三十六个路由对象
{
id: 36,
pid: 35,
- path: 'sale',
+ path:'sale',
name: 'SaleBase',
redirect: '/base/sale/origin',
component: 'base/sale/index.vue',
@@ -417,6 +459,7 @@ const routes: IRoute[] = [
icon: ''
}
},
+ // 第三十七个路由对象
{
id: 37,
pid: 36,
@@ -428,6 +471,7 @@ const routes: IRoute[] = [
icon: ''
}
},
+ // 以下是一些被注释掉的路由对象，可根据需求启用
// {
// id: 38,
// pid: 36,
@@ -439,6 +483,7 @@ const routes: IRoute[] = [
// icon: ''
// }
// },
+ // 第三十九个路由对象
{
id: 39,
pid: 35,
@@ -451,6 +496,7 @@ const routes: IRoute[] = [
icon: ''
}
},
+ // 第四十个路由对象
{
id: 40,
pid: 39,
@@ -462,6 +508,7 @@ const routes: IRoute[] = [
icon: ''
}
},
+ // 第四十一个路由对象
{
id: 41,
pid: 39,
@@ -473,6 +520,7 @@ const routes: IRoute[] = [
icon: ''
}
},
+ // 以下是一些被注释掉的路由对象，可根据需求启用
// {
// id: 42,
// pid: 35,
@@ -483,4 +531,5 @@ const routes: IRoute[] = [
// }
]
+// 导出 routes 数组，使其可以在其他模块中被导入和使用
export default routes
diff --git a/client/src/mock/users.ts b/client/src/mock/users.ts
index db8e05e..3fb3645 100644
--- a/client/src/mock/users.ts
+++ b/client/src/mock/users.ts
@@ -1,13 +1,20 @@
+// 定义一个接口 IUser，用于描述用户对象的结构
export interface IUser {
+ // 用户的唯一标识 ID，类型为数字
id: number
+ // 用户的用户名，类型为字符串
username: string
+ // 用户拥有的权限 ID 数组，数组中的元素类型为数字
auth: number[]
}
+// 导出一个默认的用户数组，类型为 IUser 数组
+// 数组中包含一个用户对象
export default [
{
id: 1,
username: 'zhangsan',
+ // 该用户拥有的权限 ID 数组，包含多个权限 ID
auth: [
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
diff --git a/client/src/plugins/element-plus/index.ts b/client/src/plugins/element-plus/index.ts
index b28a690..9901b73 100644
--- a/client/src/plugins/element-plus/index.ts
+++ b/client/src/plugins/element-plus/index.ts
@@ -1,11 +1,17 @@
+// 从 '@element-plus/icons-vue' 模块中导入所有的图标组件
import * as ElIcons from '@element-plus/icons-vue'
+// 从 'vue' 模块中导入 App 类型，用于表示 Vue 应用实例
import { App } from 'vue'
+// 定义一个名为 useElementPlus 的函数，该函数接受一个 App 类型的参数 app
const useElementPlus = (app: App) => {
- // 注册图标
+ // 遍历 ElIcons 对象的所有属性
for (const [key, component] of Object.entries(ElIcons)) {
+ // 使用 app.component 方法将每个图标组件注册为全局组件
+ // 组件的名称为属性名 key，组件本身为 component
app.component(key, component)
}
}
+// 导出 useElementPlus 函数，使其可以在其他模块中被导入和使用
export default useElementPlus
diff --git a/client/src/plugins/index.ts b/client/src/plugins/index.ts
index c6e49f2..09d5a2e 100644
--- a/client/src/plugins/index.ts
+++ b/client/src/plugins/index.ts
@@ -1,3 +1,6 @@
+// 从当前目录下的 element-plus 文件中导入名为 useElementPlus 的函数
import useElementPlus from './element-plus'
+// 重新导出 useElementPlus 函数，这样其他模块在导入这个文件时
+// 可以通过解构赋值等方式获取到 useElementPlus 函数
export { useElementPlus }
diff --git a/client/src/router/index.ts b/client/src/router/index.ts
index a63c0cf..44cf2a0 100644
--- a/client/src/router/index.ts
+++ b/client/src/router/index.ts
@@ -1,62 +1,87 @@
+// 从 vue-router 库中导入创建路由实例、路由记录类型和哈希路由历史模式的方法
import { createRouter, RouteRecordRaw, createWebHashHistory } from 'vue-router'
+// 导入布局组件
import Layout from '@/layout/index.vue'
+// 导入 Vuex 存储实例
import store from '@/store'
+// 导入初始化动态路由的工具函数
import { initRoutes } from './utils'
-// 静态路由
+// 定义静态路由数组，包含应用中固定的路由配置
const routes: Array = [
{
+ // 根路径
path: '/',
+ // 路由名称
name: 'Layout',
+ // 路由对应的组件
component: Layout,
+ // 重定向到 /home 路径
redirect: '/home',
+ // 子路由数组，初始为空
children: []
},
{
+ // 登录页面路径
path: '/login',
+ // 路由名称
name: 'Login',
+ // 路由元信息，包含页面标题
meta: {
title: '登录'
},
+ // 使用动态导入方式加载登录页面组件
component: () =>
import(/* webpackChunkName: "Login" */ '@/views/login/index.vue')
},
{
+ // 匹配所有未定义的路径
path: '/:pathMatch(.*)*',
+ // 路由名称
name: 'NotFound',
+ // 路由元信息，包含页面标题
meta: {
title: '404'
},
+ // 使用动态导入方式加载 404 错误页面组件
component: () =>
import(/* webpackChunkName: "404" */ '@/views/error/404.vue')
}
]
+// 创建路由实例
const router = createRouter({
+ // 使用哈希路由历史模式
history: createWebHashHistory(),
+ // 路由配置
routes
})
+// 定义路由白名单，包含无需验证即可访问的路径
const ROUTER_WHITE_LIST = ['/login']
+// 全局前置守卫，在每次路由跳转前执行
router.beforeEach(async (to, from, next) => {
- // 设置页面标题
- document["title"] = to.meta.title + " | 敬老院管理系统"
+ // 设置页面标题，将目标路由的元信息中的标题与固定后缀拼接
+ document.title = to.meta.title + ' | 敬老院管理系统'
- // .判断访问页面是否在路由白名单地址中，如果存在直接放行
+ // 判断访问的页面路径是否在路由白名单中，如果存在则直接放行
if (ROUTER_WHITE_LIST.includes(to.path)) return next()
- //.判断 是否有 Token，没有重定向到 login
+ // 判断是否有 Token，如果没有则重定向到登录页面
if (!store.state.app.token) return next({ path: '/login', replace: true })
- //如果没有初始化动态路由就初始化
+ // 如果没有初始化动态路由且存在 Token，则初始化动态路由
if (!store.state.app.hasAuth && store.state.app.token) {
+ // 调用初始化动态路由的工具函数
await initRoutes()
+ // 重新跳转至目标路径
return next({ path: to.path })
}
- // 7.正常访问页面
+ // 正常访问页面，放行路由跳转
next()
})
+// 导出路由实例，供应用使用
export default router
diff --git a/client/src/router/types.ts b/client/src/router/types.ts
index d90861b..5c4a69f 100644
--- a/client/src/router/types.ts
+++ b/client/src/router/types.ts
@@ -1,14 +1,25 @@
/** 路由 */
+// 定义一个接口 IRoute，用于规范路由对象的结构
export interface IRoute {
+ // 路由的唯一标识 ID，类型为数字
id: number
+ // 父路由的 ID，类型为数字，用于表示路由的层级关系
pid: number
+ // 路由的名称，在路由配置和导航中使用，类型为字符串
name: string
+ // 路由的路径，用于在浏览器地址栏中显示和导航，类型为字符串
path: string
+ // 重定向的路径，是一个可选属性，当访问该路由时会自动重定向到指定路径，类型为字符串
redirect?: string
+ // 路由对应的组件路径，指定该路由应渲染的 Vue 组件的路径，类型为字符串
component: string
+ // 路由的元数据，是一个对象，包含与路由相关的额外信息
meta: {
+ // 路由的标题，可用于页面标题、菜单显示等，类型为字符串
title: string
+ // 路由的图标名称，是一个可选属性，可用于在菜单中显示图标，类型为字符串
icon?: string
}
+ // 子路由数组，是一个可选属性，用于表示该路由下的子路由列表，元素类型为 IRoute
children?: IRoute[]
}
diff --git a/client/src/router/utils.ts b/client/src/router/utils.ts
index ec5fc53..4153b9a 100644
--- a/client/src/router/utils.ts
+++ b/client/src/router/utils.ts
@@ -1,31 +1,53 @@
+// 从项目的路由类型文件中导入 IRoute 接口，用于描述路由的结构
import { IRoute } from "@/router/types";
+// 从 vue-router 库中导入 Router 和 RouteRecordRaw 类型
+// Router 是 Vue Router 的实例类型，RouteRecordRaw 用于定义路由记录
import { Router, RouteRecordRaw } from "vue-router";
+// 导入项目的路由实例
import router from "./index";
+// 导入项目的 Vuex 存储实例
import store from "@/store";
+// 从项目的工具函数文件中导入数组去重的工具函数
import { arrayDeduplicationByFiled } from "@/utils/commonUtil";
/** 将后端返回的路由转换成生成树形结构 */
function formatRouteTree(data: IRoute[]) {
+ // 过滤出父路由，即 pid 为 0 的路由
const parents = data.filter(routeInfo => routeInfo.pid === 0);
+ // 过滤出子路由，即 pid 不为 0 的路由
const children = data.filter(routeInfo => routeInfo.pid !== 0);
+ // 调用递归函数将数据转换为树形结构
dataToTree(parents, children);
+ // 返回转换后的父路由数组，此时父路由数组中包含了子路由信息
return parents;
+ /**
+ * 递归函数，将子路由挂载到对应的父路由上
+ * @param parents 父路由数组
+ * @param children 子路由数组
+ */
function dataToTree(parents: IRoute[], children: IRoute[]) {
+ // 遍历父路由数组
parents.map(parent => {
+ // 遍历子路由数组
children.map((child, index) => {
+ // 如果子路由的 pid 等于父路由的 id
if (child.pid === parent.id) {
+ // 复制一份子路由数组，避免在原数组上进行操作
const _children: IRoute[] = JSON.parse(JSON.stringify(children));
+ // 从复制的子路由数组中移除当前处理的子路由
_children.splice(index, 1);
+ // 递归调用 dataToTree 函数，处理当前子路由的子路由
dataToTree([child], _children);
if (parent.children) {
- // 添加
+ // 如果父路由已经有子路由数组，将当前子路由添加到该数组中
parent.children.push(child);
- // 菜单去重
+ // 对父路由的子路由数组进行去重操作，根据 id 字段去重
parent.children = arrayDeduplicationByFiled(parent.children, "id");
} else {
+ // 如果父路由还没有子路由数组，创建一个包含当前子路由的数组
parent.children = [child];
}
}
@@ -36,46 +58,66 @@ function formatRouteTree(data: IRoute[]) {
/** 将树形结构路由转化成真实的路由 */
function generateRouter(routeTree: IRoute[]) {
+ // 遍历树形结构的路由数组
const newRoutes = routeTree.map(route => {
+ // 创建一个新的路由记录对象
const _route: RouteRecordRaw = {
+ // 路由的路径
path: route.path,
+ // 路由的名称
name: route.name,
+ // 路由的元信息
meta: route.meta,
+ // 路由的重定向路径
redirect: route.redirect,
- component: () => import("@/views/" + route.component), // 注意：views目录下才能引入，否则ts不识别
+ // 使用动态导入的方式加载路由对应的组件，组件位于 @/views 目录下
+ component: () => import("@/views/" + route.component),
+ // 子路由数组，初始为空
children: []
};
+ // 如果当前路由有子路由
if (route.children) {
+ // 递归调用 generateRouter 函数，处理子路由
_route.children = generateRouter(route.children);
}
+ // 返回新创建的路由记录对象
return _route;
});
+ // 返回转换后的路由记录数组
return newRoutes;
}
-//初始化动态路由
+// 初始化动态路由的函数
export async function initRoutes() {
+ // 调用 Vuex 的 action，获取路由树形结构数据
await store.dispatch("app/getRouterTree");
+ // 将获取到的路由树形结构数据转换为真实的路由记录数组
const newRoutes = generateRouter(store.state.app.routeTree);
+ // 遍历新的路由记录数组，将每个路由添加到名为 "Layout" 的父路由下
newRoutes.forEach(route => router.addRoute("Layout", route));
}
-//清除路由
+// 清除路由的函数
export function clearRoutes() {
- //删除之前注册的路由 默认状态下只有三个，如果超过三个删除多余的路由
+ // 定义默认的路由名称数组
const defaultRoutes = ["Layout", "Login", "NotFound"];
+ // 获取当前路由实例中的所有路由记录
const currentRoutes = router.getRoutes();
+ // 如果当前路由记录的数量不等于 3
if (currentRoutes.length != 3) {
- //执行删除
+ // 遍历当前的路由记录数组
currentRoutes.forEach(item => {
+ // 如果当前路由的名称不在默认路由名称数组中
if (!defaultRoutes.includes(String(item.name))) {
+ // 从路由实例中移除该路由
router.removeRoute(String(item.name));
}
});
}
}
+// 导出 formatRouteTree 和 generateRouter 函数，供其他模块使用
export { formatRouteTree, generateRouter };
diff --git a/client/src/store/index.ts b/client/src/store/index.ts
index 79a8523..10041a7 100644
--- a/client/src/store/index.ts
+++ b/client/src/store/index.ts
@@ -1,29 +1,46 @@
+// 从 vue 库中导入 InjectionKey 类型，用于在 Vue 3 中为 provide 和 inject 提供类型约束
import { InjectionKey } from 'vue'
+// 从 vuex 库中导入创建 store 的函数、基础的 useStore 函数和 Store 类型
import { createStore, useStore as baseUseStore, Store } from 'vuex'
+// 从项目的 store 类型文件中导入根状态类型
import { IRootState } from '@/store/types'
+// 从当前模块的 app 子模块中导入名为 store 的对象
import { store as app } from './modules/app'
+// 从当前模块的工具文件中导入自定义的 CommonStore 类型
import { CommonStore } from './utils'
+// 导入 vuex-persistedstate 插件，用于将 store 中的状态持久化到本地存储
import createPersistedState from 'vuex-persistedstate'
+// 定义一个包含所有模块的对象，这里目前只有 app 模块
export const modules = {
app
}
-// injectionKey：约束state类型
+// 定义一个注入键，用于在使用 useStore 时约束 state 的类型
+// 这里使用 Symbol 创建一个唯一的键，类型为 Store
export const key: InjectionKey> = Symbol()
+// 创建一个 Vuex store 实例，指定根状态类型为 IRootState
const store = createStore({
+ // 注册模块
modules,
+ // 应用插件
plugins: [
+ // 使用 vuex-persistedstate 插件
createPersistedState({
+ // 存储在本地存储中的键名
key: 'stateData',
+ // 指定需要持久化的模块路径，这里只持久化 app 模块
paths: ['app']
})
]
}) as CommonStore
+// 定义一个自定义的 useStore 函数，返回类型为 CommonStore
+// 调用 baseUseStore 函数并传入注入键，确保类型安全
export function useStore(): CommonStore {
return baseUseStore(key)
}
+// 导出创建好的 store 实例，供应用使用
export default store
diff --git a/client/src/store/modules/app/index.ts b/client/src/store/modules/app/index.ts
index 7ebbf04..31b30a1 100644
--- a/client/src/store/modules/app/index.ts
+++ b/client/src/store/modules/app/index.ts
@@ -1,26 +1,46 @@
+// 从 vuex 中导入 ActionContext 类型，用于在 action 中获取上下文
import { ActionContext } from 'vuex'
+// 从项目的 store 类型文件中导入根状态类型
import { IRootState } from '@/store/types'
+// 从当前模块的类型文件中导入当前模块的状态类型
import { IAppState } from './types'
+// 从项目的路由类型文件中导入路由类型
import { IRoute } from '@/router/types'
+// 从项目的模拟数据获取器中导入获取路由列表的函数
import { getRouterList } from '@/mock/getters'
+// 从项目的路由工具文件中导入清除路由和格式化路由树的函数
import { clearRoutes, formatRouteTree } from '@/router/utils'
+// 从项目的 API 模块中导入获取用户路由列表的函数（当前注释掉未使用）
// import { getUserRouteList } from '@/apis'
+// 从项目的用户 API 模块中导入登录请求函数
import { getLogin } from '@/apis/user'
+// 导入项目的路由实例
import router from '@/router'
+// 定义默认状态对象
const defaultState = {
+ // 用户 ID，初始为 1
uid: 1,
+ // 用户令牌，初始为空字符串
token: '',
+ // 是否有路由权限，初始为 false
hasAuth: false,
+ // 路由树，初始为空数组
routeTree: [],
+ // 侧边栏是否展开，初始为 true 表示展开
siderType: true,
+ // 用户信息，初始为空对象
userPeofile: {},
+ // 是否记住密码，初始为 false
rememberPWD: false
}
+// 导出当前模块的 store 配置
export const store = {
+ // 开启命名空间，使模块的 action、mutation 和 getter 名称唯一
namespaced: true,
+ // 模块的状态
state: {
uid: 1,
token: '',
@@ -30,38 +50,53 @@ export const store = {
userPeofile: {},
rememberPWD: false
},
+ // 模块的 mutations，用于修改状态
mutations: {
+ // 设置用户令牌的 mutation
setToken(state: IAppState, token: string) {
state.token = token
},
+ // 设置路由树的 mutation
setRouteTree(state: IAppState, routeTree: IRoute[]) {
state.routeTree = routeTree
},
+ // 设置是否有路由权限的 mutation
setAuth(state: IAppState, auth: boolean) {
state.hasAuth = auth
},
+ // 切换侧边栏展开状态的 mutation
setSiderType(state: IAppState) {
state.siderType = !state.siderType
},
+ // 设置用户信息的 mutation
setUserProfile(state: IAppState, userPeofile: any) {
state.userPeofile = userPeofile
},
+ // 设置是否记住密码的 mutation
setRememberPWD(state: IAppState, rememberPWD: boolean) {
state.rememberPWD = rememberPWD
},
+ // 清除 store 状态的 mutation，将状态重置为默认状态
clearStore(state: IAppState) {
Object.assign(state, defaultState)
}
},
+ // 模块的 actions，用于处理异步操作和提交 mutations
actions: {
- //登录
+ // 登录 action
async actionLogin(
+ // 从上下文获取 commit 和 state
{ commit, state }: ActionContext,
+ // 登录数据
data: any
) {
+ // 调用登录请求函数
const res: any = await getLogin(data)
+ // 如果登录成功
if (res.code === 200) {
+ // 提交设置令牌的 mutation
commit('setToken', res?.data?.token)
+ // 提交设置用户信息的 mutation
commit('setUserProfile', {
username: res?.data.name,
userid: res?.data.id,
@@ -69,22 +104,31 @@ export const store = {
authIdList: res?.data.authIdList
})
}
+ // 提交设置是否记住密码的 mutation
commit('setRememberPWD', data?.rememberPWD)
+ // 返回登录请求的响应
return res
},
- //获取权限菜单
+ // 获取权限菜单 action
getRouterTree({ commit, state }: ActionContext) {
- // 模拟数据
+ // 模拟获取路由列表
const routeList = getRouterList(state.uid).data as unknown as IRoute[]
+ // 格式化路由列表为路由树
const routeTree = formatRouteTree(routeList)
+ // 提交设置路由树的 mutation
commit('setRouteTree', routeTree)
+ // 提交设置有路由权限的 mutation
commit('setAuth', true)
},
- // 点击登出
+ // 点击登出 action
logout({ commit, state }: ActionContext) {
+ // 提交清除 store 状态的 mutation
commit('clearStore')
+ // 清除本地存储
localStorage.clear()
+ // 清除动态添加的路由
clearRoutes()
+ // 路由跳转到登录页
router.replace('/login')
}
}
diff --git a/client/src/store/modules/app/types.ts b/client/src/store/modules/app/types.ts
index b064c07..6ac80e7 100644
--- a/client/src/store/modules/app/types.ts
+++ b/client/src/store/modules/app/types.ts
@@ -1,11 +1,20 @@
+// 从项目的路由类型文件中导入 IRoute 接口，用于描述路由的结构
import { IRoute } from '@/router/types'
+// 定义一个接口 IAppState，用于描述应用状态的结构
export interface IAppState {
+ // 用户 ID，类型为数字
uid: number
+ // 用户令牌，类型为字符串
token: string
+ // 是否有路由权限，类型为布尔值
hasAuth: boolean
+ // 路由树，是一个 IRoute 类型的数组，用于存储路由信息
routeTree: IRoute[]
+ // 侧边栏是否展开，类型为布尔值
siderType: boolean
+ // 用户信息，类型为 any，表示可以是任意类型的数据
userPeofile: any
+ // 是否记住密码，类型为布尔值
rememberPWD: boolean
}
diff --git a/client/src/store/modules/soldManage/index.ts b/client/src/store/modules/soldManage/index.ts
index fb5688c..5417709 100644
--- a/client/src/store/modules/soldManage/index.ts
+++ b/client/src/store/modules/soldManage/index.ts
@@ -1,9 +1,16 @@
+// 从 vuex 中导入 ActionContext 类型，它用于在 actions 里获取上下文，能访问 state、getters、mutations 等
import { ActionContext } from 'vuex'
+// 从项目的路由配置文件导入路由实例，后续可能会在 actions 里使用路由进行页面跳转
import router from '@/router'
+// 导出一个名为 store 的对象，这是一个 Vuex 模块
export const store = {
+ // 设置为 true 表示开启命名空间，可避免不同模块间的 action、mutation 和 getter 名称冲突
namespaced: true,
+ // state 是存储数据的地方，这里初始为空对象，后续可添加应用所需的状态数据
state: {},
+ // mutations 用于修改 state 中的数据，是同步操作，这里初始为空对象，后续可添加具体的 mutation 函数
mutations: {},
+ // actions 用于处理异步操作，如发起网络请求等，这里初始为空对象，后续可添加具体的 action 函数
actions: {}
}
diff --git a/client/src/store/types.ts b/client/src/store/types.ts
index 28f5937..335ec26 100644
--- a/client/src/store/types.ts
+++ b/client/src/store/types.ts
@@ -1,5 +1,11 @@
+// 从项目的 app 模块的类型文件中导入 IAppState 类型，该类型描述了 app 模块的状态结构
import { IAppState } from '@/store/modules/app/types'
+/**
+ * 定义一个名为 IRootState 的类型，它表示整个 Vuex 存储的根状态结构。
+ * 在 Vuex 中，根状态可以包含多个模块的状态，这里根状态只包含一个名为 app 的模块状态。
+ */
export type IRootState = {
+ // app 字段的类型为 IAppState，意味着根状态中的 app 模块状态遵循 IAppState 类型的定义
app: IAppState
}
diff --git a/client/src/store/utils.ts b/client/src/store/utils.ts
index f96b603..509eab0 100644
--- a/client/src/store/utils.ts
+++ b/client/src/store/utils.ts
@@ -1,25 +1,29 @@
/** 智能提示 */
+// 从当前目录的 types 文件中导入 IRootState 类型，用于表示根状态
import { IRootState } from './types'
+// 从当前目录的 index 文件中导入 modules 对象，该对象包含了所有的 Vuex 模块
import { modules } from './index'
+// 从 vuex 库中导入 CommitOptions、DispatchOptions 和 Store 类型
import { CommitOptions, DispatchOptions, Store as VuexStore } from 'vuex'
-// 获取modules的类型
+
+// 获取 modules 的类型
type Modules = typeof modules
-// 获取所有模块下的mutations
-type GetMutation = T extends { mutations: infer G } ? G : never
+// 获取所有模块下的 mutations
+type GetMutation = T extends { mutations: infer G }? G : never
type GetMutations = {
[K in keyof T]: GetMutation
}
type mutationsObj = GetMutations
-// 获取所有模块下的actions
-type GetAction = T extends { actions: infer G } ? G : never
+// 获取所有模块下的 actions
+type GetAction = T extends { actions: infer G }? G : never
type GetActions = {
[K in keyof T]: GetAction
}
type actionsObj = GetActions
-// 获取所有模块下的getters
-type GetGetter = T extends { getters: infer G } ? G : never
+// 获取所有模块下的 getters
+type GetGetter = T extends { getters: infer G }? G : never
type GetGetters = {
[K in keyof T]: GetGetter
}
diff --git a/client/src/styles/element.scss b/client/src/styles/element.scss
index 81e2fba..d1e83cf 100644
--- a/client/src/styles/element.scss
+++ b/client/src/styles/element.scss
@@ -1,22 +1,27 @@
+/* 为.el-breadcrumb__inner 和.el-breadcrumb__inner a 元素设置字体加粗为 400，!important 提高优先级 */
.el-breadcrumb__inner,
.el-breadcrumb__inner a {
font-weight: 400 !important;
}
+/* 隐藏.el-upload 元素内的 input[type='file'] 元素，!important 提高优先级 */
.el-upload {
input[type='file'] {
display: none !important;
}
}
+/* 隐藏.el-upload__input 元素 */
.el-upload__input {
display: none;
}
+/* 为.upload-container 元素内的.el-upload 元素设置宽度为 100% */
.upload-container {
.el-upload {
width: 100%;
+ /* 为.upload-container 元素内的.el-upload 元素的.el-upload-dragger 子元素设置宽度为 100%，高度为 200px */
.el-upload-dragger {
width: 100%;
height: 200px;
@@ -24,62 +29,70 @@
}
}
+/* 为.el-dropdown-menu 元素设置内边距为 0，!important 提高优先级 */
.el-dropdown-menu {
padding: 0 !important;
}
+/* 为.el-range-separator 元素设置盒模型为 content-box */
.el-range-separator {
box-sizing: content-box;
}
+/* 为.is-dark 元素设置 z-index 为 9999，!important 提高优先级 */
.is-dark {
z-index: 9999 !important;
}
-/* 重置 el-button 中 icon 的 margin */
+/* 重置带有 [class*='el-icon'] 类且后面跟着 span 元素的 margin-left 为 2px，!important 提高优先级 */
.reset-margin [class*='el-icon'] + span {
margin-left: 2px !important;
}
-/* 自定义 popover 的类名 */
+/* 为.pure-popper 元素设置内边距为 0，!important 提高优先级 */
.pure-popper {
padding: 0 !important;
}
-/* 自定义 tooltip 的类名 */
+/* 为.pure-tooltip 元素设置 z-index 为 41000，!important 提高优先级，因为右侧操作面板 right-panel 类名的 z-index 为 40000，tooltip 需要大于它才能显示 */
.pure-tooltip {
- // 右侧操作面板right-panel类名的z-index为40000，tooltip需要大于它才能显示
z-index: 41000 !important;
}
-/* nprogress 适配 element-plus 的主题色 */
+/* 为 #nprogress 元素及其子元素设置样式 */
#nprogress {
- & .bar {
+ /* 为 #nprogress 元素的.bar 子元素设置背景颜色为 --el-color-primary 变量的值，!important 提高优先级 */
+ &.bar {
background-color: var(--el-color-primary) !important;
}
- & .peg {
+ /* 为 #nprogress 元素的.peg 子元素设置 box-shadow，颜色为 --el-color-primary 变量的值，!important 提高优先级 */
+ &.peg {
box-shadow: 0 0 10px var(--el-color-primary),
0 0 5px var(--el-color-primary) !important;
}
- & .spinner-icon {
+ /* 为 #nprogress 元素的.spinner-icon 子元素设置边框颜色为 --el-color-primary 变量的值 */
+ &.spinner-icon {
border-top-color: var(--el-color-primary);
border-left-color: var(--el-color-primary);
}
}
-/* 全局覆盖element-plus的el-dialog、el-drawer、el-message-box、el-notification组件右上角关闭图标的样式，表现更鲜明 */
+/* 为.el-dialog__headerbtn 和.el-message-box__headerbtn 元素的:hover 状态设置样式 */
.el-dialog__headerbtn,
.el-message-box__headerbtn {
&:hover {
+ /* 为.el-dialog__headerbtn 和.el-message-box__headerbtn 元素在:hover 状态下的.el-dialog__close 子元素设置颜色为 --el-color-info 变量的值，!important 提高优先级 */
.el-dialog__close {
color: var(--el-color-info) !important;
}
}
}
+/* 为.el-icon 元素及其特定子元素设置样式 */
.el-icon {
+ /* 为.el-icon 元素的.el-dialog__close、.el-drawer__close、.el-message-box__close 和.el-notification__closeBtn 子元素设置样式 */
&.el-dialog__close,
&.el-drawer__close,
&.el-message-box__close,
@@ -90,6 +103,7 @@
border-radius: 4px;
transition: background-color 0.2s, color 0.2s;
+ /* 为这些子元素的:hover 状态设置样式 */
&:hover {
color: rgba(0, 0, 0, 0.88) !important;
background-color: rgba(0, 0, 0, 0.06);
@@ -98,7 +112,7 @@
}
}
-/* 克隆并自定义 ElMessage 样式，不会影响 ElMessage 原本样式，在 src/utils/message.ts 中调用自定义样式 ElMessage 方法即可，暗黑模式在 src/style/dark.scss 文件进行了适配 */
+/* 克隆并自定义 ElMessage 样式，为.pure-message 元素设置样式 */
.pure-message {
border-width: 0 !important;
background: #fff !important;
@@ -106,69 +120,85 @@
box-shadow: 0 3px 6px -4px #0000001f, 0 6px 16px #00000014,
0 9px 28px 8px #0000000d !important;
- &.el-message.is-closable .el-message__content {
+ /* 为.pure-message 元素的.is-closable 子元素的.el-message__content 子元素设置内边距 */
+ &.el-message.is-closable.el-message__content {
padding-right: 17px !important;
}
- & .el-message__content {
+ /* 为.pure-message 元素的.el-message__content 子元素设置颜色、指针事件和背景图像 */
+ &.el-message__content {
color: #000000d9 !important;
pointer-events: all !important;
background-image: initial !important;
}
- & .el-message__icon {
+ /* 为.pure-message 元素的.el-message__icon 子元素设置外边距 */
+ &.el-message__icon {
margin-right: 8px !important;
}
- & .el-message__closeBtn {
+ /* 为.pure-message 元素的.el-message__closeBtn 子元素设置样式 */
+ &.el-message__closeBtn {
outline: none;
border-radius: 4px;
right: 9px !important;
transition: background-color 0.2s, color 0.2s;
+ /* 为.el-message__closeBtn 子元素的:hover 状态设置背景颜色 */
&:hover {
background-color: rgba(0, 0, 0, 0.06);
}
}
}
+/* 为.el-popconfirm 元素的.el-popconfirm__action 子元素内的不同类型的.el-button 元素设置样式 */
.el-popconfirm {
.el-popconfirm__action {
+ /* 为.el-popconfirm__action 子元素内的.el-button--primary 类型的按钮设置背景颜色 */
.el-button--primary {
background-color: #409eff !important;
+ /* 为.el-button--primary 类型的按钮的:hover 状态设置背景颜色 */
&:hover {
background-color: #79bbff !important;
}
}
+ /* 为.el-popconfirm__action 子元素内的.el-button--success 类型的按钮设置背景颜色 */
.el-button--success {
background-color: #67C23A !important;
+ /* 为.el-button--success 类型的按钮的:hover 状态设置背景颜色 */
&:hover {
background-color: #95d475 !important;
}
}
+ /* 为.el-popconfirm__action 子元素内的.el-button--warning 类型的按钮设置背景颜色 */
.el-button--warning {
background-color: #E6A23C !important;
+ /* 为.el-button--warning 类型的按钮的:hover 状态设置背景颜色 */
&:hover {
background-color: #eebe77 !important;
}
}
+ /* 为.el-popconfirm__action 子元素内的.el-button--danger 类型的按钮设置背景颜色 */
.el-button--danger {
- background-color: #f56c6c !important;
+ background-color: #F56C6C !important;
+ /* 为.el-button--danger 类型的按钮的:hover 状态设置背景颜色 */
&:hover {
background-color: #f89898 !important;
}
}
+ /* 为.el-popconfirm__action 子元素内的.el-button--info 类型的按钮设置背景颜色 */
.el-button--info {
background-color: #909399 !important;
+ /* 为.el-button--info 类型的按钮的:hover 状态设置背景颜色 */
&:hover {
background-color: #b1b3b8 !important;
}
@@ -176,46 +206,56 @@
}
}
+/* 为.el-button--primary 类型的按钮设置颜色和背景颜色 */
.el-button--primary {
color: white !important;
background-color: #409EFF !important;
+ /* 为.el-button--primary 类型的按钮的:hover 状态设置背景颜色 */
&:hover {
background-color: #79bbff !important;
}
}
+/* 为.el-button--success 类型的按钮设置颜色和背景颜色 */
.el-button--success {
color: white !important;
background-color: #67C23A !important;
+ /* 为.el-button--success 类型的按钮的:hover 状态设置背景颜色 */
&:hover {
background-color: #95d475 !important;
}
}
+/* 为.el-button--warning 类型的按钮设置颜色和背景颜色 */
.el-button--warning {
color: white !important;
background-color: #E6A23C !important;
+ /* 为.el-button--warning 类型的按钮的:hover 状态设置背景颜色 */
&:hover {
background-color: #eebe77 !important;
}
}
+/* 为.el-button--danger 类型的按钮设置颜色和背景颜色 */
.el-button--danger {
color: white !important;
background-color: #F56C6C !important;
+ /* 为.el-button--danger 类型的按钮的:hover 状态设置背景颜色 */
&:hover {
background-color: #f89898 !important;
}
}
+/* 为.el-button--info 类型的按钮设置颜色和背景颜色 */
.el-button--info {
color: white !important;
background-color: #909399 !important;
+ /* 为.el-button--info 类型的按钮的:hover 状态设置背景颜色 */
&:hover {
background-color: #b1b3b8 !important;
}
diff --git a/client/src/styles/index.scss b/client/src/styles/index.scss
index ca69fc8..eb00703 100644
--- a/client/src/styles/index.scss
+++ b/client/src/styles/index.scss
@@ -1,9 +1,26 @@
-@import './variables.module.scss'; // 常用变量
-@import './mixin.scss'; // 常用方法
-@import './base.scss'; // 基础样式
-@import './reset.scss'; // 重置样式
+// 导入常用变量文件，该文件可能包含颜色、字体大小、间距等常用变量的定义
+@import './variables.module.scss';
+
+// 导入常用方法文件，该文件可能包含一些自定义的混合宏（mixin）或函数，用于简化样式编写
+@import './mixin.scss';
+
+// 导入基础样式文件，该文件可能包含一些全局的基础样式，如字体、文本对齐、行高等
+@import './base.scss';
+
+// 导入重置样式文件，该文件通常用于重置浏览器的默认样式，使不同浏览器的样式更加一致
+@import './reset.scss';
+
+// 导入登录页面的样式文件，该文件可能包含登录页面特有的样式
@import './login.scss';
+
+// 导入导航栏的样式文件，该文件可能包含导航栏的样式
@import './navbar.scss';
+
+// 导入侧边栏的样式文件，该文件可能包含侧边栏的样式
@import './sidebar.scss';
+
+// 导入 Element Plus 组件库的样式文件，该文件可能包含对 Element Plus 组件的样式覆盖或自定义
@import './element.scss';
+
+// 导入过渡效果的样式文件，该文件可能包含一些过渡动画的样式定义
@import './transition.scss';
diff --git a/client/src/styles/login.scss b/client/src/styles/login.scss
index 83c9408..4bd7cca 100644
--- a/client/src/styles/login.scss
+++ b/client/src/styles/login.scss
@@ -1,70 +1,116 @@
+// 定义一个名为.login-container 的类选择器，用于设置登录容器的样式
.login-container {
+ // 设置定位为相对定位
position: relative;
+ // 设置高度为视口高度的 100%
height: 100vh;
+ // 设置宽度为视口宽度的 100%
width: 100vw;
+ // 设置为弹性盒子布局
display: flex;
+ // 使弹性盒子内的子元素在水平方向上两端对齐
justify-content: space-between;
+ // 选择.login-container 内的.left-box 和.right-box 元素，设置它们在弹性布局中平均分配剩余空间
.left-box,
.right-box {
flex: 1;
}
+ // 选择.login-container 内的.right-box 元素，设置其样式
.right-box {
+ // 设置为弹性盒子布局
display: flex;
+ // 使弹性盒子内的子元素在垂直方向上居中对齐
align-items: center;
+ // 向上偏移 90 像素
margin-top: -90px;
- .login-form ,
+ // 选择.right-box 内的.login-form 和.forget-pass-form 元素，设置它们的样式
+ .login-form,
.forget-pass-form {
+ // 设置宽度为 360 像素
width: 360px;
+ // 设置左边距为 50 像素
margin-left: 50px;
+ // 选择.login-form 和.forget-pass-form 内的.title 元素，设置其样式
.title {
+ // 设置为弹性盒子布局，子元素垂直排列
display: flex;
flex-direction: column;
+ // 使弹性盒子内的子元素在水平方向上居中对齐
align-items: center;
+ // 选择.title 内的 img 元素，设置其样式
img {
width: 80px;
height: 80px;
}
+ // 选择.title 内的 h2 元素，设置其样式
h2 {
+ // 设置文本颜色
color: #9193a3;
+ // 设置外边距，上 10 像素，右 0 像素，下 15 像素，左 0 像素
margin: 10px 0 15px 0;
}
}
+ // 选择.login-form 和.forget-pass-form 内的.password-set 元素，设置其样式
.password-set {
+ // 设置为弹性盒子布局
display: flex;
+ // 设置宽度为父元素的 100%
width: 100%;
+ // 设置外边距，上 -10 像素，右 0 像素，下 10 像素，左 0 像素
margin: -10px 0 10px 0;
+ // 使弹性盒子内的子元素在水平方向上向右对齐
justify-content: right;
}
}
}
+ // 选择.login-container 内的.left-box 元素，设置其样式
.left-box {
+ // 设置定位为相对定位
position: relative;
+ // 设置宽度为父元素的 100%
width: 100%;
+ // 为.left-box 元素添加一个伪元素，作为其背景图像容器
&::before {
content: '';
+ // 设置定位为绝对定位
position: absolute;
+ // 定位到元素的顶部
top: 0;
+ // 定位到元素的左侧
left: 0;
+ // 设置宽度为父元素的 100%
width: 100%;
+ // 设置高度为父元素的 100%
height: 100%;
+ // 设置背景图像，使用相对路径引用项目中的 bg.png 图片
background-image: url('~@/assets/imgs/bg.png');
+ // 设置背景图像不重复
background-repeat: no-repeat;
+ // 设置背景图像的大小，宽度自动，高度为父元素的 100%
background-size: auto 100%;
+ // 设置 z 轴层级为 -1，使其在.left-box 内的其他元素下方
z-index: -1;
}
+ // 选择.left-box 内的.img 元素，设置其样式
.img {
+ // 设置宽度为父元素的 100%
width: 100%;
+ // 设置高度为父元素的 100%
height: 100%;
+ // 设置为弹性盒子布局
display: flex;
+ // 使弹性盒子内的子元素在垂直方向上居中对齐
align-items: center;
+ // 使弹性盒子内的子元素在水平方向上居中对齐
justify-content: center;
+ // 选择.img 内的 img 元素，设置其样式
img {
width: 500px;
}
diff --git a/client/src/styles/mixin.scss b/client/src/styles/mixin.scss
index 3ca7168..68a03c8 100644
--- a/client/src/styles/mixin.scss
+++ b/client/src/styles/mixin.scss
@@ -1,26 +1,34 @@
+// 定义一个名为 clearfix 的混合宏（mixin）
@mixin clearfix {
+ // 为使用该混合宏的元素添加一个伪元素:after
&:after {
content: '';
+ // 设置伪元素的显示方式为表格，用于清除浮动
display: table;
clear: both;
}
}
+// 定义一个名为 scrollBar 的混合宏（mixin），用于设置滚动条样式
@mixin scrollBar {
+ // 设置滚动条轨道的样式
&::-webkit-scrollbar-track-piece {
background: #d3dce6;
}
+ // 设置滚动条的宽度
&::-webkit-scrollbar {
width: 6px;
}
+ // 设置滚动条滑块的样式
&::-webkit-scrollbar-thumb {
background: #99a9bf;
border-radius: 20px;
}
}
+// 定义一个名为 relative 的混合宏（mixin），用于设置元素的相对定位和尺寸
@mixin relative {
position: relative;
width: 100%;
diff --git a/client/src/styles/navbar.scss b/client/src/styles/navbar.scss
index a4af7eb..b7f5985 100644
--- a/client/src/styles/navbar.scss
+++ b/client/src/styles/navbar.scss
@@ -1,19 +1,31 @@
-// 导航划过阴影
+/* 定义一个名为.navbar-bg-hover 的类选择器，用于设置导航栏背景悬停效果的样式 */
.navbar-bg-hover {
+ /* 设置为弹性盒子布局 */
display: flex;
+ /* 使弹性盒子内的子元素在垂直方向上居中对齐 */
align-items: center;
+ /* 使弹性盒子内的子元素在水平方向上居中对齐 */
justify-content: center;
+ /* 设置高度为 48 像素 */
height: 48px;
+ /* 设置内边距为 12 像素 */
padding: 12px;
+ /* 设置所有属性的过渡效果，持续时间为 0.3 秒 */
transition: all 0.3s;
+}
- &:hover {
- background-color: #f6f6f6;
- cursor: pointer;
- transition: all 0.3s;
- }
+/* 当.navbar-bg-hover 元素被鼠标悬停时的样式 */
+&:hover {
+ /* 设置背景颜色为 #f6f6f6 */
+ background-color: #f6f6f6;
+ /* 设置鼠标指针样式为指针 */
+ cursor: pointer;
+ /* 再次设置所有属性的过渡效果，持续时间为 0.3 秒 */
+ transition: all 0.3s;
+}
- .svg-icon {
- outline: none;
- }
+/* 选择.navbar-bg-hover 元素内的.svg-icon 元素，设置其样式 */
+.svg-icon {
+ /* 去除轮廓线 */
+ outline: none;
}
diff --git a/client/src/styles/reset.scss b/client/src/styles/reset.scss
index 9ccb917..7d17a6d 100644
--- a/client/src/styles/reset.scss
+++ b/client/src/styles/reset.scss
@@ -1,61 +1,97 @@
+/* 对 html 和 body 元素设置样式 */
html,
body {
+ /* 设置高度为视口高度的 100% */
height: 100%;
+ /* 去除外边距 */
margin: 0;
+ /* 去除内边距 */
padding: 0;
+ /* 针对 Firefox 浏览器，设置字体抗锯齿为灰度模式，提高字体显示质量 */
-moz-osx-font-smoothing: grayscale;
+ /* 针对 WebKit 内核的浏览器（如 Chrome、Safari），设置字体抗锯齿，提高字体显示质量 */
-webkit-font-smoothing: antialiased;
+ /* 设置文本渲染方式为优化可读性 */
text-rendering: optimizeLegibility;
+ // 这行代码被注释掉，原本是设置字体族，由于被注释，当前不生效。
// font-family: Helvetica Neue, Helvetica, PingFang SC, Hiragino Sans GB,
// Microsoft YaHei, Arial, sans-serif;
}
+/* 对 id 为 app 的元素设置样式 */
#app {
+ /* 设置高度为视口高度的 100% */
height: 100%;
}
+/* 对所有元素及其伪元素（:before 和 :after）设置样式 */
*,
*:before,
*:after {
+ /* 使元素的 box-sizing 属性继承自父元素，通常用于统一盒模型的计算方式 */
box-sizing: inherit;
+ /* 去除外边距 */
margin: 0;
+ /* 去除内边距 */
padding: 0;
}
+/* 对处于激活（active）和获得焦点（focus）状态的 a 元素设置样式 */
a:focus,
a:active {
+ /* 去除轮廓线 */
outline: none;
}
+/* 对 a 元素及其处于获得焦点（focus）和鼠标悬停（hover）状态时设置样式 */
a,
a:focus,
a:hover {
+ /* 设置鼠标指针样式为指针 */
cursor: pointer;
+ /* 使链接文本颜色继承自父元素 */
color: inherit;
+ /* 去除链接的下划线 */
text-decoration: none;
}
+/* 对获得焦点的 div 元素设置样式 */
div:focus {
+ /* 去除轮廓线 */
outline: none;
}
+/* 定义一个名为 clearfix 的类选择器，用于清除浮动，通过伪元素:after 实现 */
.clearfix {
&:after {
+ /* 使伪元素不可见 */
visibility: hidden;
+ /* 设置伪元素的显示方式为块级元素 */
display: block;
+ /* 设置伪元素的字体大小为 0 */
font-size: 0;
+ /* 设置伪元素的内容为空字符串 */
content: ' ';
+ /* 清除浮动 */
clear: both;
+ /* 设置伪元素的高度为 0 */
height: 0;
}
}
-div#driver-popover-item .driver-popover-title {
+/* 选择 id 为 driver-popover-item 的 div 元素内的.driver-popover-title 元素，设置其文本颜色 */
+div#driver-popover-item.driver-popover-title {
color: #1890ff;
}
-div#driver-popover-item .driver-popover-footer .driver-next-btn {
+
+/* 选择 id 为 driver-popover-item 的 div 元素内的.driver-popover-footer 元素内的.driver-next-btn 元素，设置其样式 */
+div#driver-popover-item.driver-popover-footer.driver-next-btn {
+ /* 设置背景颜色 */
background-color: #1890ff;
+ /* 设置文本颜色为白色 */
color: white;
+ /* 去除文本阴影 */
text-shadow: none;
+ /* 设置元素的边框圆角为 4 像素 */
border-radius: 4px;
}
diff --git a/client/src/styles/sidebar.scss b/client/src/styles/sidebar.scss
index 74840bd..d09e538 100644
--- a/client/src/styles/sidebar.scss
+++ b/client/src/styles/sidebar.scss
@@ -1,144 +1,221 @@
+// 定义主要内容区域的样式
.main-container {
+ // 宽度为视口宽度减去侧边栏宽度
width: calc(100% - $sideBarWidth);
+ // 高度为视口高度
height: 100%;
+ // 固定定位在视口右上角
position: fixed;
top: 0;
right: 0;
+ // 设置 z-index 为 9，用于控制元素的层叠顺序
z-index: 9;
+ // 所有属性的过渡效果，持续时间为 0.28 秒
transition: all 0.28s;
}
-// 重写菜单样式
+// 重写菜单样式，定义侧边栏容器的样式
.sidebar-container {
+ // 所有属性的过渡效果，持续时间为 0.3 秒
transition: all 0.3s;
+ // 宽度为侧边栏宽度变量的值，!important 提高优先级
width: $sideBarWidth !important;
+ // 高度为视口高度
height: 100%;
+ // 固定定位在视口左侧
position: fixed;
top: 0;
bottom: 0;
left: 0;
+ // 设置 z-index 为 1001，确保侧边栏在其他元素之上
z-index: 1001;
+ // 侧边栏的背景颜色，使用变量 $menuBg
background-color: $menuBg;
+ // 侧边栏滚动条包裹元素的样式
.scrollbar-wrapper {
+ // 隐藏水平滚动条，!important 提高优先级
overflow-x: hidden !important;
}
+ // 垂直滚动条的样式
.el-scrollbar__bar.is-vertical {
+ // 滚动条靠右显示
right: 0;
}
+ // 滚动条组件的样式
.el-scrollbar {
+ // 高度为视口高度减去 92px
height: calc(100% - 92px);
}
+ // 侧边栏有 logo 时的样式
&.has-logo {
+ // PC 端滚动条的样式
.el-scrollbar.pc {
/* logo: 48px、leftCollapse: 40px、leftCollapse-shadow: 4px */
+ // 高度为视口高度减去 92px
height: calc(100% - 92px);
}
+ // 移动端滚动条的样式
.el-scrollbar.mobile {
+ // 高度为视口高度
height: 100%;
}
}
+ // 水平菜单的样式
.is-horizontal {
+ // 隐藏水平菜单
display: none;
}
+ // 侧边栏链接的样式
a {
+ // 先设置为内联块元素，再设置为弹性布局
display: inline-block;
display: flex;
+ // 左侧内边距为 10px
padding-left: 10px;
+ // 子元素换行显示
flex-wrap: wrap;
+ // 宽度为 100%
width: 100%;
}
+ // Element UI 菜单组件的样式
.el-menu {
+ // 去除菜单边框
border: none;
+ // 高度为视口高度
height: 100%;
+ // 背景颜色为透明，!important 提高优先级
background-color: transparent !important;
}
+ // 菜单项和子菜单标题的样式
.el-menu-item,
.el-sub-menu__title {
+ // 高度为 50px
height: 50px;
+ // 文字颜色，使用变量 $menuText
color: $menuText;
+ // 背景颜色为透明，!important 提高优先级
background-color: transparent !important;
+ // 左侧内边距为 18px，!important 提高优先级
padding-left: 18px !important;
+ // 鼠标悬停时的样式
&:hover {
+ // 文字颜色，使用变量 $menuActiveText，!important 提高优先级
color: $menuActiveText !important;
+ // 图标样式
.svg-icon {
+ // 图标颜色，使用变量 $menuActiveText
color: $menuActiveText;
+ // 颜色过渡效果，持续时间为 0.3 秒
transition: color 0.3s;
}
}
+ // 图标样式
.svg-icon {
+ // 图标颜色，使用变量 $menuText
color: $menuText;
+ // 颜色过渡效果，持续时间为 0.3 秒
transition: color 0.3s;
}
+ // 菜单项内的 div 和 span 元素样式
div,
span {
+ // 高度为 50px
height: 50px;
+ // 行高为 50px
line-height: 50px;
+ // 隐藏溢出内容
overflow: hidden;
+ // 溢出内容显示省略号
text-overflow: ellipsis;
}
+ // 图标样式
.svg-icon {
+ // 最小宽度为 1em
min-width: 1em;
+ // 右侧外边距为 5px
margin-right: 5px;
}
}
+ // 无子菜单的标题和子菜单标题鼠标悬停时的样式
.submenu-title-noDropdown,
.el-sub-menu__title {
&:hover {
+ // 背景颜色为透明
background-color: transparent;
}
}
- // 子级选中父级也跟着亮
+ // 子级选中时，父级菜单高亮显示
.is-active > .el-sub-menu__title,
.is-active.submenu-title-noDropdown {
+ // 文字颜色，使用变量 $menuActiveText，!important 提高优先级
color: $menuActiveText !important;
+ // 图标样式
i {
+ // 图标颜色，使用变量 $menuActiveText，!important 提高优先级
color: $menuActiveText !important;
}
}
+ // 激活状态的菜单项样式
.is-active {
+ // 颜色过渡效果，持续时间为 0.3 秒
transition: color 0.3s;
+ // 文字颜色，使用变量 $menuActiveText，!important 提高优先级
color: $menuActiveText !important;
+ // 图标样式
.svg-icon {
+ // 图标颜色，使用变量 $menuActiveText
color: $menuActiveText;
+ // 颜色过渡效果，持续时间为 0.3 秒
transition: color 0.3s;
}
}
// 子级菜单样式
.el-menu .el-sub-menu .el-menu-item {
+ // 字体大小为 12px
font-size: 12px;
+ // 最小宽度为 100px，!important 提高优先级
min-width: 100px !important;
+ // 背景颜色，使用变量 $subMenuBg，!important 提高优先级
background-color: $subMenuBg !important;
+ // 激活状态的子级菜单项样式
&.is-active {
+ // 背景颜色，使用变量 $menuActiveBg，!important 提高优先级
background: $menuActiveBg !important;
+ // 文字颜色，使用变量 $menuActiveText，!important 提高优先级
color: $menuActiveText !important;
}
}
+ // 菜单项样式
.el-menu .el-menu-item {
+ // 菜单项提示框触发器样式
.el-menu-tooltip__trigger {
+ // 内边距为 18px
padding: 18px;
}
+ // 激活状态的菜单项样式
&.is-active {
+ // 背景颜色，使用变量 $menuActiveBg，!important 提高优先级
background: $menuActiveBg !important;
}
}
@@ -146,153 +223,224 @@
// 菜单栏折叠时的宽度
.el-menu--collapse {
+ // 宽度为折叠后侧边栏宽度变量的值
width: $hideSideBarWidth;
}
// 折叠菜单时的样式
.hideSidebar {
- // 菜单栏容器
+ // 菜单栏容器样式
.sidebar-container {
+ // 宽度过渡效果，持续时间为 0.3 秒
transition: width 0.3s;
+ // 宽度为折叠后侧边栏宽度变量的值，!important 提高优先级
width: $hideSideBarWidth !important;
+ // 子菜单样式
.el-sub-menu {
+ // 激活状态的子菜单样式
&.is-active {
+ // 所有属性过渡效果，持续时间为 0.28 秒
transition: all 0.28s;
+ // 文字颜色，使用变量 $menuActiveText，!important 提高优先级
color: $menuActiveText !important;
+ // 相对定位
position: relative;
+ // 激活状态子菜单的伪元素样式
&::after {
+ // 伪元素内容为空
content: '';
+ // 高度为 50px
height: 50px;
+ // 左侧距离为 2px
left: 2px;
+ // 绝对定位
position: absolute;
+ // 顶部距离为 0
top: 0;
+ // 过渡延迟 0.28 秒，!important 提高优先级
transition-delay: 0.28s !important;
+ // 宽度为 2px
width: 2px;
+ // 背景颜色为主题色变量的值，!important 提高优先级
background-color: var(--el-color-primary) !important;
+ // 不透明度为 1
opacity: 1;
}
+ // 图标样式
.svg-icon {
+ // 图标颜色，使用变量 $menuActiveText
color: $menuActiveText;
+ // 颜色过渡效果，持续时间为 0.3 秒
transition: color 0.3s;
}
}
}
- // 可折叠菜单
+ // 可折叠菜单标题样式
.el-sub-menu__title {
+ // 内边距为 18px
padding: 18px;
}
- // 不可折叠菜单
+ // 不可折叠菜单项样式
.el-menu-item {
+ // 菜单项提示框触发器样式
.el-menu-tooltip__trigger {
+ // 内边距为 18px
padding: 18px;
}
}
}
- // 菜单的最外层
+ // 菜单最外层样式
.el-menu--vertical {
+ // 宽度为折叠后侧边栏宽度变量的值，!important 提高优先级
width: $hideSideBarWidth !important;
+ // 宽度过渡效果，持续时间为 0.3 秒
transition: width 0.3s;
}
- // 主要内容
+ // 主要内容区域样式
.main-container {
+ // 宽度为视口宽度减去折叠后侧边栏宽度
width: calc(100% - $hideSideBarWidth);
}
}
-// 展开时的菜单
+// 展开时的菜单样式
.el-menu--vertical {
+ // 宽度为侧边栏宽度变量的值，!important 提高优先级
width: $sideBarWidth !important;
+ // 宽度过渡效果，持续时间为 0.3 秒
transition: width 0.3s;
/* 子菜单中还有子菜单 */
+ // 子菜单标题样式
.el-menu .el-sub-menu__title {
+ // 字体大小为 12px
font-size: 12px;
+ // 背景颜色，使用变量 $subMenuBg，!important 提高优先级
background-color: $subMenuBg !important;
}
}
-// 折叠时的菜单
+// 折叠时的菜单弹出框样式
.el-menu--popup-container {
+ // 菜单样式
.el-menu {
+ // 背景颜色，使用变量 $subMenuBg，!important 提高优先级
background-color: $subMenuBg !important;
}
+ // 菜单项和子菜单标题样式
.el-menu-item,
.el-sub-menu__title {
+ // 高度为 50px
height: 50px;
+ // 文字颜色，使用变量 $menuText
color: $menuText;
+ // 背景颜色为透明，!important 提高优先级
background-color: transparent !important;
+ // 鼠标悬停时的样式
&:hover {
+ // 文字颜色，使用变量 $menuActiveText，!important 提高优先级
color: $menuActiveText !important;
+ // 图标样式
.svg-icon {
+ // 图标颜色，使用变量 $menuActiveText
color: $menuActiveText;
+ // 颜色过渡效果，持续时间为 0.3 秒
transition: color 0.3s;
}
}
+ // 图标样式
.svg-icon {
+ // 图标颜色，使用变量 $menuText
color: $menuText;
+ // 颜色过渡效果，持续时间为 0.3 秒
transition: color 0.3s;
}
+ // 菜单项内的 div 和 span 元素样式
div,
span {
+ // 高度为 50px
height: 50px;
+ // 行高为 50px
line-height: 50px;
+ // 隐藏溢出内容
overflow: hidden;
+ // 溢出内容显示省略号
text-overflow: ellipsis;
}
}
+ // 无子菜单的标题和子菜单标题鼠标悬停时的样式
.submenu-title-noDropdown,
.el-sub-menu__title {
&:hover {
+ // 背景颜色为透明
background-color: transparent;
}
}
+ // 子级选中时，父级菜单高亮显示
.is-active > .el-sub-menu__title,
.is-active.submenu-title-noDropdown {
+ // 文字颜色，使用变量 $menuActiveText，!important 提高优先级
color: $menuActiveText !important;
+ // 图标样式
i {
+ // 图标颜色，使用变量 $menuActiveText，!important 提高优先级
color: $menuActiveText !important;
}
}
+ // 菜单项样式
.el-menu .el-menu-item {
+ // 字体大小为 12px，!important 提高优先级
font-size: 12px !important;
+ // 最小宽度为 100px，!important 提高优先级
min-width: 100px !important;
+ // 背景颜色，使用变量 $subMenuBg，!important 提高优先级
background-color: $subMenuBg !important;
+ // 激活状态的菜单项样式
&.is-active {
+ // 背景颜色，使用变量 $menuHover，!important 提高优先级
background: $menuHover !important;
}
}
+ // 激活状态的菜单项样式
.el-menu .el-menu-item {
&.is-active {
+ // 背景颜色，使用变量 $menuHover，!important 提高优先级
background: $menuHover !important;
}
}
}
-// 修复折叠后闪烁的bug
+// 修复折叠后闪烁的 bug
.is-active {
+ // 激活状态元素的伪元素样式
&::after {
+ // 伪元素内容为空
content: '';
+ // 不透明度为 1，!important 提高优先级
opacity: 1 !important;
}
+ // 菜单图标样式
.menu-icon {
+ // 无过渡效果，!important 提高优先级
transition: none !important;
+ // 图标颜色为白色，!important 提高优先级
color: #fff !important;
}
}
diff --git a/client/src/styles/theme.scss b/client/src/styles/theme.scss
index dbdc497..5599412 100644
--- a/client/src/styles/theme.scss
+++ b/client/src/styles/theme.scss
@@ -1,15 +1,19 @@
-// 卡片数字
+/* 定义一个名为.large-card-font 的类选择器，用于设置卡片上数字的样式 */
.large-card-font {
+ /* 使用 @apply 指令，应用其他样式类的样式，这里应用了 font-semibold（半粗体字体）和 text-2xl（字体大小为 2 倍大）这两个样式类 */
@apply font-semibold text-2xl;
+ /* 设置文本颜色为 RGB 值为 (41, 137, 255) 的颜色 */
color: rgb(41, 137, 255);
}
-// 字体颜色
+/* 定义一个名为.text-main 的类选择器，用于设置文本的主要颜色 */
.text-main {
+ /* 设置文本颜色为十六进制颜色值 #cecece */
color: #cecece;
}
-// 默认边框颜色
+/* 定义一个名为.border-main 的类选择器，用于设置默认的边框颜色和样式 */
.border-main {
+ /* 设置边框为 1 像素宽的实线，颜色为十六进制颜色值 #cfcfcf */
border: #cfcfcf solid 1px;
}
diff --git a/client/src/styles/transition.scss b/client/src/styles/transition.scss
index 2cc15ce..bc96ddd 100644
--- a/client/src/styles/transition.scss
+++ b/client/src/styles/transition.scss
@@ -1,31 +1,43 @@
-// 面包屑动画
+/* 定义面包屑进入和离开时的活跃状态样式，设置过渡效果 */
.breadcrumb-enter-active,
.breadcrumb-leave-active {
+ /* 所有属性的过渡效果，持续时间为 0.5 秒 */
transition: all 0.5s;
}
+/* 定义面包屑进入前的状态和离开时的活跃状态（这里似乎重复定义了离开活跃状态，可能存在错误）的样式 */
.breadcrumb-enter-from,
.breadcrumb-leave-active {
+ /* 透明度设置为 0 */
opacity: 0;
+ /* 水平方向平移 20 像素 */
transform: translateX(20px);
}
+/* 再次定义面包屑离开时的活跃状态样式，设置为绝对定位 */
.breadcrumb-leave-active {
position: absolute;
}
-/* 页面切换过渡动画 */
+/* 定义页面切换时的过渡动画相关类的样式，设置进入和离开时的活跃状态的过渡效果 */
.fade-transform-leave-active,
.fade-transform-enter-active {
+ /* 所有属性的过渡效果，持续时间为 0.28 秒 */
transition: all 0.28s;
}
+/* 定义页面切换时进入前的状态样式 */
.fade-transform-enter-from {
+ /* 透明度设置为 0 */
opacity: 0;
+ /* 水平向左平移 30 像素 */
transform: translateX(-30px);
}
+/* 定义页面切换时离开到的状态样式 */
.fade-transform-leave-to {
+ /* 透明度设置为 0 */
opacity: 0;
+ /* 水平向右平移 30 像素 */
transform: translateX(30px);
}
diff --git a/client/src/styles/variables.module.scss b/client/src/styles/variables.module.scss
index 9099d65..82562d4 100644
--- a/client/src/styles/variables.module.scss
+++ b/client/src/styles/variables.module.scss
@@ -1,24 +1,43 @@
-// sidebar
+// 定义侧边栏相关的样式变量
+
+// 侧边栏菜单文本的默认颜色，这里的颜色值 #fefefea6 表示带有一定透明度的白色
$menuText: #fefefea6;
+// 侧边栏菜单激活时（选中时）文本的颜色，为纯白色
$menuActiveText: #fff;
+// 侧边栏菜单的背景颜色，设置为深色调 #031429
$menuBg: #031429;
+// 侧边栏菜单激活时（选中时）的背景颜色，为蓝色调 #558df6
$menuActiveBg: #558df6;
+// 侧边栏菜单项鼠标悬停时的背景颜色，同样为蓝色调 #558df6
$menuHover: #558df6;
+// 子菜单的背景颜色，设置为较深的颜色 #0e0303
$subMenuBg: #0e0303;
+// 隐藏的子菜单背景颜色，设置为更深的颜色 #00061a
$subHideMenuBg: #00061a;
+// 侧边栏展开时的宽度，设置为 210 像素
$sideBarWidth: 210px;
+// 侧边栏折叠时的宽度，设置为 54 像素
$hideSideBarWidth: 54px;
+// 使用 :export 指令将定义的变量导出，以便在其他地方（如 JavaScript 中）使用
:export {
+ // 将 $menuText 变量导出为 menuText
menuText: $menuText;
+ // 将 $menuActiveText 变量导出为 menuActiveText
menuActiveText: $menuActiveText;
+ // 将 $menuBg 变量导出为 menuBg
menuBg: $menuBg;
+ // 将 $menuHover 变量导出为 menuHover
menuHover: $menuHover;
+ // 将 $subMenuBg 变量导出为 subMenuBg
subMenuBg: $subMenuBg;
+ // 将 $subHideMenuBg 变量导出为 subHideMenuBg
subHideMenuBg: $subHideMenuBg;
+ // 将 $sideBarWidth 变量导出为 sideBarWidth
sideBarWidth: $sideBarWidth;
+ // 将 $hideSideBarWidth 变量导出为 hideSideBarWidth
hideSideBarWidth: $hideSideBarWidth;
}
diff --git a/client/src/styles/variables.module.scss.d.ts b/client/src/styles/variables.module.scss.d.ts
index a4be38b..1576325 100644
--- a/client/src/styles/variables.module.scss.d.ts
+++ b/client/src/styles/variables.module.scss.d.ts
@@ -1,12 +1,25 @@
+// 定义一个接口 IVariables，用于描述包含侧边栏样式相关变量的对象结构
export interface IVariables {
+ // 菜单文本的颜色，类型为字符串
menuText: string
+ // 菜单激活时文本的颜色，类型为字符串
menuActiveText: string
+ // 菜单的背景颜色，类型为字符串
menuBg: string
+ // 菜单鼠标悬停时的背景颜色，类型为字符串
menuHover: string
+ // 子菜单的背景颜色，类型为字符串
subMenuBg: string
+ // 隐藏子菜单的背景颜色，类型为字符串
subHideMenuBg: string
+ // 侧边栏展开时的宽度，类型为字符串
sideBarWidth: string
+ // 侧边栏折叠时的宽度，类型为字符串
hideSideBarWidth: string
}
+
+// 声明一个名为 styles 的变量，其类型为 IVariables，但未初始化
export const styles: IVariables
+
+// 默认导出 styles 变量，但由于未初始化，可能在使用时需要注意
export default styles
diff --git a/client/src/types/global.d.ts b/client/src/types/global.d.ts
index e0636d7..3fc7117 100644
--- a/client/src/types/global.d.ts
+++ b/client/src/types/global.d.ts
@@ -1,11 +1,23 @@
/** 文件类型 */
+// 声明一个模块，用于处理.svg 结尾的文件，这样在 TypeScript 中就可以导入.svg 文件而不会报错，
+// 但这里只是简单声明，没有定义具体的类型，意味着导入该类型文件时会被视为 any 类型
declare module '*.svg'
+// 声明用于处理.png 结尾的文件的模块
declare module '*.png'
+// 声明用于处理.jpg 结尾的文件的模块
declare module '*.jpg'
+// 声明用于处理.jpeg 结尾的文件的模块
declare module '*.jpeg'
+// 声明用于处理.gif 结尾的文件的模块
declare module '*.gif'
+// 声明用于处理.bmp 结尾的文件的模块
declare module '*.bmp'
+// 声明用于处理.tiff 结尾的文件的模块
declare module '*.tiff'
+// 声明用于处理.yaml 结尾的文件的模块
declare module '*.yaml'
+// 声明用于处理.json 结尾的文件的模块
declare module '*.json'
+// 声明用于处理 vue-count-to 模块，可能是为了在项目中使用 vue-count-to 这个 Vue 插件时，
+// 让 TypeScript 知道它的存在，即使没有具体的类型定义，也能正常导入和使用（类型为 any）
declare module 'vue-count-to'
diff --git a/client/src/types/vuex.d.ts b/client/src/types/vuex.d.ts
index 80d2f40..7b5e133 100644
--- a/client/src/types/vuex.d.ts
+++ b/client/src/types/vuex.d.ts
@@ -1,12 +1,17 @@
-// vuex.d.ts
+// 从 'vuex' 库中导入 Store 和 Module 类型
import { Store, Module } from 'vuex'
+// 从 './store/types' 文件中导入 IStoreType 类型，这个类型应该定义了 Vuex 存储的状态结构
import { type IStoreType } from './store/types'
-// 模块扩展
-// 模板内$store强类型支持
+// 模块扩展，用于在 Vue 运行时核心模块中添加自定义类型声明
+// 这样做可以让 TypeScript 知道在 Vue 组件中 this.$store 的具体类型
declare module '@vue/runtime-core' {
// 为 `this.$store` 提供类型声明
+ // ComponentCustomProperties 是 Vue 中用于扩展组件自定义属性的接口
interface ComponentCustomProperties {
+ // 声明 $store 属性，其类型为 Store
+ // Store 是 Vuex 中的存储类，IStoreType 是之前导入的状态类型
+ // 这意味着在 Vue 组件中使用 this.$store 时，TypeScript 会进行类型检查，确保操作符合 IStoreType 的定义
$store: Store
}
}
diff --git a/client/src/utils/commonUtil.ts b/client/src/utils/commonUtil.ts
index 8258bd6..191e548 100644
--- a/client/src/utils/commonUtil.ts
+++ b/client/src/utils/commonUtil.ts
@@ -1,46 +1,47 @@
-// TODO 初始化Array
+// 导出一个函数initArray，用于初始化数组
+// 如果传入的array存在则返回array，否则返回一个空数组
export const initArray = (array: any) => {
- return array ? array : [];
+ return array? array : [];
};
-// TODO 将一个Array的某个字段所有的值全部添加到了一个Array
+// 导出一个函数arrayPushAllByFiled，用于将一个数组中某个字段的所有值添加到另一个数组
export const arrayPushAllByFiled = (dataArray: any, pushArray: any, field: any) => {
- // 初始化
+ // 初始化dataArray和pushArray
dataArray = initArray(dataArray);
pushArray = initArray(pushArray);
- // 法一
+ // 法一：使用for...of循环遍历dataArray，将每个元素的指定字段值添加到pushArray中
// for (const item of dataArray) {
// pushArray.push(item[field]);
// }
// return pushArray;
- // 法二
+ // 法二：使用map方法遍历dataArray，返回一个包含所有指定字段值的新数组
return dataArray.map((item: any) => item[field]);
};
-// TODO 将一个Array的数据全部添加到了一个Array
+// 导出一个函数arrayPushAllByObj，用于将一个数组的数据全部添加到另一个数组
export const arrayPushAllByObj = (dataArray: any, pushArray: any) => {
- // 初始化
+ // 初始化dataArray和pushArray
dataArray = initArray(dataArray);
pushArray = initArray(pushArray);
- // push
+ // 使用展开运算符将dataArray的所有元素添加到pushArray中
pushArray.push(...dataArray);
return pushArray;
};
-// TODO Array根据字段去重
+// 导出一个函数arrayDeduplicationByFiled，用于根据指定字段对数组进行去重
export const arrayDeduplicationByFiled = (array: any, field: string) => {
- // 初始化
+ // 初始化array
array = initArray(array);
- // 去重 法一：该方法对编号进行去重返回的是[1,3,5]的编号数组
+ // 去重 法一：使用Set和map方法对指定字段进行去重，返回一个包含去重后字段值的新数组
// const idArray = [...new Set(array.map((item: any) => item[field]))];
// 再使用for循环依次取出id对应数据即可
- // 去重 法二
+ // 去重 法二：使用reduce方法遍历数组，检查当前对象的指定字段是否已存在于新数组中，不存在则添加
return array.reduce((newArray: any, thisObj: any) => {
// 检查当前对象的属性是否已经存在于新数组中
const exists = newArray.some((item: any) => thisObj[field] === item[field]);
@@ -52,16 +53,16 @@ export const arrayDeduplicationByFiled = (array: any, field: string) => {
}, []);
};
-// TODO Array根据对象去重(适用于非对象数组)
+// 导出一个函数arrayDeduplicationByObj，用于根据对象对数组进行去重（适用于非对象数组）
export const arrayDeduplicationByObj = (array: any) => {
- // 初始化
+ // 初始化array
array = initArray(array);
- // 去重 法一：该方法对编号进行去重返回的是[1,3,5]的编号数组
+ // 去重 法一：使用Set和map方法对数组元素进行去重，返回一个包含去重后元素的新数组
// const idArray = [...new Set(array.map((item: any) => item))];
// 再使用for循环依次取出id对应数据即可
- // 去重 法二
+ // 去重 法二：使用reduce方法遍历数组，检查当前对象是否已存在于新数组中，不存在则添加
return array.reduce((newArray: any, thisObj: any) => {
// 检查当前对象的属性是否已经存在于新数组中
const exists = newArray.some((item: any) => thisObj === item);
diff --git a/client/src/utils/formRules.ts b/client/src/utils/formRules.ts
index 9953f35..1b6ac04 100644
--- a/client/src/utils/formRules.ts
+++ b/client/src/utils/formRules.ts
@@ -1,4 +1,4 @@
-// 电话规则
+// 从 @/utils/is 模块中导入多个用于验证的函数
import {
isNotEmail,
isNotIdNum,
@@ -7,43 +7,58 @@ import {
isNotNumber
} from "@/utils/is";
-// 电话规则
+// 电话规则验证函数
export function phoneRule(rule: any, value: any, callback: any, field: string) {
+ // 去除输入值的首尾空格
const trim = value?.trim();
+ // 如果输入值为空
if (!trim) {
+ // 调用回调函数并传递错误信息，提示电话不能为空
callback(new Error(field + "电话不能为空"));
} else if (isNotPhone(trim)) {
+ // 如果输入值不是有效的电话号码格式
callback(new Error(field + "电话格式有误"));
} else {
+ // 如果输入值有效，调用回调函数且不传递错误信息
callback();
}
}
-// 邮箱规则
+// 邮箱规则验证函数
export function emailRule(rule: any, value: any, callback: any, field: string) {
+ // 去除输入值的首尾空格
const trim = value?.trim();
+ // 如果输入值为空
if (!trim) {
+ // 调用回调函数并传递错误信息，提示邮箱不能为空
callback(new Error(field + "邮箱不能为空"));
} else if (isNotEmail(trim)) {
+ // 如果输入值不是有效的邮箱格式
callback(new Error(field + "邮箱格式有误"));
} else {
+ // 如果输入值有效，调用回调函数且不传递错误信息
callback();
}
}
-// 身份证号规则
+// 身份证号规则验证函数
export function idNumRule(rule: any, value: any, callback: any, field: string) {
+ // 去除输入值的首尾空格
const trim = value?.trim();
+ // 如果输入值为空
if (!trim) {
+ // 调用回调函数并传递错误信息，提示身份证号不能为空
callback(new Error(field + "身份证号不能为空"));
} else if (isNotIdNum(trim)) {
+ // 如果输入值不是有效的身份证号格式
callback(new Error(field + "身份证号格式有误"));
} else {
+ // 如果输入值有效，调用回调函数且不传递错误信息
callback();
}
}
-// 字符串规则
+// 字符串规则验证函数
export function stringRule(
rule: any,
value: any,
@@ -52,17 +67,22 @@ export function stringRule(
mixLen: number,
maxLen: number
) {
+ // 去除输入值的首尾空格
const trim = value?.trim();
+ // 如果输入值为空
if (!trim) {
+ // 调用回调函数并传递错误信息，提示该字段不能为空
callback(new Error(field + "不能为空"));
} else if (trim.length < mixLen || trim.length > maxLen) {
+ // 如果输入值的长度不在指定范围内
callback(new Error(field + "长度应为" + mixLen + "~" + maxLen));
} else {
+ // 如果输入值有效，调用回调函数且不传递错误信息
callback();
}
}
-// 数字（整数/小数）规则
+// 数字（整数/小数）规则验证函数
export function numberRule(
rule: any,
value: any,
@@ -71,21 +91,27 @@ export function numberRule(
mix: number,
max: number
) {
+ // 如果输入值为空
if (!value) {
+ // 调用回调函数并传递错误信息，提示该字段不能为空
callback(new Error(field + "不能为空"));
} else {
+ // 将输入值转换为字符串并去除首尾空格
const trim = value.toString()?.trim();
+ // 如果输入值不是有效的数字格式
if (isNotNumber(trim)) {
callback(new Error(field + "格式有误"));
} else if (trim < mix || trim > max) {
+ // 如果输入值不在指定的数字范围内
callback(new Error(field + "应该在" + mix + "~" + max + "之间"));
} else {
+ // 如果输入值有效，调用回调函数且不传递错误信息
callback();
}
}
}
-// 整数规则
+// 整数规则验证函数
export function integerRule(
rule: any,
value: any,
@@ -94,24 +120,32 @@ export function integerRule(
mix: number,
max: number
) {
+ // 如果输入值为空
if (!value) {
+ // 调用回调函数并传递错误信息，提示该字段不能为空
callback(new Error(field + "不能为空"));
} else {
+ // 将输入值转换为字符串并去除首尾空格
const trim = value.toString()?.trim();
+ // 如果输入值不是有效的整数格式
if (isNotInteger(trim)) {
callback(new Error(field + "格式有误"));
} else if (trim < mix || trim > max) {
+ // 如果输入值不在指定的整数范围内
callback(new Error(field + "应该在" + mix + "~" + max + "之间"));
} else {
+ // 如果输入值有效，调用回调函数且不传递错误信息
callback();
}
}
}
-// 日期规则
+// 日期规则验证函数，禁用当前时间之前的日期
export const disabledNowBeforeDate = (time: Date) => {
return time.getTime() < Date.now();
};
+
+// 日期规则验证函数，禁用当前时间之后的日期
export const disabledNowAfterDate = (time: Date) => {
return time.getTime() > Date.now();
};
diff --git a/client/src/utils/http/index.ts b/client/src/utils/http/index.ts
index 7aad11f..f2af8ec 100644
--- a/client/src/utils/http/index.ts
+++ b/client/src/utils/http/index.ts
@@ -1,35 +1,52 @@
+// 从 '@/store' 导入 Vuex 的 store 实例
import store from "@/store";
+// 导入 axios 库，并解构出 AxiosRequestConfig 和 AxiosResponse 类型
import baseAxios, { AxiosRequestConfig, AxiosResponse } from "axios";
+// 从 'element-plus' 导入 ElMessage 用于显示消息提示
import { ElMessage } from "element-plus";
+// 定义基础 URL
export const baseUrl = "http://127.0.0.1:9001/";
+// 创建一个 axios 实例，设置基础 URL、超时时间和默认 headers
const axios = baseAxios.create({
- baseURL: "",
- timeout: 5000,
- headers: {}
+ baseURL: "", // 这里可以根据实际情况设置基础 URL，如果为空则使用全局的 baseUrl
+ timeout: 5000, // 设置请求超时时间为 5000 毫秒
+ headers: {} // 可以在这里设置默认的请求头
});
-// 请求拦截器
+// 请求拦截器，在请求发送前会被调用
axios.interceptors.request.use((config: any) => {
+ // 从 localStorage 中获取名为 "stateData" 的数据，并解析为 JSON 对象
+ // 然后尝试获取其中的 app.token 作为令牌
const token = JSON.parse(localStorage.getItem("stateData")!)?.app?.token;
+ // 将令牌设置到请求头的 "token" 字段中
config.headers.token = token;
+ // 返回配置好的请求对象
return config;
});
-// 响应拦截器
+// 响应拦截器，在接收到响应后会被调用
axios.interceptors.response.use(
(res: AxiosResponse) => {
+ // 如果响应数据中的 code 为 500 且 msg 为 "令牌无效"
if (res.data.code === 500 && res.data.msg === "令牌无效") {
+ // 调用 store 的 app/logout 方法进行登出操作
store.dispatch("app/logout");
+ // 显示错误消息提示 "登录过期，请重新登录"
ElMessage.error({ message: "登录过期，请重新登录" });
}
+ // 如果响应数据中的 err 为 1
if (res.data.err === 1) {
+ // 则返回一个被拒绝的 Promise，携带响应数据
return Promise.reject(res.data);
}
+ // 返回响应数据
return res.data;
},
- err => Promise.reject(err) // 响应出问题
+ // 如果响应出现错误，返回一个被拒绝的 Promise，携带错误信息
+ err => Promise.reject(err)
);
+// 默认导出创建好的 axios 实例
export default axios;
diff --git a/client/src/utils/index.ts b/client/src/utils/index.ts
index 0135629..bf6a3d8 100644
--- a/client/src/utils/index.ts
+++ b/client/src/utils/index.ts
@@ -1,3 +1,7 @@
+// 从 './http' 文件中导入名为 http 的模块
+// 这里假设 './http' 文件中导出了一个名为 http 的对象，这个对象可能是封装好的 HTTP 请求工具，例如使用 axios 封装的请求实例
import http from './http'
+// 导出导入的 http 对象
+// 这样其他文件就可以通过导入这个文件来使用 http 对象进行 HTTP 请求操作
export { http }
diff --git a/client/src/utils/is/index.ts b/client/src/utils/is/index.ts
index 3f4c3ff..77c8660 100644
--- a/client/src/utils/is/index.ts
+++ b/client/src/utils/is/index.ts
@@ -1,174 +1,277 @@
-const toString = Object.prototype.toString
-// 保留两位小数的实数校验规则
-const REGEXP_NUMBER = /^[+-]?(0|([1-9]\d*))(\.\d{1,2})?$/
-// 密码校验规则
-const REGEXP_EMAIL = /^[a-zA-Z0-9]+@[a-zA-Z0-9]+\.[a-zA-Z0-9]+$/
-// 手机号校验规则
-const REGEXP_PHONE = /^1[3456789]\d{9}$/
-// 身份证号校验规则
+// 获取 Object.prototype.toString 方法的引用，用于后续类型判断
+const toString = Object.prototype.toString;
+// 定义一个正则表达式，用于校验保留两位小数的实数
+// 支持正负号，整数部分可以是 0 或者以 1 - 9 开头的数字串，小数部分可以有 1 到 2 位
+const REGEXP_NUMBER = /^[+-]?(0|([1-9]\d*))(\.\d{1,2})?$/;
+// 定义一个正则表达式，用于校验邮箱格式
+// 要求邮箱由字母、数字组成，中间有 @ 符号，并且有正确的域名和顶级域名
+const REGEXP_EMAIL = /^[a-zA-Z0-9]+@[a-zA-Z0-9]+\.[a-zA-Z0-9]+$/;
+// 定义一个正则表达式，用于校验手机号格式
+// 要求手机号以 1 开头，第二位是 3 - 9 中的一个数字，后面跟着 9 位数字
+const REGEXP_PHONE = /^1[3456789]\d{9}$/;
+// 定义一个正则表达式，用于校验身份证号格式
+// 符合中国 18 位身份证号码的格式规则
const REGEXP_ID_NUM =
- /^[1-9]\d{5}(18|19|([23]\d))\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]$/
+ /^[1-9]\d{5}(18|19|([23]\d))\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]$/;
/**
* @description: 判断值是否为账号（手机号/邮箱）
+ * @param {string} account - 待判断的账号字符串
+ * @returns {boolean} - 如果既不是手机号也不是邮箱，返回 true；否则返回 false
*/
export function isNotAccount(account: string) {
- return !REGEXP_PHONE.test(account) && !REGEXP_EMAIL.test(account)
+ // 使用正则表达式检查账号是否既不是手机号也不是邮箱
+ return !REGEXP_PHONE.test(account) && !REGEXP_EMAIL.test(account);
}
/**
* @description: 判断值是否为手机号
+ * @param {string} phone - 待判断的手机号字符串
+ * @returns {boolean} - 如果不是手机号，返回 true；否则返回 false
*/
export function isNotPhone(phone: string) {
- return !REGEXP_PHONE.test(phone)
+ // 使用正则表达式检查是否不是手机号
+ return !REGEXP_PHONE.test(phone);
}
/**
* @description: 判断值是否为邮箱
+ * @param {string} email - 待判断的邮箱字符串
+ * @returns {boolean} - 如果不是邮箱，返回 true；否则返回 false
*/
export function isNotEmail(email: string) {
- return !REGEXP_EMAIL.test(email)
+ // 使用正则表达式检查是否不是邮箱
+ return !REGEXP_EMAIL.test(email);
}
/**
* @description: 判断值是否为身份证号
+ * @param {string} idNum - 待判断的身份证号字符串
+ * @returns {boolean} - 如果不是身份证号，返回 true；否则返回 false
*/
export function isNotIdNum(idNum: string) {
- return !REGEXP_ID_NUM.test(idNum)
+ // 使用正则表达式检查是否不是身份证号
+ return !REGEXP_ID_NUM.test(idNum);
}
/**
* @description: 判断值是否为数字
+ * @param {string} num - 待判断的数字字符串
+ * @returns {boolean} - 如果不是符合规则的数字，返回 true；否则返回 false
*/
export function isNotNumber(num: string) {
- return !REGEXP_NUMBER.test(num)
+ // 使用正则表达式检查是否不是符合规则的数字
+ return !REGEXP_NUMBER.test(num);
}
/**
* @description: 判断值是否为整数
+ * @param {number} num - 待判断的数字
+ * @returns {boolean} - 如果不是整数，返回 true；否则返回 false
*/
export function isNotInteger(num: number) {
- return !Number.isInteger(Number(num))
+ // 使用 Number.isInteger 方法检查是否不是整数
+ return !Number.isInteger(Number(num));
}
/**
- * @description: 判断值是否未某个类型
+ * @description: 判断值是否为某个类型
+ * @param {unknown} val - 待判断的值
+ * @param {string} type - 要判断的类型名称
+ * @returns {boolean} - 如果值是指定类型，返回 true；否则返回 false
*/
export function is(val: unknown, type: string) {
- return toString.call(val) === `[object ${type}]`
+ // 使用 toString 方法获取值的类型字符串，并与指定类型比较
+ return toString.call(val) === `[object ${type}]`;
}
/**
- * @description: 是否为函数
+ * @description: 是否为函数
+ * @param {unknown} val - 待判断的值
+ * @returns {val is T} - 如果是函数，返回 true；否则返回 false
*/
export function isFunction void>(val: unknown): val is T {
- return is(val, 'Function')
+ // 调用 is 函数判断是否为 Function 类型
+ return is(val, 'Function');
}
/**
* @description: 是否已定义
+ * @param {T} val - 待判断的值
+ * @returns {val is T} - 如果值已定义（不是 undefined），返回 true；否则返回 false
*/
export const isDef = (val?: T): val is T => {
- return typeof val !== 'undefined'
+ // 使用 typeof 检查值是否不是 undefined
+ return typeof val !== 'undefined';
}
+/**
+ * @description: 是否未定义
+ * @param {T} val - 待判断的值
+ * @returns {val is T} - 如果值未定义（是 undefined），返回 true；否则返回 false
+ */
export const isUnDef = (val?: T): val is T => {
- return !isDef(val)
+ // 调用 isDef 函数取反判断是否未定义
+ return !isDef(val);
}
+
/**
* @description: 是否为对象
+ * @param {any} val - 待判断的值
+ * @returns {val is Record} - 如果是对象且不为 null，返回 true；否则返回 false
*/
export const isObject = (val: any): val is Record => {
- return val !== null && is(val, 'Object')
+ // 检查值不为 null 且是 Object 类型
+ return val !== null && is(val, 'Object');
}
/**
- * @description: 是否为时间
+ * @description: 是否为时间
+ * @param {unknown} val - 待判断的值
+ * @returns {val is Date} - 如果是 Date 类型，返回 true；否则返回 false
*/
export function isDate(val: unknown): val is Date {
- return is(val, 'Date')
+ // 调用 is 函数判断是否为 Date 类型
+ return is(val, 'Date');
}
/**
- * @description: 是否为数值
+ * @description: 是否为数值
+ * @param {unknown} val - 待判断的值
+ * @returns {val is number} - 如果是 Number 类型，返回 true；否则返回 false
*/
export function isNumber(val: unknown): val is number {
- return is(val, 'Number')
+ // 调用 is 函数判断是否为 Number 类型
+ return is(val, 'Number');
}
/**
- * @description: 是否为AsyncFunction
+ * @description: 是否为 AsyncFunction
+ * @param {unknown} val - 待判断的值
+ * @returns {val is Promise} - 如果是 AsyncFunction 类型，返回 true；否则返回 false
+ * 注：这里类型标注有误，实际应是检查是否为异步函数类型
*/
export function isAsyncFunction(val: unknown): val is Promise {
- return is(val, 'AsyncFunction')
+ // 调用 is 函数判断是否为 AsyncFunction 类型
+ return is(val, 'AsyncFunction');
}
/**
- * @description: 是否为promise
+ * @description: 是否为 promise
+ * @param {unknown} val - 待判断的值
+ * @returns {val is Promise} - 如果是 Promise 对象，返回 true；否则返回 false
*/
export function isPromise(val: unknown): val is Promise {
+ // 检查值是 Promise 类型，是对象，且有 then 和 catch 方法
return (
is(val, 'Promise') &&
isObject(val) &&
isFunction(val.then) &&
isFunction(val.catch)
- )
+ );
}
/**
- * @description: 是否为字符串
+ * @description: 是否为字符串
+ * @param {unknown} val - 待判断的值
+ * @returns {val is string} - 如果是 String 类型，返回 true；否则返回 false
*/
export function isString(val: unknown): val is string {
- return is(val, 'String')
+ // 调用 is 函数判断是否为 String 类型
+ return is(val, 'String');
}
/**
- * @description: 是否为boolean类型
+ * @description: 是否为 boolean 类型
+ * @param {unknown} val - 待判断的值
+ * @returns {val is boolean} - 如果是 Boolean 类型，返回 true；否则返回 false
*/
export function isBoolean(val: unknown): val is boolean {
- return is(val, 'Boolean')
+ // 调用 is 函数判断是否为 Boolean 类型
+ return is(val, 'Boolean');
}
/**
- * @description: 是否为数组
+ * @description: 是否为数组
+ * @param {any} val - 待判断的值
+ * @returns {val is Array} - 如果是数组，返回 true；否则返回 false
*/
export function isArray(val: any): val is Array {
- return val && Array.isArray(val)
+ // 检查值存在且是数组
+ return val && Array.isArray(val);
}
/**
* @description: 是否客户端
+ * @returns {boolean} - 如果在客户端环境（window 对象存在），返回 true；否则返回 false
*/
export const isClient = () => {
- return typeof window !== 'undefined'
+ // 检查 window 对象是否已定义
+ return typeof window !== 'undefined';
}
/**
* @description: 是否为浏览器
+ * @param {any} val - 待判断的值
+ * @returns {val is Window} - 如果是 window 对象，返回 true；否则返回 false
*/
export const isWindow = (val: any): val is Window => {
- return typeof window !== 'undefined' && is(val, 'Window')
+ // 检查 window 对象已定义且值是 Window 类型
+ return typeof window !== 'undefined' && is(val, 'Window');
}
+/**
+ * @description: 是否为元素
+ * @param {unknown} val - 待判断的值
+ * @returns {val is Element} - 如果是 DOM 元素，返回 true；否则返回 false
+ */
export const isElement = (val: unknown): val is Element => {
- return isObject(val) && !!val.tagName
+ // 检查值是对象且有 tagName 属性
+ return isObject(val) && !!val.tagName;
}
-export const isServer = typeof window === 'undefined'
+/**
+ * @description: 是否为服务器端
+ * @type {boolean} - 如果在服务器端环境（window 对象不存在），值为 true；否则为 false
+ */
+export const isServer = typeof window === 'undefined';
-// 是否为图片节点
+/**
+ * @description: 是否为图片节点
+ * @param {Element} o - 待判断的 DOM 元素
+ * @returns {boolean} - 如果是图片元素，返回 true；否则返回 false
+ */
export function isImageDom(o: Element) {
- return o && ['IMAGE', 'IMG'].includes(o.tagName)
+ // 检查元素存在且标签名是 IMAGE 或 IMG
+ return o && ['IMAGE', 'IMG'].includes(o.tagName);
}
+/**
+ * @description: 是否为 null
+ * @param {unknown} val - 待判断的值
+ * @returns {val is null} - 如果值为 null，返回 true；否则返回 false
+ */
export function isNull(val: unknown): val is null {
- return val === null
+ // 检查值是否等于 null
+ return val === null;
}
+/**
+ * @description: 是否同时为 null 和 undefined（此逻辑有误，实际不可能同时成立）
+ * @param {unknown} val - 待判断的值
+ * @returns {val is null | undefined} - 如果值同时为 null 和 undefined，返回 true；否则返回 false
+ */
export function isNullAndUnDef(val: unknown): val is null | undefined {
- return isUnDef(val) && isNull(val)
+ // 调用 isUnDef 和 isNull 函数判断
+ return isUnDef(val) && isNull(val);
}
+/**
+ * @description: 是否为 null 或 undefined
+ * @param {unknown} val - 待判断的值
+ * @returns {val is null | undefined} - 如果值为 null 或 undefined，返回 true；否则返回 false
+ */
export function isNullOrUnDef(val: unknown): val is null | undefined {
- return isUnDef(val) || isNull(val)
+ // 调用 isUnDef 和 isNull 函数取或判断
+ return isUnDef(val) || isNull(val);
}
diff --git a/client/src/utils/util.ts b/client/src/utils/util.ts
index 3714383..5a739fb 100644
--- a/client/src/utils/util.ts
+++ b/client/src/utils/util.ts
@@ -1,37 +1,55 @@
+// 从 './is' 文件中导入 isArray 函数，用于判断一个值是否为数组
import { isArray } from './is'
+// 定义一个函数 formatValue，用于格式化传入的值
export function formatValue(callValue: any) {
- // 如果当前值为数组,使用 / 拼接（根据需求自定义）
- if (isArray(callValue)) return callValue.length ? callValue.join(' / ') : '--'
- return callValue ?? '--'
+ // 如果传入的值是数组，使用 '/' 拼接数组元素（如果数组有元素），否则返回 '--'
+ if (isArray(callValue)) return callValue.length? callValue.join(' / ') : '--'
+ // 如果传入的值不是数组，直接返回该值，如果值为 null 或 undefined，则返回 '--'
+ return callValue?? '--'
}
+// 定义一个函数 handleRowAccordingToProp，根据属性路径处理行数据
export function handleRowAccordingToProp(
- row: { [key: string]: any },
- prop: string
+ row: { [key: string]: any }, // 表示一个对象，键为字符串类型，值为任意类型
+ prop: string // 表示属性路径字符串
) {
- if (!prop.includes('.')) return row[prop] ?? '--'
- prop.split('.').forEach(item => (row = row[item] ?? '--'))
+ // 如果属性路径中不包含 '.'，直接返回行数据中该属性的值，如果值为 null 或 undefined，则返回 '--'
+ if (!prop.includes('.')) return row[prop]?? '--'
+ // 如果属性路径中包含 '.'，按 '.' 分割属性路径，依次获取嵌套对象的属性值
+ prop.split('.').forEach(item => (row = row[item]?? '--'))
+ // 返回最终获取到的值
return row
}
+// 定义一个函数 handleProp，处理属性路径字符串
export function handleProp(prop: string) {
+ // 按 '.' 分割属性路径字符串，得到一个数组
const propArr = prop.split('.')
+ // 如果分割后的数组长度为 1，说明属性路径没有嵌套，直接返回原属性路径字符串
if (propArr.length == 1) return prop
+ // 如果数组长度大于 1，返回属性路径字符串中最后一个部分
return propArr[propArr.length - 1]
}
+// 定义一个函数 filterEnum，根据枚举数据过滤并格式化值
export function filterEnum(
- callValue: any,
- enumData: any[] | undefined,
- fieldNames?: { label: string; value: string },
- type?: 'tag'
+ callValue: any, // 要过滤的值
+ enumData: any[] | undefined, // 枚举数据数组或 undefined
+ fieldNames?: { label: string; value: string }, // 可选的字段名称配置对象，默认为 { label: 'label', value: 'value' }
+ type?: 'tag' // 可选的类型，默认为 undefined
): string {
- const value = fieldNames?.value ?? 'value'
- const label = fieldNames?.label ?? 'label'
+ // 获取字段名称配置中的 'value' 字段名，如果未提供则默认为 'value'
+ const value = fieldNames?.value?? 'value'
+ // 获取字段名称配置中的 'label' 字段名，如果未提供则默认为 'label'
+ const label = fieldNames?.label?? 'label'
+ // 定义一个空对象，用于存储过滤后的数据
let filterData: { [key: string]: any } = {}
+ // 如果枚举数据是一个数组，查找与传入值匹配的枚举项
if (Array.isArray(enumData))
filterData = enumData.find((item: any) => item[value] === callValue)
- if (type == 'tag') return filterData?.tagType ? filterData.tagType : ''
- return filterData ? filterData[label] : '--'
+ // 如果类型为 'tag'，返回过滤数据中的 'tagType' 字段值，如果不存在则返回空字符串
+ if (type == 'tag') return filterData?.tagType? filterData.tagType : ''
+ // 返回过滤数据中的 'label' 字段值，如果过滤数据不存在则返回 '--'
+ return filterData? filterData[label] : '--'
}
diff --git a/client/src/views/base/activity/index.vue b/client/src/views/base/activity/index.vue
index 37386f2..d7f7279 100644
--- a/client/src/views/base/activity/index.vue
+++ b/client/src/views/base/activity/index.vue
@@ -1,9 +1,18 @@
+
+
+
+
+
+
+
+
+
+
+
diff --git a/client/src/layout/components/Tags/index.vue b/client/src/layout/components/Tags/index.vue
index 97c40c2..4ac0bb9 100644
--- a/client/src/layout/components/Tags/index.vue
+++ b/client/src/layout/components/Tags/index.vue
@@ -1,17 +1,30 @@
+
diff --git a/client/src/layout/index.vue b/client/src/layout/index.vue
index 6debadf..b8f9bd5 100644
--- a/client/src/layout/index.vue
+++ b/client/src/layout/index.vue
@@ -1,19 +1,32 @@
+
+
+
+
+
+
+
+
-
+
-
+
diff --git a/client/src/views/base/index.vue b/client/src/views/base/index.vue
index cf9ed48..ad13d94 100644
--- a/client/src/views/base/index.vue
+++ b/client/src/views/base/index.vue
@@ -1,7 +1,22 @@
+
activity
+
+ v-model="dialogVisible"
+
+ :title="drawerProps.title"
+
+ destroy-on-close
>
-
-
-
+
+ rowData:
diff --git a/client/src/views/base/live/index.vue b/client/src/views/base/live/index.vue
index cf9ed48..52d2b92 100644
--- a/client/src/views/base/live/index.vue
+++ b/client/src/views/base/live/index.vue
@@ -1,7 +1,17 @@
+
-
-
-
-
-
-
-
-
-
-
-
+
+
+ :model="formData"
+ class="login-form"
+
+ ref="ruleFormRef"
+
+ :rules="rules"
+ label-width="120px"
+ >
+
+
+
+
+
+
+
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+ title="用户列表"
+ :columns="columns"
+ :requestApi="getTableList"
+ :initParam="initParam"
+ :dataCallback="dataCallback"
>
-
-
-
-
-
+
+
+
+
+
+
+
-
-
-
- 查看
-
-
- 编辑
-
-
-
- 删除
-
-
+
+
+
+
+ 查看
+
+
+
+ 编辑
+
+
+
+ @confirm="deleteData(scope)"
+ confirm-button-type="danger"
+ >
+
+
+ 删除
+
+
+
diff --git a/client/src/views/base/live/room/roomDialog/index.vue b/client/src/views/base/live/room/roomDialog/index.vue
index e4772ff..b5d73b0 100644
--- a/client/src/views/base/live/room/roomDialog/index.vue
+++ b/client/src/views/base/live/room/roomDialog/index.vue
@@ -1,107 +1,136 @@
+
+
+ v-model="dialogVisible"
+ :title="drawerProps.title"
+ destroy-on-close
>
-
-
-
+
+
+
diff --git a/client/src/views/base/sale/origin/index.vue b/client/src/views/base/sale/origin/index.vue
index fae4f59..31d830f 100644
--- a/client/src/views/base/sale/origin/index.vue
+++ b/client/src/views/base/sale/origin/index.vue
@@ -1,5 +1,9 @@
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+ class="login-form"
+ ref="ruleFormRef"
+ :rules="rules"
+ label-width="120px"
+ >
+
+
+
+
+
+
+
+
+
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
+
+
+
+ 新增
+
-
+
+
查看
+
编辑
+
+
删除
+
-
+
diff --git a/client/src/views/base/sale/origin/originDialog/index.vue b/client/src/views/base/sale/origin/originDialog/index.vue
index 97998e8..d97022a 100644
--- a/client/src/views/base/sale/origin/originDialog/index.vue
+++ b/client/src/views/base/sale/origin/originDialog/index.vue
@@ -1,138 +1,172 @@
+
+ :title="drawerProps.title"
+ destroy-on-close
>
-
-
-
+
+
diff --git a/client/src/views/charge/audit/auditDialog/index.vue b/client/src/views/charge/audit/auditDialog/index.vue
index f382ae5..8c97ac7 100644
--- a/client/src/views/charge/audit/auditDialog/index.vue
+++ b/client/src/views/charge/audit/auditDialog/index.vue
@@ -1,152 +1,194 @@
-
-
-
-
-
-
-
-
-
-
-
+
+
+ class="login-form"
+ ref="ruleFormRef"
+ :rules="rules"
+ label-width="120px"
+ >
+
+
+
+
+
+
+
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+ :title="drawerProps.title"
+ destroy-on-close
>
-
-
-
-
+
diff --git a/client/src/views/charge/index.vue b/client/src/views/charge/index.vue
index cf9ed48..b6740fe 100644
--- a/client/src/views/charge/index.vue
+++ b/client/src/views/charge/index.vue
@@ -1,7 +1,27 @@
+
-
-
+
+
+
+
+
+
+
+ class="login-form"
+ ref="ruleFormRef"
+ :rules="rules"
+ label-width="120px"
+ >
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
-
+
+
+
+ title="用户列表"
+ :columns="columns"
+ :requestApi="getTableList"
+ :initParam="initParam"
+ :dataCallback="dataCallback"
>
-
-
-
-
-
- 账户充值
-
-
+
+
+
+
+ link
+ :icon="CreditCard"
+ @click="openDrawer('账户充值',scope)"
+ >
+ 账户充值
+
+
+
-
+
diff --git a/client/src/views/charge/prestore/prestoreDialog/index.vue b/client/src/views/charge/prestore/prestoreDialog/index.vue
index 03f28ba..7ba812b 100644
--- a/client/src/views/charge/prestore/prestoreDialog/index.vue
+++ b/client/src/views/charge/prestore/prestoreDialog/index.vue
@@ -1,133 +1,166 @@
+
+ v-model="dialogVisible"
+ :title="drawerProps.title"
+ destroy-on-close
>
- list = Arrays.stream(metaObject.getGetterNames()).collect(Collectors.toList());
+ // 判断列表中是否包含创建用户 ID 字段
if (list.contains(CREATEID)) {
- // 有登录信息
+ // 如果登录用户信息不为空
if (loginUserInfo != null) {
+ // 设置创建用户 ID 字段的值为当前登录用户的 ID
this.setFieldValByName(CREATEID, loginUserInfo.getId(), metaObject);
- // 无登录信息
} else {
+ // 若登录用户信息为空，设置创建用户 ID 字段的值为默认值 1L
this.setFieldValByName(CREATEID, 1L, metaObject);
}
}
+ // 判断列表中是否包含创建时间字段
if (list.contains(CREATETIME)) {
+ // 设置创建时间字段的值为当前时间
this.setFieldValByName(CREATETIME, new Date(), metaObject);
}
+ // 判断列表中是否包含更新用户 ID 字段
if (list.contains(UPDATEID)) {
- // 有登录信息
+ // 如果登录用户信息不为空
if (loginUserInfo != null) {
+ // 设置更新用户 ID 字段的值为当前登录用户的 ID
this.setFieldValByName(UPDATEID, loginUserInfo.getId(), metaObject);
- // 无登录信息
} else {
+ // 若登录用户信息为空，设置更新用户 ID 字段的值为默认值 1L
this.setFieldValByName(UPDATEID, 1L, metaObject);
}
}
+ // 判断列表中是否包含更新时间字段
if (list.contains(UPDATETIME)) {
+ // 设置更新时间字段的值为当前时间
this.setFieldValByName(UPDATETIME, new Date(), metaObject);
}
}
@Override
public void updateFill(MetaObject metaObject) {
- // 获取登录信息
+ // 调用 authorityAssert 的方法获取当前登录用户的信息
LoginUserVo loginUserInfo = authorityAssert.getLoginUserInfo();
- //获取所有的字段名称
+ // 获取元对象中所有可获取的字段名称，并存储在列表中
List list = Arrays.stream(metaObject.getGetterNames()).collect(Collectors.toList());
+ // 判断列表中是否包含更新用户 ID 字段
if (list.contains(UPDATEID)) {
- // 有登录信息
+ // 如果登录用户信息不为空
if (loginUserInfo != null) {
+ // 设置更新用户 ID 字段的值为当前登录用户的 ID
this.setFieldValByName(UPDATEID, loginUserInfo.getId(), metaObject);
- // 无登录信息
} else {
+ // 若登录用户信息为空，设置更新用户 ID 字段的值为默认值 1L
this.setFieldValByName(UPDATEID, 1L, metaObject);
}
}
+ // 判断列表中是否包含更新时间字段
if (list.contains(UPDATETIME)) {
+ // 设置更新时间字段的值为当前时间
this.setFieldValByName(UPDATETIME, new Date(), metaObject);
}
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/config/quartz/QuartzConfig.java b/server/src/main/java/com/ew/gerocomium/common/config/quartz/QuartzConfig.java
index eb9dc75..b2191f9 100644
--- a/server/src/main/java/com/ew/gerocomium/common/config/quartz/QuartzConfig.java
+++ b/server/src/main/java/com/ew/gerocomium/common/config/quartz/QuartzConfig.java
@@ -1,33 +1,57 @@
+// 声明该类所在的包，用于组织和管理代码结构
package com.ew.gerocomium.common.config.quartz;
-import org.quartz.*;
+// 导入 Quartz 框架的 JobDetail 接口，用于定义作业的详细信息
+import org.quartz.JobDetail;
+// 导入 Quartz 框架的 Trigger 接口，用于定义作业的触发条件
+import org.quartz.Trigger;
+// 导入 Quartz 框架的 JobBuilder 类，用于构建 JobDetail 对象
+import org.quartz.JobBuilder;
+// 导入 Quartz 框架的 TriggerBuilder 类，用于构建 Trigger 对象
+import org.quartz.TriggerBuilder;
+// 导入 Quartz 框架的 CronScheduleBuilder 类，用于构建基于 Cron 表达式的调度器
+import org.quartz.CronScheduleBuilder;
+// 导入 Quartz 框架的 JobDataMap 类，用于存储作业的数据
+import org.quartz.JobDataMap;
+// 导入 Spring 框架的配置类注解，表明这是一个配置类
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
+// 导入 Spring 框架中 Quartz 作业的基类
import org.springframework.scheduling.quartz.QuartzJobBean;
+// 使用 Spring 的 Configuration 注解，将该类标记为配置类
@Configuration
-public class QuartzConfig {
- // 预定过期
- @Bean
- public JobDetail reserveExpireJobDetail() {
- return newJobDetail(QuartzJob.ReserveExpireJob.class, "reserveExpireJobDetail");
- }
+ public class QuartzConfig {
- @Bean
- public Trigger reserveExpireTrigger() {
- return newTrigger(reserveExpireJobDetail(), "reserveExpireJobTrigger", "0 0 0 ? * *");
- }
+ // 定义一个名为 reserveExpireJobDetail 的 Bean，用于配置预定过期的作业详情
+ @Bean
+ public JobDetail reserveExpireJobDetail() {
+ // 调用自定义的 newJobDetail 方法创建并返回一个 JobDetail 对象
+ return newJobDetail(QuartzJob.ReserveExpireJob.class, "reserveExpireJobDetail");
+ }
- // 合同到期
- @Bean
- public JobDetail contractExpireJobDetail() {
- return newJobDetail(QuartzJob.ContractExpireJob.class, "contractExpireJobDetail");
- }
+ // 定义一个名为 reserveExpireTrigger 的 Bean，用于配置预定过期作业的触发器
+ @Bean
+ public Trigger reserveExpireTrigger() {
+ // 调用自定义的 newTrigger 方法创建并返回一个 Trigger 对象，关联到 reserveExpireJobDetail 作业详情
+ return newTrigger(reserveExpireJobDetail(), "reserveExpireJobTrigger", "0 0 0 ? * *");
+ }
- @Bean
- public Trigger contractExpireTrigger() {
- return newTrigger(contractExpireJobDetail(), "contractExpireJobTrigger", "0 0 8 ? * *");
- }
+ // 定义一个名为 contractExpireJobDetail 的 Bean，用于配置合同到期的作业详情
+ @Bean
+ public JobDetail contractExpireJobDetail() {
+ // 调用自定义的 newJobDetail 方法创建并返回一个 JobDetail 对象
+ return newJobDetail(QuartzJob.ContractExpireJob.class, "contractExpireJobDetail");
+ }
+
+ // 定义一个名为 contractExpireTrigger 的 Bean，用于配置合同到期作业的触发器
+ @Bean
+ public Trigger contractExpireTrigger() {
+ // 调用自定义的 newTrigger 方法创建并返回一个 Trigger 对象，关联到 contractExpireJobDetail 作业详情
+ return newTrigger(contractExpireJobDetail(), "contractExpireJobTrigger", "0 0 8 ? * *");
+ }
+
+ // 通用的作业详情构建方法，参数为作业类和作业详情名称
// 任务封装
private JobDetail newJobDetail(Class jobDetailClass, String jobDetailName) {
diff --git a/server/src/main/java/com/ew/gerocomium/common/config/quartz/QuartzJob.java b/server/src/main/java/com/ew/gerocomium/common/config/quartz/QuartzJob.java
index 8435b7c..aa1308c 100644
--- a/server/src/main/java/com/ew/gerocomium/common/config/quartz/QuartzJob.java
+++ b/server/src/main/java/com/ew/gerocomium/common/config/quartz/QuartzJob.java
@@ -1,37 +1,54 @@
+// 声明该类所在的包，用于组织和管理代码结构
package com.ew.gerocomium.common.config.quartz;
+// 导入自定义的合同服务接口
import com.ew.gerocomium.service.ContractService;
+// 导入自定义的预定服务接口
import com.ew.gerocomium.service.ReserveService;
+// 导入 Lombok 提供的注解，用于简化异常处理，自动抛出异常
import lombok.SneakyThrows;
+// 导入 Quartz 框架中作业的基类，Spring 整合 Quartz 时使用的作业类需要继承该类
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;
+// 导入 Spring 框架的服务注解，将该类标记为服务层组件
import org.springframework.stereotype.Service;
+// 导入 Spring 的资源注入注解
import javax.annotation.Resource;
+// 使用 Spring 的 Service 注解，将该类标记为服务层组件，让 Spring 框架管理
@Service
public class QuartzJob {
+
+ // 使用 Spring 的 Resource 注解注入 ReserveService 接口的实现类实例
@Resource
private ReserveService reserveService;
+ // 使用 Spring 的 Resource 注解注入 ContractService 接口的实现类实例
@Resource
private ContractService contractService;
- // 床位预定过期任务
+ // 定义一个内部类，表示床位预定过期任务，继承自 QuartzJobBean
public class ReserveExpireJob extends QuartzJobBean {
+ // 使用 Lombok 的 @SneakyThrows 注解，自动处理方法内可能抛出的异常
@SneakyThrows
@Override
+ // 重写 QuartzJobBean 的 executeInternal 方法，该方法在作业执行时被调用
protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
+ // 调用 ReserveService 中的 reserveExpireJob 方法，执行床位预定过期的业务逻辑
reserveService.reserveExpireJob();
}
}
- // 老人合同到期任务
+ // 定义一个内部类，表示老人合同到期任务，继承自 QuartzJobBean
public class ContractExpireJob extends QuartzJobBean {
+ // 使用 Lombok 的 @SneakyThrows 注解，自动处理方法内可能抛出的异常
@SneakyThrows
@Override
+ // 重写 QuartzJobBean 的 executeInternal 方法，该方法在作业执行时被调用
protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
+ // 调用 ContractService 中的 contractExpireJob 方法，执行老人合同到期的业务逻辑
contractService.contractExpireJob();
}
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/config/redis/FastJsonRedisSerializer.java b/server/src/main/java/com/ew/gerocomium/common/config/redis/FastJsonRedisSerializer.java
index 5b83078..0f2718a 100644
--- a/server/src/main/java/com/ew/gerocomium/common/config/redis/FastJsonRedisSerializer.java
+++ b/server/src/main/java/com/ew/gerocomium/common/config/redis/FastJsonRedisSerializer.java
@@ -1,53 +1,93 @@
+// 声明该类所在的包，用于组织和管理代码结构
package com.ew.gerocomium.common.config.redis;
+// 导入阿里巴巴的 FastJSON 库，用于 JSON 处理
import com.alibaba.fastjson.JSON;
+// 导入 FastJSON 库中用于设置序列化特性的类
import com.alibaba.fastjson.serializer.SerializerFeature;
+// 导入 Jackson 库中用于处理 Java 类型的类，在反序列化等操作中会用到
import com.fasterxml.jackson.databind.JavaType;
+// 导入 Jackson 库中用于创建类型工厂的类，通过该工厂创建 JavaType 等类型对象
import com.fasterxml.jackson.databind.type.TypeFactory;
+// 导入 Spring Data Redis 中用于定义 Redis 序列化器的接口
import org.springframework.data.redis.serializer.RedisSerializer;
+// 导入 Spring Data Redis 中序列化异常类，用于处理序列化过程中可能出现的异常情况
import org.springframework.data.redis.serializer.SerializationException;
+// 导入 FastJSON 库中用于解析配置的类
import com.alibaba.fastjson.parser.ParserConfig;
+// 导入 Java 标准库中用于处理字符集的类
import java.nio.charset.Charset;
/**
* Redis使用FastJson序列化
+ * 该类实现了RedisSerializer接口，用于将Java对象序列化为字节数组，以及将字节数组反序列化为Java对象
*/
public class FastJsonRedisSerializer implements RedisSerializer {
+ // 默认字符集，使用UTF-8编码
public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
+ // 泛型T对应的具体类的Class对象
private Class clazz;
+ // 静态代码块，在类加载时执行
+ // 开启FastJson的自动类型支持，这样在序列化和反序列化时可以保留对象的类型信息
static {
ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
}
+ /**
+ * 构造函数，用于初始化泛型T对应的具体类的Class对象
+ * @param clazz 泛型T对应的具体类的Class对象
+ */
public FastJsonRedisSerializer(Class clazz) {
super();
this.clazz = clazz;
}
+ /**
+ * 序列化方法，将Java对象序列化为字节数组
+ * @param t 要序列化的Java对象
+ * @return 序列化后的字节数组
+ * @throws SerializationException 如果序列化过程中出现异常
+ */
@Override
public byte[] serialize(T t) throws SerializationException {
+ // 如果要序列化的对象为null，则返回一个空的字节数组
if (t == null) {
return new byte[0];
}
+ // 使用FastJson将对象转换为JSON字符串，并写入类名信息
+ // 然后将JSON字符串按照默认字符集编码为字节数组
return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
}
+ /**
+ * 反序列化方法，将字节数组反序列化为Java对象
+ * @param bytes 要反序列化的字节数组
+ * @return 反序列化后的Java对象
+ * @throws SerializationException 如果反序列化过程中出现异常
+ */
@Override
public T deserialize(byte[] bytes) throws SerializationException {
+ // 如果字节数组为null或者长度为0，则返回null
if (bytes == null || bytes.length <= 0) {
return null;
}
+ // 将字节数组按照默认字符集解码为字符串
String str = new String(bytes, DEFAULT_CHARSET);
-
+ // 使用FastJson将JSON字符串反序列化为指定类型的对象
return JSON.parseObject(str, clazz);
}
-
+ /**
+ * 获取指定类的JavaType对象
+ * @param clazz 要获取JavaType的类
+ * @return 对应的JavaType对象
+ */
protected JavaType getJavaType(Class clazz) {
+ // 使用Jackson的TypeFactory构建指定类的JavaType对象
return TypeFactory.defaultInstance().constructType(clazz);
}
}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/config/redis/RedisConfig.java b/server/src/main/java/com/ew/gerocomium/common/config/redis/RedisConfig.java
index 78ff5c3..38d8b7a 100644
--- a/server/src/main/java/com/ew/gerocomium/common/config/redis/RedisConfig.java
+++ b/server/src/main/java/com/ew/gerocomium/common/config/redis/RedisConfig.java
@@ -1,30 +1,53 @@
+// 声明该类所在的包，包名为 com.ew.gerocomium.common.config.redis
package com.ew.gerocomium.common.config.redis;
+// 导入 Spring 框架中用于声明 Bean 的注解
import org.springframework.context.annotation.Bean;
+// 导入 Spring 框架中用于声明配置类的注解
import org.springframework.context.annotation.Configuration;
+// 导入 Spring Data Redis 中用于表示 Redis 连接工厂的类
import org.springframework.data.redis.connection.RedisConnectionFactory;
+// 导入 Spring Data Redis 中用于操作 Redis 的核心类
import org.springframework.data.redis.core.RedisTemplate;
+// 导入 Spring Data Redis 中用于将字符串进行序列化的类
import org.springframework.data.redis.serializer.StringRedisSerializer;
+// 使用 @Configuration 注解将该类标记为 Spring 的配置类，用于定义 Bean
+
+// 此注解表明该类是一个配置类，Spring会对其进行扫描并处理其中的配置信息
@Configuration
public class RedisConfig {
+ /**
+ * 创建一个RedisTemplate的Bean，用于与Redis进行交互
+ * @param connectionFactory Redis连接工厂，用于创建Redis连接
+ * @return 配置好的RedisTemplate实例
+ */
@Bean
+ // 抑制未经检查的类型转换和原始类型使用的警告
@SuppressWarnings(value = {"unchecked", "rawtypes"})
public RedisTemplate redisTemplate(RedisConnectionFactory connectionFactory) {
+ // 创建一个RedisTemplate实例
RedisTemplate template = new RedisTemplate<>();
+ // 设置RedisTemplate使用的连接工厂
template.setConnectionFactory(connectionFactory);
+ // 创建一个FastJsonRedisSerializer实例，用于对值进行序列化和反序列化
FastJsonRedisSerializer serializer = new FastJsonRedisSerializer(Object.class);
- // 使用StringRedisSerializer来序列化和反序列化redis的key值
+ // 设置Redis的键（key）使用StringRedisSerializer进行序列化和反序列化
+ // 这样可以确保键以字符串形式存储在Redis中
template.setKeySerializer(new StringRedisSerializer());
+ // 设置Redis的值（value）使用FastJsonRedisSerializer进行序列化和反序列化
template.setValueSerializer(serializer);
- // Hash的key也采用StringRedisSerializer的序列化方式
+ // 对于Redis中的Hash类型数据，设置其键（Hash key）使用StringRedisSerializer进行序列化和反序列化
template.setHashKeySerializer(new StringRedisSerializer());
+ // 设置Hash类型数据的值（Hash value）使用FastJsonRedisSerializer进行序列化和反序列化
template.setHashValueSerializer(serializer);
+ // 调用该方法来完成RedisTemplate的初始化操作，确保所有属性都已正确设置
template.afterPropertiesSet();
+ // 返回配置好的RedisTemplate实例
return template;
}
}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/config/security/config/SecurityConfig.java b/server/src/main/java/com/ew/gerocomium/common/config/security/config/SecurityConfig.java
index 22ccf7b..d1f6c2d 100644
--- a/server/src/main/java/com/ew/gerocomium/common/config/security/config/SecurityConfig.java
+++ b/server/src/main/java/com/ew/gerocomium/common/config/security/config/SecurityConfig.java
@@ -1,81 +1,110 @@
+// 声明该类所在的包，用于 Spring Security 相关的配置
package com.ew.gerocomium.common.config.security.config;
+// 导入自定义的 JWT 认证过滤器类
import com.ew.gerocomium.common.config.security.filter.JwtAuthenticationTokenFilter;
+// 导入自定义的密码编码器实现类
import com.ew.gerocomium.common.config.security.handler.PasswordEncoderImpl;
+// 导入自定义的通用工具类
import com.ew.gerocomium.common.util.CommonUtil;
+// 导入 Spring 框架中用于声明 Bean 的注解
import org.springframework.context.annotation.Bean;
+// 导入 Spring 框架中用于声明配置类的注解
import org.springframework.context.annotation.Configuration;
+// 导入 Spring Security 中用于表示认证管理器的类
import org.springframework.security.authentication.AuthenticationManager;
+// 导入 Spring Security 中用于构建认证管理器的类
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
+// 导入 Spring Security 中用于启用全局方法级安全注解的注解
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
+// 导入 Spring Security 中用于构建 HTTP 安全配置的类
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+// 导入 Spring Security 中用于配置 Web 安全的适配器类
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
+// 导入 Spring Security 中用于配置会话创建策略的枚举类
import org.springframework.security.config.http.SessionCreationPolicy;
+// 导入 Spring Security 中用于加载用户详细信息的服务接口
import org.springframework.security.core.userdetails.UserDetailsService;
+// 导入 Spring Security 中用于处理认证入口点的接口
import org.springframework.security.web.AuthenticationEntryPoint;
+// 导入 Spring Security 中用于处理访问被拒绝情况的接口
import org.springframework.security.web.access.AccessDeniedHandler;
+// 导入 Spring Security 中用于处理用户名和密码认证的过滤器类
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
+// 导入 Spring 框架中用于自动注入依赖的注解
import javax.annotation.Resource;
/**
* 自定义全局配置
*/
+// 使用 @Configuration 注解将该类标记为 Spring 的配置类，用于定义 Bean
@Configuration
+// 启用全局方法级安全注解，允许在方法上使用 @PreAuthorize、@PostAuthorize 等注解
@EnableGlobalMethodSecurity(prePostEnabled = true)
+// 继承 WebSecurityConfigurerAdapter 类，用于配置 Spring Security 的 Web 安全
public class SecurityConfig extends WebSecurityConfigurerAdapter {
+ // 使用 @Resource 注解自动注入 JwtAuthenticationTokenFilter 实例
@Resource
private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
+ // 使用 @Resource 注解自动注入 UserDetailsService 实例
@Resource
private UserDetailsService userDetailsService;
+ // 使用 @Resource 注解自动注入 PasswordEncoderImpl 实例
@Resource
private PasswordEncoderImpl passwordEncoder;
+ // 使用 @Resource 注解自动注入 AuthenticationEntryPoint 实例
@Resource
private AuthenticationEntryPoint authenticationEntryPoint;
+ // 使用 @Resource 注解自动注入 AccessDeniedHandler 实例
@Resource
private AccessDeniedHandler accessDeniedHandler;
+ // 使用 @Resource 注解自动注入 CommonUtil 实例
@Resource
private CommonUtil commonUtil;
+ // 重写 configure 方法，用于配置 HTTP 安全策略
@Override
protected void configure(HttpSecurity http) throws Exception {
http
- // 关闭csrf
+ // 关闭 CSRF（跨站请求伪造）防护，因为在前后端分离的项目中一般不需要
.csrf().disable()
- // 开启跨域以便前端调用接口
+ // 开启跨域支持，以便前端可以调用后端接口
.cors()
.and()
- // 禁用session
+ // 配置会话创建策略为无状态，即不使用 HTTP 会话
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
+ // 开始配置请求的授权规则
.authorizeRequests()
- // 放行登录接口后就不需要登录安全框架自带的登录页面
- // 允许匿名访问的接口（建议是登录和忘记密码接口）
+ // 允许匿名访问 CommonUtil 中定义的忽略 URL 列表中的接口，通常是登录和忘记密码接口
.antMatchers(commonUtil.getIgnoreUrlArray()).anonymous()
- // 允许全部放通的接口
+ // 允许所有用户访问 CommonUtil 中定义的忽略 URL 列表中的接口
.antMatchers(commonUtil.getIgnoreUrlArray()).permitAll()
- // 需要鉴权认证的接口
+ // 除了上述放行的接口，其他所有请求都需要进行认证
.anyRequest().authenticated();
- // 配置过滤器，将jwt认证过滤器添加到UsernamePasswordAuthenticationFilter过滤器之前
+ // 将 JwtAuthenticationTokenFilter 过滤器添加到 UsernamePasswordAuthenticationFilter 之前执行
http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
- // 配置异常处理器
+ // 配置异常处理
http.exceptionHandling()
- // 配置认证失败处理器
+ // 配置认证失败时的处理逻辑，使用注入的 AuthenticationEntryPoint 实例
.authenticationEntryPoint(authenticationEntryPoint)
- // 配置授权失败处理器
+ // 配置授权失败时的处理逻辑，使用注入的 AccessDeniedHandler 实例
.accessDeniedHandler(accessDeniedHandler);
}
- // 指定userDetailsService加密器
+ // 重写 configure 方法，用于指定 UserDetailsService 和密码编码器
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
+ // 设置使用 userDetailsService 加载用户信息，并使用 passwordEncoder 进行密码编码
auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder);
}
- // 重写该方法，通过Bean注解暴露
+ // 重写 authenticationManagerBean 方法，并使用 @Bean 注解将其暴露为 Spring Bean
@Bean
@Override
public AuthenticationManager authenticationManagerBean() throws Exception {
+ // 调用父类的方法获取 AuthenticationManager 实例并返回
return super.authenticationManagerBean();
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/config/security/entity/LoginUserDetails.java b/server/src/main/java/com/ew/gerocomium/common/config/security/entity/LoginUserDetails.java
index a3de5e3..0cd9dfe 100644
--- a/server/src/main/java/com/ew/gerocomium/common/config/security/entity/LoginUserDetails.java
+++ b/server/src/main/java/com/ew/gerocomium/common/config/security/entity/LoginUserDetails.java
@@ -1,62 +1,89 @@
+// 声明该类所在的包，此包主要用于 Spring Security 相关的实体类
package com.ew.gerocomium.common.config.security.entity;
+// 导入自定义的登录用户视图对象类
import com.ew.gerocomium.dao.vo.LoginUserVo;
+// 导入 Lombok 注解，用于自动生成全参构造函数
import lombok.AllArgsConstructor;
+// 导入 Lombok 注解，用于自动生成 getter、setter、toString 等方法
import lombok.Data;
+// 导入 Lombok 注解，用于自动生成无参构造函数
import lombok.NoArgsConstructor;
+// 导入 Spring Security 中表示权限的接口
import org.springframework.security.core.GrantedAuthority;
+// 导入 Spring Security 中表示用户详细信息的接口
import org.springframework.security.core.userdetails.UserDetails;
+// 导入 Java 集合框架中的 Collection 接口
import java.util.Collection;
+// 使用 Lombok 的 @Data 注解，自动生成 getter、setter、toString 等方法
@Data
+// 使用 Lombok 的 @NoArgsConstructor 注解，自动生成无参构造函数
@NoArgsConstructor
+// 使用 Lombok 的 @AllArgsConstructor 注解，自动生成全参构造函数
@AllArgsConstructor
+// 定义一个实现了 UserDetails 接口的类，用于封装登录用户的详细信息
public class LoginUserDetails implements UserDetails {
+ // 定义一个 LoginUserVo 类型的成员变量，用于存储登录用户的信息
private LoginUserVo loginUserVo;
+ // 重写 getAuthorities 方法，用于获取用户的权限集合
@Override
public Collection getAuthorities() {
- // 把permissions中String类型的权限信息封装成SimpleGrantedAuthority对象
- // 法一
+ // 以下是两种将权限字符串列表转换为 SimpleGrantedAuthority 对象列表的示例方法
+ // 法一：使用传统的 for 循环遍历权限字符串列表，将每个字符串封装成 SimpleGrantedAuthority 对象并添加到列表中
// List authorityList = new ArrayList<>();
// for (String permission : permissions) {
// SimpleGrantedAuthority simpleGrantedAuthority = new SimpleGrantedAuthority(permission);
// authorityList.add(simpleGrantedAuthority);
// }
- // 法二
+ // 法二：使用 Java 8 的 Stream API 对权限字符串列表进行处理，将每个字符串映射为 SimpleGrantedAuthority 对象并收集到列表中
// List authorityList =
// permissions.stream().map(SimpleGrantedAuthority::new).collect(Collectors.toList());
+ // 当前方法暂时返回 null，实际使用时需要根据具体情况实现权限获取逻辑
return null;
}
+ // 重写 getPassword 方法，用于获取用户的密码
@Override
public String getPassword() {
+ // 从 loginUserVo 对象中获取用户的密码并返回
return loginUserVo.getPass();
}
+ // 重写 getUsername 方法，用于获取用户的用户名
@Override
public String getUsername() {
+ // 从 loginUserVo 对象中获取用户的电话号码作为用户名并返回
return loginUserVo.getPhone();
}
+ // 重写 isAccountNonExpired 方法，用于判断用户账户是否未过期
@Override
public boolean isAccountNonExpired() {
+ // 这里默认返回 true，表示用户账户未过期，实际应用中可根据业务需求修改逻辑
return true;
}
+ // 重写 isAccountNonLocked 方法，用于判断用户账户是否未被锁定
@Override
public boolean isAccountNonLocked() {
+ // 这里默认返回 true，表示用户账户未被锁定，实际应用中可根据业务需求修改逻辑
return true;
}
+ // 重写 isCredentialsNonExpired 方法，用于判断用户的凭证（如密码）是否未过期
@Override
public boolean isCredentialsNonExpired() {
+ // 这里默认返回 true，表示用户的凭证未过期，实际应用中可根据业务需求修改逻辑
return true;
}
+ // 重写 isEnabled 方法，用于判断用户账户是否已启用
@Override
public boolean isEnabled() {
+ // 这里默认返回 true，表示用户账户已启用，实际应用中可根据业务需求修改逻辑
return true;
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/config/security/filter/JwtAuthenticationTokenFilter.java b/server/src/main/java/com/ew/gerocomium/common/config/security/filter/JwtAuthenticationTokenFilter.java
index 3b8aa12..a68d2d5 100644
--- a/server/src/main/java/com/ew/gerocomium/common/config/security/filter/JwtAuthenticationTokenFilter.java
+++ b/server/src/main/java/com/ew/gerocomium/common/config/security/filter/JwtAuthenticationTokenFilter.java
@@ -1,91 +1,129 @@
+// 声明该类所在的包，此包主要用于 Spring Security 相关的过滤器
package com.ew.gerocomium.common.config.security.filter;
+// 导入 Hutool 工具包中的 BeanUtil 类，用于对象属性的复制和转换
import cn.hutool.core.bean.BeanUtil;
+// 导入 Hutool 工具包中的 DateUtil 类，用于日期和时间的处理
import cn.hutool.core.date.DateUtil;
+// 导入自定义的常量类
import com.ew.gerocomium.common.constant.Constant;
+// 导入自定义的异常枚举类
import com.ew.gerocomium.common.constant.ExceptionEnum;
+// 导入自定义的工具类
import com.ew.gerocomium.common.util.*;
+// 导入自定义的登录用户视图对象类
import com.ew.gerocomium.dao.vo.LoginUserVo;
+// 导入 JWT 相关的 Claims 类，用于存储 JWT 中的声明信息
import io.jsonwebtoken.Claims;
+// 导入 JWT 相关的 Jws 类，用于表示已签名的 JWT
import io.jsonwebtoken.Jws;
+// 导入 Lombok 的日志注解，用于自动生成日志记录器
import lombok.extern.slf4j.Slf4j;
+// 导入 Spring Security 中用于表示用户名和密码认证令牌的类
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+// 导入 Spring Security 中用于表示简单权限的类
import org.springframework.security.core.authority.SimpleGrantedAuthority;
+// 导入 Spring Security 中用于存储安全上下文信息的类
import org.springframework.security.core.context.SecurityContextHolder;
+// 导入 Spring 框架中用于标记组件的注解
import org.springframework.stereotype.Component;
+// 导入 Spring 框架中用于字符串操作的工具类
import org.springframework.util.StringUtils;
+// 导入 Spring 框架中用于确保每个请求只执行一次过滤逻辑的过滤器基类
import org.springframework.web.filter.OncePerRequestFilter;
+// 导入 Spring 框架中用于自动注入依赖的注解
import javax.annotation.Resource;
+// 导入 Servlet 规范中的过滤器链接口，用于调用下一个过滤器
import javax.servlet.FilterChain;
+// 导入 Servlet 规范中的 Servlet 异常类
import javax.servlet.ServletException;
+// 导入 Servlet 规范中的 HTTP 请求对象类
import javax.servlet.http.HttpServletRequest;
+// 导入 Servlet 规范中的 HTTP 响应对象类
import javax.servlet.http.HttpServletResponse;
+// 导入 Java 中的输入输出异常类
import java.io.IOException;
+// 导入 Java 8 中的本地日期时间类
import java.time.LocalDateTime;
+// 导入 Java 中的日期类
import java.util.Date;
+// 导入 Java 中的列表接口
import java.util.List;
+// 导入 Java 8 中的 Stream 操作工具类
import java.util.stream.Collectors;
+// 使用 Lombok 的 @Slf4j 注解，自动生成日志记录器
@Slf4j
+// 使用 Spring 的 @Component 注解，将该类标记为组件，以便 Spring 自动扫描和管理
@Component
+// 定义一个继承自 OncePerRequestFilter 的过滤器类，用于处理 JWT 认证
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
+ // 使用 @Resource 注解自动注入 RedisUtil 实例，用于操作 Redis 缓存
@Resource
private RedisUtil redisUtil;
+ // 使用 @Resource 注解自动注入 CommonUtil 实例，用于通用工具方法
@Resource
private CommonUtil commonUtil;
+ // 重写 doFilterInternal 方法，该方法是过滤器的核心处理逻辑
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
- // 打印访问日志
+ // 打印当前请求的 URL 信息，方便调试和日志记录
log.info(request.getRequestURL().toString());
- // 获取jwt
+ // 从请求的头部获取名为 "token" 的 JWT 信息
String jwt = request.getHeader("token");
- // 获取请求路径
+ // 获取当前请求的 URI 路径
String requestURI = request.getRequestURI();
- // 验证url是否在白名单之内
+ // 调用 CommonUtil 的 existFlag 方法，验证请求的 URI 是否在白名单之内
boolean ignore = commonUtil.existFlag(commonUtil.getIgnoreUrlArray(), requestURI);
- // jwt为空 且 url在白名单之内
+ // 如果 JWT 为空且请求的 URI 在白名单之内
if (!StringUtils.hasText(jwt) && ignore) {
+ // 直接放行请求，调用过滤器链中的下一个过滤器
filterChain.doFilter(request, response);
return;
}
- // （jwt为空 但 url未在白名单之内） 或 （jwt不为空 且 url在白名单之内）
+ // 检查是否存在访问错误的情况，即（JWT 为空但请求的 URI 不在白名单之内）或（JWT 不为空且请求的 URI 在白名单之内）
boolean accessError = (!StringUtils.hasText(jwt) && !ignore) || (StringUtils.hasText(jwt) && ignore);
if (accessError) {
+ // 如果存在访问错误，调用 ResponseUtil 的 exceptionEnumOut 方法，返回相应的异常信息给客户端
ResponseUtil.exceptionEnumOut(response, ExceptionEnum.ACCESS_ERROR);
return;
}
- // jwt不为空 且 url未在白名单之内
- // 解析jwt获取用户id
+ // 如果 JWT 不为空且请求的 URI 不在白名单之内
+ // 定义一个变量用于存储从 JWT 中解析出的用户 ID
String id;
try {
+ // 调用 JwtUtil 的 parseJwt 方法解析 JWT，得到一个 Jws 对象
Jws claimsJws = JwtUtil.parseJwt(jwt);
+ // 从 JWT 的声明信息中获取名为 "id" 的值，并转换为字符串
id = claimsJws.getBody().get("id").toString();
} catch (Exception e) {
+ // 如果解析 JWT 过程中出现异常，打印异常堆栈信息
e.printStackTrace();
- // token解析出错（非法token/token过期）
+ // 调用 ResponseUtil 的 exceptionEnumOut 方法，返回 TOKEN_ERROR 异常信息给客户端
ResponseUtil.exceptionEnumOut(response, ExceptionEnum.TOKEN_ERROR);
return;
}
- // 从redis获取用户信息
+ // 从 Redis 中获取用户信息，根据常量 LOGIN_REDIS 和用户 ID 拼接缓存键，获取缓存对象并转换为 LoginUserVo 类型
LoginUserVo loginUserVo = BeanUtil.toBean(redisUtil.getCacheObject(Constant.LOGIN_REDIS + id), LoginUserVo.class);
- // 获取redis数据为空
+ // 如果从 Redis 中获取的用户信息为空
if (loginUserVo == null) {
+ // 调用 ResponseUtil 的 exceptionEnumOut 方法，返回 TOKEN_ERROR 异常信息给客户端
ResponseUtil.exceptionEnumOut(response, ExceptionEnum.TOKEN_ERROR);
return;
}
- // TODO 存入SecurityContextHolder上下文
- // 获取权限列表并转换
+ // TODO 存入 SecurityContextHolder 上下文
+ // 从登录用户信息中获取权限列表，并将其转换为 SimpleGrantedAuthority 对象列表
List authorityList = loginUserVo.getAuthUrlList().stream()
.map(SimpleGrantedAuthority::new)
.collect(Collectors.toList());
- // 认证
+ // 创建一个用户名和密码认证令牌对象，包含登录用户信息、凭证（这里为 null）和权限列表
UsernamePasswordAuthenticationToken authenticationToken =
new UsernamePasswordAuthenticationToken(loginUserVo, null, authorityList);
- // 存入上下文
+ // 将认证令牌存入 SecurityContextHolder 的上下文，以便后续的安全检查和授权操作可以使用
SecurityContextHolder.getContext().setAuthentication(authenticationToken);
- // 放行
+ // 放行请求，调用过滤器链中的下一个过滤器
filterChain.doFilter(request, response);
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/config/security/handler/AccessDeniedHandlerImpl.java b/server/src/main/java/com/ew/gerocomium/common/config/security/handler/AccessDeniedHandlerImpl.java
index d36a9fc..43767ca 100644
--- a/server/src/main/java/com/ew/gerocomium/common/config/security/handler/AccessDeniedHandlerImpl.java
+++ b/server/src/main/java/com/ew/gerocomium/common/config/security/handler/AccessDeniedHandlerImpl.java
@@ -1,23 +1,38 @@
+// 声明该类所在的包，此包主要用于 Spring Security 相关的处理器
package com.ew.gerocomium.common.config.security.handler;
+// 导入自定义的异常枚举类，用于定义各种异常情况
import com.ew.gerocomium.common.constant.ExceptionEnum;
+// 导入自定义的响应工具类，用于处理响应输出
import com.ew.gerocomium.common.util.ResponseUtil;
+// 导入 Spring Security 中表示访问被拒绝异常的类
import org.springframework.security.access.AccessDeniedException;
+// 导入 Spring Security 中处理访问被拒绝情况的接口
import org.springframework.security.web.access.AccessDeniedHandler;
+// 导入 Spring 框架中用于标记组件的注解
import org.springframework.stereotype.Component;
+// 导入 Servlet 规范中的 Servlet 异常类
import javax.servlet.ServletException;
+// 导入 Servlet 规范中的 HTTP 请求对象类
import javax.servlet.http.HttpServletRequest;
+// 导入 Servlet 规范中的 HTTP 响应对象类
import javax.servlet.http.HttpServletResponse;
+// 导入 Java 中的输入输出异常类
import java.io.IOException;
/**
* 自定义授权失败处理器
*/
+// 使用 Spring 的 @Component 注解，将该类标记为组件，以便 Spring 自动扫描和管理
@Component
+// 定义一个实现了 AccessDeniedHandler 接口的类，用于处理授权失败的情况
public class AccessDeniedHandlerImpl implements AccessDeniedHandler {
+ // 重写 handle 方法，该方法在用户访问被拒绝时被调用
@Override
public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException e) throws IOException, ServletException {
+ // 调用 ResponseUtil 工具类的 exceptionEnumOut 方法，将 AUTH_ERROR 异常信息输出到响应中
+ // 当用户请求的资源没有足够的权限访问时，会触发此逻辑，向客户端返回相应的错误信息
ResponseUtil.exceptionEnumOut(response, ExceptionEnum.AUTH_ERROR);
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/config/security/handler/AuthenticationEntryPointImpl.java b/server/src/main/java/com/ew/gerocomium/common/config/security/handler/AuthenticationEntryPointImpl.java
index 536542e..721ce04 100644
--- a/server/src/main/java/com/ew/gerocomium/common/config/security/handler/AuthenticationEntryPointImpl.java
+++ b/server/src/main/java/com/ew/gerocomium/common/config/security/handler/AuthenticationEntryPointImpl.java
@@ -1,23 +1,38 @@
+// 声明该类所在的包，用于存放Spring Security相关的处理器类
package com.ew.gerocomium.common.config.security.handler;
+// 导入自定义的异常枚举类，其中定义了各种异常情况对应的枚举值
import com.ew.gerocomium.common.constant.ExceptionEnum;
+// 导入自定义的响应工具类，用于将异常信息输出到HTTP响应中
import com.ew.gerocomium.common.util.ResponseUtil;
+// 导入Spring Security中表示认证异常的类，当认证过程失败时会抛出此类异常
import org.springframework.security.core.AuthenticationException;
+// 导入Spring Security中处理认证入口点的接口，用于在用户未认证时进行相应处理
import org.springframework.security.web.AuthenticationEntryPoint;
+// 导入Spring框架的注解，用于将该类标记为组件，以便Spring能够自动扫描并管理该类
import org.springframework.stereotype.Component;
+// 导入Servlet规范中的Servlet异常类，用于处理Servlet相关的异常情况
import javax.servlet.ServletException;
+// 导入Servlet规范中的HTTP请求对象类，封装了客户端的HTTP请求信息
import javax.servlet.http.HttpServletRequest;
+// 导入Servlet规范中的HTTP响应对象类，用于向客户端发送HTTP响应
import javax.servlet.http.HttpServletResponse;
+// 导入Java的输入输出异常类，用于处理输入输出操作中可能出现的异常
import java.io.IOException;
/**
* 自定义认证失败处理器
*/
+// 使用@Component注解将该类标记为Spring组件，使其能够被Spring容器管理
@Component
+// 定义一个类实现AuthenticationEntryPoint接口，用于自定义认证失败时的处理逻辑
public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint {
+ // 重写commence方法，该方法在用户未通过认证就尝试访问受保护资源时被调用
@Override
public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
+ // 调用自定义的ResponseUtil工具类的exceptionEnumOut方法
+ // 将ExceptionEnum.CERTIFICATION_ERROR异常信息输出到HTTP响应中，告知客户端认证失败
ResponseUtil.exceptionEnumOut(response, ExceptionEnum.CERTIFICATION_ERROR);
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/config/security/handler/AuthorityAssert.java b/server/src/main/java/com/ew/gerocomium/common/config/security/handler/AuthorityAssert.java
index a40e5e1..13d7238 100644
--- a/server/src/main/java/com/ew/gerocomium/common/config/security/handler/AuthorityAssert.java
+++ b/server/src/main/java/com/ew/gerocomium/common/config/security/handler/AuthorityAssert.java
@@ -1,36 +1,52 @@
+// 声明该类所在的包，用于存放Spring Security相关的权限断言处理类
package com.ew.gerocomium.common.config.security.handler;
+// 导入Hutool工具包中的对象工具类，用于对象的判空等操作
import cn.hutool.core.util.ObjUtil;
+// 导入自定义的常量类，其中可能包含一些与权限、用户相关的常量定义
import com.ew.gerocomium.common.constant.Constant;
+// 导入自定义的登录用户视图对象类，用于封装登录用户的相关信息
import com.ew.gerocomium.dao.vo.LoginUserVo;
+// 导入Spring Security中表示认证信息的接口，包含用户的认证相关信息
import org.springframework.security.core.Authentication;
+// 导入Spring Security中用于存储安全上下文信息的类，可获取当前用户的认证信息等
import org.springframework.security.core.context.SecurityContextHolder;
+// 导入Spring框架的注解，用于将该类标记为组件，以便Spring能够自动扫描并管理该类
import org.springframework.stereotype.Component;
+// 导入Java标准库中的工具类，用于对象的比较等操作
import java.util.List;
import java.util.Objects;
/**
* 自定义权限断言
*/
+// 使用@Component注解将该类标记为Spring组件，并指定组件名称为"AuthorityAssert"
@Component("AuthorityAssert")
+// 定义一个类用于实现自定义的权限断言相关逻辑
public class AuthorityAssert {
+ // 定义一个方法用于获取当前登录用户的信息
public LoginUserVo getLoginUserInfo() {
- // 获取登录用户消息
+ // 从Spring Security的安全上下文中获取当前用户的认证信息
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+ // 判断认证信息是否为空，或者当前用户是否为匿名用户（通过与常量ANONYMOUS_USER比较）
return ObjUtil.isEmpty(authentication) || Objects.equals(authentication.getPrincipal(), Constant.ANONYMOUS_USER) ?
null :
+ // 如果不是匿名用户且认证信息不为空，则将认证信息中的主体（用户信息）转换为LoginUserVo类型并返回
(LoginUserVo) authentication.getPrincipal();
}
+ // 定义一个方法用于获取当前登录用户的ID
public Long getLoginUserId() {
+ // 调用getLoginUserInfo方法获取当前登录用户的信息，然后获取其ID并返回
return getLoginUserInfo().getId();
}
+ // 定义一个方法用于判断当前用户是否具有指定的权限
public Boolean hasAuthority(String authority) {
- // 获取当前用户的权限
+ // 获取当前登录用户的权限列表
List authList = getLoginUserInfo().getAuthUrlList();
- // 判断用户权限集合中是否存在authority
+ // 判断权限列表中是否包含指定的权限字符串
return authList.contains(authority);
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/config/security/handler/PasswordEncoderImpl.java b/server/src/main/java/com/ew/gerocomium/common/config/security/handler/PasswordEncoderImpl.java
index c718146..4852472 100644
--- a/server/src/main/java/com/ew/gerocomium/common/config/security/handler/PasswordEncoderImpl.java
+++ b/server/src/main/java/com/ew/gerocomium/common/config/security/handler/PasswordEncoderImpl.java
@@ -1,21 +1,33 @@
+// 声明该类所在的包，用于存放Spring Security相关的处理器类
package com.ew.gerocomium.common.config.security.handler;
+// 导入自定义的AES加密工具类，该类提供了AES加密和解密的方法
import com.ew.gerocomium.common.util.AesUtil;
+// 导入Spring Security中用于密码编码的接口，定义了密码编码和匹配的方法
import org.springframework.security.crypto.password.PasswordEncoder;
+// 导入Spring框架的注解，用于将该类标记为组件，以便Spring能够自动扫描并管理该类
import org.springframework.stereotype.Component;
/**
* 自定义加密组件
*/
+// 使用@Component注解将该类标记为Spring组件，使其能被Spring容器管理
@Component
+// 定义一个类继承自AesUtil并实现PasswordEncoder接口，用于自定义密码加密和验证逻辑
public class PasswordEncoderImpl extends AesUtil implements PasswordEncoder {
+ // 重写PasswordEncoder接口的encode方法，用于对原始密码进行编码
@Override
public String encode(CharSequence rawPassword) {
+ // 将传入的原始密码（CharSequence类型）转换为字符串，然后调用AesUtil类的aesEncode方法进行AES加密
+ // 最后返回加密后的密码字符串
return aesEncode(rawPassword.toString());
}
+ // 重写PasswordEncoder接口的matches方法，用于验证原始密码和已编码密码是否匹配
@Override
public boolean matches(CharSequence rawPassword, String encodedPassword) {
+ // 将传入的原始密码（CharSequence类型）转换为字符串，然后调用AesUtil类的aesMatch方法
+ // 该方法会将原始密码进行加密后与已编码密码进行比较，返回比较结果（布尔值）
return aesMatch(rawPassword.toString(), encodedPassword);
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/config/security/service/UserDetailsServiceImpl.java b/server/src/main/java/com/ew/gerocomium/common/config/security/service/UserDetailsServiceImpl.java
index b1b572a..877d04e 100644
--- a/server/src/main/java/com/ew/gerocomium/common/config/security/service/UserDetailsServiceImpl.java
+++ b/server/src/main/java/com/ew/gerocomium/common/config/security/service/UserDetailsServiceImpl.java
@@ -1,50 +1,79 @@
+// 声明该类所在的包，用于存放Spring Security相关的服务类
package com.ew.gerocomium.common.config.security.service;
+// 导入Hutool工具包中的BeanUtil类，用于对象属性的复制和转换
import cn.hutool.core.bean.BeanUtil;
+// 导入自定义的包含登录用户详细信息的实体类
import com.ew.gerocomium.common.config.security.entity.LoginUserDetails;
+// 导入自定义的异常枚举类，定义了各种异常情况
import com.ew.gerocomium.common.constant.ExceptionEnum;
+// 导入自定义的断言工具类，用于进行条件判断
import com.ew.gerocomium.common.util.AssertUtil;
+// 导入数据访问层的权限映射器接口
import com.ew.gerocomium.dao.mapper.AuthMapper;
+// 导入数据持久化对象（PO）类，用于表示权限信息
import com.ew.gerocomium.dao.po.Auth;
+// 导入数据持久化对象（PO）类，用于表示员工信息
import com.ew.gerocomium.dao.po.Staff;
+// 导入数据视图对象（VO）类，用于封装登录用户的相关信息
import com.ew.gerocomium.dao.vo.LoginUserVo;
+// 导入自定义的员工功能服务接口
import com.ew.gerocomium.service.common.StaffFunc;
+// 导入Spring Security中表示用户详细信息的接口
import org.springframework.security.core.userdetails.UserDetails;
+// 导入Spring Security中用于加载用户详细信息的服务接口
import org.springframework.security.core.userdetails.UserDetailsService;
+// 导入Spring Security中当用户名未找到时抛出的异常类
import org.springframework.security.core.userdetails.UsernameNotFoundException;
+// 导入Spring框架的注解，用于将该类标记为服务组件，以便Spring能够自动扫描并管理该类
import org.springframework.stereotype.Service;
+// 导入Spring框架中用于自动注入依赖的注解
import javax.annotation.Resource;
+// 导入Java标准库中的ArrayList类，用于创建和操作列表
import java.util.ArrayList;
+// 导入Java标准库中的List接口，用于表示列表
import java.util.List;
/**
* 自定义数据库查询
*/
+// 使用@Service注解将该类标记为Spring服务组件，使其能被Spring容器管理
@Service
+// 定义一个类实现UserDetailsService接口，用于从数据库中加载用户详细信息
public class UserDetailsServiceImpl implements UserDetailsService {
+ // 使用@Resource注解自动注入StaffFunc接口的实现类实例，用于操作员工相关业务
@Resource
private StaffFunc staffFunc;
+ // 使用@Resource注解自动注入AuthMapper接口的实现类实例，用于操作权限相关数据
@Resource
private AuthMapper authMapper;
+ // 重写UserDetailsService接口的loadUserByUsername方法，根据用户名加载用户详细信息
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
- // 查询基本信息
+ // 调用StaffFunc的getStaffByAccount方法，根据传入的用户名查询员工的基本信息
Staff staff = staffFunc.getStaffByAccount(username);
- // 未查询到数据
+ // 使用AssertUtil的notNull方法进行断言，确保查询到的员工信息不为空
+ // 如果为空，则抛出ExceptionEnum.CERTIFICATION_ERROR对应的异常
AssertUtil.notNull(staff, ExceptionEnum.CERTIFICATION_ERROR);
- // 查询权限信息
+ // 创建两个ArrayList用于存储权限ID列表和权限URL列表
List authIdList = new ArrayList<>();
List authUrlList = new ArrayList<>();
+ // 遍历通过AuthMapper的listAuthByRoleId方法查询到的与员工角色ID相关的权限列表
for (Auth auth : authMapper.listAuthByRoleId(staff.getRoleId())) {
+ // 将权限ID添加到authIdList中
authIdList.add(auth.getId());
+ // 将权限URL添加到authUrlList中
authUrlList.add(auth.getUrl());
}
- // 把数据封装成UserDetails返回
+ // 使用BeanUtil的toBean方法将员工信息（Staff对象）转换为LoginUserVo对象
LoginUserVo loginUserVo = BeanUtil.toBean(staff, LoginUserVo.class);
+ // 将权限ID列表设置到LoginUserVo对象中
loginUserVo.setAuthIdList(authIdList);
+ // 将权限URL列表设置到LoginUserVo对象中
loginUserVo.setAuthUrlList(authUrlList);
+ // 创建一个LoginUserDetails对象，将封装好的LoginUserVo对象传入，并返回
return new LoginUserDetails(loginUserVo);
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/config/swagger/SwaggerConfig.java b/server/src/main/java/com/ew/gerocomium/common/config/swagger/SwaggerConfig.java
index be5f7ed..bdd26e4 100644
--- a/server/src/main/java/com/ew/gerocomium/common/config/swagger/SwaggerConfig.java
+++ b/server/src/main/java/com/ew/gerocomium/common/config/swagger/SwaggerConfig.java
@@ -1,40 +1,72 @@
+// 声明该类所在的包，此包用于存放Swagger相关的配置类
package com.ew.gerocomium.common.config.swagger;
+// 导入自定义的常量类，其中可能包含一些通用的常量信息
import com.ew.gerocomium.common.constant.Constant;
+// 导入Spring框架中用于声明Bean的注解
import org.springframework.context.annotation.Bean;
+// 导入Spring框架中用于声明配置类的注解
import org.springframework.context.annotation.Configuration;
+// 导入Spring框架中用于表示环境信息的接口
import org.springframework.core.env.Environment;
+// 导入Spring框架中用于表示环境配置文件的类
import org.springframework.core.env.Profiles;
+// 导入Swagger文档构建器，用于构建API信息
import springfox.documentation.builders.ApiInfoBuilder;
+// 导入Swagger请求处理器选择器，用于指定扫描的控制器包路径
import springfox.documentation.builders.RequestHandlerSelectors;
+// 导入Swagger中表示API信息的类
import springfox.documentation.service.ApiInfo;
+// 导入Swagger中表示联系人信息的类
import springfox.documentation.service.Contact;
+// 导入Swagger文档类型的枚举类
import springfox.documentation.spi.DocumentationType;
+// 导入Swagger的Spring Web插件类，用于创建Swagger文档
import springfox.documentation.spring.web.plugins.Docket;
+// 导入Swagger2的启用注解，用于开启Swagger功能
import springfox.documentation.swagger2.annotations.EnableSwagger2;
+// 使用 @Configuration 注解将该类标记为Spring的配置类，用于定义Bean
@Configuration
+// 使用 @EnableSwagger2 注解启用Swagger2功能
@EnableSwagger2
+// 定义一个名为 SwaggerConfig 的配置类，用于配置Swagger文档生成
public class SwaggerConfig {
+ // 使用 @Bean 注解将该方法返回的对象注册为Spring容器中的Bean
@Bean
+ // 定义一个名为 docket 的方法，用于创建和配置Swagger的Docket对象
public Docket docket(Environment environment) {
+ // 创建一个Profiles对象，指定开发、测试、生产环境
Profiles profiles = Profiles.of("dev", "test", "prod");
- // 判断是否处于自己设置的环境中
+ // 判断当前环境是否为指定的开发、测试、生产环境之一
boolean flag = environment.acceptsProfiles(profiles);
+ // 创建一个Docket对象，指定文档类型为SWAGGER_2
return new Docket(DocumentationType.SWAGGER_2)
+ // 设置API的基本信息，调用 apiInfo() 方法获取
.apiInfo(apiInfo())
+ // 根据环境判断结果决定是否启用Swagger
.enable(flag)
+ // 开启选择器，用于选择需要生成文档的API
.select()
- .apis(RequestHandlerSelectors.basePackage("com.ew.gerocomium.controller")) // 设置扫描路径
+ // 指定扫描的控制器包路径，这里指定为 com.ew.gerocomium.controller 包下的所有控制器
+ .apis(RequestHandlerSelectors.basePackage("com.ew.gerocomium.controller"))
+ // 构建Docket对象
.build();
}
+ // 定义一个名为 apiInfo 的方法，用于创建API的基本信息
public ApiInfo apiInfo() {
+ // 使用 ApiInfoBuilder 构建API信息
return new ApiInfoBuilder()
- .title("数据服务API") // 标题
- .description("") // 描述
- .version("1.0") // 版本
+ // 设置API的标题为 数据服务API
+ .title("数据服务API")
+ // 设置API的描述信息，这里为空字符串
+ .description("")
+ // 设置API的版本号为 1.0
+ .version("1.0")
+ // 设置API的联系人信息，联系人姓名从常量类中获取，网址和邮箱为空
.contact(new Contact(Constant.EMPEROR_WEN, "", ""))
+ // 构建API信息对象
.build();
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/config/web/IgnoreConfig.java b/server/src/main/java/com/ew/gerocomium/common/config/web/IgnoreConfig.java
index 0c6646e..869fdf6 100644
--- a/server/src/main/java/com/ew/gerocomium/common/config/web/IgnoreConfig.java
+++ b/server/src/main/java/com/ew/gerocomium/common/config/web/IgnoreConfig.java
@@ -1,15 +1,26 @@
+// 声明该类所在的包，此包用于存放与Web相关的配置类
package com.ew.gerocomium.common.config.web;
+// 导入Lombok的@Data注解，该注解会自动生成类的getter、setter、equals、hashCode、toString等方法，简化代码编写
import lombok.Data;
+// 导入Spring Boot中的@ConfigurationProperties注解，用于将配置文件中特定前缀的属性值绑定到该类的属性上
import org.springframework.boot.context.properties.ConfigurationProperties;
+// 导入Spring框架中用于声明配置类的注解，被该注解标记的类会被Spring容器识别并管理，可在其中定义Bean等配置
import org.springframework.context.annotation.Configuration;
+// 导入Java标准库中的List接口，用于表示列表类型
import java.util.List;
+// 使用@Data注解，自动为类生成常见的方法
@Data
+// 使用@Configuration注解，将该类标记为一个Spring配置类，Spring会扫描并管理这个类
@Configuration
+// 使用@ConfigurationProperties注解，指定属性的前缀为"ignore"，表示会从配置文件中读取以"ignore"开头的属性，并绑定到类的对应属性上
@ConfigurationProperties("ignore")
+// 定义一个名为IgnoreConfig的类，用于存储与忽略相关的配置信息
public class IgnoreConfig {
+ // 定义一个List类型的属性ignoreUrl，用于存储需要忽略的URL列表，这些URL可能在某些处理逻辑（如权限校验等）中被跳过
List ignoreUrl;
+ // 定义一个List类型的属性tokenUrl，用于存储与令牌相关的URL列表，可能在处理令牌相关逻辑时使用
List tokenUrl;
}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/config/web/WebMvcConfig.java b/server/src/main/java/com/ew/gerocomium/common/config/web/WebMvcConfig.java
index e936166..03b2ef8 100644
--- a/server/src/main/java/com/ew/gerocomium/common/config/web/WebMvcConfig.java
+++ b/server/src/main/java/com/ew/gerocomium/common/config/web/WebMvcConfig.java
@@ -1,46 +1,70 @@
+// 声明该类所在的包，用于存放Web相关的配置类
package com.ew.gerocomium.common.config.web;
+// 导入自定义的文件临时路径配置类，用于获取文件存储路径
import com.ew.gerocomium.common.config.file.FileTempPath;
+// 导入Lombok的注解，用于自动生成全参构造函数
import lombok.AllArgsConstructor;
+// 导入Spring框架中用于声明配置类的注解
import org.springframework.context.annotation.Configuration;
+// 导入Spring MVC中用于配置跨域资源共享的注册类
import org.springframework.web.servlet.config.annotation.CorsRegistry;
+// 导入Spring MVC中用于配置资源处理器的注册类
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
+// 导入Spring MVC中用于配置Web MVC的接口
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+// 使用 @Configuration 注解将该类标记为Spring的配置类，用于定义Bean和配置Spring MVC
@Configuration
+// 使用 @AllArgsConstructor 注解，自动生成包含所有成员变量的构造函数
@AllArgsConstructor
+// 定义一个实现了 WebMvcConfigurer 接口的类，用于自定义 Web MVC 配置
public class WebMvcConfig implements WebMvcConfigurer {
+ // 定义一个 final 类型的成员变量，用于存储文件临时路径配置类的实例
private final FileTempPath fileTempPath;
+ // 重写 addResourceHandlers 方法，用于配置资源处理器，将特定的请求路径映射到对应的资源位置
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
- // swagger资源
+ // 配置 Swagger 相关资源的映射
+ // 将 /doc.html 请求映射到 classpath:/META-INF/resources/ 目录下的资源
registry.addResourceHandler("/doc.html").addResourceLocations("classpath:/META-INF/resources/");
+ // 将 favicon.ico 请求映射到 classpath:/META-INF/resources/ 目录下的资源
registry.addResourceHandler("favicon.ico").addResourceLocations("classpath:/META-INF/resources/");
+ // 将 /v2/api-docs 请求映射到 classpath:/META-INF/resources/ 目录下的资源
registry.addResourceHandler("/v2/api-docs").addResourceLocations("classpath:/META-INF/resources/");
+ // 将 /swagger-*/** 请求映射到 classpath:/META-INF/resources/ 目录下的资源
registry.addResourceHandler("/swagger-*/**").addResourceLocations("classpath:/META-INF/resources/");
+ // 将 swagger-ui.html 请求映射到 classpath:/META-INF/resources/ 目录下的资源
registry.addResourceHandler("swagger-ui.html").addResourceLocations("classpath:/META-INF/resources/");
+ // 将 /webjars/** 请求映射到 classpath:/META-INF/resources/webjars/ 目录下的资源
registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
- // 文件资源
+
+ // 配置文件资源的映射
+ // 将 /download/** 请求映射到文件系统中由 fileTempPath.downloadPath() 方法返回的路径下的资源
registry.addResourceHandler("/download/**").addResourceLocations("file:" + fileTempPath.downloadPath());
+ // 将 /upload/img/** 请求映射到文件系统中由 fileTempPath.imgSrcPath() 方法返回的路径下的资源
registry.addResourceHandler("/upload/img/**").addResourceLocations("file:" + fileTempPath.imgSrcPath());
+ // 将 /upload/video/** 请求映射到文件系统中由 fileTempPath.videoSrcPath() 方法返回的路径下的资源
registry.addResourceHandler("/upload/video/**").addResourceLocations("file:" + fileTempPath.videoSrcPath());
+ // 将 /upload/file/** 请求映射到文件系统中由 fileTempPath.filePath() 方法返回的路径下的资源
registry.addResourceHandler("/upload/file/**").addResourceLocations("file:" + fileTempPath.filePath());
}
+ // 重写 addCorsMappings 方法，用于配置跨域资源共享（CORS）
@Override
public void addCorsMappings(CorsRegistry registry) {
- // 设置允许跨域的路径
+ // 配置允许跨域的路径，这里设置为所有路径
registry.addMapping("/**")
- // 设置允许跨域请求的域名
+ // 设置允许跨域请求的域名，使用 * 表示允许所有域名
.allowedOriginPatterns("*")
- // 是否允许cookie
+ // 允许携带 cookie 进行跨域请求
.allowCredentials(true)
- // 设置允许的请求方式
+ // 设置允许的请求方式，包括 GET、POST、PUT、DELETE
.allowedMethods("GET", "POST", "PUT", "DELETE")
- // 设置允许的header属性
+ // 设置允许的请求头，使用 * 表示允许所有请求头
.allowedHeaders("*")
- // 跨域允许时间
+ // 设置跨域请求的缓存时间，单位为秒
.maxAge(3600);
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/constant/AuditEnum.java b/server/src/main/java/com/ew/gerocomium/common/constant/AuditEnum.java
index 2d6d9f9..5aa2c1a 100644
--- a/server/src/main/java/com/ew/gerocomium/common/constant/AuditEnum.java
+++ b/server/src/main/java/com/ew/gerocomium/common/constant/AuditEnum.java
@@ -1,16 +1,46 @@
+// 声明该类所在的包，此包用于存放项目中的常量相关内容
package com.ew.gerocomium.common.constant;
+// 导入Lombok的注解，用于自动生成包含所有参数的构造函数
+// 使用该注解后，Lombok会自动为类生成一个包含所有成员变量作为参数的构造函数
import lombok.AllArgsConstructor;
+// 导入Lombok的注解，用于自动生成类中所有成员变量的getter方法
+// 使用该注解后，无需手动编写getter方法，Lombok会在编译时自动添加
import lombok.Getter;
+// 后续代码应该会定义一个类，使用@AllArgsConstructor注解会为这个类生成全参构造函数
+// 使用@Getter注解会为类中的成员变量生成getter方法，方便外部访问这些变量
+// 通常在常量类中，成员变量一般为final类型，用于存储不可变的常量值
+
+/**
+ * 审核状态枚举类，用于定义和管理审核相关的状态
+ */
@Getter
+// 为枚举的每个实例提供一个包含所有字段的构造函数
@AllArgsConstructor
public enum AuditEnum {
+ /**
+ * 审核通过状态
+ */
PASS("通过"),
+ /**
+ * 审核不通过状态
+ */
NO_PASS("不通过"),
+ /**
+ * 待审核状态
+ */
STAY_AUDIT("待审核"),
+ /**
+ * 审核未通过状态，与NO_PASS语义相近，可能用于不同业务场景区分
+ */
NOT_PASS("未通过"),
+ /**
+ * 已审核通过状态，强调审核已经完成且通过
+ */
HAVE_PASS("已通过"),
;
+
+ // 审核状态对应的字符串描述
private final String status;
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/constant/BedEnum.java b/server/src/main/java/com/ew/gerocomium/common/constant/BedEnum.java
index ebc4ea3..472d78c 100644
--- a/server/src/main/java/com/ew/gerocomium/common/constant/BedEnum.java
+++ b/server/src/main/java/com/ew/gerocomium/common/constant/BedEnum.java
@@ -1,15 +1,42 @@
+// 声明该类所在的包，此包用于存放项目中的常量相关内容
package com.ew.gerocomium.common.constant;
+// 导入Lombok的注解，用于自动生成包含所有参数的构造函数
+// 使用该注解后，Lombok会自动为类生成一个包含所有成员变量作为参数的构造函数
import lombok.AllArgsConstructor;
+// 导入Lombok的注解，用于自动生成类中所有成员变量的getter方法
+// 使用该注解后，无需手动编写getter方法，Lombok会在编译时自动添加
import lombok.Getter;
+// 后续代码应该会定义一个类，使用@AllArgsConstructor注解会为这个类生成全参构造函数
+// 使用@Getter注解会为类中的成员变量生成getter方法，方便外部访问这些变量
+// 通常在常量类中，成员变量一般为final类型，用于存储不可变的常量值
+
+/**
+ * 床位状态枚举类，用于定义和管理床位的不同状态
+ */
@Getter
+// 为枚举的每个实例提供一个包含所有字段的构造函数
@AllArgsConstructor
public enum BedEnum {
+ /**
+ * 床位空闲状态，表示该床位当前无人使用，可以被预定或入住
+ */
IDLE("空闲"),
+ /**
+ * 床位预定状态，表示该床位已被预订，但尚未入住
+ */
RESERVE("预定"),
+ /**
+ * 床位入住状态，表示该床位当前已有人员入住
+ */
ENTER("入住"),
+ /**
+ * 床位退住审核状态，表示有人员申请退住该床位，正在等待审核
+ */
EXIT_AUDIT("退住审核"),
;
+
+ // 床位状态对应的字符串描述
private final String status;
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/constant/ChargeEnum.java b/server/src/main/java/com/ew/gerocomium/common/constant/ChargeEnum.java
index cca202e..48b70e9 100644
--- a/server/src/main/java/com/ew/gerocomium/common/constant/ChargeEnum.java
+++ b/server/src/main/java/com/ew/gerocomium/common/constant/ChargeEnum.java
@@ -1,14 +1,38 @@
+// 声明该类所在的包，此包用于存放项目中的常量相关内容
package com.ew.gerocomium.common.constant;
+// 导入Lombok的注解，用于自动生成包含所有参数的构造函数
+// 使用该注解后，Lombok会自动为类生成一个包含所有成员变量作为参数的构造函数
import lombok.AllArgsConstructor;
+// 导入Lombok的注解，用于自动生成类中所有成员变量的getter方法
+// 使用该注解后，无需手动编写getter方法，Lombok会在编译时自动添加
import lombok.Getter;
+// 后续代码应该会定义一个类，使用@AllArgsConstructor注解会为这个类生成全参构造函数
+// 使用@Getter注解会为类中的成员变量生成getter方法，方便外部访问这些变量
+// 通常在常量类中，成员变量一般为final类型，用于存储不可变的常量值
+
+/**
+ * 收费方式枚举类，定义了不同的收费方法
+ */
@Getter
+// 为枚举中的每个实例提供一个包含所有字段的构造函数
@AllArgsConstructor
public enum ChargeEnum {
+ /**
+ * 按次收费，即根据使用的次数来收取费用
+ */
ONCE("按次"),
+ /**
+ * 按月收费，按照每个月的周期来收取费用
+ */
MONTH("按月"),
+ /**
+ * 表示所有收费方式，可能用于某些需要涵盖所有收费情况的业务逻辑
+ */
ALL("所有"),
;
+
+ // 收费方式对应的字符串描述
private final String method;
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/constant/CheckEnum.java b/server/src/main/java/com/ew/gerocomium/common/constant/CheckEnum.java
index a3cc53d..d1207d0 100644
--- a/server/src/main/java/com/ew/gerocomium/common/constant/CheckEnum.java
+++ b/server/src/main/java/com/ew/gerocomium/common/constant/CheckEnum.java
@@ -1,18 +1,54 @@
package com.ew.gerocomium.common.constant;
+
+// 导入Lombok的注解，用于自动生成包含所有参数的构造函数
+// 使用该注解后，Lombok会自动为类生成一个包含所有成员变量作为参数的构造函数
import lombok.AllArgsConstructor;
+// 导入Lombok的注解，用于自动生成类中所有成员变量的getter方法
+// 使用该注解后，无需手动编写getter方法，Lombok会在编译时自动添加
import lombok.Getter;
+// 后续代码应该会定义一个类，使用@AllArgsConstructor注解会为这个类生成全参构造函数
+// 使用@Getter注解会为类中的成员变量生成getter方法，方便外部访问这些变量
+// 通常在常量类中，成员变量一般为final类型，用于存储不可变的常量值
+/**
+ * 用于表示某种检查或业务流程状态的枚举类
+ * 定义了一系列可能的状态值，可用于描述相关业务对象在不同阶段的状态
+ */
@Getter
+// 为枚举的每个实例自动生成一个包含所有参数的构造函数
@AllArgsConstructor
public enum CheckEnum {
+ /**
+ * 表示处于咨询阶段，即客户正在进行咨询相关的活动
+ */
CONSULT("咨询中"),
+ /**
+ * 表示客户有一定意向，正在进行跟进工作，以促进业务的进一步发展
+ */
INTENTION("意向跟进"),
+ /**
+ * 表示已经完成预定操作，相关资源（如床位等）已被预留
+ */
RESERVE("预定"),
+ /**
+ * 表示已经成功入住，处于实际使用相关服务或资源的状态
+ */
ENTER("入住"),
+ /**
+ * 表示提出退住申请后，正在等待审核，审核通过后才能完成退住流程
+ */
EXIT_AUDIT("退住审核"),
+ /**
+ * 表示已经完成退住流程，不再使用相关服务或资源
+ */
EXIT("已退住"),
+ /**
+ * 表示该业务对象（如客户的预定等）已不再有效，可能由于过期、取消等原因
+ */
FAILURE("已失效"),
;
+
+ // 用于存储状态对应的字符串描述
private final String status;
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/constant/CodeEnum.java b/server/src/main/java/com/ew/gerocomium/common/constant/CodeEnum.java
index c06e95b..82651b5 100644
--- a/server/src/main/java/com/ew/gerocomium/common/constant/CodeEnum.java
+++ b/server/src/main/java/com/ew/gerocomium/common/constant/CodeEnum.java
@@ -1,14 +1,39 @@
+// 声明该类所在的包，此包用于存放项目中的常量相关内容
package com.ew.gerocomium.common.constant;
+// 导入Lombok的注解，用于自动生成包含所有参数的构造函数
+// 使用该注解后，Lombok会自动为类生成一个包含所有成员变量作为参数的构造函数
import lombok.AllArgsConstructor;
+// 导入Lombok的注解，用于自动生成类中所有成员变量的getter方法
+// 使用该注解后，无需手动编写getter方法，Lombok会在编译时自动添加
import lombok.Getter;
+// 后续代码应该会定义一个类，使用@AllArgsConstructor注解会为这个类生成全参构造函数
+// 使用@Getter注解会为类中的成员变量生成getter方法，方便外部访问这些变量
+// 通常在常量类中，成员变量一般为final类型，用于存储不可变的常量值
+/**
+ * 通用的状态码和消息枚举类，用于定义操作结果的状态码和对应的消息
+ */
@Getter
+// 为枚举的每个实例提供包含所有字段的构造函数
@AllArgsConstructor
public enum CodeEnum {
+ /**
+ * 表示操作成功的状态
+ * 状态码为 200，通常在 HTTP 协议中 200 代表请求成功
+ * 对应的消息为 "操作成功"，用于在业务逻辑中反馈操作结果给调用方
+ */
SUCCESS(200, "操作成功"),
+ /**
+ * 表示操作失败的状态
+ * 状态码为 500，在 HTTP 协议中 500 表示服务器内部错误
+ * 对应的消息为 "操作失败"，可用于在业务逻辑出现异常或操作未达成预期时反馈结果
+ */
ERROR(500, "操作失败"),
;
+
+ // 状态码
private final Integer code;
+ // 状态码对应的消息
private final String msg;
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/constant/ConsumeEnum.java b/server/src/main/java/com/ew/gerocomium/common/constant/ConsumeEnum.java
index 7167c50..ad44eb3 100644
--- a/server/src/main/java/com/ew/gerocomium/common/constant/ConsumeEnum.java
+++ b/server/src/main/java/com/ew/gerocomium/common/constant/ConsumeEnum.java
@@ -1,13 +1,36 @@
+// 声明该类所在的包，此包用于存放项目中的常量相关内容
package com.ew.gerocomium.common.constant;
+// 导入Lombok的注解，用于自动生成包含所有参数的构造函数
+// 使用该注解后，Lombok会自动为类生成一个包含所有成员变量作为参数的构造函数
import lombok.AllArgsConstructor;
+// 导入Lombok的注解，用于自动生成类中所有成员变量的getter方法
+// 使用该注解后，无需手动编写getter方法，Lombok会在编译时自动添加
import lombok.Getter;
+// 后续代码应该会定义一个类，使用@AllArgsConstructor注解会为这个类生成全参构造函数
+// 使用@Getter注解会为类中的成员变量生成getter方法，方便外部访问这些变量
+// 通常在常量类中，成员变量一般为final类型，用于存储不可变的常量值
+
+/**
+ * 消费类型枚举类，用于定义不同的消费类型
+ */
@Getter
+// 为枚举的每个实例提供包含所有字段的构造函数
@AllArgsConstructor
public enum ConsumeEnum {
+ /**
+ * 护理消费类型
+ * 表示与护理服务相关的消费，例如老人在养老院接受的各种护理服务所产生的费用
+ */
NURSE("护理"),
+ /**
+ * 点餐消费类型
+ * 表示与餐饮点餐相关的消费，例如在养老院或其他场所点取餐食所产生的费用
+ */
DISHES("点餐"),
;
+
+ // 消费类型对应的字符串描述
private final String type;
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/constant/ExceptionEnum.java b/server/src/main/java/com/ew/gerocomium/common/constant/ExceptionEnum.java
index f9c1ff0..75618d3 100644
--- a/server/src/main/java/com/ew/gerocomium/common/constant/ExceptionEnum.java
+++ b/server/src/main/java/com/ew/gerocomium/common/constant/ExceptionEnum.java
@@ -1,8 +1,17 @@
+// 声明该类所在的包，此包用于存放项目中的常量相关内容
package com.ew.gerocomium.common.constant;
+// 导入Lombok的注解，用于自动生成包含所有参数的构造函数
+// 使用该注解后，Lombok会自动为类生成一个包含所有成员变量作为参数的构造函数
import lombok.AllArgsConstructor;
+// 导入Lombok的注解，用于自动生成类中所有成员变量的getter方法
+// 使用该注解后，无需手动编写getter方法，Lombok会在编译时自动添加
import lombok.Getter;
+// 后续代码应该会定义一个类，使用@AllArgsConstructor注解会为这个类生成全参构造函数
+// 使用@Getter注解会为类中的成员变量生成getter方法，方便外部访问这些变量
+// 通常在常量类中，成员变量一般为final类型，用于存储不可变的常量值
+
/**
* 异常分类
*/
diff --git a/server/src/main/java/com/ew/gerocomium/common/constant/MarkEnum.java b/server/src/main/java/com/ew/gerocomium/common/constant/MarkEnum.java
index 51307f0..cc90e7a 100644
--- a/server/src/main/java/com/ew/gerocomium/common/constant/MarkEnum.java
+++ b/server/src/main/java/com/ew/gerocomium/common/constant/MarkEnum.java
@@ -1,14 +1,41 @@
+// 声明该类所在的包，此包用于存放项目中的常量相关内容
package com.ew.gerocomium.common.constant;
+// 导入Lombok的注解，用于自动生成包含所有参数的构造函数
+// 使用该注解后，Lombok会自动为类生成一个包含所有成员变量作为参数的构造函数
import lombok.AllArgsConstructor;
+// 导入Lombok的注解，用于自动生成类中所有成员变量的getter方法
+// 使用该注解后，无需手动编写getter方法，Lombok会在编译时自动添加
import lombok.Getter;
+// 后续代码应该会定义一个类，使用@AllArgsConstructor注解会为这个类生成全参构造函数
+// 使用@Getter注解会为类中的成员变量生成getter方法，方便外部访问这些变量
+// 通常在常量类中，成员变量一般为final类型，用于存储不可变的常量值
+
+/**
+ * 标记类型枚举类，用于定义不同的位置标记类型
+ */
@Getter
+// 为枚举的每个实例提供包含所有字段的构造函数
@AllArgsConstructor
public enum MarkEnum {
+ /**
+ * 表示楼栋标记类型
+ * 用于标识建筑中的每一栋楼，在一些场景中可用于定位、管理等操作
+ */
BUILDING("楼栋"),
+ /**
+ * 表示楼层标记类型
+ * 用于标识建筑物内的每一层，有助于在楼层相关的业务逻辑中进行区分和处理
+ */
FLOOR("楼层"),
+ /**
+ * 表示房间标记类型
+ * 用于标识建筑物内具体的房间，可用于房间分配、管理等业务场景
+ */
ROOM("房间"),
;
+
+ // 标记类型对应的字符串描述
private final String mark;
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/constant/RecipientEnum.java b/server/src/main/java/com/ew/gerocomium/common/constant/RecipientEnum.java
index 9f86e25..7b02b70 100644
--- a/server/src/main/java/com/ew/gerocomium/common/constant/RecipientEnum.java
+++ b/server/src/main/java/com/ew/gerocomium/common/constant/RecipientEnum.java
@@ -1,13 +1,36 @@
+// 声明该类所在的包，此包用于存放项目中的常量相关内容
package com.ew.gerocomium.common.constant;
+// 导入Lombok的注解，用于自动生成包含所有参数的构造函数
+// 使用该注解后，Lombok会自动为类生成一个包含所有成员变量作为参数的构造函数
import lombok.AllArgsConstructor;
+// 导入Lombok的注解，用于自动生成类中所有成员变量的getter方法
+// 使用该注解后，无需手动编写getter方法，Lombok会在编译时自动添加
import lombok.Getter;
+// 后续代码应该会定义一个类，使用@AllArgsConstructor注解会为这个类生成全参构造函数
+// 使用@Getter注解会为类中的成员变量生成getter方法，方便外部访问这些变量
+// 通常在常量类中，成员变量一般为final类型，用于存储不可变的常量值
+
+/**
+ * 接收者类型枚举类，用于定义不同的接收者类型
+ */
@Getter
+// 为枚举的每个实例提供包含所有字段的构造函数
@AllArgsConstructor
public enum RecipientEnum {
+ /**
+ * 表示接收者类型为老人
+ * 在业务场景中，当有信息、物品等需要传递时，接收对象可能是养老院中的老人
+ */
ELDER("老人"),
+ /**
+ * 表示接收者类型为员工
+ * 同样在业务场景里，信息、任务等可能需要传递给养老院的员工
+ */
STAFF("员工"),
;
+
+ // 接收者类型对应的字符串描述
private final String type;
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/constant/VisitEnum.java b/server/src/main/java/com/ew/gerocomium/common/constant/VisitEnum.java
index 5c4fd4f..8beec85 100644
--- a/server/src/main/java/com/ew/gerocomium/common/constant/VisitEnum.java
+++ b/server/src/main/java/com/ew/gerocomium/common/constant/VisitEnum.java
@@ -1,13 +1,36 @@
+// 声明该类所在的包，此包用于存放项目中的常量相关内容
package com.ew.gerocomium.common.constant;
+// 导入Lombok的注解，用于自动生成包含所有参数的构造函数
+// 使用该注解后，Lombok会自动为类生成一个包含所有成员变量作为参数的构造函数
import lombok.AllArgsConstructor;
+// 导入Lombok的注解，用于自动生成类中所有成员变量的getter方法
+// 使用该注解后，无需手动编写getter方法，Lombok会在编译时自动添加
import lombok.Getter;
+// 后续代码应该会定义一个类，使用@AllArgsConstructor注解会为这个类生成全参构造函数
+// 使用@Getter注解会为类中的成员变量生成getter方法，方便外部访问这些变量
+// 通常在常量类中，成员变量一般为final类型，用于存储不可变的常量值
+
+/**
+ * 访客状态枚举类，用于定义访客在访问过程中的不同状态
+ */
@Getter
+// 为枚举的每个实例提供包含所有字段的构造函数
@AllArgsConstructor
public enum VisitEnum {
+ /**
+ * 表示访客处于待离开的状态
+ * 意味着访客已经进入访问区域，但还没有完成离开的操作
+ */
STAY_LEAVE("待离开"),
+ /**
+ * 表示访客已经离开的状态
+ * 表明访客已经完成访问并离开了相应的区域
+ */
ALREADY_LEAVE("已离开"),
;
+
+ // 访客状态对应的字符串描述
private final String status;
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/constant/YesNoEnum.java b/server/src/main/java/com/ew/gerocomium/common/constant/YesNoEnum.java
index 240e492..ad40770 100644
--- a/server/src/main/java/com/ew/gerocomium/common/constant/YesNoEnum.java
+++ b/server/src/main/java/com/ew/gerocomium/common/constant/YesNoEnum.java
@@ -3,12 +3,27 @@ package com.ew.gerocomium.common.constant;
import lombok.AllArgsConstructor;
import lombok.Getter;
+/**
+ * 是/否状态枚举类，用于表示二元选择的状态
+ */
@Getter
+// 为枚举的每个实例提供包含所有字段的构造函数
@AllArgsConstructor
public enum YesNoEnum {
+ /**
+ * 表示肯定状态
+ * 名称为 "是"，对应的代码为 "Y"，可用于在数据存储或传输中简洁地表示肯定的选择
+ */
YES("是", "Y"),
+ /**
+ * 表示否定状态
+ * 名称为 "否"，对应的代码为 "N"，用于在数据存储或传输中简洁地表示否定的选择
+ */
NO("否", "N"),
;
+
+ // 状态的中文名称
private final String name;
+ // 状态对应的代码，可用于数据存储或传输
private final String code;
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/util/AesUtil.java b/server/src/main/java/com/ew/gerocomium/common/util/AesUtil.java
index d38a8ba..e7c1e55 100644
--- a/server/src/main/java/com/ew/gerocomium/common/util/AesUtil.java
+++ b/server/src/main/java/com/ew/gerocomium/common/util/AesUtil.java
@@ -1,35 +1,53 @@
+// 声明该类所在的包，用于存放项目中的工具类
package com.ew.gerocomium.common.util;
+// 导入自定义的常量类，其中包含AES加密相关的常量
import com.ew.gerocomium.common.constant.Constant;
-import org.springframework.security.crypto.codec.Hex;
+// 导入Spring框架中用于标记组件的注解，使该类可被Spring容器管理
import org.springframework.stereotype.Component;
+// 导入Spring Security中用于十六进制编解码的工具类
+import org.springframework.security.crypto.codec.Hex;
+// 导入Java加密扩展（JCE）中的Cipher类，用于加密和解密操作
import javax.crypto.Cipher;
+// 导入Java加密扩展（JCE）中用于表示初始化向量（IV）的类
import javax.crypto.spec.IvParameterSpec;
+// 导入Java加密扩展（JCE）中用于表示密钥规范的类
import javax.crypto.spec.SecretKeySpec;
+// 导入Java标准库中的Objects类，用于进行对象的比较等操作
import java.util.Objects;
/**
* 自定义密码组件
*/
+// 使用@Component注解将该类标记为Spring组件，使其能够被Spring容器自动扫描和管理
@Component
+// 定义一个名为AesUtil的工具类，用于实现AES加密、解密和密码校验功能
public class AesUtil {
/**
* 加密
*
- * @param encodeStr
- * @return
+ * @param encodeStr 待加密的字符串
+ * @return 加密后的字符串，如果加密失败则返回null
*/
public static String aesEncode(String encodeStr) {
try {
+ // 根据常量类中的IV值创建初始化向量对象
IvParameterSpec ivParameterSpec = new IvParameterSpec(Constant.IV.getBytes());
+ // 根据常量类中的AES_KEY值创建密钥规范对象，指定加密算法为AES
SecretKeySpec secretKeySpec = new SecretKeySpec(Constant.AES_KEY.getBytes(), "AES");
+ // 获取指定算法（AES）的Cipher实例
Cipher cipher = Cipher.getInstance(Constant.AES_TYPE);
+ // 初始化Cipher对象为加密模式，传入密钥规范和初始化向量
cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, ivParameterSpec);
+ // 对传入的字符串进行加密操作，得到加密后的字节数组
byte[] bytes = cipher.doFinal(encodeStr.getBytes());
+ // 将加密后的字节数组进行十六进制编码，并转换为字符串返回
return new String(Hex.encode(bytes));
} catch (Exception e) {
+ // 如果加密过程中出现异常，打印异常堆栈信息
e.printStackTrace();
+ // 加密失败，返回null
return null;
}
}
@@ -37,19 +55,27 @@ public class AesUtil {
/**
* 解密
*
- * @param decodeStr
- * @return
+ * @param decodeStr 待解密的字符串
+ * @return 解密后的字符串，如果解密失败则返回null
*/
public static String aesDecode(String decodeStr) {
try {
+ // 根据常量类中的IV值创建初始化向量对象
IvParameterSpec ivParameterSpec = new IvParameterSpec(Constant.IV.getBytes());
+ // 根据常量类中的AES_KEY值创建密钥规范对象，指定加密算法为AES
SecretKeySpec secretKeySpec = new SecretKeySpec(Constant.AES_KEY.getBytes(), "AES");
+ // 获取指定算法（AES）的Cipher实例
Cipher cipher = Cipher.getInstance(Constant.AES_TYPE);
+ // 初始化Cipher对象为解密模式，传入密钥规范和初始化向量
cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, ivParameterSpec);
+ // 对传入的字符串进行十六进制解码，得到字节数组，然后进行解密操作
byte[] bytes = cipher.doFinal(Hex.decode(decodeStr));
+ // 将解密后的字节数组转换为字符串返回
return new String(bytes);
} catch (Exception e) {
+ // 如果解密过程中出现异常，打印异常堆栈信息
e.printStackTrace();
+ // 解密失败，返回null
return null;
}
}
@@ -57,11 +83,12 @@ public class AesUtil {
/**
* 校验
*
- * @param needCheckPassword
- * @param encodePassword
- * @return
+ * @param needCheckPassword 需要校验的原始密码字符串
+ * @param encodePassword 已加密的密码字符串
+ * @return 如果原始密码加密后与已加密密码相同则返回true，否则返回false
*/
public static Boolean aesMatch(String needCheckPassword, String encodePassword) {
+ // 对需要校验的原始密码进行加密，然后与已加密的密码进行比较
return Objects.equals(aesEncode(needCheckPassword), encodePassword);
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/util/AssertUtil.java b/server/src/main/java/com/ew/gerocomium/common/util/AssertUtil.java
index 78d5997..3c9ef9e 100644
--- a/server/src/main/java/com/ew/gerocomium/common/util/AssertUtil.java
+++ b/server/src/main/java/com/ew/gerocomium/common/util/AssertUtil.java
@@ -1,64 +1,136 @@
+// 声明该类所在的包，用于存放项目中的工具类
package com.ew.gerocomium.common.util;
+// 导入自定义的业务运行时异常类，用于在条件不满足时抛出业务异常
import com.ew.gerocomium.common.config.exception.BusinessRuntimeException;
+// 导入自定义的异常枚举类，用于定义不同类型的业务异常
import com.ew.gerocomium.common.constant.ExceptionEnum;
+// 导入Spring框架中用于集合操作的工具类，提供了判断集合是否为空等方法
import org.springframework.util.CollectionUtils;
+// 导入Spring框架中用于对象操作的工具类，提供了判断对象是否为空等方法
import org.springframework.util.ObjectUtils;
+// 导入Java标准库中的Collection接口，用于表示集合类型
import java.util.Collection;
/**
- * 断言工具类
+ * 断言工具类，用于对各种条件进行检查，如果条件不满足则抛出业务异常
*/
+// 定义一个名为AssertUtil的工具类，用于提供各种断言方法
public class AssertUtil {
+ // 私有构造函数，防止外部实例化该工具类，因为它只提供静态方法，不需要创建实例
public AssertUtil() {
}
+ /**
+ * 检查表达式是否为真，如果不为真则抛出业务异常
+ * @param expression 要检查的布尔表达式
+ * @param type 异常类型枚举，用于指定抛出异常的信息
+ * @throws BusinessRuntimeException 如果表达式为假，抛出指定类型的业务异常
+ */
public static void isTrue(boolean expression, ExceptionEnum type) throws BusinessRuntimeException {
+ // 如果表达式的值为假
if (!expression) {
+ // 抛出一个BusinessRuntimeException异常，异常信息由传入的ExceptionEnum类型指定
throw new BusinessRuntimeException(type);
}
}
+ /**
+ * 检查表达式是否为假，如果为真则抛出业务异常
+ * @param expression 要检查的布尔表达式
+ * @param type 异常类型枚举，用于指定抛出异常的信息
+ * @throws BusinessRuntimeException 如果表达式为真，抛出指定类型的业务异常
+ */
public static void notTrue(boolean expression, ExceptionEnum type) throws BusinessRuntimeException {
+ // 如果表达式的值为真
if (expression) {
+ // 抛出一个BusinessRuntimeException异常，异常信息由传入的ExceptionEnum类型指定
throw new BusinessRuntimeException(type);
}
}
+ /**
+ * 检查对象是否为 null，如果不为 null 则抛出业务异常
+ * @param object 要检查的对象
+ * @param type 异常类型枚举，用于指定抛出异常的信息
+ * @throws BusinessRuntimeException 如果对象不为 null，抛出指定类型的业务异常
+ */
public static void isNull(Object object, ExceptionEnum type) throws BusinessRuntimeException {
+ // 如果对象不为 null
if (object != null) {
+ // 抛出一个BusinessRuntimeException异常，异常信息由传入的ExceptionEnum类型指定
throw new BusinessRuntimeException(type);
}
}
+ /**
+ * 检查对象是否不为 null，如果为 null 则抛出业务异常
+ * @param object 要检查的对象
+ * @param type 异常类型枚举，用于指定抛出异常的信息
+ * @throws BusinessRuntimeException 如果对象为 null，抛出指定类型的业务异常
+ */
public static void notNull(Object object, ExceptionEnum type) throws BusinessRuntimeException {
+ // 如果对象为 null
if (object == null) {
+ // 抛出一个BusinessRuntimeException异常，异常信息由传入的ExceptionEnum类型指定
throw new BusinessRuntimeException(type);
}
}
+ /**
+ * 检查数组是否为空，如果不为空则抛出业务异常
+ * @param array 要检查的数组
+ * @param type 异常类型枚举，用于指定抛出异常的信息
+ * @throws BusinessRuntimeException 如果数组不为空，抛出指定类型的业务异常
+ */
public static void isEmpty(Object[] array, ExceptionEnum type) throws BusinessRuntimeException {
+ // 使用ObjectUtils的isEmpty方法检查数组是否为空，如果不为空
if (!ObjectUtils.isEmpty(array)) {
+ // 抛出一个BusinessRuntimeException异常，异常信息由传入的ExceptionEnum类型指定
throw new BusinessRuntimeException(type);
}
}
+ /**
+ * 检查数组是否不为空，如果为空则抛出业务异常
+ * @param array 要检查的数组
+ * @param type 异常类型枚举，用于指定抛出异常的信息
+ * @throws BusinessRuntimeException 如果数组为空，抛出指定类型的业务异常
+ */
public static void notEmpty(Object[] array, ExceptionEnum type) throws BusinessRuntimeException {
+ // 使用ObjectUtils的isEmpty方法检查数组是否为空，如果为空
if (ObjectUtils.isEmpty(array)) {
+ // 抛出一个BusinessRuntimeException异常，异常信息由传入的ExceptionEnum类型指定
throw new BusinessRuntimeException(type);
}
}
+ /**
+ * 检查集合是否为空，如果不为空则抛出业务异常
+ * @param collection 要检查的集合
+ * @param type 异常类型枚举，用于指定抛出异常的信息
+ * @throws BusinessRuntimeException 如果集合不为空，抛出指定类型的业务异常
+ */
public static void isEmpty(Collection collection, ExceptionEnum type) throws BusinessRuntimeException {
+ // 使用CollectionUtils的isEmpty方法检查集合是否为空，如果不为空
if (!CollectionUtils.isEmpty(collection)) {
+ // 抛出一个BusinessRuntimeException异常，异常信息由传入的ExceptionEnum类型指定
throw new BusinessRuntimeException(type);
}
}
+ /**
+ * 检查集合是否不为空，如果为空则抛出业务异常
+ * @param collection 要检查的集合
+ * @param type 异常类型枚举，用于指定抛出异常的信息
+ * @throws BusinessRuntimeException 如果集合为空，抛出指定类型的业务异常
+ */
public static void notEmpty(Collection collection, ExceptionEnum type) throws BusinessRuntimeException {
+ // 使用CollectionUtils的isEmpty方法检查集合是否为空，如果为空
if (CollectionUtils.isEmpty(collection)) {
+ // 抛出一个BusinessRuntimeException异常，异常信息由传入的ExceptionEnum类型指定
throw new BusinessRuntimeException(type);
}
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/util/ClassJavaToTSUtil.java b/server/src/main/java/com/ew/gerocomium/common/util/ClassJavaToTSUtil.java
index 30a8992..7999f0c 100644
--- a/server/src/main/java/com/ew/gerocomium/common/util/ClassJavaToTSUtil.java
+++ b/server/src/main/java/com/ew/gerocomium/common/util/ClassJavaToTSUtil.java
@@ -1,63 +1,125 @@
+// 声明该类所在的包，用于存放项目中的工具类
package com.ew.gerocomium.common.util;
+// 导入Hutool工具包中的对象工具类，用于对象的判空等操作
import cn.hutool.core.util.ObjUtil;
+// 导入自定义的数据访问层查询类（这里导入了多个，但未在代码中全部使用，可能在其他地方有作用）
import com.ew.gerocomium.dao.query.*;
+// 导入自定义的数据视图对象类
import com.ew.gerocomium.dao.vo.PageNurseReserveByKeyVo;
+// 导入Java反射包中的Field类，用于获取类的字段信息
import java.lang.reflect.Field;
+// 导入Java反射包中的Modifier类，用于获取字段的修饰符信息
import java.lang.reflect.Modifier;
+// 导入Java标准库中的BigDecimal类，用于处理高精度数值
import java.math.BigDecimal;
+/**
+ * 该工具类用于将 Java 类转换为 TypeScript 接口定义
+ */
+// 定义一个名为ClassJavaToTSUtil的工具类，用于实现将Java类转换为TypeScript接口定义的功能
public class ClassJavaToTSUtil {
+
+ /**
+ * 将 Java 类转换为 TypeScript 接口定义
+ * @param clazz 要转换的 Java 类
+ * @param returnClassName 自定义的 TypeScript 接口名称，如果为空则使用 Java 类名转换后的名称
+ * @return 转换后的 TypeScript 接口定义字符串
+ */
public static String convertClassToTS(Class clazz, String returnClassName) {
+ // 创建一个StringBuilder对象，用于构建最终的TypeScript接口定义字符串
StringBuilder sb = new StringBuilder();
+ // 开始定义TypeScript接口，添加"export interface "前缀
sb.append("export interface ");
+ // 判断是否提供了自定义的接口名称，如果提供了则使用，否则调用getClassName方法获取转换后的Java类名
sb.append(ObjUtil.isNotEmpty(returnClassName) ? returnClassName : getClassName(clazz));
sb.append(" {\n");
+ // 获取传入的Java类的所有声明字段
Field[] fields = clazz.getDeclaredFields();
+ // 遍历所有字段
for (Field field : fields) {
+ // 判断字段是否为静态字段并且不是getter/setter方法名（通过isGetterOrSetter方法判断）
if (!Modifier.isStatic(field.getModifiers()) && !isGetterOrSetter(field.getName())) {
+ // 添加字段的缩进（制表符\t）
sb.append("\t");
+ // 添加字段名
sb.append(field.getName());
sb.append(": ");
+ // 调用convertTypeToTS方法将Java字段类型转换为TypeScript类型，并添加到字符串中
sb.append(convertTypeToTS(field.getType()));
sb.append(";\n");
}
}
+ // 结束TypeScript接口定义，添加"}"
sb.append("}");
+ // 返回构建好的TypeScript接口定义字符串
return sb.toString();
}
+ /**
+ * 获取 Java 类名并转换为首字母大写的格式
+ * @param clazz Java 类
+ * @return 转换后的类名
+ */
private static String getClassName(Class clazz) {
+ // 获取Java类的简单名称（不包含包名）
String name = clazz.getSimpleName();
+ // 将类名的首字母转换为大写，并拼接上剩余部分
return name.substring(0, 1).toUpperCase() + name.substring(1);
}
+ /**
+ * 将 Java 类型转换为 TypeScript 类型
+ * @param type Java 类型
+ * @return 对应的 TypeScript 类型
+ */
private static String convertTypeToTS(Class type) {
+ // 判断是否为数值类型（包括基本类型和包装类型以及BigDecimal类型）
if (type == int.class || type == Integer.class ||
type == long.class || type == Long.class ||
type == float.class || type == Float.class ||
type == double.class || type == Double.class ||
type == BigDecimal.class) {
+ // 如果是数值类型，返回"number"作为TypeScript类型
return "number";
- } else if (type == boolean.class || type == Boolean.class) {
+ }
+ // 判断是否为布尔类型（包括基本类型和包装类型）
+ else if (type == boolean.class || type == Boolean.class) {
+ // 如果是布尔类型，返回"boolean"作为TypeScript类型
return "boolean";
- } else if (type == String.class) {
+ }
+ // 判断是否为字符串类型
+ else if (type == String.class) {
+ // 如果是字符串类型，返回"string"作为TypeScript类型
return "string";
- } else {
+ }
+ // 对于其他类型，调用getClassName方法获取转换后的类名作为TypeScript类型
+ else {
return getClassName(type);
}
}
+ /**
+ * 判断字段名是否为 getter/setter 方法名
+ * @param fieldName 字段名
+ * @return 如果是 getter/setter 方法名返回 true，否则返回 false
+ */
private static boolean isGetterOrSetter(String fieldName) {
+ // 判断字段名是否以"get"、"set"或"is"开头
return fieldName.startsWith("get") ||
fieldName.startsWith("set") ||
fieldName.startsWith("is");
}
+ /**
+ * 主方法，用于测试转换功能
+ * @param args 命令行参数
+ */
public static void main(String[] args) {
- System.out.println(convertClassToTS(PageNurseReserveByKeyVo.class,null));
+ // 调用convertClassToTS方法，将PageNurseReserveByKeyVo类转换为TypeScript接口定义，并打印输出
+ System.out.println(convertClassToTS(PageNurseReserveByKeyVo.class, null));
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/util/DateUtilWen.java b/server/src/main/java/com/ew/gerocomium/common/util/DateUtilWen.java
index 3e0c2ce..ad3d0af 100644
--- a/server/src/main/java/com/ew/gerocomium/common/util/DateUtilWen.java
+++ b/server/src/main/java/com/ew/gerocomium/common/util/DateUtilWen.java
@@ -1,224 +1,292 @@
+// 声明该类所在的包，用于存放项目中的工具类
package com.ew.gerocomium.common.util;
+// 导入Hutool工具包中的日期工具类，用于日期和时间的处理
import cn.hutool.core.date.DateUtil;
+// 导入Hutool工具包中的对象工具类，用于对象的判空等操作
import cn.hutool.core.util.ObjUtil;
+// 导入Java标准库中的Calendar类，用于处理日期和时间的各种操作
import java.util.Calendar;
+// 导入Java标准库中的Date类，用于表示日期和时间
import java.util.Date;
+// 定义一个名为DateUtilWen的工具类，用于处理日期和时间相关的操作
public class DateUtilWen {
+
/**
* Date字符串转Date
*
- * @param dateStr
- * @return
+ * @param dateStr 要转换的日期字符串
+ * @return 转换后的Date对象，如果输入字符串为空则返回null
*/
public static Date dateStrToDate(String dateStr) {
- return ObjUtil.isEmpty(dateStr) ?
+ // 判断输入的日期字符串是否为空
+ return ObjUtil.isEmpty(dateStr)?
null :
+ // 使用Hutool的DateUtil将字符串解析为Date对象
DateUtil.parseDate(dateStr);
}
/**
* Date转Date字符串
*
- * @param date
- * @param "yyyy/MM/dd hh:mm:ss"
- * @return
+ * @param date 要转换的Date对象
+ * @param formatStr 日期格式字符串，例如"yyyy/MM/dd hh:mm:ss"
+ * @return 转换后的日期字符串，如果输入的Date对象为空则返回null
*/
public static String dateToDateStr(Date date, String formatStr) {
- return ObjUtil.isEmpty(date) ?
+ // 判断输入的Date对象是否为空
+ return ObjUtil.isEmpty(date)?
null :
+ // 使用Hutool的DateUtil将Date对象格式化为指定格式的字符串
DateUtil.format(date, formatStr);
}
/**
* 根据时间获取【前n天】或【后n天】
*
- * @param date
- * @param dayBdeforeNum
- * @return
+ * @param date 基准日期
+ * @param dayBdeforeNum 天数，正数表示后n天，负数表示前n天
+ * @return 计算后的日期
*/
public static Date getNowDayAroundTime(Date date, Integer dayBdeforeNum) {
+ // 获取Calendar实例
Calendar calendar = Calendar.getInstance();
+ // 设置Calendar的时间为基准日期
calendar.setTime(date);
+ // 根据指定的天数调整日期
calendar.add(Calendar.DATE, dayBdeforeNum);
+ // 返回调整后的日期
return calendar.getTime();
}
/**
* 根据时间获取【前n月】或【后n月】
*
- * @param date
- * @param monthBeforeNum
- * @return
+ * @param date 基准日期
+ * @param monthBeforeNum 月数，正数表示后n月，负数表示前n月
+ * @return 计算后的日期
*/
public static Date getNowMonthAroundTime(Date date, Integer monthBeforeNum) {
+ // 获取Calendar实例
Calendar calendar = Calendar.getInstance();
+ // 设置Calendar的时间为基准日期
calendar.setTime(date);
+ // 根据指定的月数调整日期
calendar.add(Calendar.MONTH, monthBeforeNum);
+ // 返回调整后的日期
return calendar.getTime();
}
/**
* 获取时间所对应当天的开始时间
*
- * @param date
- * @return
+ * @param date 目标日期
+ * @return 当天的开始时间（00:00:00），如果输入日期为空则返回null
*/
public static Date getDayStartTime(Date date) {
+ // 判断输入的日期是否为空
if (date == null) {
return null;
}
+ // 获取Calendar实例
Calendar calendar = Calendar.getInstance();
+ // 设置Calendar的时间为目标日期
calendar.setTime(date);
+ // 设置小时为0
calendar.set(Calendar.HOUR_OF_DAY, 0);
+ // 设置分钟为0
calendar.set(Calendar.MINUTE, 0);
+ // 设置秒为0
calendar.set(Calendar.SECOND, 0);
+ // 返回设置后的日期
return calendar.getTime();
}
/**
* 获取时间所对应当天的结束时间
*
- * @param date
- * @return
+ * @param date 目标日期
+ * @return 当天的结束时间（23:59:59），如果输入日期为空则返回null
*/
public static Date getDayEndTime(Date date) {
+ // 判断输入的日期是否为空
if (date == null) {
return null;
}
+ // 获取Calendar实例
Calendar calendar = Calendar.getInstance();
+ // 设置Calendar的时间为目标日期
calendar.setTime(date);
+ // 设置小时为23
calendar.set(Calendar.HOUR_OF_DAY, 23);
+ // 设置分钟为59
calendar.set(Calendar.MINUTE, 59);
+ // 设置秒为59
calendar.set(Calendar.SECOND, 59);
+ // 返回设置后的日期
return calendar.getTime();
}
/**
* 获取时间所对应月份的第一天
*
- * @param date
- * @return
+ * @param date 目标日期
+ * @return 对应月份的第一天（00:00:00）
*/
public static Date getMonthFirstDay(Date date) {
+ // 获取Calendar实例
Calendar calendar = Calendar.getInstance();
+ // 设置Calendar的时间为目标日期
calendar.setTime(date);
+ // 设置日期为该月的最小日期（即第一天）
calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMinimum(Calendar.DAY_OF_MONTH));
+ // 设置小时为0
calendar.set(Calendar.HOUR_OF_DAY, 0);
+ // 设置分钟为0
calendar.set(Calendar.MINUTE, 0);
+ // 设置秒为0
calendar.set(Calendar.SECOND, 0);
+ // 返回设置后的日期
return calendar.getTime();
}
/**
* 获取时间所对应月份的最后一天
*
- * @param date
- * @return
+ * @param date 目标日期
+ * @return 对应月份的最后一天（23:59:59）
*/
public static Date getMonthLastDay(Date date) {
+ // 获取Calendar实例
Calendar calendar = Calendar.getInstance();
+ // 设置Calendar的时间为目标日期
calendar.setTime(date);
+ // 设置日期为该月的最大日期（即最后一天）
calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
+ // 设置小时为23
calendar.set(Calendar.HOUR_OF_DAY, 23);
+ // 设置分钟为59
calendar.set(Calendar.MINUTE, 59);
+ // 设置秒为59
calendar.set(Calendar.SECOND, 59);
+ // 返回设置后的日期
return calendar.getTime();
}
/**
* 获取时间所对应年份的第一天
*
- * @param date
- * @return
+ * @param date 目标日期
+ * @return 对应年份的第一天（00:00:00）
*/
public static Date getYearFirstDay(Date date) {
+ // 获取Calendar实例
Calendar calendar = Calendar.getInstance();
+ // 设置Calendar的时间为目标日期
calendar.setTime(date);
+ // 设置日期为该年的最小日期（即第一天）
calendar.set(Calendar.DAY_OF_YEAR, calendar.getActualMinimum(Calendar.DAY_OF_YEAR));
+ // 设置小时为0
calendar.set(Calendar.HOUR_OF_DAY, 0);
+ // 设置分钟为0
calendar.set(Calendar.MINUTE, 0);
+ // 设置秒为0
calendar.set(Calendar.SECOND, 0);
+ // 返回设置后的日期
return calendar.getTime();
}
/**
* 获取时间所对应年份的最后一天
*
- * @param date
- * @return
+ * @param date 目标日期
+ * @return 对应年份的最后一天（23:59:59）
*/
public static Date getYearLastDay(Date date) {
+ // 获取Calendar实例
Calendar calendar = Calendar.getInstance();
+ // 设置Calendar的时间为目标日期
calendar.setTime(date);
+ // 设置日期为该年的最大日期（即最后一天）
calendar.set(Calendar.DAY_OF_YEAR, calendar.getActualMaximum(Calendar.DAY_OF_YEAR));
+ // 设置小时为23
calendar.set(Calendar.HOUR_OF_DAY, 23);
+ // 设置分钟为59
calendar.set(Calendar.MINUTE, 59);
+ // 设置秒为59
calendar.set(Calendar.SECOND, 59);
+ // 返回设置后的日期
return calendar.getTime();
}
/**
* 根据时间获取当前月份
*
- * @param date
- * @return
+ * @param date 目标日期
+ * @return 当前月份（1-12）
*/
public static Integer getMonthNum(Date date) {
+ // 获取Calendar实例
Calendar calendar = Calendar.getInstance();
+ // 设置Calendar的时间为目标日期
calendar.setTime(date);
+ // 获取月份（注意：Calendar的月份是从0开始的，所以需要加1）
return calendar.get(Calendar.MONTH) + 1;
}
/**
* 根据时间获取【年月】的格式化日期
*
- * @param date
- * @param symbol
- * @return
+ * @param date 目标日期
+ * @param symbol 分隔符号，例如"-"、"/"等
+ * @return 格式化后的年月字符串，例如"2023-05"
*/
public static String getYearToMonthFormatDateStr(Date date, String symbol) {
+ // 获取Calendar实例
Calendar calendar = Calendar.getInstance();
+ // 设置Calendar的时间为目标日期
calendar.setTime(date);
+ // 获取月份（注意：Calendar的月份是从0开始的，所以需要加1）
int month = calendar.get(Calendar.MONTH) + 1;
+ // 拼接年份、分隔符号和月份，生成格式化后的字符串
return String.valueOf(calendar.getWeekYear())
.concat(symbol)
- .concat(month < 10 ? "0" + month : String.valueOf(month));
+ .concat(month < 10? "0" + month : String.valueOf(month));
}
/**
* 根据出生日期获取年龄
*
- * @param birthday
- * @return
+ * @param birthday 出生日期
+ * @return 年龄
*/
public static Integer getAgeByBirthDay(Date birthday) {
- //获取当前时间的Calendar对象
+ // 获取当前时间的Calendar对象
Calendar cal = Calendar.getInstance();
- //获取出生日期的Calendar对象
+ // 获取出生日期的Calendar对象
Calendar bir = Calendar.getInstance();
bir.setTime(birthday);
- //如果出生日期大于当前日期，则返回0
+ // 如果出生日期大于当前日期，则返回0
if (cal.before(birthday)) {
return 0;
}
- //取出当前年月日
+ // 取出当前年月日
int nowYear = cal.get(Calendar.YEAR);
int nowMonth = cal.get(Calendar.MONTH);
int nowDay = cal.get(Calendar.DAY_OF_MONTH);
- //取出出生日期的年月日
+ // 取出出生日期的年月日
int birthYear = bir.get(Calendar.YEAR);
int birthMonth = bir.get(Calendar.MONTH);
int birthDay = bir.get(Calendar.DAY_OF_MONTH);
- //计算年份
+ // 计算年份
int age = nowYear - birthYear;
- //计算月份和日，看看是否大于当前月日，如果小于则减去一岁
+ // 计算月份和日，看看是否大于当前月日，如果小于则减去一岁
if (nowMonth < birthMonth || (nowMonth == birthMonth && nowDay < birthDay)) {
age--;
}
@@ -228,29 +296,40 @@ public class DateUtilWen {
/**
* 获取两时间相差几月零几天
*
- * @param startTime
- * @param endTime
+ * @param startTime 开始时间
+ * @param endTime 结束时间
*/
public void getBetweenMonthAndDay(Date startTime, Date endTime) {
+ // 将开始时间设置为当天的开始时间
startTime = getDayStartTime(startTime);
+ // 将结束时间设置为当天的结束时间
endTime = getDayEndTime(endTime);
+ // 获取当前时间的当天结束时间
Date nowTime = getDayEndTime(new Date());
- endTime = nowTime.before(endTime) ? nowTime : endTime;
+ // 如果当前时间的当天结束时间早于结束时间，则将结束时间设置为当前时间的当天结束时间
+ endTime = nowTime.before(endTime)? nowTime : endTime;
Date temporaryDate;
long month = 0L;
long day = 0L;
+ // 当开始时间早于结束时间时循环
while (startTime.before(endTime)) {
+ // 获取开始时间后一个月的时间
temporaryDate = getNowMonthAroundTime(startTime, 1);
+ // 如果后一个月的时间早于结束时间，则月份加1
if (temporaryDate.before(endTime)) {
month++;
} else {
+ // 否则计算开始时间和结束时间之间的天数
day = DateUtil.betweenDay(startTime, endTime, true);
}
+ // 将开始时间更新为后一个月的时间
startTime = temporaryDate;
}
+ // 打印相差的月数
System.out.println(month);
+ // 打印相差的天数
System.out.println(day);
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/util/EntityCodeGeneratorUtil.java b/server/src/main/java/com/ew/gerocomium/common/util/EntityCodeGeneratorUtil.java
index 06c954c..80bb423 100644
--- a/server/src/main/java/com/ew/gerocomium/common/util/EntityCodeGeneratorUtil.java
+++ b/server/src/main/java/com/ew/gerocomium/common/util/EntityCodeGeneratorUtil.java
@@ -1,69 +1,113 @@
+// 声明该类所在的包，用于存放项目中的工具类
package com.ew.gerocomium.common.util;
+// 导入MyBatis-Plus中用于标识数据库类型的枚举类
import com.baomidou.mybatisplus.annotation.DbType;
+// 导入MyBatis-Plus中用于标识字段填充策略的枚举类
import com.baomidou.mybatisplus.annotation.FieldFill;
+// 导入MyBatis-Plus中用于标识主键生成类型的枚举类
import com.baomidou.mybatisplus.annotation.IdType;
+// 导入MyBatis-Plus的代码生成器类
import com.baomidou.mybatisplus.generator.AutoGenerator;
+// 导入MyBatis-Plus中用于配置数据源的类
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
+// 导入MyBatis-Plus中用于配置全局信息的类
import com.baomidou.mybatisplus.generator.config.GlobalConfig;
+// 导入MyBatis-Plus中用于配置包信息的类
import com.baomidou.mybatisplus.generator.config.PackageConfig;
+// 导入MyBatis-Plus中用于配置生成策略的类
import com.baomidou.mybatisplus.generator.config.StrategyConfig;
+// 导入MyBatis-Plus中用于配置表字段填充信息的类
import com.baomidou.mybatisplus.generator.config.po.TableFill;
+// 导入MyBatis-Plus中用于标识日期类型的枚举类
import com.baomidou.mybatisplus.generator.config.rules.DateType;
+// 导入MyBatis-Plus中用于标识命名策略的枚举类
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
+// 导入自定义的数据访问层的基础实体类
import com.ew.gerocomium.dao.base.BaseEntity;
+// 导入Java标准库中的ArrayList类，用于创建和操作列表
import java.util.ArrayList;
+// 定义一个名为EntityCodeGeneratorUtil的工具类，用于生成MyBatis-Plus相关的代码
public class EntityCodeGeneratorUtil {
public static void main(String[] args) {
- // 构建一个代码生成器对象
+ // 创建一个MyBatis-Plus的代码生成器对象
AutoGenerator mpg = new AutoGenerator();
- // 配置策略
+
// 1、全局配置
GlobalConfig gc = new GlobalConfig();
- String property = System.getProperty("user.dir"); // 获取当前项目的目录
- gc.setOutputDir(property + "/src/main/java/"); // 设置生成代码的目录
- gc.setAuthor("EmperorWen"); // 生成代码的作者
- gc.setOpen(false); // 生成完成后，打开项目所在windows下的文件夹(false 不打开)
- gc.setFileOverride(false); // 是否覆盖原来的文件(false 不覆盖)
- gc.setServiceName("%sBaseService"); // 去除IService的I前缀
- gc.setServiceImplName("%sBaseServiceImpl"); // 去除IServiceImpl的I前缀
- gc.setIdType(IdType.AUTO); // 设置pojo类主键策略
- gc.setDateType(DateType.ONLY_DATE); // 设置pojo类data的类型
- gc.setSwagger2(false); // 设置swagger文档
- mpg.setGlobalConfig(gc); // 将配置丢入自动生成器内
+ // 获取当前项目的目录
+ String property = System.getProperty("user.dir");
+ // 设置生成代码的目录为当前项目目录下的src/main/java/
+ gc.setOutputDir(property + "/src/main/java/");
+ // 设置生成代码的作者
+ gc.setAuthor("EmperorWen");
+ // 设置生成完成后不打开项目所在的Windows文件夹
+ gc.setOpen(false);
+ // 设置不覆盖原来的文件
+ gc.setFileOverride(false);
+ // 设置Service接口的命名规则，去除IService的I前缀
+ gc.setServiceName("%sBaseService");
+ // 设置ServiceImpl类的命名规则，去除IServiceImpl的I前缀
+ gc.setServiceImplName("%sBaseServiceImpl");
+ // 设置pojo类的主键生成策略为自动生成
+ gc.setIdType(IdType.AUTO);
+ // 设置pojo类中日期类型为只包含日期
+ gc.setDateType(DateType.ONLY_DATE);
+ // 设置不生成Swagger文档
+ gc.setSwagger2(false);
+ // 将全局配置设置到代码生成器中
+ mpg.setGlobalConfig(gc);
// 2、设置数据源
DataSourceConfig dsc = new DataSourceConfig();
+ // 设置数据库连接URL
dsc.setUrl("jdbc:mysql://127.0.0.1:3306/gerocomium?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8");
+ // 设置数据库驱动名称
dsc.setDriverName("com.mysql.cj.jdbc.Driver");
+ // 设置数据库用户名
dsc.setUsername("root");
+ // 设置数据库密码
dsc.setPassword("242680");
- dsc.setDbType(DbType.MYSQL); // 使用的是mysql
+ // 设置使用的数据库类型为MySQL
+ dsc.setDbType(DbType.MYSQL);
+ // 将数据源配置设置到代码生成器中
mpg.setDataSource(dsc);
// 3、包的配置
PackageConfig pc = new PackageConfig();
+ // 设置父包名
pc.setParent("com.ew.gerocomium");
+ // 设置模块名
pc.setModuleName("dao");
+ // 设置实体类所在的包名
pc.setEntity("po");
+ // 设置Mapper接口所在的包名
pc.setMapper("mapper");
+ // 设置Service接口所在的包名
pc.setService("service");
// pc.setController("controller");
+ // 将包配置设置到代码生成器中
mpg.setPackageInfo(pc);
// 4、配置策略
StrategyConfig strategy = new StrategyConfig();
- strategy.setInclude(); // 设置要映射的表；多个则使用 ”,“ 分割；全部则不设置
- strategy.setNaming(NamingStrategy.underline_to_camel); // 命名规则(下划线转驼峰)
- strategy.setColumnNaming(NamingStrategy.underline_to_camel); //列的名字(下划线转驼峰)
- strategy.setSuperEntityClass(BaseEntity.class); // 父类实体类
- strategy.setSuperEntityColumns("id","create_id","create_time","update_id","update_time"); // 去掉父类属性
- strategy.setEntityLombokModel(true); // 是否使用lombok开启注解
+ // 设置要映射的表，这里未设置（多个表使用 “,” 分割；全部表则不设置）
+ strategy.setInclude();
+ // 设置表名的命名规则为下划线转驼峰
+ strategy.setNaming(NamingStrategy.underline_to_camel);
+ // 设置列名的命名规则为下划线转驼峰
+ strategy.setColumnNaming(NamingStrategy.underline_to_camel);
+ // 设置父类实体类
+ strategy.setSuperEntityClass(BaseEntity.class);
+ // 设置从父类实体类中去掉的属性
+ strategy.setSuperEntityColumns("id", "create_id", "create_time", "update_id", "update_time");
+ // 设置是否使用Lombok注解生成实体类
+ strategy.setEntityLombokModel(true);
- // 设置逻辑删除的别名
+ // 设置逻辑删除字段的名称
strategy.setLogicDeleteFieldName("deleted");
// 设置自动填充配置
@@ -76,20 +120,21 @@ public class EntityCodeGeneratorUtil {
tableFiledLists.add(create_time);
tableFiledLists.add(update_id);
tableFiledLists.add(update_time);
+ // 将自动填充配置设置到生成策略中
strategy.setTableFillList(tableFiledLists);
- // 乐观锁策略
+ // 设置乐观锁字段的名称
strategy.setVersionFieldName("version");
- // controller 驼峰命名
+ // 设置Controller类的风格为驼峰命名
strategy.setRestControllerStyle(true);
- strategy.setControllerMappingHyphenStyle(true); // requestMapping中使用下划线命名
+ // 设置Controller类中RequestMapping的命名风格为使用下划线
+ strategy.setControllerMappingHyphenStyle(true);
+ // 将生成策略设置到代码生成器中
mpg.setStrategy(strategy);
- // 执行
+ // 执行代码生成操作
mpg.execute();
}
-
-}
-
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/util/ExcelUtil.java b/server/src/main/java/com/ew/gerocomium/common/util/ExcelUtil.java
index f37f5f6..7d079d7 100644
--- a/server/src/main/java/com/ew/gerocomium/common/util/ExcelUtil.java
+++ b/server/src/main/java/com/ew/gerocomium/common/util/ExcelUtil.java
@@ -1,81 +1,117 @@
+// 声明该类所在的包，用于存放项目中的工具类
package com.ew.gerocomium.common.util;
+// 导入Hutool工具包中的对象工具类，用于对象的判空等操作
import cn.hutool.core.util.ObjUtil;
+// 导入自定义的文件上传配置属性类，用于获取文件上传相关配置
import com.ew.gerocomium.common.config.file.FileUploadConfigPropertity;
+// 导入Swagger的注解，用于为模型属性添加描述信息
import io.swagger.annotations.ApiModelProperty;
+// 导入Lombok的注解，用于自动生成全参构造函数
import lombok.AllArgsConstructor;
+// 导入Lombok的注解，用于自动生成getter、setter、toString等方法
import lombok.Data;
+// 导入Apache POI中用于操作Excel工作簿的接口
import org.apache.poi.ss.usermodel.*;
+// 导入Apache POI中用于操作Excel 2007+文件的单元格样式类
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
+// 导入Apache POI中用于操作Excel 2007+文件的颜色类
import org.apache.poi.xssf.usermodel.XSSFColor;
+// 导入Apache POI中用于操作Excel 2007+文件的工作簿类
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
+// 导入Spring框架中用于标记组件的注解，使该类可被Spring容器管理
import org.springframework.stereotype.Component;
+// 导入Spring框架中用于自动注入依赖的注解
import javax.annotation.Resource;
+// 导入Java标准库中用于字节数组输出流的类
import java.io.ByteArrayOutputStream;
+// 导入Java标准库中用于文件输出流的类
import java.io.FileOutputStream;
+// 导入Java标准库中用于处理输入输出异常的类
import java.io.IOException;
+// 导入Java反射包中的Field类，用于获取类的字段信息
import java.lang.reflect.Field;
+// 导入Java反射包中的InvocationTargetException异常类，用于反射调用方法时可能抛出的异常
import java.lang.reflect.InvocationTargetException;
+// 导入Java反射包中的Method类，用于获取类的方法信息
import java.lang.reflect.Method;
+// 导入Java标准库中的ArrayList类，用于创建和操作列表
import java.util.ArrayList;
+// 导入Java标准库中的List接口，用于表示列表类型
import java.util.List;
+// 导入Java标准库中的Objects类，用于进行对象的比较等操作
import java.util.Objects;
+// 导入Java标准库中的UUID类，用于生成唯一标识符
import java.util.UUID;
+// 导入Java标准库中的原子整数类，用于原子操作
import java.util.concurrent.atomic.AtomicInteger;
+// 使用@Component注解将该类标记为Spring组件，使其能够被Spring容器自动扫描和管理
@Component
+// 定义一个名为ExcelUtil的工具类，用于处理Excel文件的导出操作
public class ExcelUtil {
+ // 使用@Resource注解自动注入FileUploadConfigPropertity实例，用于获取文件上传相关配置
@Resource
private FileUploadConfigPropertity fileUploadConfigPropertity;
/**
* @param dataList 导出数据列表
* @param aClass 反射对象
- * @return
- * @throws IOException
+ * @return 导出的Excel文件的请求路径
+ * @throws IOException 处理文件操作时可能抛出的输入输出异常
*/
public String exportExcel(List dataList, Class aClass) throws IOException {
- // 生成文件名
+ // 生成一个UUID作为文件名
UUID fileName = UUID.randomUUID();
+ // 拼接生成文件在本地的完整路径，包括下载文件夹和文件名，文件扩展名为.xlsx
String filePath = fileUploadConfigPropertity.getWindows() + "/download/" + fileName + ".xlsx";
+ // 拼接生成文件的请求路径，用于后续返回给调用方
String requestPath = fileUploadConfigPropertity.getLocalHead() + "/download/" + fileName + ".xlsx";
- // 获取表头以及getter名称
+ // 获取表头以及对应的getter方法名称列表
List headerNameList = new ExcelUtil().getHeaderNameList(aClass);
- // 生成excel
+ // 创建一个Excel 2007+格式的工作簿对象
Workbook workbook = new XSSFWorkbook();
+ // 在工作簿中创建一个名为"Sheet1"的工作表
Sheet sheet = workbook.createSheet("Sheet1");
- // 表头样式
+ // 创建表头的单元格样式对象
XSSFCellStyle headerStyle = (XSSFCellStyle) workbook.createCellStyle();
- // 设置背景颜色
+ // 设置表头背景颜色
headerStyle.setFillForegroundColor(new XSSFColor(new java.awt.Color(177, 179, 184)));
+ // 设置填充模式为纯色填充
headerStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
- // 设置水平居中
+ // 设置水平居中对齐
headerStyle.setAlignment(HorizontalAlignment.CENTER);
- // 设置垂直居中
+ // 设置垂直居中对齐
headerStyle.setVerticalAlignment(VerticalAlignment.CENTER);
- // 设置背景颜色为灰色
+ // 设置背景颜色为25%灰色
headerStyle.setFillForegroundColor(IndexedColors.GREY_25_PERCENT.getIndex());
- // 表头
+ // 创建一个原子整数对象，用于记录行号
AtomicInteger rowNum = new AtomicInteger();
+ // 创建表头行
Row headerRow = sheet.createRow(rowNum.getAndIncrement());
+ // 设置第一列的宽度
sheet.setColumnWidth(0, 10 * 256);
+ // 设置第一列的单元格值为"序号"，应用表头样式，标记为表头
setCell(headerRow, 0, "序号", headerStyle, true);
int headI = 1;
+ // 遍历表头名称列表，设置表头各列的单元格值和样式
for (Test test : headerNameList) {
setCell(headerRow, headI, test.getHeadName(), headerStyle, true);
headI++;
}
- // 内容
+ // 内容部分
int contentI = 1;
+ // 遍历数据列表，设置每一行的数据
for (Object item : dataList) {
+ // 创建数据行
Row row = sheet.createRow(rowNum.getAndIncrement());
- // 序号
+ // 设置序号列的值
setCell(row, 0, String.valueOf(contentI), headerStyle, false);
contentI++;
try {
@@ -88,76 +124,101 @@ public class ExcelUtil {
// System.out.println(o);
// }
int contentJ = 1;
+ // 遍历表头名称列表，通过反射获取对应属性的值并设置到单元格中
for (Test test : headerNameList) {
- // 通过反射对象获取一般方法
+ // 通过反射获取对象的指定方法（getter方法）
Method method = aClass.getMethod(test.getGetterName());
- // 利用反射的invoke方法激活通过反射调取的方法,里面的参数是实例对象和方法参数
+ // 利用反射的invoke方法调用该方法，获取属性值
Object getValue = method.invoke(item);
- String value = ObjUtil.isNotEmpty(getValue) ? getValue.toString() : "";
- // 某一行某一格内容
+ // 将属性值转换为字符串，若属性值为空则设置为空字符串
+ String value = ObjUtil.isNotEmpty(getValue)? getValue.toString() : "";
+ // 设置某一行某一格的内容，应用表头样式，标记为非表头
setCell(row, contentJ, value, headerStyle, false);
+ // 如果当前单元格的值长度大于该列已记录的最大长度，则更新最大长度
if (test.getMaxLength() < value.length()) {
test.setMaxLength(value.length() + 10);
}
contentJ++;
}
} catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
+ // 捕获反射操作可能抛出的异常并打印堆栈信息
e.printStackTrace();
}
}
- // 统一设置列宽
+ // 统一设置各列的宽度
int widthI = 1;
for (Test test : headerNameList) {
+ // 根据每列的最大长度设置列宽
sheet.setColumnWidth(widthI, test.getMaxLength() * 256);
widthI++;
}
- // 生成本地文件流
+ // 创建字节数组输出流对象
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+ // 将工作簿内容写入字节数组输出流
workbook.write(byteArrayOutputStream);
- // 保存到本地
+ // 创建文件输出流对象，用于将字节数组输出流的内容保存到本地文件
FileOutputStream fos = new FileOutputStream(filePath);
+ // 将字节数组输出流的内容写入文件输出流
byteArrayOutputStream.writeTo(fos);
+ // 关闭文件输出流
fos.close();
+ // 关闭字节数组输出流
byteArrayOutputStream.close();
- // 完成
+ // 关闭工作簿
workbook.close();
+ // 返回文件的请求路径
return requestPath;
}
- // 表格设值
+ // 表格设值方法，用于设置单元格的值和样式
public void setCell(Row row, Integer i, String value, XSSFCellStyle headerStyle, Boolean headFlag) {
+ // 在指定行创建单元格
Cell cell = row.createCell(i);
+ // 设置单元格的值
cell.setCellValue(value);
+ // 设置单元格内容自动换行
cell.getCellStyle().setWrapText(true);
+ // 如果是表头，则应用表头样式
if (headFlag) {
cell.setCellStyle(headerStyle);
}
}
- // 获取表头
+ // 获取表头方法，用于获取反射对象的表头信息和对应的getter方法名称
public List getHeaderNameList(Class aClass) {
+ // 创建一个列表用于存储表头信息对象
List testList = new ArrayList<>();
+ // 获取反射对象的所有声明字段
Field[] fields = aClass.getDeclaredFields();
+ // 遍历所有字段
for (Field field : fields) {
+ // 获取字段上的ApiModelProperty注解
ApiModelProperty apiModelProperty = field.getAnnotation(ApiModelProperty.class);
+ // 如果注解存在且字段名不是"id"
if (apiModelProperty != null && !Objects.equals(field.getName(), "id")) {
+ // 获取字段名
String fieldName = field.getName();
+ // 获取ApiModelProperty注解的value值，即表头名称
String apiModelPropertyName = apiModelProperty.value();
+ // 构建对应的getter方法名称
String getMethodName = "get" + Character.toUpperCase(fieldName.charAt(0)) + fieldName.substring(1);
+ // 创建一个表头信息对象并添加到列表中
Test test = new Test(apiModelPropertyName, getMethodName, 0);
testList.add(test);
}
}
+ // 返回表头信息列表
return testList;
}
+ // 内部静态类，用于存储表头信息，包括表头名称、getter方法名称和该列的最大长度
@Data
@AllArgsConstructor
private static class Test {
@@ -174,4 +235,4 @@ public class ExcelUtil {
*/
private Integer maxLength;
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/util/JavaToTsConverter.java b/server/src/main/java/com/ew/gerocomium/common/util/JavaToTsConverter.java
index d503958..944c009 100644
--- a/server/src/main/java/com/ew/gerocomium/common/util/JavaToTsConverter.java
+++ b/server/src/main/java/com/ew/gerocomium/common/util/JavaToTsConverter.java
@@ -1,66 +1,123 @@
+// 声明该类所在的包，用于存放项目中的工具类
package com.ew.gerocomium.common.util;
+// 导入自定义的数据持久化对象（PO）类，这里是Elder类，用于示例转换
import com.ew.gerocomium.dao.po.Elder;
-import java.lang.reflect.*;
+// 导入Java反射包中的Field类，用于获取类的字段信息
+import java.lang.reflect.Field;
+// 导入Java反射包中的Modifier类，用于获取字段和方法的修饰符信息
+import java.lang.reflect.Modifier;
+// 导入Java反射包中的Method类，用于获取类的方法信息
+import java.lang.reflect.Method;
+// 导入Java反射包中的Type类，用于表示类型信息
+import java.lang.reflect.Type;
+/**
+ * JavaToTsConverter 类用于将 Java 类转换为 TypeScript 接口定义。
+ * 它会遍历 Java 类的字段和公共方法，并将其转换为对应的 TypeScript 类型。
+ */
+// 定义一个名为JavaToTsConverter的工具类，用于实现将Java类转换为TypeScript接口定义的功能
public class JavaToTsConverter {
-
+
+ /**
+ * 将指定的 Java 类转换为 TypeScript 接口定义的字符串。
+ *
+ * @param clazz 要转换的 Java 类
+ * @return 转换后的 TypeScript 接口定义字符串
+ */
public String convert(Class clazz) {
+ // 创建一个StringBuilder对象，用于构建最终的TypeScript接口定义字符串
StringBuilder sb = new StringBuilder();
-
+
+ // 开始定义TypeScript接口，接口名称使用Java类的简单名称
sb.append("interface ").append(clazz.getSimpleName()).append(" {\n");
-
- // 处理字段
+
+ // 获取Java类的所有声明字段
Field[] fields = clazz.getDeclaredFields();
+ // 遍历所有字段
for (Field field : fields) {
+ // 添加字段名、冒号、对应的TypeScript类型以及分号和换行符
sb.append("\t").append(field.getName()).append(": ").append(getTypeScriptType(field.getType())).append(";\n");
}
-
- // 处理方法
+
+ // 获取Java类的所有声明方法
Method[] methods = clazz.getDeclaredMethods();
+ // 遍历所有方法
for (Method method : methods) {
+ // 判断方法是否为公共方法（通过检查方法的修饰符）
if (Modifier.isPublic(method.getModifiers())) {
+ // 添加方法名和左括号
sb.append("\t").append(method.getName()).append("(");
-
- // 处理参数
+
+ // 获取方法的参数类型数组
Class[] paramTypes = method.getParameterTypes();
+ // 遍历参数类型数组
for (int i = 0; i < paramTypes.length; i++) {
if (i > 0) {
+ // 如果不是第一个参数，添加逗号分隔
sb.append(", ");
}
+ // 为每个参数添加占位符名称（arg加上参数索引）、冒号和对应的TypeScript类型
sb.append("arg").append(i).append(": ").append(getTypeScriptType(paramTypes[i]));
}
-
+
+ // 添加右括号、冒号和方法返回类型的TypeScript类型，以及分号和换行符
sb.append("): ").append(getTypeScriptType(method.getReturnType())).append(";\n");
}
}
-
+
+ // 结束TypeScript接口定义，添加右花括号
sb.append("}");
-
+
+ // 返回构建好的TypeScript接口定义字符串
return sb.toString();
}
-
+
+ /**
+ * 将 Java 类型转换为对应的 TypeScript 类型。
+ *
+ * @param type Java 类型
+ * @return 对应的 TypeScript 类型
+ */
private String getTypeScriptType(Class type) {
+ // 判断是否为布尔类型（包括基本类型和包装类型）
if (type == boolean.class || type == Boolean.class) {
+ // 如果是布尔类型，返回"boolean"作为TypeScript类型
return "boolean";
- } else if (type == byte.class || type == Byte.class ||
- type == short.class || type == Short.class ||
- type == int.class || type == Integer.class ||
- type == long.class || type == Long.class ||
- type == float.class || type == Float.class ||
- type == double.class || type == Double.class) {
+ }
+ // 判断是否为数值类型（包括基本类型和包装类型）
+ else if (type == byte.class || type == Byte.class ||
+ type == short.class || type == Short.class ||
+ type == int.class || type == Integer.class ||
+ type == long.class || type == Long.class ||
+ type == float.class || type == Float.class ||
+ type == double.class || type == Double.class) {
+ // 如果是数值类型，返回"number"作为TypeScript类型
return "number";
- } else if (type == String.class || type == char.class || type == Character.class) {
+ }
+ // 判断是否为字符串类型或字符类型（包括基本类型和包装类型）
+ else if (type == String.class || type == char.class || type == Character.class) {
+ // 如果是字符串或字符类型，返回"string"作为TypeScript类型
return "string";
- } else {
+ }
+ // 对于其他类型，使用类的简单名称作为TypeScript类型
+ else {
return type.getSimpleName();
}
}
+ /**
+ * 主方法，用于测试 Java 类到 TypeScript 接口的转换功能。
+ *
+ * @param args 命令行参数
+ */
public static void main(String[] args) {
+ // 创建JavaToTsConverter类的实例
JavaToTsConverter converter = new JavaToTsConverter();
+ // 调用convert方法，将Elder类转换为TypeScript接口定义
String tsCode = converter.convert(Elder.class);
+ // 打印转换后的TypeScript接口定义字符串
System.out.println(tsCode);
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/util/JwtUtil.java b/server/src/main/java/com/ew/gerocomium/common/util/JwtUtil.java
index 0172c07..3f945ff 100644
--- a/server/src/main/java/com/ew/gerocomium/common/util/JwtUtil.java
+++ b/server/src/main/java/com/ew/gerocomium/common/util/JwtUtil.java
@@ -1,53 +1,73 @@
+// 声明该类所在的包，用于存放项目中的工具类
package com.ew.gerocomium.common.util;
+// 导入自定义的常量类，用于获取JWT相关的常量配置
import com.ew.gerocomium.common.constant.Constant;
+// 导入io.jsonwebtoken库中的Claims类，用于表示JWT中的声明信息
import io.jsonwebtoken.Claims;
+// 导入io.jsonwebtoken库中的Jws类，用于表示JSON Web Signature对象
import io.jsonwebtoken.Jws;
+// 导入io.jsonwebtoken库中的Jwts类，用于构建和解析JWT
import io.jsonwebtoken.Jwts;
+// 导入io.jsonwebtoken库中的SignatureAlgorithm类，用于指定签名算法
import io.jsonwebtoken.SignatureAlgorithm;
+// 导入io.jsonwebtoken库中的Keys类，用于生成和处理密钥
import io.jsonwebtoken.security.Keys;
+// 导入Java标准库中的字符集类，用于指定字符编码
import java.nio.charset.StandardCharsets;
+// 导入Java标准库中的日期类，用于处理日期和时间
import java.util.Date;
+// 定义一个名为JwtUtil的工具类，用于处理JWT（JSON Web Token）的生成和解析
public class JwtUtil {
/**
* 签发token
*
* @param id 用户id
- * @return jwt
+ * @return jwt 生成的JWT字符串
*/
public static String createJwt(String id) {
+ // 获取当前时间，作为签发时间
Date signTime = new Date();
+ // 使用Jwts.builder()构建JWT
return Jwts.builder()
- // 头部
+ // 设置JWT头部信息，指定类型为JWT
.setHeaderParam("type", "JWT")
+ // 设置JWT头部信息，指定签名算法为HS256
.setHeaderParam("alg", "HS256")
- // 主题
+ // 设置JWT的主题，从常量类中获取
.setSubject(Constant.TOKEN_SUBJECT)
- // 发行人
+ // 设置JWT的发行人，从常量类中获取
.setIssuer(Constant.TOKEN_ISSURE)
- // 签发时间
+ // 设置JWT的签发时间为当前时间
.setIssuedAt(signTime)
- // 生效时间
+ // 设置JWT的生效时间为当前时间
.setNotBefore(signTime)
- // 到期时间
+ // 设置JWT的到期时间，为签发时间加上常量类中定义的过期时间
.setExpiration(new Date(signTime.getTime() + Constant.EXPIRE_TIME))
- // 登录用户id
+ // 在JWT中添加自定义声明，记录用户ID
.claim("id", id)
- // 签名哈希
+ // 使用指定的密钥和签名算法进行签名
.signWith(Keys.hmacShaKeyFor(Constant.TOKEN_SECRET.getBytes(StandardCharsets.UTF_8)), SignatureAlgorithm.HS256)
- // 签名
+ // 构建最终的JWT字符串
.compact();
}
/**
* 解析token
+ *
+ * @param jwt 待解析的JWT字符串
+ * @return Jws 解析后的JWS对象，包含声明信息
*/
public static Jws parseJwt(String jwt) {
+ // 使用Jwts.parserBuilder()构建JWT解析器
return Jwts.parserBuilder()
+ // 设置解析JWT时使用的签名密钥
.setSigningKey(Keys.hmacShaKeyFor(Constant.TOKEN_SECRET.getBytes(StandardCharsets.UTF_8)))
+ // 构建解析器
.build()
+ // 解析传入的JWT字符串，并返回包含声明信息的JWS对象
.parseClaimsJws(jwt);
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/util/PageUtil.java b/server/src/main/java/com/ew/gerocomium/common/util/PageUtil.java
index 4be77dd..62e3e18 100644
--- a/server/src/main/java/com/ew/gerocomium/common/util/PageUtil.java
+++ b/server/src/main/java/com/ew/gerocomium/common/util/PageUtil.java
@@ -1,71 +1,97 @@
+// 声明该类所在的包，用于存放项目中的工具类
package com.ew.gerocomium.common.util;
+// 导入MyBatis-Plus中用于表示分页信息的接口
import com.baomidou.mybatisplus.core.metadata.IPage;
+// 导入MyBatis-Plus中用于实现分页功能的类
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+// 导入自定义的数据访问层的基础分页结果类
import com.ew.gerocomium.dao.base.PageResult;
+// 导入自定义的数据访问层的基础排序接口
import com.ew.gerocomium.dao.base.Rank;
+// 导入Spring框架中用于标记组件的注解，使该类可被Spring容器管理
import org.springframework.stereotype.Component;
+// 导入Java反射包中的InvocationTargetException异常类，用于反射调用方法时可能抛出的异常
import java.lang.reflect.InvocationTargetException;
+// 导入Java反射包中的Method类，用于获取类的方法信息
import java.lang.reflect.Method;
+// 导入Java标准库中的ArrayList类，用于创建和操作列表
import java.util.ArrayList;
+// 导入Java标准库中的List接口，用于表示列表类型
import java.util.List;
+// 导入Java 8+中用于流操作的Collectors类，用于对流进行收集操作
import java.util.stream.Collectors;
+// 使用@Component注解将该类标记为Spring组件，使其能够被Spring容器自动扫描和管理
@Component
+// 定义一个名为PageUtil的工具类，用于处理分页和数据排序等操作
public class PageUtil {
- // 分页法一
+ // 分页法一：使用Java 8+的流操作进行分页
public List getPageData(List list, Integer pageNum, Integer pageSize) {
+ // 使用流操作，跳过前面的 (pageNum - 1) * pageSize 条数据，然后取 pageSize 条数据
return list.stream()
.skip((long) (pageNum - 1) * pageSize).limit(pageSize)
+ // 将处理后的流收集为List
.collect(Collectors.toList());
}
- // 分页法二
+ // 分页法二：使用传统的循环方式进行分页
public IPage getIPageData(List list, Integer pageNum, Integer pageSize) {
- int curIdx = pageNum > 1 ? (pageNum - 1) * pageSize : 0;
+ // 计算当前页数据的起始索引
+ int curIdx = pageNum > 1? (pageNum - 1) * pageSize : 0;
+ // 创建一个新的列表用于存储当前页的数据
List pageList = new ArrayList<>();
+ // 遍历数据列表，将当前页的数据添加到pageList中
for (int i = 0; i < pageSize && curIdx + i < list.size(); i++) {
pageList.add(list.get(curIdx + i));
}
+ // 创建一个IPage对象，设置当前页码和每页大小
IPage page = new Page<>(pageNum, pageSize);
+ // 设置当前页的数据
page.setRecords(pageList);
+ // 设置总数据条数
page.setTotal(list.size());
+ // 返回IPage对象
return page;
}
- // 编序号
+ // 编序号：为列表中的每个元素设置序号
public List rank(List list) {
// public List rank(List list) {
+ // 定义一个数组，用于存储当前的序号，初始值为1
Long[] ranNum = {1L};
+ // 使用流操作，对每个元素进行操作，设置其序号
return list.stream()
.peek(item -> {
- // 法一
+ // 法一：使用反射调用对象的setRank方法设置序号
try {
- // 获取反射对象
+ // 获取对象的Class对象
Class aClass = item.getClass();
- // 通过反射对象获取一般方法
+ // 通过反射获取对象的setRank方法，该方法接受一个Long类型的参数
Method method = aClass.getMethod("setRank", Long.class);
- // 利用反射的invoke方法激活通过反射调取的方法,里面的参数是实例对象和方法参数
+ // 利用反射的invoke方法调用setRank方法，传入对象和当前序号，并将序号自增
method.invoke(item, ranNum[0]++);
} catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
+ // 捕获反射操作可能抛出的异常并打印堆栈信息
e.printStackTrace();
}
// 法二 不可用，需重新设计
// item.setRank(ranNum[0]++);
})
+ // 将处理后的流收集为List
.collect(Collectors.toList());
}
- // 封装分页返回数据
+ // 封装分页返回数据：将分页和排序后的数据封装为PageResult对象
public PageResult packPageResultData(List list, Integer pageNum, Integer pageSize) {
- // 排序
+ // 对数据进行排序，设置序号
list = rank(list);
- // 获取总条数
+ // 获取数据总条数
int total = list.size();
- // 截取分页数据
+ // 对数据进行分页处理
list = getPageData(list, pageNum, pageSize);
- // 封装返回数据
+ // 封装返回数据，创建PageResult对象，传入当前页码、每页大小、总数据条数和分页后的数据
return new PageResult<>(pageNum, pageSize, (long) total, list);
}
}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/util/ResponseUtil.java b/server/src/main/java/com/ew/gerocomium/common/util/ResponseUtil.java
index 85ab587..c6d770f 100644
--- a/server/src/main/java/com/ew/gerocomium/common/util/ResponseUtil.java
+++ b/server/src/main/java/com/ew/gerocomium/common/util/ResponseUtil.java
@@ -1,34 +1,74 @@
+// 声明该类所在的包，用于存放项目中的工具类
package com.ew.gerocomium.common.util;
+// 导入Hutool工具包中的JSON工具类，用于处理JSON相关操作
import cn.hutool.json.JSONUtil;
+// 导入自定义的异常枚举类，用于定义不同类型的业务异常
import com.ew.gerocomium.common.constant.ExceptionEnum;
+// 导入自定义的数据访问层的基础结果类，用于封装处理结果
import com.ew.gerocomium.dao.base.Result;
+// 导入Lombok的注解，用于生成日志记录器
import lombok.extern.slf4j.Slf4j;
+// 导入Java标准库中用于处理HTTP响应的类
import javax.servlet.http.HttpServletResponse;
+// 导入Java标准库中用于处理输入输出异常的类
import java.io.IOException;
+/**
+ * 响应工具类，用于将处理结果以 JSON 格式输出到 HTTP 响应中
+ */
+// 使用@Slf4j注解生成日志记录器，方便记录日志
@Slf4j
+// 定义一个名为ResponseUtil的工具类，用于处理HTTP响应并将结果以JSON格式输出
public class ResponseUtil {
+ /**
+ * 将 Result 对象转换为 JSON 字符串并输出到 HTTP 响应中
+ *
+ * @param response HTTP 响应对象
+ * @param result 处理结果对象
+ */
public static void resultOut(HttpServletResponse response, Result result) {
+ // 使用Hutool的JSONUtil将Result对象转换为JSON字符串
String errorJson = JSONUtil.toJsonStr(result);
+ // 调用内部的out方法，将生成的JSON字符串输出到HTTP响应中
out(response, errorJson);
}
+ /**
+ * 根据异常枚举生成错误结果的 JSON 字符串并输出到 HTTP 响应中
+ *
+ * @param response HTTP 响应对象
+ * @param exceptionEnum 异常枚举
+ */
public static void exceptionEnumOut(HttpServletResponse response, ExceptionEnum exceptionEnum) {
+ // 根据异常枚举创建错误结果对象，并使用Hutool的JSONUtil将其转换为JSON字符串
String errorJson = JSONUtil.toJsonStr(Result.error(exceptionEnum));
+ // 调用内部的out方法，将生成的JSON字符串输出到HTTP响应中
out(response, errorJson);
}
+ /**
+ * 将 JSON 字符串输出到 HTTP 响应中
+ *
+ * @param response HTTP 响应对象
+ * @param errorJson 要输出的 JSON 字符串
+ */
private static void out(HttpServletResponse response, String errorJson) {
+ // 设置HTTP响应的状态码为200，表示请求成功
response.setStatus(200);
+ // 设置HTTP响应的内容类型为JSON格式，字符编码为UTF-8
response.setContentType("application/json;charset=UTF-8");
+ // 添加HTTP响应头，指定内容类型和字符编码
response.addHeader("Content-Type", "application/json;charset=utf-8");
try {
+ // 获取HTTP响应的输出流，并将JSON字符串写入输出流
response.getWriter().write(errorJson);
+ // 刷新响应缓冲区，确保数据发送到客户端
response.flushBuffer();
} catch (IOException e) {
+ // 如果在写入数据过程中发生异常，记录警告日志并打印异常堆栈信息
log.warn("Write data failed.", e);
}
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/util/SendEmailUtil.java b/server/src/main/java/com/ew/gerocomium/common/util/SendEmailUtil.java
index cbabe63..61f6f1a 100644
--- a/server/src/main/java/com/ew/gerocomium/common/util/SendEmailUtil.java
+++ b/server/src/main/java/com/ew/gerocomium/common/util/SendEmailUtil.java
@@ -1,37 +1,54 @@
+// 声明该类所在的包，用于存放项目中的工具类
package com.ew.gerocomium.common.util;
+// 导入自定义的常量类，用于获取邮件发送相关的常量配置
import com.ew.gerocomium.common.constant.Constant;
+// 导入Apache Commons Email库中的EmailException异常类，用于处理邮件发送过程中可能出现的异常
import org.apache.commons.mail.EmailException;
+// 导入Apache Commons Email库中的HtmlEmail类，用于发送HTML格式的邮件
import org.apache.commons.mail.HtmlEmail;
+// 导入Java标准库中的Arrays类，用于处理数组相关操作
import java.util.Arrays;
+// 导入Java标准库中的List接口，用于表示列表类型
import java.util.List;
+// 定义一个名为SendEmailUtil的工具类，用于实现邮件发送功能
public class SendEmailUtil {
+ /**
+ * 向指定的邮箱列表发送邮件
+ *
+ * @param emailList 接收邮件的邮箱列表
+ * @param content 邮件的内容
+ */
public static void sendEmail(List emailList, String content) {
+ // 遍历邮箱列表，为每个邮箱单独发送邮件
for (String email : emailList) {
try {
+ // 创建一个HtmlEmail对象，用于发送HTML格式的邮件
HtmlEmail htmlEmail = new HtmlEmail();
- // 配置发送邮箱的host
+ // 配置发送邮箱的SMTP服务器主机名，从常量类中获取
htmlEmail.setHostName(Constant.MAIL_HOST);
- // 配置发送邮箱和邮箱授权码
+ // 配置发送邮箱的认证信息，包括邮箱地址和授权码，从常量类中获取
htmlEmail.setAuthentication(Constant.MAIL, Constant.PASS);
- // 配置发送方
+ // 配置邮件的发送方邮箱地址，从常量类中获取
htmlEmail.setFrom(Constant.MAIL);
- // 配置接收人
+ // 配置邮件的接收方邮箱地址，即当前遍历到的邮箱
htmlEmail.addTo(email);
- // 配置邮箱主题
+ // 配置邮件的主题，从常量类中获取
htmlEmail.setSubject(Constant.SUBJECT);
- // 配置编码格式
+ // 配置邮件的字符编码格式为UTF-8，防止中文乱码
htmlEmail.setCharset("UTF-8");
- // 设置发送的消息
+ // 设置邮件要发送的消息内容
htmlEmail.setMsg(content);
- // 发送
+ // 调用send方法发送邮件，并获取发送结果
String send = htmlEmail.send();
+ // 打印邮件发送结果
System.out.println(send);
} catch (EmailException e) {
+ // 如果在邮件发送过程中出现异常，打印异常堆栈信息
e.printStackTrace();
}
}
}
-}
+}
\ No newline at end of file
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/AccountController.java b/server/src/main/java/com/ew/gerocomium/controller/AccountController.java
index 8c3a83c..73cf229 100644
--- a/server/src/main/java/com/ew/gerocomium/controller/AccountController.java
+++ b/server/src/main/java/com/ew/gerocomium/controller/AccountController.java
@@ -1,54 +1,136 @@
+// 声明该类所在的包名，用于组织代码结构
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.EditQuery;
import com.ew.gerocomium.dao.query.ForgetQuery;
import com.ew.gerocomium.dao.query.LoginQuery;
import com.ew.gerocomium.dao.query.SendCodeQuery;
+// 导入账号管理业务逻辑的服务接口
import com.ew.gerocomium.service.AccountService;
+// 导入 Swagger 相关注解，用于生成接口文档，方便前后端开发人员进行对接
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
+// 导入 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 注解，定义该控制器的基础请求路径为 /account，所有该控制器下的接口请求路径都会以 /account 开头
@RequestMapping("/account")
public class AccountController {
+
+ // 使用 @Resource 注解进行依赖注入，将 AccountService 接口的实现类实例注入到当前控制器中
@Resource
private AccountService accountService;
+ /**
+ * 处理用户登录请求的方法。
+ *
+ * @param loginQuery 包含用户登录信息的请求参数对象，如用户名、密码等。
+ * @return 包含登录操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 使用 @PostMapping 注解，指定该方法处理 HTTP POST 请求，请求路径为 /account/login
@PostMapping("/login")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该接口的功能为“登录”，并添加备注信息，备注信息包含开发者信息
@ApiOperation(value = "登录", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result login(@ApiParam(value = "登录请求参数", required = true) @RequestBody LoginQuery loginQuery) {
+ public Result login(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数为“登录请求参数”，并标记为必需参数
+ // 使用 @RequestBody 注解，将 HTTP 请求体中的 JSON 数据映射到 LoginQuery 对象中
+ @ApiParam(value = "登录请求参数", required = true) @RequestBody LoginQuery loginQuery) {
+ // 调用 AccountService 中的 login 方法处理登录逻辑，并将 LoginQuery 对象作为参数传入
+ // 返回处理结果，结果会被封装在 Result 对象中
return accountService.login(loginQuery);
}
+ /**
+ * 处理发送验证码请求的方法。
+ *
+ * @param sendCodeQuery 包含发送验证码相关信息的请求参数对象，如手机号或邮箱等。
+ * @return 包含发送验证码操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 使用 @GetMapping 注解，指定该方法处理 HTTP GET 请求，请求路径为 /account/sendCode
@GetMapping("/sendCode")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该接口的功能为“发送验证码”，并添加备注信息
@ApiOperation(value = "发送验证码", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result sendCode(@ApiParam(value = "发送验证码请求参数", required = true) SendCodeQuery sendCodeQuery) {
+ public Result sendCode(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数为“发送验证码请求参数”，并标记为必需参数
+ @ApiParam(value = "发送验证码请求参数", required = true) SendCodeQuery sendCodeQuery) {
+ // 调用 AccountService 中的 sendCode 方法处理发送验证码逻辑，并将 SendCodeQuery 对象作为参数传入
+ // 返回处理结果，结果会被封装在 Result 对象中
return accountService.sendCode(sendCodeQuery);
}
+ /**
+ * 处理用户忘记密码请求的方法。
+ *
+ * @param forgetQuery 包含忘记密码相关信息的请求参数对象，如手机号、验证码、新密码等。
+ * @return 包含忘记密码操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 使用 @PutMapping 注解，指定该方法处理 HTTP PUT 请求，请求路径为 /account/forget
@PutMapping("/forget")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该接口的功能为“忘记密码”，并添加备注信息
@ApiOperation(value = "忘记密码", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result forget(@ApiParam(value = "忘记密码请求参数", required = true) @RequestBody ForgetQuery forgetQuery) {
+ public Result forget(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数为“忘记密码请求参数”，并标记为必需参数
+ // 使用 @RequestBody 注解，将 HTTP 请求体中的 JSON 数据映射到 ForgetQuery 对象中
+ @ApiParam(value = "忘记密码请求参数", required = true) @RequestBody ForgetQuery forgetQuery) {
+ // 调用 AccountService 中的 forget 方法处理忘记密码逻辑，并将 ForgetQuery 对象作为参数传入
+ // 返回处理结果，结果会被封装在 Result 对象中
return accountService.forget(forgetQuery);
}
+ /**
+ * 处理用户修改密码请求的方法。
+ *
+ * @param editQuery 包含修改密码相关信息的请求参数对象，如旧密码、新密码等。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有登录用户才能修改密码。
+ * @return 包含修改密码操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 使用 @PutMapping 注解，指定该方法处理 HTTP PUT 请求，请求路径为 /account/edit
@PutMapping("/edit")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该接口的功能为“修改密码”，并添加备注信息
@ApiOperation(value = "修改密码", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result edit(@ApiParam(value = "忘记密码请求参数", required = true) @RequestBody EditQuery editQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result edit(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数为“忘记密码请求参数”，这里描述有误，应是“修改密码请求参数”
+ // 使用 @RequestBody 注解，将 HTTP 请求体中的 JSON 数据映射到 EditQuery 对象中
+ @ApiParam(value = "忘记密码请求参数", required = true) @RequestBody EditQuery editQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数为“接口访问请求头”，并标记为必需参数
+ // 使用 @RequestHeader 注解，从 HTTP 请求头中获取名为 token 的值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 AccountService 中的 edit 方法处理修改密码逻辑，并将 EditQuery 对象作为参数传入
+ // 返回处理结果，结果会被封装在 Result 对象中
return accountService.edit(editQuery);
}
+ /**
+ * 处理用户登出请求的方法。
+ *
+ * @param token 接口访问请求头中的令牌，用于身份验证，确认当前登录用户进行登出操作。
+ * @return 包含登出操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 使用 @DeleteMapping 注解，指定该方法处理 HTTP DELETE 请求，请求路径为 /account/logout
@DeleteMapping("/logout")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该接口的功能为“登出”，并添加备注信息
@ApiOperation(value = "登出", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result logout(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result logout(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数为“接口访问请求头”，并标记为必需参数
+ // 使用 @RequestHeader 注解，从 HTTP 请求头中获取名为 token 的值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 AccountService 中的 logout 方法处理登出逻辑
+ // 返回处理结果，结果会被封装在 Result 对象中
return accountService.logout();
}
-}
+}
\ 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/BedPanoramaController.java b/server/src/main/java/com/ew/gerocomium/controller/BedPanoramaController.java
index eb3fc6d..0c7958e 100644
--- a/server/src/main/java/com/ew/gerocomium/controller/BedPanoramaController.java
+++ b/server/src/main/java/com/ew/gerocomium/controller/BedPanoramaController.java
@@ -1,43 +1,104 @@
+// 声明该类所在的包名，用于组织代码结构
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.ListRoomByKeyQuery;
+// 导入床位全景业务逻辑的服务接口
import com.ew.gerocomium.service.BedPanoramaService;
+// 导入 Swagger 相关注解，用于生成详细的 API 文档，方便前后端开发人员理解和使用接口
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
+// 这里的 org.apache.ibatis.annotations.Param 注解未在代码中实际使用，属于无用导入
import org.apache.ibatis.annotations.Param;
+// 导入 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 注解，定义该控制器的基础请求路径为 /bedPanorama，后续该控制器下的所有请求路径都以 /bedPanorama 开头
@RequestMapping("/bedPanorama")
+// 使用 Spring Security 的 @PreAuthorize 注解进行权限控制，只有拥有 '/check-in/bed' 权限的用户才能访问该控制器的方法
@PreAuthorize("@AuthorityAssert.hasAuthority('/check-in/bed')")
public class BedPanoramaController {
+
+ // 使用 @Resource 注解进行依赖注入，将 BedPanoramaService 接口的实现类实例注入到当前控制器中
@Resource
private BedPanoramaService bedPanoramaService;
+ /**
+ * 获取楼栋列表的方法。
+ *
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含获取楼栋列表操作结果的 Result 对象，封装了操作是否成功以及获取到的楼栋列表数据等信息。
+ */
+ // 使用 @GetMapping 注解，指定该方法处理 HTTP GET 请求，请求路径为 /bedPanorama/listBuilding
@GetMapping("/listBuilding")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该接口的功能为“获取楼栋列表”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "获取楼栋列表", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result listBuilding(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result listBuilding(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数为“接口访问请求头”，并标记为必需参数
+ // 使用 @RequestHeader 注解，从 HTTP 请求头中获取名为 token 的值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 BedPanoramaService 中的 listBuilding 方法处理获取楼栋列表的逻辑
+ // 返回处理结果，结果会被封装在 Result 对象中
return bedPanoramaService.listBuilding();
}
+ /**
+ * 根据楼栋 ID 获取楼层列表的方法。
+ *
+ * @param buildingId 要获取楼层列表的楼栋 ID（参数可为空，但根据业务逻辑可能需要提供有效的 ID）。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含获取楼层列表操作结果的 Result 对象，封装了操作是否成功以及获取到的楼层列表数据等信息。
+ */
+ // 使用 @GetMapping 注解，指定该方法处理 HTTP GET 请求，请求路径为 /bedPanorama/listFloorByBuildingId
@GetMapping("/listFloorByBuildingId")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该接口的功能为“获取楼层列表”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "获取楼层列表", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result listFloorByBuildingId(@ApiParam(value = "获取楼层列表请求参数", required = false) Long buildingId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result listFloorByBuildingId(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数为“获取楼层列表请求参数”，并标记为非必需参数
+ @ApiParam(value = "获取楼层列表请求参数", required = false) Long buildingId,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数为“接口访问请求头”，并标记为必需参数
+ // 使用 @RequestHeader 注解，从 HTTP 请求头中获取名为 token 的值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 BedPanoramaService 中的 listFloorByBuildingId 方法处理根据楼栋 ID 获取楼层列表的逻辑，并传入 buildingId 参数
+ // 返回处理结果，结果会被封装在 Result 对象中
return bedPanoramaService.listFloorByBuildingId(buildingId);
}
+ /**
+ * 根据特定条件获取房间列表的方法。
+ *
+ * @param listRoomByKeyQuery 包含获取房间列表所需条件的请求实体（例如房间的一些属性条件等）。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含获取房间列表操作结果的 Result 对象，封装了操作是否成功以及获取到的房间列表数据等信息。
+ */
+ // 使用 @GetMapping 注解，指定该方法处理 HTTP GET 请求，请求路径为 /bedPanorama/listRoomByKey
@GetMapping("/listRoomByKey")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该接口的功能为“获取房间列表”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "获取房间列表", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result listRoomByKey(@ApiParam(value = "获取房间列表请求实体", required = true) ListRoomByKeyQuery listRoomByKeyQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result listRoomByKey(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数为“获取房间列表请求实体”，并标记为必需参数
+ @ApiParam(value = "获取房间列表请求实体", required = true) ListRoomByKeyQuery listRoomByKeyQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数为“接口访问请求头”，并标记为必需参数
+ // 使用 @RequestHeader 注解，从 HTTP 请求头中获取名为 token 的值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 BedPanoramaService 中的 listRoomByKey 方法处理根据条件获取房间列表的逻辑，并传入 listRoomByKeyQuery 参数
+ // 返回处理结果，结果会被封装在 Result 对象中
return bedPanoramaService.listRoomByKey(listRoomByKeyQuery);
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/controller/BuildController.java b/server/src/main/java/com/ew/gerocomium/controller/BuildController.java
index 03fa696..e9d7301 100644
--- a/server/src/main/java/com/ew/gerocomium/controller/BuildController.java
+++ b/server/src/main/java/com/ew/gerocomium/controller/BuildController.java
@@ -1,139 +1,444 @@
+// 声明该类所属的包，用于组织和管理 Java 类，这里表明该类位于 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.*;
+// 导入楼栋管理相关的服务类，控制器通过调用该服务类的方法来实现具体的业务逻辑
import com.ew.gerocomium.service.BuildService;
+// 导入 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 Web 相关的注解，用于处理 HTTP 请求和响应
import org.springframework.web.bind.annotation.*;
-
+// 导入资源注入注解，用于将 Spring 容器中的 Bean 注入到当前类中
import javax.annotation.Resource;
+/**
+ * 楼栋管理控制器类，用于处理与楼栋、楼层、房间以及床位相关的管理操作请求。
+ */
+// 使用 Swagger 注解，标记该控制器在 API 文档中的标签为“楼栋管理”，方便分类展示
@Api(tags = "楼栋管理")
+// 标记该类为 RESTful 风格的控制器，会自动将方法的返回值转换为 JSON 等格式响应给客户端
@RestController
+// 定义该控制器处理的请求的基础路径为 /build，后续该控制器内的方法的请求路径都将以此为前缀
@RequestMapping("/build")
+// 权限控制注解，只有拥有 /base/check-in/building 权限的用户才能访问该控制器中的方法
@PreAuthorize("@AuthorityAssert.hasAuthority('/base/check-in/building')")
public class BuildController {
+
+ // 通过依赖注入的方式，将 BuildService 的实例注入到该控制器中，以便调用其业务方法
@Resource
private BuildService buildService;
+ /**
+ * 获取楼栋-楼层-房间树的方法。
+ *
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含获取楼栋-楼层-房间树操作结果的 Result 对象，封装了操作是否成功以及获取到的树状结构数据等信息。
+ */
+ // 处理 HTTP GET 请求，路径为 /build/getNoBedTree，用于获取楼栋-楼层-房间树
@GetMapping("/getNoBedTree")
+ // 使用 Swagger 注解，描述该接口的功能为“获取楼栋-楼层-房间树”，并注明开发者信息
@ApiOperation(value = "获取楼栋-楼层-房间树", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result getNoBedTreeAndPageBedByKey(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result getNoBedTreeAndPageBedByKey(
+ // 使用 Swagger 注解，标记该参数为接口访问请求头，且为必填参数
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取名为 token 的参数，用于身份验证
+ @RequestHeader String token) {
+ // 调用 buildService 的 getNoBedTreeAndPageBedByKey 方法获取楼栋-楼层-房间树，并返回结果
return buildService.getNoBedTreeAndPageBedByKey();
}
+ /**
+ * 分页查询床位的方法。
+ *
+ * @param pageBedByKeyQuery 分页查询床位的请求实体，包含查询条件（如床位状态、房间编号等）和分页信息（如页码、每页数量等）。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含分页查询床位操作结果的 Result 对象，封装了操作是否成功以及查询到的床位数据列表等信息。
+ */
+ // 处理 HTTP GET 请求，路径为 /build/pageBedByKey，用于分页查询床位
@GetMapping("/pageBedByKey")
+ // 使用 Swagger 注解，描述该接口的功能为“分页查询床位”，并注明开发者信息
@ApiOperation(value = "分页查询床位", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result pageBedByKey(@ApiParam(value = "分页查询床位请求实体", required = true) PageBedByKeyQuery pageBedByKeyQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result pageBedByKey(
+ // 使用 Swagger 注解，标记该参数为分页查询床位请求实体，且为必填参数
+ @ApiParam(value = "分页查询床位请求实体", required = true)
+ // 接收分页查询床位的请求实体对象
+ PageBedByKeyQuery pageBedByKeyQuery,
+ // 使用 Swagger 注解，标记该参数为接口访问请求头，且为必填参数
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取名为 token 的参数，用于身份验证
+ @RequestHeader String token) {
+ // 调用 buildService 的 pageBedByKey 方法进行分页查询床位，并返回结果
return buildService.pageBedByKey(pageBedByKeyQuery);
}
+ /**
+ * 新增楼栋的方法。
+ *
+ * @param operateBuildingQuery 新增楼栋的请求实体，包含要新增的楼栋的详细信息，如楼栋名称、描述等。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含新增楼栋操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 处理 HTTP POST 请求，路径为 /build/addBuilding，用于新增楼栋
@PostMapping("/addBuilding")
+ // 使用 Swagger 注解，描述该接口的功能为“新增楼栋”，并注明开发者信息
@ApiOperation(value = "新增楼栋", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result addBuilding(@ApiParam(value = "新增楼栋请求实体", required = true) @RequestBody OperateBuildingQuery operateBuildingQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result addBuilding(
+ // 使用 Swagger 注解，标记该参数为新增楼栋请求实体，且为必填参数
+ @ApiParam(value = "新增楼栋请求实体", required = true)
+ // 接收新增楼栋的请求实体对象，从请求体中获取数据
+ @RequestBody OperateBuildingQuery operateBuildingQuery,
+ // 使用 Swagger 注解，标记该参数为接口访问请求头，且为必填参数
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取名为 token 的参数，用于身份验证
+ @RequestHeader String token) {
+ // 调用 buildService 的 addBuilding 方法新增楼栋，并返回结果
return buildService.addBuilding(operateBuildingQuery);
}
+ /**
+ * 根据编号获取楼栋的方法。
+ *
+ * @param buildingId 要获取的楼栋的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含根据编号获取楼栋操作结果的 Result 对象，封装了操作是否成功以及获取到的楼栋详细信息等。
+ */
+ // 处理 HTTP GET 请求，路径为 /build/getBuildingById，用于根据编号获取楼栋
@GetMapping("/getBuildingById")
+ // 使用 Swagger 注解，描述该接口的功能为“根据编号获取楼栋”，并注明开发者信息
@ApiOperation(value = "根据编号获取楼栋", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result getBuildingById(@ApiParam(value = "根据编号获取楼栋请求参数", required = true) @RequestParam Long buildingId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result getBuildingById(
+ // 使用 Swagger 注解，标记该参数为根据编号获取楼栋请求参数，且为必填参数
+ @ApiParam(value = "根据编号获取楼栋请求参数", required = true)
+ // 接收要获取的楼栋的编号参数
+ @RequestParam Long buildingId,
+ // 使用 Swagger 注解，标记该参数为接口访问请求头，且为必填参数
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取名为 token 的参数，用于身份验证
+ @RequestHeader String token) {
+ // 调用 buildService 的 getBuildingById 方法根据编号获取楼栋，并返回结果
return buildService.getBuildingById(buildingId);
}
+ /**
+ * 编辑楼栋的方法。
+ *
+ * @param operateBuildingQuery 编辑楼栋的请求实体，包含要修改的楼栋的详细信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含编辑楼栋操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 处理 HTTP PUT 请求，路径为 /build/editBuilding，用于编辑楼栋
@PutMapping("/editBuilding")
+ // 使用 Swagger 注解，描述该接口的功能为“编辑楼栋”，并注明开发者信息
@ApiOperation(value = "编辑楼栋", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result editBuilding(@ApiParam(value = "编辑楼栋请求实体", required = true) @RequestBody OperateBuildingQuery operateBuildingQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result editBuilding(
+ // 使用 Swagger 注解，标记该参数为编辑楼栋请求实体，且为必填参数
+ @ApiParam(value = "编辑楼栋请求实体", required = true)
+ // 接收编辑楼栋的请求实体对象，从请求体中获取数据
+ @RequestBody OperateBuildingQuery operateBuildingQuery,
+ // 使用 Swagger 注解，标记该参数为接口访问请求头，且为必填参数
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取名为 token 的参数，用于身份验证
+ @RequestHeader String token) {
+ // 调用 buildService 的 editBuilding 方法编辑楼栋，并返回结果
return buildService.editBuilding(operateBuildingQuery);
}
+ /**
+ * 新增楼层的方法。
+ *
+ * @param operateFloorQuery 新增楼层的请求实体，包含要新增的楼层的详细信息，如楼层编号、楼层名称等。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含新增楼层操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 处理 HTTP POST 请求，路径为 /build/addFloor，用于新增楼层
@PostMapping("/addFloor")
+ // 使用 Swagger 注解，描述该接口的功能为“新增楼层”，并注明开发者信息
@ApiOperation(value = "新增楼层", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result addFloor(@ApiParam(value = "新增楼层请求实体", required = true) @RequestBody OperateFloorQuery operateFloorQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result addFloor(
+ // 使用 Swagger 注解，标记该参数为新增楼层请求实体，且为必填参数
+ @ApiParam(value = "新增楼层请求实体", required = true)
+ // 接收新增楼层的请求实体对象，从请求体中获取数据
+ @RequestBody OperateFloorQuery operateFloorQuery,
+ // 使用 Swagger 注解，标记该参数为接口访问请求头，且为必填参数
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取名为 token 的参数，用于身份验证
+ @RequestHeader String token) {
+ // 调用 buildService 的 addFloor 方法新增楼层，并返回结果
return buildService.addFloor(operateFloorQuery);
}
+ /**
+ * 根据编号获取楼层的方法。
+ *
+ * @param floorId 要获取的楼层的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含根据编号获取楼层操作结果的 Result 对象，封装了操作是否成功以及获取到的楼层详细信息等。
+ */
+ // 处理 HTTP GET 请求，路径为 /build/getFloorById，用于根据编号获取楼层
@GetMapping("/getFloorById")
+ // 使用 Swagger 注解，描述该接口的功能为“根据编号获取楼层”，并注明开发者信息
@ApiOperation(value = "根据编号获取楼层", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result getFloorById(@ApiParam(value = "根据编号获取楼层请求参数", required = true) @RequestParam Long floorId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result getFloorById(
+ // 使用 Swagger 注解，标记该参数为根据编号获取楼层请求参数，且为必填参数
+ @ApiParam(value = "根据编号获取楼层请求参数", required = true)
+ // 接收要获取的楼层的编号参数
+ @RequestParam Long floorId,
+ // 使用 Swagger 注解，标记该参数为接口访问请求头，且为必填参数
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取名为 token 的参数，用于身份验证
+ @RequestHeader String token) {
+ // 调用 buildService 的 getFloorById 方法根据编号获取楼层，并返回结果
return buildService.getFloorById(floorId);
}
+ /**
+ * 编辑楼层的方法。
+ *
+ * @param operateFloorQuery 编辑楼层的请求实体，包含要修改的楼层的详细信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含编辑楼层操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 处理 HTTP PUT 请求，路径为 /build/editFloor，用于编辑楼层
@PutMapping("/editFloor")
+ // 使用 Swagger 注解，描述该接口的功能为“编辑楼层”，并注明开发者信息
@ApiOperation(value = "编辑楼层", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result editFloor(@ApiParam(value = "编辑楼层请求实体", required = true) @RequestBody OperateFloorQuery operateFloorQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result editFloor(
+ // 使用 Swagger 注解，标记该参数为编辑楼层请求实体，且为必填参数
+ @ApiParam(value = "编辑楼层请求实体", required = true)
+ // 接收编辑楼层的请求实体对象，从请求体中获取数据
+ @RequestBody OperateFloorQuery operateFloorQuery,
+ // 使用 Swagger 注解，标记该参数为接口访问请求头，且为必填参数
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取名为 token 的参数，用于身份验证
+ @RequestHeader String token) {
+ // 调用 buildService 的 editFloor 方法编辑楼层，并返回结果
return buildService.editFloor(operateFloorQuery);
}
+ /**
+ * 获取房间类型列表的方法。
+ *
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含获取房间类型列表操作结果的 Result 对象，封装了操作是否成功以及获取到的房间类型列表数据等信息。
+ */
+ // 处理 HTTP GET 请求，路径为 /build/listRoomType，用于获取房间类型列表
@GetMapping("/listRoomType")
+ // 使用 Swagger 注解，描述该接口的功能为“获取房间类型列表”，并注明开发者信息
@ApiOperation(value = "获取房间类型列表", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result listRoomType(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result listRoomType(
+ // 使用 Swagger 注解，标记该参数为接口访问请求头，且为必填参数
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取名为 token 的参数，用于身份验证
+ @RequestHeader String token) {
+ // 调用 buildService 的 listRoomType 方法获取房间类型列表，并返回结果
return buildService.listRoomType();
}
+ /**
+ * 新增房间的方法。
+ *
+ * @param operateRoomQuery 新增房间的请求实体，包含要新增的房间的详细信息，如房间编号、房间类型等。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含新增房间操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 处理 HTTP POST 请求，路径为 /build/addRoom，用于新增房间
@PostMapping("/addRoom")
+ // 使用 Swagger 注解，描述该接口的功能为“新增房间”，并注明开发者信息
@ApiOperation(value = "新增房间", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result addRoom(@ApiParam(value = "新增房间请求实体", required = true) @RequestBody OperateRoomQuery operateRoomQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result addRoom(
+ // 使用 Swagger 注解，标记该参数为新增房间请求实体，且为必填参数
+ @ApiParam(value = "新增房间请求实体", required = true)
+ // 接收新增房间的请求实体对象，从请求体中获取数据
+ @RequestBody OperateRoomQuery operateRoomQuery,
+ // 使用 Swagger 注解，标记该参数为接口访问请求头，且为必填参数
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取名为 token 的参数，用于身份验证
+ @RequestHeader String token) {
+ // 调用 buildService 的 addRoom 方法新增房间，并返回结果
return buildService.addRoom(operateRoomQuery);
}
+ /**
+ * 根据编号获取房间的方法。
+ *
+ * @param roomId 要获取的房间的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含根据编号获取房间操作结果的 Result 对象，封装了操作是否成功以及获取到的房间详细信息等。
+ */
+ // 处理 HTTP GET 请求，请求路径为 /build/getRoomById，用于根据房间编号获取房间信息
@GetMapping("/getRoomById")
+// 使用 Swagger 注解，描述该接口的功能为“根据编号获取房间”，并在注释中添加开发者信息
@ApiOperation(value = "根据编号获取房间", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result getRoomById(@ApiParam(value = "根据编号获取房间请求参数", required = true) @RequestParam Long roomId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+// 定义一个公开的方法，返回类型为 Result，用于封装操作结果
+ public Result getRoomById(
+ // 使用 Swagger 注解，描述该参数为根据编号获取房间的请求参数，且为必填项
+ @ApiParam(value = "根据编号获取房间请求参数", required = true)
+ // 从请求的参数中获取名为 roomId 的参数，类型为 Long
+ @RequestParam Long roomId,
+ // 使用 Swagger 注解，描述该参数为接口访问请求头，且为必填项
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取名为 token 的参数，用于身份验证
+ @RequestHeader String token) {
+ // 调用 BuildService 类中的 getRoomById 方法，传入房间编号，获取房间信息
return buildService.getRoomById(roomId);
}
+ /**
+ * 编辑房间的方法。
+ *
+ * @param operateRoomQuery 编辑房间的请求实体，包含要修改的房间的详细信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含编辑房间操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+// 处理 HTTP PUT 请求，请求路径为 /build/editRoom，用于编辑房间信息
@PutMapping("/editRoom")
+// 使用 Swagger 注解，描述该接口的功能为“编辑房间”，并在注释中添加开发者信息
@ApiOperation(value = "编辑房间", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result editRoom(@ApiParam(value = "编辑房间请求实体", required = true) @RequestBody OperateRoomQuery operateRoomQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+// 定义一个公开的方法，返回类型为 Result，用于封装操作结果
+ public Result editRoom(
+ // 使用 Swagger 注解，描述该参数为编辑房间的请求实体，且为必填项
+ @ApiParam(value = "编辑房间请求实体", required = true)
+ // 从请求体中获取 OperateRoomQuery 类型的对象，包含要编辑的房间信息
+ @RequestBody OperateRoomQuery operateRoomQuery,
+ // 使用 Swagger 注解，描述该参数为接口访问请求头，且为必填项
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取名为 token 的参数，用于身份验证
+ @RequestHeader String token) {
+ // 调用 BuildService 类中的 editRoom 方法，传入要编辑的房间信息，执行编辑操作
return buildService.editRoom(operateRoomQuery);
}
+ /**
+ * 删除节点（可能是楼栋、楼层或房间等节点）的方法。
+ *
+ * @param deleteNodeQuery 删除节点的请求实体，包含要删除的节点的相关信息，如节点编号等。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含删除节点操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+// 处理 HTTP DELETE 请求，请求路径为 /build/deleteNode，用于删除节点信息
@DeleteMapping("/deleteNode")
+// 使用 Swagger 注解，描述该接口的功能为“删除节点”，并在注释中添加开发者信息
@ApiOperation(value = "删除节点", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result deleteNode(@ApiParam(value = "删除节点请求实体", required = true) DeleteNodeQuery deleteNodeQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+// 定义一个公开的方法，返回类型为 Result，用于封装操作结果
+ public Result deleteNode(
+ // 使用 Swagger 注解，描述该参数为删除节点的请求实体，且为必填项
+ @ApiParam(value = "删除节点请求实体", required = true)
+ // 接收 DeleteNodeQuery 类型的对象，包含要删除的节点信息
+ DeleteNodeQuery deleteNodeQuery,
+ // 使用 Swagger 注解，描述该参数为接口访问请求头，且为必填项
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取名为 token 的参数，用于身份验证
+ @RequestHeader String token) {
+ // 调用 BuildService 类中的 deleteNode 方法，传入要删除的节点信息，执行删除操作
return buildService.deleteNode(deleteNodeQuery);
}
+ /**
+ * 新增床位的方法。
+ *
+ * @param operateBedQuery 新增床位的请求实体，包含要新增的床位的详细信息，如床位编号、所属房间等。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含新增床位操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+// 处理 HTTP POST 请求，请求路径为 /build/addBed，用于新增床位信息
@PostMapping("/addBed")
+// 使用 Swagger 注解，描述该接口的功能为“新增床位”，并在注释中添加开发者信息
@ApiOperation(value = "新增床位", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result addBed(@ApiParam(value = "新增床位请求实体", required = true) @RequestBody OperateBedQuery operateBedQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+// 定义一个公开的方法，返回类型为 Result，用于封装操作结果
+ public Result addBed(
+ // 使用 Swagger 注解，描述该参数为新增床位的请求实体，且为必填项
+ @ApiParam(value = "新增床位请求实体", required = true)
+ // 从请求体中获取 OperateBedQuery 类型的对象，包含要新增的床位信息
+ @RequestBody OperateBedQuery operateBedQuery,
+ // 使用 Swagger 注解，描述该参数为接口访问请求头，且为必填项
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取名为 token 的参数，用于身份验证
+ @RequestHeader String token) {
+ // 调用 BuildService 类中的 addBed 方法，传入要新增的床位信息，执行新增操作
return buildService.addBed(operateBedQuery);
}
+ /**
+ * 根据编号获取床位的方法。
+ *
+ * @param bedId 要获取的床位的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含根据编号获取床位操作结果的 Result 对象，封装了操作是否成功以及获取到的床位详细信息等。
+ */
+// 处理 HTTP GET 请求，请求路径为 /build/getBedById，用于根据床位编号获取床位信息
@GetMapping("/getBedById")
+// 使用 Swagger 注解，描述该接口的功能为“根据编号获取床位”，并在注释中添加开发者信息
@ApiOperation(value = "根据编号获取床位", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result getBedById(@ApiParam(value = "根据编号获取床位请求参数", required = true) @RequestParam Long bedId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+// 定义一个公开的方法，返回类型为 Result，用于封装操作结果
+ public Result getBedById(
+ // 使用 Swagger 注解，描述该参数为根据编号获取床位的请求参数，且为必填项
+ @ApiParam(value = "根据编号获取床位请求参数", required = true)
+ // 从请求的参数中获取名为 bedId 的参数，类型为 Long
+ @RequestParam Long bedId,
+ // 使用 Swagger 注解，描述该参数为接口访问请求头，且为必填项
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取名为 token 的参数，用于身份验证
+ @RequestHeader String token) {
+ // 调用 BuildService 类中的 getBedById 方法，传入床位编号，获取床位信息
return buildService.getBedById(bedId);
}
+ /**
+ * 编辑床位的方法。
+ *
+ * @param operateBedQuery 编辑床位的请求实体，包含要修改的床位的详细信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含编辑床位操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+// 处理 HTTP PUT 请求，请求路径为 /build/editBed，用于编辑床位信息
@PutMapping("/editBed")
+// 使用 Swagger 注解，描述该接口的功能为“编辑床位”，并在注释中添加开发者信息
@ApiOperation(value = "编辑床位", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result editBed(@ApiParam(value = "编辑床位请求实体", required = true) @RequestBody OperateBedQuery operateBedQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+// 定义一个公开的方法，返回类型为 Result，用于封装操作结果
+ public Result editBed(
+ // 使用 Swagger 注解，描述该参数为编辑床位的请求实体，且为必填项
+ @ApiParam(value = "编辑床位请求实体", required = true)
+ // 从请求体中获取 OperateBedQuery 类型的对象，包含要编辑的床位信息
+ @RequestBody OperateBedQuery operateBedQuery,
+ // 使用 Swagger 注解，描述该参数为接口访问请求头，且为必填项
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取名为 token 的参数，用于身份验证
+ @RequestHeader String token) {
+ // 调用 BuildService 类中的 editBed 方法，传入要编辑的床位信息，执行编辑操作
return buildService.editBed(operateBedQuery);
}
+ /**
+ * 删除床位的方法。
+ *
+ * @param bedId 要删除的床位的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含删除床位操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+// 处理 HTTP DELETE 请求，请求路径为 /build/deleteBed，用于删除床位信息
@DeleteMapping("/deleteBed")
+// 使用 Swagger 注解，描述该接口的功能为“删除床位”，并在注释中添加开发者信息
@ApiOperation(value = "删除床位", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result deleteBed(@ApiParam(value = "删除床位请求参数", required = true) @RequestParam Long bedId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+// 定义一个公开的方法，返回类型为 Result，用于封装操作结果
+ public Result deleteBed(
+ // 使用 Swagger 注解，描述该参数为删除床位的请求参数，且为必填项
+ @ApiParam(value = "删除床位请求参数", required = true)
+ // 从请求的参数中获取名为 bedId 的参数，类型为 Long
+ @RequestParam Long bedId,
+ // 使用 Swagger 注解，描述该参数为接口访问请求头，且为必填项
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取名为 token 的参数，用于身份验证
+ @RequestHeader String token) {
+ // 调用 BuildService 类中的 deleteBed 方法，传入要删除的床位编号，执行删除操作
return buildService.deleteBed(bedId);
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/controller/CateringSetController.java b/server/src/main/java/com/ew/gerocomium/controller/CateringSetController.java
index e38a9b2..bf1bc40 100644
--- a/server/src/main/java/com/ew/gerocomium/controller/CateringSetController.java
+++ b/server/src/main/java/com/ew/gerocomium/controller/CateringSetController.java
@@ -1,76 +1,216 @@
+// 声明该类所在的包路径
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.OperateCateringSetQuery;
+// 导入按关键字分页查询餐饮套餐的查询类，封装查询条件和分页信息
import com.ew.gerocomium.dao.query.PageCateringSetByKeyQuery;
+// 导入按关键字分页查询菜品的查询类，封装查询条件和分页信息
import com.ew.gerocomium.dao.query.PageDishesByKeyQuery;
+// 导入餐饮套餐服务类，控制器会调用该类的方法处理餐饮套餐相关业务
import com.ew.gerocomium.service.CateringSetService;
+// 导入菜品服务类，控制器会调用该类的方法处理菜品相关业务
import com.ew.gerocomium.service.DishesService;
+// 导入 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 容器中的 Bean 注入到当前类
import javax.annotation.Resource;
+/**
+ * 餐饮套餐控制器类，用于处理与餐饮套餐和菜品相关的操作请求，如查询、新增、编辑、删除等。
+ */
+// 使用 Swagger 注解，为该控制器添加标签，方便在 API 文档中分类展示
@Api(tags = "餐饮套餐")
+// 标记该类为 RESTful 风格的控制器，会自动将返回值转换为 JSON 格式
@RestController
+// 定义该控制器处理的请求的基础路径，所有请求路径都会以 /cateringSet 开头
@RequestMapping("/cateringSet")
+// 权限控制注解，只有拥有 /food/list 权限的用户才能访问该控制器的接口
@PreAuthorize("@AuthorityAssert.hasAuthority('/food/list')")
public class CateringSetController {
+
+ // 注入餐饮套餐服务类的实例，通过该实例调用餐饮套餐相关的业务方法
@Resource
private CateringSetService cateringSetService;
+ // 注入菜品服务类的实例，通过该实例调用菜品相关的业务方法
@Resource
private DishesService dishesService;
+ /**
+ * 分页查询餐饮套餐的方法。
+ *
+ * @param pageCateringSetByKeyQuery 分页查询餐饮套餐的请求实体，包含查询条件（如套餐名称、价格范围等）和分页信息（如页码、每页数量等）。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含分页查询餐饮套餐操作结果的 Result 对象，封装了操作是否成功以及查询到的餐饮套餐数据列表等信息。
+ */
+ // 处理 HTTP GET 请求，请求路径为 /cateringSet/pageCateringSetByKey
@GetMapping("/pageCateringSetByKey")
+ // 使用 Swagger 注解，描述该接口的功能和开发者信息
@ApiOperation(value = "分页查询餐饮套餐", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result pageCateringSetByKey(@ApiParam(value = "分页查询餐饮套餐请求实体", required = true) PageCateringSetByKeyQuery pageCateringSetByKeyQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result pageCateringSetByKey(
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "分页查询餐饮套餐请求实体", required = true)
+ // 接收分页查询餐饮套餐的请求实体
+ PageCateringSetByKeyQuery pageCateringSetByKeyQuery,
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌，用于身份验证
+ @RequestHeader String token) {
+ // 调用餐饮套餐服务类的分页查询方法，并返回结果
return cateringSetService.pageCateringSetByKey(pageCateringSetByKeyQuery);
}
+ /**
+ * 获取菜品分类的方法。
+ *
+ * @param dishesTypeName 可选的菜品分类名称参数，用于筛选特定分类（可为空，获取所有分类）。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含获取菜品分类操作结果的 Result 对象，封装了操作是否成功以及获取到的菜品分类数据等信息。
+ */
+ // 处理 HTTP GET 请求，请求路径为 /cateringSet/listDishesType
@GetMapping("/listDishesType")
+ // 使用 Swagger 注解，描述该接口的功能和开发者信息
@ApiOperation(value = "获取菜品分类", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result listDishesType(@ApiParam(value = "获取菜品分类请求参数", required = false) String dishesTypeName,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result listDishesType(
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "获取菜品分类请求参数", required = false)
+ // 接收可选的菜品分类名称参数
+ String dishesTypeName,
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌，用于身份验证
+ @RequestHeader String token) {
+ // 调用菜品服务类的获取菜品分类方法，并返回结果
return dishesService.listDishesType(dishesTypeName);
}
+ /**
+ * 分页查询菜品的方法。
+ *
+ * @param pageDishesByKeyQuery 分页查询菜品的请求实体，包含查询条件（如菜品名称、所属分类等）和分页信息（如页码、每页数量等）。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含分页查询菜品操作结果的 Result 对象，封装了操作是否成功以及查询到的菜品数据列表等信息。
+ */
+ // 处理 HTTP GET 请求，请求路径为 /cateringSet/pageDishesByKey
@GetMapping("/pageDishesByKey")
+ // 使用 Swagger 注解，描述该接口的功能和开发者信息
@ApiOperation(value = "分页查询菜品", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result pageDishesByKey(@ApiParam(value = "分页查询菜品请求实体", required = true) PageDishesByKeyQuery pageDishesByKeyQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result pageDishesByKey(
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "分页查询菜品请求实体", required = true)
+ // 接收分页查询菜品的请求实体
+ PageDishesByKeyQuery pageDishesByKeyQuery,
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌，用于身份验证
+ @RequestHeader String token) {
+ // 调用菜品服务类的分页查询菜品方法，并返回结果
return dishesService.pageDishesByKey(pageDishesByKeyQuery);
}
+ /**
+ * 新增餐饮套餐的方法。
+ *
+ * @param operateCateringSetQuery 新增餐饮套餐的请求实体，包含要新增的餐饮套餐的详细信息，如套餐名称、包含菜品、价格等。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含新增餐饮套餐操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 处理 HTTP POST 请求，请求路径为 /cateringSet/addCateringSet
@PostMapping("/addCateringSet")
+ // 使用 Swagger 注解，描述该接口的功能和开发者信息
@ApiOperation(value = "新增餐饮套餐", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result addCateringSet(@ApiParam(value = "新增餐饮套餐请求实体", required = true) @RequestBody OperateCateringSetQuery operateCateringSetQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result addCateringSet(
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "新增餐饮套餐请求实体", required = true)
+ // 接收新增餐饮套餐的请求实体，从请求体中获取数据
+ @RequestBody OperateCateringSetQuery operateCateringSetQuery,
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌，用于身份验证
+ @RequestHeader String token) {
+ // 调用餐饮套餐服务类的新增餐饮套餐方法，并返回结果
return cateringSetService.addCateringSet(operateCateringSetQuery);
}
+ /**
+ * 根据编号查询餐饮套餐的方法。
+ *
+ * @param setId 要查询的餐饮套餐的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含根据编号查询餐饮套餐操作结果的 Result 对象，封装了操作是否成功以及查询到的餐饮套餐详细信息等。
+ */
+ // 处理 HTTP GET 请求，请求路径为 /cateringSet/getCateringSetById
@GetMapping("/getCateringSetById")
+ // 使用 Swagger 注解，描述该接口的功能和开发者信息
@ApiOperation(value = "根据编号查询餐饮套餐", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result getCateringSetById(@ApiParam(value = "根据编号查询餐饮套餐请求参数", required = true) @RequestParam Long setId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result getCateringSetById(
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "根据编号查询餐饮套餐请求参数", required = true)
+ // 接收要查询的餐饮套餐编号
+ @RequestParam Long setId,
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌，用于身份验证
+ @RequestHeader String token) {
+ // 调用餐饮套餐服务类的根据编号查询餐饮套餐方法，并返回结果
return cateringSetService.getCateringSetById(setId);
}
+ /**
+ * 编辑餐饮套餐的方法。
+ *
+ * @param operateCateringSetQuery 编辑餐饮套餐的请求实体，包含要修改的餐饮套餐的详细信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含编辑餐饮套餐操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 处理 HTTP PUT 请求，请求路径为 /cateringSet/editCateringSet
@PutMapping("/editCateringSet")
+ // 使用 Swagger 注解，描述该接口的功能和开发者信息
@ApiOperation(value = "编辑餐饮套餐", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result editCateringSet(@ApiParam(value = "编辑餐饮套餐请求实体", required = true) @RequestBody OperateCateringSetQuery operateCateringSetQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result editCateringSet(
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "编辑餐饮套餐请求实体", required = true)
+ // 接收编辑餐饮套餐的请求实体，从请求体中获取数据
+ @RequestBody OperateCateringSetQuery operateCateringSetQuery,
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌，用于身份验证
+ @RequestHeader String token) {
+ // 调用餐饮套餐服务类的编辑餐饮套餐方法，并返回结果
return cateringSetService.editCateringSet(operateCateringSetQuery);
}
+ /**
+ * 删除餐饮套餐的方法。
+ *
+ * @param setId 要删除的餐饮套餐的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含删除餐饮套餐操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 处理 HTTP DELETE 请求，请求路径为 /cateringSet/deleteCateringSet
@DeleteMapping("/deleteCateringSet")
+ // 使用 Swagger 注解，描述该接口的功能和开发者信息
@ApiOperation(value = "删除餐饮套餐", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result deleteCateringSet(@ApiParam(value = "删除餐饮套餐请求参数", required = true) @RequestParam Long setId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result deleteCateringSet(
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "删除餐饮套餐请求参数", required = true)
+ // 接收要删除的餐饮套餐编号
+ @RequestParam Long setId,
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌，用于身份验证
+ @RequestHeader String token) {
+ // 调用餐饮套餐服务类的删除餐饮套餐方法，并返回结果
return cateringSetService.deleteCateringSet(setId);
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/controller/CheckContractController.java b/server/src/main/java/com/ew/gerocomium/controller/CheckContractController.java
index c7bb3f6..4bef5bf 100644
--- a/server/src/main/java/com/ew/gerocomium/controller/CheckContractController.java
+++ b/server/src/main/java/com/ew/gerocomium/controller/CheckContractController.java
@@ -1,115 +1,355 @@
+// 声明该类所在的包路径
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 容器中的 Bean 注入到当前类中
import javax.annotation.Resource;
+/**
+ * 入住签约控制器类，负责处理与入住签约相关的各种操作请求。
+ * 涵盖了入住签约信息的查询、新增、编辑和删除等操作，
+ * 同时还提供了护理等级、餐饮套餐、楼栋、床位以及营销人员等相关信息的获取接口。
+ */
+// 使用 Swagger 注解，标记该控制器的标签为“入住签约”，方便在生成 API 文档时进行分类展示
@Api(tags = "入住签约")
+// 标记该类为 RESTful 风格的控制器，用于处理 HTTP 请求并返回 JSON 等格式的响应
@RestController
+// 定义该控制器的基础请求路径为 /checkContract，该控制器下的所有请求都以此为前缀
@RequestMapping("/checkContract")
+// 权限控制注解，只有拥有指定权限（/check-in/enter）的用户才能访问该控制器的方法
@PreAuthorize("@AuthorityAssert.hasAuthority('/check-in/enter')")
public class CheckContractController {
+
+ // 注入入住签约相关的业务逻辑服务类，通过依赖注入的方式获取 CheckContractService 的实例
@Resource
private CheckContractService checkContractService;
+ // 注入护理等级相关的业务逻辑服务类，通过依赖注入的方式获取 NurseGradeService 的实例
@Resource
private NurseGradeService nurseGradeService;
+ // 注入餐饮套餐相关的业务逻辑服务类，通过依赖注入的方式获取 CateringSetService 的实例
@Resource
private CateringSetService cateringSetService;
+ // 注入咨询（可能与营销人员相关）相关的业务逻辑服务类，通过依赖注入的方式获取 ConsultService 的实例
@Resource
private ConsultService consultService;
+ /**
+ * 分页查询入住签约信息的方法。
+ * 该方法接收分页查询的请求参数和请求头中的令牌，调用服务层方法进行查询，并返回查询结果。
+ *
+ * @param pageCheckContractByKeyQuery 分页查询入住签约的请求实体，包含查询条件（如签约时间、老人姓名等）和分页信息（如页码、每页数量等）。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含分页查询入住签约操作结果的 Result 对象，封装了操作是否成功以及查询到的入住签约数据列表等信息。
+ */
+ // 定义该方法处理 HTTP GET 请求，请求路径为 /checkContract/pageCheckContractByKey
@GetMapping("/pageCheckContractByKey")
+ // 使用 Swagger 注解，描述该接口的功能和开发者信息
@ApiOperation(value = "分页查询入住签约", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result pageCheckContractByKey(@ApiParam(value = "分页查询入住签约请求实体", required = true) PageCheckContractByKeyQuery pageCheckContractByKeyQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result pageCheckContractByKey(
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "分页查询入住签约请求实体", required = true)
+ // 接收分页查询请求实体，作为查询参数
+ PageCheckContractByKeyQuery pageCheckContractByKeyQuery,
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌，用于身份验证
+ @RequestHeader String token) {
+ // 调用 checkContractService 的 pageCheckContractByKey 方法进行分页查询入住签约操作，并返回结果
return checkContractService.pageCheckContractByKey(pageCheckContractByKeyQuery);
}
+ /**
+ * 分页搜索老人信息的方法。
+ * 该方法接收分页搜索的请求参数和请求头中的令牌，调用服务层方法进行搜索，并返回搜索结果。
+ *
+ * @param pageSearchElderByKeyQuery 分页搜索老人的请求实体，包含搜索条件（如老人姓名、身份证号等）和分页信息（如页码、每页数量等）。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含分页搜索老人操作结果的 Result 对象，封装了操作是否成功以及搜索到的老人数据列表等信息。
+ */
+ // 定义该方法处理 HTTP GET 请求，请求路径为 /checkContract/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) {
+ // 调用 checkContractService 的 pageSearchElderByKey 方法进行分页搜索老人操作，并返回结果
return checkContractService.pageSearchElderByKey(pageSearchElderByKeyQuery);
}
+ /**
+ * 获取护理等级列表的方法。
+ * 该方法接收请求头中的令牌，调用服务层方法获取护理等级列表，并返回结果。
+ *
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含获取护理等级列表操作结果的 Result 对象，封装了操作是否成功以及获取到的护理等级数据列表等信息。
+ */
+ // 定义该方法处理 HTTP GET 请求，请求路径为 /checkContract/listNurseGrade
@GetMapping("/listNurseGrade")
+ // 使用 Swagger 注解，描述该接口的功能和开发者信息
@ApiOperation(value = "获取护理等级列表", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result listNurseGrade(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result listNurseGrade(
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌，用于身份验证
+ @RequestHeader String token) {
+ // 调用 checkContractService 的 listNurseGrade 方法获取护理等级列表，并返回结果
return checkContractService.listNurseGrade();
}
+ /**
+ * 根据编号查询护理等级信息的方法。
+ * 该方法接收护理等级编号和请求头中的令牌，调用服务层方法进行查询，并返回查询结果。
+ *
+ * @param nurseGradeId 要查询的护理等级的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含根据编号查询护理等级操作结果的 Result 对象，封装了操作是否成功以及查询到的护理等级详细信息等。
+ */
+ // 定义该方法处理 HTTP GET 请求，请求路径为 /checkContract/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) {
+ // 调用 nurseGradeService 的 getNurseGradeById 方法根据编号查询护理等级信息，并返回结果
return nurseGradeService.getNurseGradeById(nurseGradeId);
}
+ /**
+ * 获取餐饮套餐列表的方法。
+ * 该方法接收请求头中的令牌，调用服务层方法获取餐饮套餐列表，并返回结果。
+ *
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含获取餐饮套餐列表操作结果的 Result 对象，封装了操作是否成功以及获取到的餐饮套餐数据列表等信息。
+ */
+ // 定义该方法处理 HTTP GET 请求，请求路径为 /checkContract/listCateringSet
@GetMapping("/listCateringSet")
+ // 使用 Swagger 注解，描述该接口的功能和开发者信息
@ApiOperation(value = "获取餐饮套餐列表", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result listCateringSet(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result listCateringSet(
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌，用于身份验证
+ @RequestHeader String token) {
+ // 调用 checkContractService 的 listCateringSet 方法获取餐饮套餐列表，并返回结果
return checkContractService.listCateringSet();
}
+ /**
+ * 根据编号查询餐饮套餐信息的方法。
+ * 该方法接收餐饮套餐编号和请求头中的令牌，调用服务层方法进行查询，并返回查询结果。
+ *
+ * @param cateringSetId 要查询的餐饮套餐的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含根据编号查询餐饮套餐操作结果的 Result 对象，封装了操作是否成功以及查询到的餐饮套餐详细信息等。
+ */
+ // 定义该方法处理 HTTP GET 请求，请求路径为 /checkContract/getCateringSetById
@GetMapping("/getCateringSetById")
+ // 使用 Swagger 注解，描述该接口的功能和开发者信息
@ApiOperation(value = "根据编号查询餐饮套餐", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result getCateringSetById(@ApiParam(value = "根据编号查询餐饮套餐请求参数", required = true) @RequestParam Long cateringSetId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result getCateringSetById(
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "根据编号查询餐饮套餐请求参数", required = true)
+ // 接收餐饮套餐编号，作为查询参数
+ @RequestParam Long cateringSetId,
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌，用于身份验证
+ @RequestHeader String token) {
+ // 调用 cateringSetService 的 getCateringSetById 方法根据编号查询餐饮套餐信息，并返回结果
return cateringSetService.getCateringSetById(cateringSetId);
}
+ /**
+ * 获取楼栋树信息的方法。
+ * 该方法接收请求头中的令牌，调用服务层方法获取楼栋树信息，并返回结果。
+ *
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含获取楼栋树操作结果的 Result 对象，封装了操作是否成功以及获取到的楼栋树结构数据等信息。
+ */
+ // 定义该方法处理 HTTP GET 请求，请求路径为 /checkContract/getBuildTree
@GetMapping("/getBuildTree")
+ // 使用 Swagger 注解，描述该接口的功能和开发者信息
@ApiOperation(value = "获取楼栋树", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result getBuildTree(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result getBuildTree(
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌，用于身份验证
+ @RequestHeader String token) {
+ // 调用 checkContractService 的 getBuildTree 方法获取楼栋树信息，并返回结果
return checkContractService.getBuildTree();
}
+ /**
+ * 根据编号查询床位信息的方法。
+ * 该方法接收床位编号和请求头中的令牌，调用服务层方法进行查询，并返回查询结果。
+ *
+ * @param bedId 要查询的床位的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含根据编号查询床位操作结果的 Result 对象，封装了操作是否成功以及查询到的床位详细信息等。
+ */
+ // 定义该方法处理 HTTP GET 请求，请求路径为 /checkContract/getBedById
@GetMapping("/getBedById")
+ // 使用 Swagger 注解，描述该接口的功能和开发者信息
@ApiOperation(value = "根据编号查询床位", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result getBedById(@ApiParam(value = "根据编号查询床位请求参数", required = true) @RequestParam Long bedId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result getBedById(
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "根据编号查询床位请求参数", required = true)
+ // 接收床位编号，作为查询参数
+ @RequestParam Long bedId,
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌，用于身份验证
+ @RequestHeader String token) {
+ // 调用 checkContractService 的 getBedById 方法根据编号查询床位信息，并返回结果
return checkContractService.getBedById(bedId);
}
+ /**
+ * 获取营销人员列表的方法。
+ * 该方法接收请求头中的令牌，调用服务层方法获取营销人员列表，并返回结果。
+ *
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含获取营销人员操作结果的 Result 对象，封装了操作是否成功以及获取到的营销人员数据列表等信息。
+ */
+ // 定义该方法处理 HTTP GET 请求，请求路径为 /checkContract/listReserveStaff
@GetMapping("/listReserveStaff")
+ // 使用 Swagger 注解，描述该接口的功能和开发者信息
@ApiOperation(value = "获取营销人员", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result listReserveStaff(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result listReserveStaff(
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌，用于身份验证
+ @RequestHeader String token) {
+ // 调用 consultService 的 listConsultStaff 方法获取营销人员列表，并返回结果
return consultService.listConsultStaff();
}
+ /**
+ * 新增入住签约信息的方法。
+ * 该方法接收新增入住签约的请求实体和请求头中的令牌，调用服务层方法进行新增操作，并返回操作结果。
+ *
+ * @param operateCheckContractQuery 新增入住签约的请求实体，包含要新增的入住签约的详细信息，如老人信息、签约时间、所选护理等级等。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含新增入住签约操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 定义该方法处理 HTTP POST 请求，请求路径为 /checkContract/addCheckContract
@PostMapping("/addCheckContract")
+ // 使用 Swagger 注解，描述该接口的功能和开发者信息
@ApiOperation(value = "新增入住签约", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result addCheckContract(@ApiParam(value = "新增入住签约请求实体", required = true) @RequestBody OperateCheckContractQuery operateCheckContractQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result addCheckContract(
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "新增入住签约请求实体", required = true)
+ // 接收新增入住签约请求实体，作为新增数据
+ @RequestBody OperateCheckContractQuery operateCheckContractQuery,
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌，用于身份验证
+ @RequestHeader String token) {
+ // 调用 checkContractService 的 addCheckContract 方法新增入住签约信息，并返回结果
return checkContractService.addCheckContract(operateCheckContractQuery);
}
+ /**
+ * 根据老人编号查询入住签约信息的方法。
+ * 该方法接收老人编号和请求头中的令牌，调用服务层方法进行查询，并返回查询结果。
+ *
+ * @param elderId 要查询的老人的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含根据老人编号查询入住签约操作结果的 Result 对象，封装了操作是否成功以及查询到的入住签约详细信息等。
+ */
+ // 定义该方法处理 HTTP GET 请求，请求路径为 /checkContract/getCheckContractById
@GetMapping("/getCheckContractById")
+ // 使用 Swagger 注解，描述该接口的功能和开发者信息
@ApiOperation(value = "根据老人编号查询入住签约", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result getCheckContractById(@ApiParam(value = "根据老人编号查询入住签约请求参数", required = true) @RequestParam Long elderId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result getCheckContractById(
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "根据老人编号查询入住签约请求参数", required = true)
+ // 接收老人编号，作为查询参数
+ @RequestParam Long elderId,
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌，用于身份验证
+ @RequestHeader String token) {
+ // 调用 checkContractService 的 getCheckContractById 方法根据老人编号查询入住签约信息，并返回结果
return checkContractService.getCheckContractById(elderId);
}
+ /**
+ * 编辑入住签约信息的方法。
+ * 该方法接收编辑入住签约的请求实体和请求头中的令牌，调用服务层方法进行编辑操作，并返回操作结果。
+ *
+ * @param operateCheckContractQuery 编辑入住签约的请求实体，包含要修改的入住签约的详细信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含编辑入住签约操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 定义该方法处理 HTTP PUT 请求，请求路径为 /checkContract/editCheckContract
@PutMapping("/editCheckContract")
+ // 使用 Swagger 注解，描述该接口的功能和开发者信息
@ApiOperation(value = "编辑入住签约", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result editCheckContract(@ApiParam(value = "编辑入住签约请求实体", required = true) @RequestBody OperateCheckContractQuery operateCheckContractQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result editCheckContract(
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "编辑入住签约请求实体", required = true)
+ // 接收编辑入住签约请求实体，作为修改数据
+ @RequestBody OperateCheckContractQuery operateCheckContractQuery,
+ // 使用 Swagger 注解，描述该参数的作用和是否必填
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌，用于身份验证
+ @RequestHeader String token) {
+ // 调用 checkContractService 的 editCheckContract 方法编辑入住签约信息，并返回结果
return checkContractService.editCheckContract(operateCheckContractQuery);
}
+ /**
+ * 删除入住签约信息的方法。
+ * 该方法接收要删除的入住签约所关联的老人编号和请求头中的令牌，调用服务层方法进行删除操作，并返回操作结果。
+ *
+ * @param elderId 要删除的入住签约所关联的老人的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含删除入住签约操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 定义该方法处理 HTTP DELETE 请求，请求路径为 /checkContract/deleteCheckContract
@DeleteMapping("/deleteCheckContract")
+ // 使用 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) {
+ // 调用 checkContractService 的 deleteCheckContract 方法删除入住签约信息，并返回结果
return checkContractService.deleteCheckContract(elderId);
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/controller/ConsultController.java b/server/src/main/java/com/ew/gerocomium/controller/ConsultController.java
index c2fd675..b8567f3 100644
--- a/server/src/main/java/com/ew/gerocomium/controller/ConsultController.java
+++ b/server/src/main/java/com/ew/gerocomium/controller/ConsultController.java
@@ -1,78 +1,224 @@
+// 声明该类所在的包，此包为 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.GetConsultByConsultIdAndElderIdQuery;
+// 导入操作咨询的查询实体类，用于封装新增、编辑咨询时的请求数据
import com.ew.gerocomium.dao.query.OperateConsultQuery;
+// 导入分页查询咨询的查询实体类，用于封装分页查询咨询时的请求数据，含查询条件和分页信息
import com.ew.gerocomium.dao.query.PageConsultByKeyQuery;
+// 导入咨询业务逻辑服务类，用于处理咨询相关的具体业务逻辑
import com.ew.gerocomium.service.ConsultService;
+// 导入 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 文档时进行分类展示
@Api(tags = "咨询管理")
+// 标记该类为 RESTful 风格的控制器，用于处理 HTTP 请求并返回 JSON 等格式的响应
@RestController
+// 定义该控制器的基础请求路径为 /consult，该控制器下的所有请求都以此为前缀
@RequestMapping("/consult")
+// 权限控制注解，只有拥有指定权限（'/soles/counsel'）的用户才能访问该控制器的方法
@PreAuthorize("@AuthorityAssert.hasAuthority('/soles/counsel')")
public class ConsultController {
+ // 通过依赖注入的方式获取 ConsultService 的实例，用于调用该服务类的方法处理业务逻辑
@Resource
private ConsultService consultService;
+ /**
+ * 获取咨询来源渠道列表。
+ *
+ * @param token 接口访问请求头中的令牌，用于身份验证
+ * @return 包含咨询来源渠道列表的结果对象
+ */
+ // 处理 HTTP GET 请求，请求路径为 /consult/listConsultSource，用于获取咨询来源渠道列表
@GetMapping("/listConsultSource")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "来源渠道", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result listConsultSource(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result listConsultSource(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用咨询服务类的获取咨询来源渠道列表方法，并返回操作结果
return consultService.listConsultSource();
}
+ /**
+ * 获取咨询接待人员列表。
+ *
+ * @param token 接口访问请求头中的令牌，用于身份验证
+ * @return 包含咨询接待人员列表的结果对象
+ */
+ // 处理 HTTP GET 请求，请求路径为 /consult/listConsultStaff，用于获取咨询接待人员列表
@GetMapping("/listConsultStaff")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "接待人", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result listConsultStaff(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result listConsultStaff(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用咨询服务类的获取咨询接待人员列表方法，并返回操作结果
return consultService.listConsultStaff();
}
+ /**
+ * 分页查询咨询信息。
+ *
+ * @param pageConsultByKeyQuery 分页查询咨询的请求实体，包含查询条件和分页信息
+ * @param token 接口访问请求头中的令牌，用于身份验证
+ * @return 包含分页查询结果的结果对象
+ */
+ // 处理 HTTP GET 请求，请求路径为 /consult/pageConsultByKey，用于分页查询咨询信息
@GetMapping("/pageConsultByKey")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "分页查询咨询", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result pageConsultByKey(@ApiParam(value = "分页查询咨询请求实体", required = true) PageConsultByKeyQuery pageConsultByKeyQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result pageConsultByKey(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为分页查询咨询的请求实体
+ @ApiParam(value = "分页查询咨询请求实体", required = true)
+ // 接收分页查询咨询的请求实体
+ PageConsultByKeyQuery pageConsultByKeyQuery,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用咨询服务类的分页查询咨询方法，并返回操作结果
return consultService.pageConsultByKey(pageConsultByKeyQuery);
}
+ /**
+ * 新增咨询信息。
+ *
+ * @param operateConsultQuery 新增咨询的请求实体，包含咨询的详细信息
+ * @param token 接口访问请求头中的令牌，用于身份验证
+ * @return 包含新增操作结果的结果对象
+ */
+ // 处理 HTTP POST 请求，请求路径为 /consult/addConsult，用于新增咨询信息
@PostMapping("/addConsult")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "新增咨询", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result addConsult(@ApiParam(value = "新增咨询请求实体", required = true) @RequestBody OperateConsultQuery operateConsultQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result addConsult(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为新增咨询的请求实体
+ @ApiParam(value = "新增咨询请求实体", required = true)
+ // 从请求体中接收新增咨询的请求实体
+ @RequestBody OperateConsultQuery operateConsultQuery,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用咨询服务类的新增咨询方法，并返回操作结果
return consultService.addConsult(operateConsultQuery);
}
+ /**
+ * 根据咨询人编号和老人编号获取咨询信息。
+ *
+ * @param getConsultByConsultIdAndElderIdQuery 包含咨询人编号和老人编号的请求实体
+ * @param token 接口访问请求头中的令牌，用于身份验证
+ * @return 包含查询到的咨询信息的结果对象
+ */
+ // 处理 HTTP GET 请求，请求路径为 /consult/getConsultByConsultIdAndElderId，用于根据咨询人编号和老人编号获取咨询信息
@GetMapping("/getConsultByConsultIdAndElderId")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "根据咨询人编号和老人编号获取咨询信息", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result getConsultByConsultIdAndElderId(@ApiParam(value = "根据咨询人编号和老人编号获取咨询信息请求实体", required = true) GetConsultByConsultIdAndElderIdQuery getConsultByConsultIdAndElderIdQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result getConsultByConsultIdAndElderId(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为包含咨询人编号和老人编号的请求实体
+ @ApiParam(value = "根据咨询人编号和老人编号获取咨询信息请求实体", required = true)
+ // 接收包含咨询人编号和老人编号的请求实体
+ GetConsultByConsultIdAndElderIdQuery getConsultByConsultIdAndElderIdQuery,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用咨询服务类的根据咨询人编号和老人编号获取咨询信息方法，并返回操作结果
return consultService.getConsultByConsultIdAndElderId(getConsultByConsultIdAndElderIdQuery);
}
+ /**
+ * 编辑咨询信息。
+ *
+ * @param operateConsultQuery 编辑咨询的请求实体，包含要修改的咨询信息
+ * @param token 接口访问请求头中的令牌，用于身份验证
+ * @return 包含编辑操作结果的结果对象
+ */
+ // 处理 HTTP PUT 请求，请求路径为 /consult/editConsult，用于编辑咨询信息
@PutMapping("/editConsult")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "编辑咨询", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result editConsult(@ApiParam(value = "编辑咨询请求实体", required = true) @RequestBody OperateConsultQuery operateConsultQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result editConsult(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为编辑咨询的请求实体
+ @ApiParam(value = "编辑咨询请求实体", required = true)
+ // 从请求体中接收编辑咨询的请求实体
+ @RequestBody OperateConsultQuery operateConsultQuery,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用咨询服务类的编辑咨询方法，并返回操作结果
return consultService.editConsult(operateConsultQuery);
}
+ /**
+ * 删除咨询信息。
+ *
+ * @param elderId 要删除的咨询关联的老人编号
+ * @param token 接口访问请求头中的令牌，用于身份验证
+ * @return 包含删除操作结果的结果对象
+ */
+ // 处理 HTTP DELETE 请求，请求路径为 /consult/deleteConsult，用于删除咨询信息
@DeleteMapping("/deleteConsult")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "删除咨询", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result deleteConsult(@ApiParam(value = "删除咨询请求参数", required = true) @RequestParam Long elderId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result deleteConsult(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为要删除的咨询关联的老人编号
+ @ApiParam(value = "删除咨询请求参数", required = true)
+ // 从请求参数中获取老人编号
+ @RequestParam Long elderId,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用咨询服务类的删除咨询方法，并返回操作结果
return consultService.deleteConsult(elderId);
}
+ /**
+ * 将咨询客户转为意向客户。
+ *
+ * @param elderId 要转换的咨询关联的老人编号
+ * @param token 接口访问请求头中的令牌，用于身份验证
+ * @return 包含转换操作结果的结果对象
+ */
+ // 处理 HTTP PUT 请求，请求路径为 /consult/intentionConsult，用于将咨询客户转为意向客户
@PutMapping("/intentionConsult")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "转为意向客户", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result intentionConsult(@ApiParam(value = "转为意向客户请求参数", required = true) @RequestParam Long elderId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result intentionConsult(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为要转换的咨询关联的老人编号
+ @ApiParam(value = "转为意向客户请求参数", required = true)
+ // 从请求参数中获取老人编号
+ @RequestParam Long elderId,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用咨询服务类的将咨询客户转为意向客户方法，并返回操作结果
return consultService.intentionConsult(elderId);
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/controller/ConsumeController.java b/server/src/main/java/com/ew/gerocomium/controller/ConsumeController.java
index f5f3f22..9951c05 100644
--- a/server/src/main/java/com/ew/gerocomium/controller/ConsumeController.java
+++ b/server/src/main/java/com/ew/gerocomium/controller/ConsumeController.java
@@ -1,33 +1,67 @@
+// 声明该类所属的包，用于组织代码结构，标识该类在项目中的位置
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.PageConsumeByKeyQuery;
+// 导入分页查询预存充值的请求实体类（此处未使用，可能是多余导入）
import com.ew.gerocomium.dao.query.PageDepositRechargeByKeyQuery;
+// 导入消费业务逻辑的服务类，负责处理与消费相关的具体操作，如查询消费记录等
import com.ew.gerocomium.service.ConsumeService;
+// 导入 Swagger 的注解，用于生成 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 请求，定义请求映射和请求方法等
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
-
+// 导入 Spring 的注解，用于实现依赖注入，将所需的服务类实例注入到当前类中
import javax.annotation.Resource;
+/**
+ * 消费记录控制器，负责处理与消费记录相关的 HTTP 请求。
+ */
+// 使用 Swagger 的 @Api 注解，标记该控制器的功能模块为“消费记录”，方便在生成 API 文档时进行分类展示
@Api(tags = "消费记录")
+// 使用 Spring MVC 的 @RestController 注解，将该类标记为 RESTful 风格的控制器，用于处理 HTTP 请求并返回 JSON 等格式的响应
@RestController
+// 使用 Spring MVC 的 @RequestMapping 注解，定义该控制器处理的请求的基础路径为 /consume，该控制器下的所有接口路径都会基于此路径
@RequestMapping("/consume")
+// 使用 Spring Security 的 @PreAuthorize 注解，进行权限验证，只有拥有 /fee/record 权限的用户才能访问该控制器的接口，确保系统的安全性
@PreAuthorize("@AuthorityAssert.hasAuthority('/fee/record')")
public class ConsumeController {
+
+ // 使用 @Resource 注解，将 ConsumeService 类型的实例注入到当前类中，以便调用其方法处理消费相关业务逻辑
@Resource
private ConsumeService consumeService;
+ /**
+ * 分页查询消费记录。
+ *
+ * @param pageConsumeByKeyQuery 分页查询消费记录的请求实体，包含查询条件和分页信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证。
+ * @return 包含分页查询结果的结果对象。
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，处理 HTTP GET 请求，路径为 /consume/pageConsumeByKey
@GetMapping("/pageConsumeByKey")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“分页查询消费记录”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "分页查询消费记录", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result pageConsumeByKey(@ApiParam(value = "分页查询消费记录请求实体", required = true) PageConsumeByKeyQuery pageConsumeByKeyQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result pageConsumeByKey(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“分页查询消费记录请求实体”，并标记为必需参数
+ @ApiParam(value = "分页查询消费记录请求实体", required = true)
+ PageConsumeByKeyQuery pageConsumeByKeyQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 ConsumeService 的 pageConsumeByKey 方法，传入分页查询请求实体，执行分页查询消费记录的操作并返回结果
return consumeService.pageConsumeByKey(pageConsumeByKeyQuery);
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/controller/DepositRechargeController.java b/server/src/main/java/com/ew/gerocomium/controller/DepositRechargeController.java
index 507febc..bcc938e 100644
--- a/server/src/main/java/com/ew/gerocomium/controller/DepositRechargeController.java
+++ b/server/src/main/java/com/ew/gerocomium/controller/DepositRechargeController.java
@@ -1,46 +1,110 @@
+// 声明该类所属的包，用于组织代码结构，体现代码的模块划分
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.PageCheckContractByKeyQuery;
+// 导入分页查询预存充值的请求实体类，用于封装查询条件和分页信息
import com.ew.gerocomium.dao.query.PageDepositRechargeByKeyQuery;
+// 导入分页搜索老人的请求实体类，用于封装搜索条件和分页信息
import com.ew.gerocomium.dao.query.PageSearchElderByKeyQuery;
+// 导入入住老人账户充值的请求实体类，用于封装充值相关信息
import com.ew.gerocomium.dao.query.RechargeQuery;
+// 导入预存充值业务逻辑的服务类，负责处理预存充值相关的具体业务操作
import com.ew.gerocomium.service.DepositRechargeService;
+// 导入 Swagger 的注解，用于生成 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 请求，定义请求映射和请求方法等
import org.springframework.web.bind.annotation.*;
-
+// 导入 Spring 的注解，用于实现依赖注入，将所需的服务类实例注入到当前类中
import javax.annotation.Resource;
+/**
+ * 预存充值控制器类，用于处理与预存充值相关的各种操作请求，如分页查询预存充值记录、分页搜索老人以及入住老人账户充值等。
+ */
+// 使用 Swagger 的 @Api 注解，标记该控制器的标签为“预存充值”，方便在生成 API 文档时进行分类展示
@Api(tags = "预存充值")
+// 使用 Spring MVC 的 @RestController 注解，将该类标记为 RESTful 风格的控制器，用于处理 HTTP 请求并返回 JSON 等格式的响应
@RestController
+// 使用 Spring MVC 的 @RequestMapping 注解，定义该控制器的基础请求路径为 /depositRecharge，该控制器下的所有请求都以此为前缀
@RequestMapping("/depositRecharge")
+// 使用 Spring Security 的 @PreAuthorize 注解，进行权限控制，只有拥有指定权限（/fee/pay）的用户才能访问该控制器的方法
@PreAuthorize("@AuthorityAssert.hasAuthority('/fee/pay')")
public class DepositRechargeController {
+
+ // 使用 @Resource 注解，将 DepositRechargeService 类型的实例注入到当前类中，以便调用其方法处理预存充值相关业务逻辑
@Resource
private DepositRechargeService depositRechargeService;
+ /**
+ * 分页查询预存充值记录的方法。
+ *
+ * @param pageDepositRechargeByKeyQuery 分页查询预存充值的请求实体，包含查询条件（如充值时间、充值金额范围等）和分页信息（如页码、每页数量等）。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含分页查询预存充值记录操作结果的 Result 对象，封装了操作是否成功以及查询到的预存充值数据列表等信息。
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，处理 HTTP GET 请求，路径为 /depositRecharge/pageDepositRechargeByKey
@GetMapping("/pageDepositRechargeByKey")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“分页查询预存充值”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "分页查询预存充值", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result pageDepositRechargeByKey(@ApiParam(value = "分页查询预存充值请求实体", required = true) PageDepositRechargeByKeyQuery pageDepositRechargeByKeyQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result pageDepositRechargeByKey(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“分页查询预存充值请求实体”，并标记为必需参数
+ @ApiParam(value = "分页查询预存充值请求实体", required = true)
+ PageDepositRechargeByKeyQuery pageDepositRechargeByKeyQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 DepositRechargeService 的 pageDepositRechargeByKey 方法，传入分页查询请求实体，获取分页查询的预存充值记录信息并返回结果
return depositRechargeService.pageDepositRechargeByKey(pageDepositRechargeByKeyQuery);
}
+ /**
+ * 分页搜索老人的方法。
+ *
+ * @param pageSearchElderByKeyQuery 分页搜索老人的请求实体，包含搜索条件（如老人姓名、身份证号等）和分页信息（如页码、每页数量等）。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含分页搜索老人操作结果的 Result 对象，封装了操作是否成功以及搜索到的老人数据列表等信息。
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，处理 HTTP GET 请求，路径为 /depositRecharge/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 rechargeQuery 入住老人账户充值的请求实体，包含充值的详细信息，如老人编号、充值金额等。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含入住老人账户充值操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 使用 Spring MVC 的 @PutMapping 注解，处理 HTTP PUT 请求，路径为 /depositRecharge/recharge
@PutMapping("/recharge")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“入住老人账户充值”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "入住老人账户充值", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result recharge(@ApiParam(value = "入住老人账户充值请求实体", required = true) @RequestBody RechargeQuery rechargeQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result recharge(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“入住老人账户充值请求实体”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+ @ApiParam(value = "入住老人账户充值请求实体", required = true) @RequestBody
+ RechargeQuery rechargeQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 DepositRechargeService 的 recharge 方法，传入入住老人账户充值请求实体，执行充值操作并返回结果
return depositRechargeService.recharge(rechargeQuery);
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/controller/DishesController.java b/server/src/main/java/com/ew/gerocomium/controller/DishesController.java
index a5f8f17..effe626 100644
--- a/server/src/main/java/com/ew/gerocomium/controller/DishesController.java
+++ b/server/src/main/java/com/ew/gerocomium/controller/DishesController.java
@@ -1,94 +1,282 @@
+// 声明该类所在的包，此包为 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.OperateDishesQuery;
+// 导入操作菜品类型的查询实体类，用于封装新增、编辑菜品类型时的请求数据
import com.ew.gerocomium.dao.query.OperateDishesTypeQuery;
+// 导入分页查询菜品的查询实体类，用于封装分页查询菜品时的请求数据，含查询条件和分页信息
import com.ew.gerocomium.dao.query.PageDishesByKeyQuery;
+// 导入菜品业务逻辑服务类，用于处理菜品相关的具体业务逻辑
import com.ew.gerocomium.service.DishesService;
+// 导入 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 文档时进行分类展示
@Api(tags = "菜品管理")
+// 标记该类为 RESTful 风格的控制器，用于处理 HTTP 请求并返回 JSON 等格式的响应
@RestController
+// 定义该控制器的基础请求路径为 /dishes，该控制器下的所有请求都以此为前缀
@RequestMapping("/dishes")
+// 权限控制注解，只有拥有指定权限（'/food/dish'）的用户才能访问该控制器的方法
@PreAuthorize("@AuthorityAssert.hasAuthority('/food/dish')")
public class DishesController {
+ // 通过依赖注入的方式获取 DishesService 的实例，用于调用该服务类的方法处理业务逻辑
@Resource
private DishesService dishesService;
+ /**
+ * 获取菜品分类列表。
+ *
+ * @param dishesTypeName 可选的菜品分类名称，用于筛选特定名称的分类，可为空。
+ * @param token 接口访问请求头中的令牌，用于身份验证。
+ * @return 包含菜品分类列表的结果对象。
+ */
+ // 处理 HTTP GET 请求，请求路径为 /dishes/listDishesType，用于获取菜品分类列表
@GetMapping("/listDishesType")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "获取菜品分类", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result listDishesType(@ApiParam(value = "获取菜品分类请求参数", required = false) String dishesTypeName,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result listDishesType(
+ // 使用 Swagger 注解描述该参数的作用，该参数为可选的菜品分类名称，用于筛选特定名称的分类
+ @ApiParam(value = "获取菜品分类请求参数", required = false)
+ // 接收菜品分类名称参数
+ String dishesTypeName,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用菜品服务类的获取菜品分类列表方法，并返回操作结果
return dishesService.listDishesType(dishesTypeName);
}
+ /**
+ * 分页查询菜品信息。
+ *
+ * @param pageDishesByKeyQuery 分页查询菜品的请求实体，包含查询条件和分页信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证。
+ * @return 包含分页查询结果的结果对象。
+ */
+ // 处理 HTTP GET 请求，请求路径为 /dishes/pageDishesByKey，用于分页查询菜品信息
@GetMapping("/pageDishesByKey")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "分页查询菜品", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result pageDishesByKey(@ApiParam(value = "分页查询菜品请求实体", required = true) PageDishesByKeyQuery pageDishesByKeyQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result pageDishesByKey(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为分页查询菜品的请求实体
+ @ApiParam(value = "分页查询菜品请求实体", required = true)
+ // 接收分页查询菜品的请求实体
+ PageDishesByKeyQuery pageDishesByKeyQuery,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用菜品服务类的分页查询菜品方法，并返回操作结果
return dishesService.pageDishesByKey(pageDishesByKeyQuery);
}
+ /**
+ * 新增菜品分类。
+ *
+ * @param operateDishesTypeQuery 新增菜品分类的请求实体，包含菜品分类的详细信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证。
+ * @return 包含新增操作结果的结果对象。
+ */
+ // 处理 HTTP POST 请求，请求路径为 /dishes/addDishesType，用于新增菜品分类
@PostMapping("/addDishesType")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "新增菜品分类", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result addDishesType(@ApiParam(value = "新增菜品分类请求实体", required = true) @RequestBody OperateDishesTypeQuery operateDishesTypeQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result addDishesType(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为新增菜品分类的请求实体
+ @ApiParam(value = "新增菜品分类请求实体", required = true)
+ // 从请求体中接收新增菜品分类的请求实体
+ @RequestBody OperateDishesTypeQuery operateDishesTypeQuery,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用菜品服务类的新增菜品分类方法，并返回操作结果
return dishesService.addDishesType(operateDishesTypeQuery);
}
+ /**
+ * 根据编号查询菜品分类信息。
+ *
+ * @param dishesTypeId 要查询的菜品分类的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证。
+ * @return 包含查询到的菜品分类信息的结果对象。
+ */
+ // 处理 HTTP GET 请求，请求路径为 /dishes/getDishesTypeById，用于根据编号查询菜品分类信息
@GetMapping("/getDishesTypeById")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "根据编号查询菜品分类", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result getDishesTypeById(@ApiParam(value = "根据编号查询菜品分类请求参数", required = true) @RequestParam Long dishesTypeId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result getDishesTypeById(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为要查询的菜品分类的编号
+ @ApiParam(value = "根据编号查询菜品分类请求参数", required = true)
+ // 从请求参数中获取菜品分类编号
+ @RequestParam Long dishesTypeId,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用菜品服务类的根据编号查询菜品分类方法，并返回操作结果
return dishesService.getDishesTypeById(dishesTypeId);
}
+ /**
+ * 编辑菜品分类信息。
+ *
+ * @param operateDishesTypeQuery 编辑菜品分类的请求实体，包含要修改的菜品分类信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证。
+ * @return 包含编辑操作结果的结果对象。
+ */
+ // 处理 HTTP PUT 请求，请求路径为 /dishes/editDishesType，用于编辑菜品分类信息
@PutMapping("/editDishesType")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "编辑菜品分类", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result editDishesType(@ApiParam(value = "编辑菜品分类请求实体", required = true) @RequestBody OperateDishesTypeQuery operateDishesTypeQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result editDishesType(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为编辑菜品分类的请求实体
+ @ApiParam(value = "编辑菜品分类请求实体", required = true)
+ // 从请求体中接收编辑菜品分类的请求实体
+ @RequestBody OperateDishesTypeQuery operateDishesTypeQuery,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用菜品服务类的编辑菜品分类方法，并返回操作结果
return dishesService.editDishesType(operateDishesTypeQuery);
}
+ /**
+ * 删除菜品分类信息。
+ *
+ * @param dishesTypeId 要删除的菜品分类的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证。
+ * @return 包含删除操作结果的结果对象。
+ */
+ // 处理 HTTP DELETE 请求，请求路径为 /dishes/deleteDishesType，用于删除菜品分类信息
@DeleteMapping("/deleteDishesType")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "删除菜品分类", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result deleteDishesType(@ApiParam(value = "删除菜品分类请求参数", required = true) @RequestParam Long dishesTypeId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result deleteDishesType(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为要删除的菜品分类的编号
+ @ApiParam(value = "删除菜品分类请求参数", required = true)
+ // 从请求参数中获取菜品分类编号
+ @RequestParam Long dishesTypeId,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用菜品服务类的删除菜品分类方法，并返回操作结果
return dishesService.deleteDishesType(dishesTypeId);
}
+ /**
+ * 新增菜品信息。
+ *
+ * @param operateDishesQuery 新增菜品的请求实体，包含菜品的详细信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证。
+ * @return 包含新增操作结果的结果对象。
+ */
+ // 处理 HTTP POST 请求，请求路径为 /dishes/addDishes，用于新增菜品信息
@PostMapping("/addDishes")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "新增菜品", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result addDishes(@ApiParam(value = "新增菜品请求实体", required = true) @RequestBody OperateDishesQuery operateDishesQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result addDishes(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为新增菜品的请求实体
+ @ApiParam(value = "新增菜品请求实体", required = true)
+ // 从请求体中接收新增菜品的请求实体
+ @RequestBody OperateDishesQuery operateDishesQuery,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用菜品服务类的新增菜品方法，并返回操作结果
return dishesService.addDishes(operateDishesQuery);
}
+ /**
+ * 根据编号查询菜品信息。
+ *
+ * @param dishesId 要查询的菜品的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证。
+ * @return 包含查询到的菜品信息的结果对象。
+ */
+ // 处理 HTTP GET 请求，请求路径为 /dishes/getDishesById，用于根据编号查询菜品信息
@GetMapping("/getDishesById")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "根据编号查询菜品", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result getDishesById(@ApiParam(value = "根据编号查询菜品请求参数", required = true) @RequestParam Long dishesId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result getDishesById(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为要查询的菜品的编号
+ @ApiParam(value = "根据编号查询菜品请求参数", required = true)
+ // 从请求参数中获取菜品编号
+ @RequestParam Long dishesId,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用菜品服务类的根据编号查询菜品方法，并返回操作结果
return dishesService.getDishesById(dishesId);
}
+ /**
+ * 编辑菜品信息。
+ *
+ * @param operateDishesQuery 编辑菜品的请求实体，包含要修改的菜品信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证。
+ * @return 包含编辑操作结果的结果对象。
+ */
+ // 处理 HTTP PUT 请求，请求路径为 /dishes/editDishes，用于编辑菜品信息
@PutMapping("/editDishes")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "编辑菜品", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result editDishes(@ApiParam(value = "编辑菜品请求实体", required = true) @RequestBody OperateDishesQuery operateDishesQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result editDishes(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为编辑菜品的请求实体
+ @ApiParam(value = "编辑菜品请求实体", required = true)
+ // 从请求体中接收编辑菜品的请求实体
+ @RequestBody OperateDishesQuery operateDishesQuery,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用菜品服务类的编辑菜品方法，并返回操作结果
return dishesService.editDishes(operateDishesQuery);
}
+ /**
+ * 删除菜品信息。
+ *
+ * @param dishesId 要删除的菜品的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证。
+ * @return 包含删除操作结果的结果对象。
+ */
+ // 处理 HTTP DELETE 请求，请求路径为 /dishes/deleteDishes，用于删除菜品信息
@DeleteMapping("/deleteDishes")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "删除菜品", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result deleteDishes(@ApiParam(value = "删除菜品请求参数", required = true) @RequestParam Long dishesId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result deleteDishes(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为要删除的菜品的编号
+ @ApiParam(value = "删除菜品请求参数", required = true)
+ // 从请求参数中获取菜品编号
+ @RequestParam Long dishesId,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用菜品服务类的删除菜品方法，并返回操作结果
return dishesService.deleteDishes(dishesId);
}
-}
+}
\ 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/FileController.java b/server/src/main/java/com/ew/gerocomium/controller/FileController.java
index 453fb41..996cb0f 100644
--- a/server/src/main/java/com/ew/gerocomium/controller/FileController.java
+++ b/server/src/main/java/com/ew/gerocomium/controller/FileController.java
@@ -1,32 +1,75 @@
+// 声明该类所属的包，用于组织代码结构，标识该类在项目中的位置
package com.ew.gerocomium.controller;
+// 导入自定义的常量类，该类可能包含项目中通用的字符串常量等信息
import com.ew.gerocomium.common.constant.Constant;
+// 导入自定义的基础结果类，用于封装接口返回的结果，通常包含操作状态、消息和数据等
import com.ew.gerocomium.dao.base.Result;
+// 导入文件业务逻辑的服务类，负责处理与文件相关的具体操作，如文件上传等
import com.ew.gerocomium.service.FileService;
+// 导入 Swagger 的多个注解，用于生成 API 文档时对控制器、操作和参数进行描述
import io.swagger.annotations.*;
+// 导入 Spring MVC 的注解，用于处理 HTTP 请求，定义请求映射和请求方法等
import org.springframework.web.bind.annotation.*;
+// 导入用于处理文件上传的 MultipartFile 类，该类表示上传的文件
import org.springframework.web.multipart.MultipartFile;
-
+// 导入 Spring 的注解，用于实现依赖注入，将所需的服务类实例注入到当前类中
import javax.annotation.Resource;
+/**
+ * 文件上传控制器类，负责处理与文件上传相关的操作请求，包括图片上传和附件上传。
+ */
+// 使用 Swagger 的 @Api 注解，标记该控制器的功能模块为“文件上传”，方便在生成 API 文档时进行分类展示
@Api(tags = "文件上传")
+// 使用 Spring MVC 的 @RestController 注解，将该类标记为 RESTful 风格的控制器，用于处理 HTTP 请求并返回 JSON 等格式的响应
@RestController
+// 使用 Spring MVC 的 @RequestMapping 注解，定义该控制器处理的请求的基础路径为 /file，该控制器下的所有接口路径都会基于此路径
@RequestMapping("/file")
public class FileController {
+
+ // 使用 @Resource 注解，将 FileService 类型的实例注入到当前类中，以便调用其方法处理文件上传相关的业务逻辑
@Resource
private FileService fileService;
+ /**
+ * 单文件上传-图片的方法。
+ *
+ * @param file 要上传的图片文件，通过 @RequestBody 注解接收前端传递的 MultipartFile 对象。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含文件上传操作结果的 Result 对象，封装了操作是否成功以及可能的文件存储信息等。
+ */
+ // 使用 Spring MVC 的 @PostMapping 注解，处理 HTTP POST 请求，路径为 /file/uploadImg
@PostMapping("/uploadImg")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“单文件上传-图片”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "单文件上传-图片", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result uploadImg(@ApiParam(value = "图片文件", required = true) @RequestBody MultipartFile file,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result uploadImg(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“图片文件”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值（这里接收 MultipartFile 对象）
+ @ApiParam(value = "图片文件", required = true) @RequestBody
+ MultipartFile file,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 FileService 的 save 方法，传入要上传的文件和表示上传图片的常量，执行文件上传操作并返回结果
return fileService.save(file, Constant.STR_UPLOAD_IMG);
}
+ /**
+ * 单文件上传-附件的方法。
+ *
+ * @param file 要上传的附件文件，通过 @RequestBody 注解接收前端传递的 MultipartFile 对象。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含文件上传操作结果的 Result 对象，封装了操作是否成功以及可能的文件存储信息等。
+ */
+ // 使用 Spring MVC 的 @PostMapping 注解，处理 HTTP POST 请求，路径为 /file/uploadFile
@PostMapping("/uploadFile")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“单文件上传-附件”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "单文件上传-附件", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result uploadFile(@ApiParam(value = "附件文件", required = true) @RequestBody MultipartFile file,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result uploadFile(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“附件文件”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值（这里接收 MultipartFile 对象）
+ @ApiParam(value = "附件文件", required = true) @RequestBody
+ MultipartFile file,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 FileService 的 save 方法，传入要上传的文件和表示上传附件的常量，执行文件上传操作并返回结果
return fileService.save(file, Constant.STR_UPLOAD_FILE);
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/controller/HomeController.java b/server/src/main/java/com/ew/gerocomium/controller/HomeController.java
index 20bb4d2..60ebccf 100644
--- a/server/src/main/java/com/ew/gerocomium/controller/HomeController.java
+++ b/server/src/main/java/com/ew/gerocomium/controller/HomeController.java
@@ -1,57 +1,144 @@
+// 声明该类所属的包，用于组织代码结构，体现代码的所属模块
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.ClientSourceQuery;
+// 导入首页业务逻辑的服务类，负责处理与首页相关的具体业务操作
import com.ew.gerocomium.service.HomeService;
+// 导入 Swagger 的注解，用于生成 API 文档时对控制器进行分类和描述
import io.swagger.annotations.Api;
+// 导入 Swagger 的注解，用于描述 API 操作的详细信息，如操作名称和备注
import io.swagger.annotations.ApiOperation;
+// 导入 Swagger 的注解，用于描述 API 参数的详细信息，如参数名称、是否必填等
import io.swagger.annotations.ApiParam;
+// 导入 Spring MVC 的注解，用于处理 HTTP 请求，定义请求映射和请求方法等
import org.springframework.web.bind.annotation.*;
-
+// 导入 Spring 的注解，用于实现依赖注入，将所需的服务类实例注入到当前类中
import javax.annotation.Resource;
+/**
+ * 首页控制器类，用于处理与系统首页相关的各种数据查询请求，
+ * 提供如今日概览、可售床位、今日销售跟进、本月业绩排行、客户来源渠道和业务趋势等信息。
+ */
+// 使用 Swagger 的 @Api 注解，标记该控制器的标签为“首页”，方便在生成 API 文档时进行分类展示
@Api(tags = "首页")
+// 使用 Spring MVC 的 @RestController 注解，将该类标记为 RESTful 风格的控制器，用于处理 HTTP 请求并返回 JSON 等格式的响应
@RestController
+// 使用 Spring MVC 的 @RequestMapping 注解，定义该控制器的基础请求路径为 /home，该控制器下的所有请求都以此为前缀
@RequestMapping("/home")
public class HomeController {
+
+ // 使用 @Resource 注解，将 HomeService 类型的实例注入到当前类中，以便调用其方法处理首页相关业务逻辑
@Resource
private HomeService homeService;
+ /**
+ * 获取今日概览信息的方法。
+ *
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含今日概览操作结果的 Result 对象，封装了操作是否成功以及获取到的今日概览数据等信息。
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，处理 HTTP GET 请求，路径为 /home/todayOverview
@GetMapping("/todayOverview")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“今日概览”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "今日概览", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result todayOverview(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result todayOverview(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 HomeService 的 todayOverview 方法，获取今日概览信息并返回结果
return homeService.todayOverview();
}
+ /**
+ * 获取可售床位信息的方法。
+ *
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含可售床位操作结果的 Result 对象，封装了操作是否成功以及获取到的可售床位数据等信息。
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，处理 HTTP GET 请求，路径为 /home/availableBed
@GetMapping("/availableBed")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“可售床位”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "可售床位", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result availableBed(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result availableBed(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 HomeService 的 availableBed 方法，获取可售床位信息并返回结果
return homeService.availableBed();
}
+ /**
+ * 获取今日销售跟进信息的方法。
+ *
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含今日销售跟进操作结果的 Result 对象，封装了操作是否成功以及获取到的今日销售跟进数据等信息。
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，处理 HTTP GET 请求，路径为 /home/todaySaleFollow
@GetMapping("/todaySaleFollow")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“今日销售跟进”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "今日销售跟进", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result todaySaleFollow(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result todaySaleFollow(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 HomeService 的 todaySaleFollow 方法，获取今日销售跟进信息并返回结果
return homeService.todaySaleFollow();
}
+ /**
+ * 获取本月业绩排行信息的方法。
+ *
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含本月业绩排行操作结果的 Result 对象，封装了操作是否成功以及获取到的本月业绩排行数据等信息。
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，处理 HTTP GET 请求，路径为 /home/monthPerformanceRank
@GetMapping("/monthPerformanceRank")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“本月业绩排行”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "本月业绩排行", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result monthPerformanceRank(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result monthPerformanceRank(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 HomeService 的 monthPerformanceRank 方法，获取本月业绩排行信息并返回结果
return homeService.monthPerformanceRank();
}
+ /**
+ * 获取客户来源渠道信息的方法。
+ *
+ * @param clientSourceQuery 客户来源渠道的请求实体，可能包含一些筛选或查询条件。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含客户来源渠道操作结果的 Result 对象，封装了操作是否成功以及获取到的客户来源渠道数据等信息。
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，处理 HTTP GET 请求，路径为 /home/clientSource
@GetMapping("/clientSource")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“客户来源渠道”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "客户来源渠道", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result clientSource(@ApiParam(value = "接口访问请求头", required = true) ClientSourceQuery clientSourceQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result clientSource(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“客户来源渠道请求实体”，并标记为必需参数
+ @ApiParam(value = "客户来源渠道请求实体", required = true)
+ ClientSourceQuery clientSourceQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 HomeService 的 clientSource 方法，传入客户来源渠道请求实体，获取客户来源渠道信息并返回结果
return homeService.clientSource(clientSourceQuery);
}
+ /**
+ * 获取业务趋势信息的方法。
+ *
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含业务趋势操作结果的 Result 对象，封装了操作是否成功以及获取到的业务趋势数据等信息。
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，处理 HTTP GET 请求，路径为 /home/businessTrend
@GetMapping("/businessTrend")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“业务趋势”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "业务趋势", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result businessTrend(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result businessTrend(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 HomeService 的 businessTrend 方法，获取业务趋势信息并返回结果
return homeService.businessTrend();
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/controller/IntentionController.java b/server/src/main/java/com/ew/gerocomium/controller/IntentionController.java
index 6b62b5f..fc8a0e3 100644
--- a/server/src/main/java/com/ew/gerocomium/controller/IntentionController.java
+++ b/server/src/main/java/com/ew/gerocomium/controller/IntentionController.java
@@ -1,140 +1,438 @@
+// 声明该类所在的包，表明它属于 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.*;
+// 导入意向客户相关的业务逻辑服务类，用于处理与意向客户相关的具体业务
import com.ew.gerocomium.service.IntentionService;
+// 导入 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
+// 定义该控制器的基础请求路径为 /intention，该控制器下的所有请求都以此为前缀
@RequestMapping("/intention")
+// 权限控制注解，只有拥有指定权限（'/soles/intention'）的用户才能访问该控制器的方法
@PreAuthorize("@AuthorityAssert.hasAuthority('/soles/intention')")
public class IntentionController {
+ // 通过依赖注入的方式获取 IntentionService 的实例，用于调用该服务类的方法处理业务逻辑
@Resource
private IntentionService intentionService;
+ /**
+ * 获取客户标签列表的方法。
+ *
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含获取客户标签列表操作结果的 Result 对象，封装了操作是否成功以及获取到的标签列表数据等信息。
+ */
+ // 处理 HTTP GET 请求，请求路径为 /intention/listLabel，用于获取客户标签列表
@GetMapping("/listLabel")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "客户标签", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result listLabel(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result listLabel(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用意向客户服务类的获取客户标签列表方法，并返回操作结果
return intentionService.listLabel();
}
+ /**
+ * 分页查询意向客户的方法。
+ *
+ * @param pageIntentionByKeyQuery 分页查询意向客户的请求实体，包含查询条件和分页信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含分页查询意向客户操作结果的 Result 对象，封装了操作是否成功以及查询到的意向客户数据列表等信息。
+ */
+ // 处理 HTTP GET 请求，请求路径为 /intention/pageIntentionByKey，用于分页查询意向客户
@GetMapping("/pageIntentionByKey")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "分页查询意向客户", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result pageIntentionByKey(@ApiParam(value = "分页查询意向客户请求实体", required = true) PageIntentionByKeyQuery pageIntentionByKeyQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result pageIntentionByKey(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为分页查询意向客户的请求实体
+ @ApiParam(value = "分页查询意向客户请求实体", required = true)
+ // 接收分页查询意向客户的请求实体
+ PageIntentionByKeyQuery pageIntentionByKeyQuery,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用意向客户服务类的分页查询意向客户方法，并返回操作结果
return intentionService.pageIntentionByKey(pageIntentionByKeyQuery);
}
+ /**
+ * 分页搜索老人的方法。
+ *
+ * @param pageSearchElderByKeyQuery 分页搜索老人的请求实体，包含查询条件和分页信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含分页搜索老人操作结果的 Result 对象，封装了操作是否成功以及查询到的老人数据列表等信息。
+ */
+ // 处理 HTTP GET 请求，请求路径为 /intention/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 intentionService.pageSearchElderByKey(pageSearchElderByKeyQuery);
}
+ /**
+ * 新增意向客户的方法。
+ *
+ * @param operateIntentionQuery 新增意向客户的请求实体，包含要新增的意向客户的详细信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含新增意向客户操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 处理 HTTP POST 请求，请求路径为 /intention/addIntention，用于新增意向客户
@PostMapping("/addIntention")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "新增意向客户", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result addIntention(@ApiParam(value = "新增意向客户请求实体", required = true) @RequestBody OperateIntentionQuery operateIntentionQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result addIntention(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为新增意向客户的请求实体
+ @ApiParam(value = "新增意向客户请求实体", required = true)
+ // 从请求体中接收新增意向客户的请求实体
+ @RequestBody OperateIntentionQuery operateIntentionQuery,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用意向客户服务类的新增意向客户方法，并返回操作结果
return intentionService.addIntention(operateIntentionQuery);
}
+ /**
+ * 根据编号获取意向客户信息的方法。
+ *
+ * @param elderId 要查询的意向客户对应的老人编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含根据编号获取意向客户操作结果的 Result 对象，封装了操作是否成功以及获取到的意向客户详细信息等。
+ */
+ // 处理 HTTP GET 请求，请求路径为 /intention/getIntentById，用于根据编号获取意向客户信息
@GetMapping("/getIntentById")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "根据编号获取意向客户", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result getIntentById(@ApiParam(value = "根据编号获取意向客户请求参数", required = true) @RequestParam Long elderId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result getIntentById(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为要查询的意向客户对应的老人编号
+ @ApiParam(value = "根据编号获取意向客户请求参数", required = true)
+ // 从请求参数中获取老人编号
+ @RequestParam Long elderId,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用意向客户服务类的根据编号获取意向客户方法，并返回操作结果
return intentionService.getIntentById(elderId);
}
+ /**
+ * 根据编号获取意向客户标签的方法。
+ *
+ * @param elderId 要查询的意向客户对应的老人编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含根据编号获取意向客户标签操作结果的 Result 对象，封装了操作是否成功以及获取到的标签信息等。
+ */
+ // 处理 HTTP GET 请求，请求路径为 /intention/getElderLabelById，用于根据编号获取意向客户标签
@GetMapping("/getElderLabelById")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "根据编号获取意向客户标签", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result getElderLabelById(@ApiParam(value = "根据编号获取意向客户标签请求参数", required = true) @RequestParam Long elderId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result getElderLabelById(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为要查询的意向客户对应的老人编号
+ @ApiParam(value = "根据编号获取意向客户标签请求参数", required = true)
+ // 从请求参数中获取老人编号
+ @RequestParam Long elderId,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用意向客户服务类的根据编号获取意向客户标签方法，并返回操作结果
return intentionService.getElderLabelById(elderId);
}
+ /**
+ * 编辑意向客户信息的方法。
+ *
+ * @param operateIntentionQuery 编辑意向客户的请求实体，包含要修改的意向客户的详细信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含编辑意向客户操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 处理 HTTP PUT 请求，请求路径为 /intention/editIntention，用于编辑意向客户信息
@PutMapping("/editIntention")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "编辑意向客户", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result editIntention(@ApiParam(value = "编辑意向客户请求实体", required = true) @RequestBody OperateIntentionQuery operateIntentionQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result editIntention(
+ // 使用 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 GET 请求，请求路径为 /intention/getEditElderLabelById，用于根据编号获取编辑意向客户标签
@GetMapping("/getEditElderLabelById")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "根据编号获取编辑意向客户标签", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result getEditElderLabelById(@ApiParam(value = "根据编号获取编辑意向客户标签请求参数", required = true) @RequestParam Long elderId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result getEditElderLabelById(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为要查询的意向客户对应的老人编号
+ @ApiParam(value = "根据编号获取编辑意向客户标签请求参数", required = true)
+ // 从请求参数中获取老人编号
+ @RequestParam Long elderId,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用意向客户服务类的根据编号获取编辑意向客户标签方法，并返回操作结果
return intentionService.getEditElderLabelById(elderId);
}
+ /**
+ * 编辑老人标签的方法。
+ *
+ * @param editElderLabelQuery 编辑老人标签的请求实体，包含要修改的老人标签的详细信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含编辑老人标签操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 处理 HTTP PUT 请求，请求路径为 /intention/editElderLabel，用于编辑老人标签
@PutMapping("/editElderLabel")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "编辑老人标签", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result editElderLabel(@ApiParam(value = "编辑老人标签请求实体", required = true) @RequestBody EditElderLabelQuery editElderLabelQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result editElderLabel(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为编辑老人标签的请求实体
+ @ApiParam(value = "编辑老人标签请求实体", required = true)
+ // 从请求体中接收编辑老人标签的请求实体
+ @RequestBody EditElderLabelQuery editElderLabelQuery,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用意向客户服务类的编辑老人标签方法，并返回操作结果
return intentionService.editElderLabel(editElderLabelQuery);
}
+ /**
+ * 分页查询回访计划的方法。
+ *
+ * @param pageVisitPlanQuery 分页查询回访计划的请求实体，包含查询条件和分页信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含分页查询回访计划操作结果的 Result 对象，封装了操作是否成功以及查询到的回访计划数据列表等信息。
+ */
+ // 处理 HTTP GET 请求，请求路径为 /intention/pageVisitPlan，用于分页查询回访计划
@GetMapping("/pageVisitPlan")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "分页查询回访计划", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result pageVisitPlan(@ApiParam(value = "分页查询回访计划请求实体", required = true) PageVisitPlanQuery pageVisitPlanQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result pageVisitPlan(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为分页查询回访计划的请求实体
+ @ApiParam(value = "分页查询回访计划请求实体", required = true)
+ // 接收分页查询回访计划的请求实体
+ PageVisitPlanQuery pageVisitPlanQuery,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用意向客户服务类的分页查询回访计划方法，并返回操作结果
return intentionService.pageVisitPlan(pageVisitPlanQuery);
}
+ /**
+ * 新增回访计划的方法。
+ *
+ * @param addVisitPlanQuery 新增回访计划的请求实体，包含要新增的回访计划的详细信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含新增回访计划操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 处理 HTTP POST 请求，请求路径为 /intention/addVisitPlan，用于新增回访计划
@PostMapping("/addVisitPlan")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "新增回访计划", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result addVisitPlan(@ApiParam(value = "新增回访计划请求实体", required = true) @RequestBody AddVisitPlanQuery addVisitPlanQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result addVisitPlan(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为新增回访计划的请求实体
+ @ApiParam(value = "新增回访计划请求实体", required = true)
+ // 从请求体中接收新增回访计划的请求实体
+ @RequestBody AddVisitPlanQuery addVisitPlanQuery,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用意向客户服务类的新增回访计划方法，并返回操作结果
return intentionService.addVisitPlan(addVisitPlanQuery);
}
+ /**
+ * 执行回访计划的方法。
+ *
+ * @param completeVisitPlanQuery 执行回访计划的请求实体，包含执行回访计划所需的详细信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含执行回访计划操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 处理 HTTP PUT 请求，请求路径为 /intention/executeVisitPlan，用于执行回访计划
@PutMapping("/executeVisitPlan")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "执行回访计划", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result executeVisitPlan(@ApiParam(value = "执行回访计划请求实体", required = true) @RequestBody CompleteVisitPlanQuery completeVisitPlanQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result executeVisitPlan(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为执行回访计划的请求实体
+ @ApiParam(value = "执行回访计划请求实体", required = true)
+ // 从请求体中接收执行回访计划的请求实体
+ @RequestBody CompleteVisitPlanQuery completeVisitPlanQuery,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用意向客户服务类的执行回访计划方法，并返回操作结果
return intentionService.executeVisitPlan(completeVisitPlanQuery);
}
+ /**
+ * 删除回访计划的方法。
+ *
+ * @param visitPlanId 要删除的回访计划的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含删除回访计划操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 处理 HTTP DELETE 请求，请求路径为 /intention/deleteVisitPlan，用于删除回访计划
@DeleteMapping("/deleteVisitPlan")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "删除回访计划", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result deleteVisitPlan(@ApiParam(value = "删除回访计划请求参数", required = true) @RequestParam Long visitPlanId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result deleteVisitPlan(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为要删除的回访计划的编号
+ @ApiParam(value = "删除回访计划请求参数", required = true)
+ // 从请求参数中获取回访计划编号
+ @RequestParam Long visitPlanId,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用意向客户服务类的删除回访计划方法，并返回操作结果
return intentionService.deleteVisitPlan(visitPlanId);
}
+ /**
+ * 分页查询沟通记录的方法。
+ *
+ * @param pageCommunicationRecordQuery 分页查询沟通记录的请求实体，包含查询条件和分页信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含分页查询沟通记录操作结果的 Result 对象，封装了操作是否成功以及查询到的沟通记录数据列表等信息。
+ */
+ // 处理 HTTP GET 请求，请求路径为 /intention/pageCommunicationRecord，用于分页查询沟通记录
@GetMapping("/pageCommunicationRecord")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "分页查询沟通记录", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result pageCommunicationRecord(@ApiParam(value = "分页查询沟通记录请求实体", required = true) PageCommunicationRecordQuery pageCommunicationRecordQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result pageCommunicationRecord(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为分页查询沟通记录的请求实体
+ @ApiParam(value = "分页查询沟通记录请求实体", required = true)
+ // 接收分页查询沟通记录的请求实体
+ PageCommunicationRecordQuery pageCommunicationRecordQuery,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用意向客户服务类的分页查询沟通记录方法，并返回操作结果
return intentionService.pageCommunicationRecord(pageCommunicationRecordQuery);
}
+ /**
+ * 新增沟通记录的方法。
+ *
+ * @param addCommunicationRecordQuery 新增沟通记录的请求实体，包含要新增的沟通记录的详细信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含新增沟通记录操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 处理 HTTP POST 请求，请求路径为 /intention/addCommunicationRecord，用于新增沟通记录
@PostMapping("/addCommunicationRecord")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "新增沟通记录", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result addCommunicationRecord(@ApiParam(value = "新增沟通记录请求实体", required = true) @RequestBody AddCommunicationRecordQuery addCommunicationRecordQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result addCommunicationRecord(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为新增沟通记录的请求实体
+ @ApiParam(value = "新增沟通记录请求实体", required = true)
+ // 从请求体中接收新增沟通记录的请求实体
+ @RequestBody AddCommunicationRecordQuery addCommunicationRecordQuery,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用意向客户服务类的新增沟通记录方法，并返回操作结果
return intentionService.addCommunicationRecord(addCommunicationRecordQuery);
}
+ /**
+ * 编辑沟通记录的方法。
+ *
+ * @param editCommunicationRecordQuery 编辑沟通记录的请求实体，包含要修改的沟通记录的详细信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含编辑沟通记录操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 处理 HTTP PUT 请求，请求路径为 /intention/editCommunicationRecord，用于编辑沟通记录
@PutMapping("/editCommunicationRecord")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "编辑沟通记录", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result editCommunicationRecord(@ApiParam(value = "编辑沟通记录请求实体", required = true) @RequestBody EditCommunicationRecordQuery editCommunicationRecordQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result editCommunicationRecord(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为编辑沟通记录的请求实体
+ @ApiParam(value = "编辑沟通记录请求实体", required = true)
+ // 从请求体中接收编辑沟通记录的请求实体
+ @RequestBody EditCommunicationRecordQuery editCommunicationRecordQuery,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用意向客户服务类的编辑沟通记录方法，并返回操作结果
return intentionService.editCommunicationRecord(editCommunicationRecordQuery);
}
+ /**
+ * 删除沟通记录的方法。
+ *
+ * @param communicationRecordId 要删除的沟通记录的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含删除沟通记录操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 处理 HTTP DELETE 请求，请求路径为 /intention/deleteCommunicationRecord，用于删除沟通记录
@DeleteMapping("/deleteCommunicationRecord")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "删除沟通记录", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result deleteCommunicationRecord(@ApiParam(value = "删除沟通记录请求参数", required = true) @RequestParam Long communicationRecordId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result deleteCommunicationRecord(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为要删除的沟通记录的编号
+ @ApiParam(value = "删除沟通记录请求参数", required = true)
+ // 从请求参数中获取沟通记录编号
+ @RequestParam Long communicationRecordId,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用意向客户服务类的删除沟通记录方法，并返回操作结果
return intentionService.deleteCommunicationRecord(communicationRecordId);
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/controller/InventoryController.java b/server/src/main/java/com/ew/gerocomium/controller/InventoryController.java
index 39f6efe..f7f87f1 100644
--- a/server/src/main/java/com/ew/gerocomium/controller/InventoryController.java
+++ b/server/src/main/java/com/ew/gerocomium/controller/InventoryController.java
@@ -1,41 +1,91 @@
+// 声明该类所属的包，表明该类位于 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.PageInventoryByKeyQuery;
+// 导入库存相关的业务逻辑服务类，用于处理库存相关的业务操作，如分页查询库存信息
import com.ew.gerocomium.service.InventoryService;
+// 导入仓库记录相关的业务逻辑服务类，用于处理仓库记录相关的业务操作，如获取仓库列表
import com.ew.gerocomium.service.WarehouseRecordService;
+// 导入 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.GetMapping;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
-
+// 导入 Spring 的资源注入注解，用于实现依赖注入，将所需的服务类实例注入到控制器中
import javax.annotation.Resource;
+/**
+ * 库存查询控制器类，用于处理与库存查询相关的操作请求，如获取仓库列表和分页查询库存信息。
+ */
+// 使用 Swagger 注解，标记该控制器的标签为“库存查询”，方便在生成 API 文档时进行分类展示
@Api(tags = "库存查询")
+// 标记该类为 RESTful 风格的控制器，用于处理 HTTP 请求并返回 JSON 等格式的响应
@RestController
+// 定义该控制器的基础请求路径为 /inventory，该控制器下的所有请求都以此为前缀
@RequestMapping("/inventory")
+// 权限控制注解，只有拥有指定权限（'/resource/search'）的用户才能访问该控制器的方法
@PreAuthorize("@AuthorityAssert.hasAuthority('/resource/search')")
public class InventoryController {
+
+ // 注入库存相关的业务逻辑服务类，通过依赖注入的方式获取 InventoryService 的实例，以便在控制器中调用该服务类的方法处理库存业务
@Resource
private InventoryService inventoryService;
+
+ // 注入仓库记录相关的业务逻辑服务类，通过依赖注入的方式获取 WarehouseRecordService 的实例，用于处理仓库记录相关业务
@Resource
private WarehouseRecordService warehouseRecordService;
+ /**
+ * 获取仓库列表的方法。
+ *
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含获取仓库列表操作结果的 Result 对象，封装了操作是否成功以及获取到的仓库列表数据等信息。
+ */
+ // 处理 HTTP GET 请求，请求路径为 /inventory/listWarehouse，用于获取仓库列表
@GetMapping("/listWarehouse")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "获取仓库列表", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result listWarehouse(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result listWarehouse(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用仓库记录服务类的获取仓库列表方法，并返回操作结果
return warehouseRecordService.listWarehouse();
}
+ /**
+ * 分页查询库存信息的方法。
+ *
+ * @param pageInventoryByKeyQuery 分页查询库存的请求实体，包含查询条件（如库存名称、库存数量范围等）和分页信息（如页码、每页数量等）。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含分页查询库存操作结果的 Result 对象，封装了操作是否成功以及查询到的库存数据列表等信息。
+ */
+ // 处理 HTTP GET 请求，请求路径为 /inventory/pageInventoryByKey，用于分页查询库存信息
@GetMapping("/pageInventoryByKey")
+ // 使用 Swagger 注解描述该接口的功能和开发者信息
@ApiOperation(value = "分页查询库存", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result pageInventoryByKey(@ApiParam(value = "分页查询库存请求实体", required = true) PageInventoryByKeyQuery pageInventoryByKeyQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result pageInventoryByKey(
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为分页查询库存的请求实体
+ @ApiParam(value = "分页查询库存请求实体", required = true)
+ // 接收分页查询库存的请求实体
+ PageInventoryByKeyQuery pageInventoryByKeyQuery,
+ // 使用 Swagger 注解描述该参数的作用，并标记为必需参数，该参数为接口访问请求头中的令牌
+ @ApiParam(value = "接口访问请求头", required = true)
+ // 从请求头中获取令牌
+ @RequestHeader String token) {
+ // 调用库存服务类的分页查询库存方法，并返回操作结果
return inventoryService.pageInventoryByKey(pageInventoryByKeyQuery);
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/controller/LabelController.java b/server/src/main/java/com/ew/gerocomium/controller/LabelController.java
index ca32e89..62a8cc8 100644
--- a/server/src/main/java/com/ew/gerocomium/controller/LabelController.java
+++ b/server/src/main/java/com/ew/gerocomium/controller/LabelController.java
@@ -1,85 +1,229 @@
+// 声明该类所属的包，包名通常反映了代码的功能模块或业务领域
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.OperateLabelQuery;
+// 导入用于操作标签类型的查询类，该类封装了操作标签类型时所需的参数
import com.ew.gerocomium.dao.query.OperateLabelTypeQuery;
+// 导入标签业务逻辑的服务类，该类实现了与标签相关的具体业务逻辑
import com.ew.gerocomium.service.LabelService;
+// 导入 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 请求，@DeleteMapping 处理 DELETE 请求
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 注解，定义该控制器处理的请求的基础路径为 /label，该控制器下的所有接口路径都会基于此路径
@RequestMapping("/label")
+// 使用 Spring Security 的 @PreAuthorize 注解，进行权限验证，只有拥有 /base/marketing/tag 权限的用户才能访问该控制器下的接口，确保系统的安全性
@PreAuthorize("@AuthorityAssert.hasAuthority('/base/marketing/tag')")
public class LabelController {
+
+ // 使用 @Resource 注解，将 LabelService 类型的实例注入到当前类中，用于调用该服务类的方法处理与标签相关的业务逻辑
@Resource
private LabelService labelService;
+ /**
+ * 获取客户标签列表的方法。
+ *
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含获取客户标签列表操作结果的 Result 对象，封装了操作是否成功以及获取到的标签列表数据等信息。
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，处理 HTTP GET 请求，路径为 /label/listLabel
@GetMapping("/listLabel")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“获取客户标签列表”，并添加备注信息，通常包含开发者等相关信息
@ApiOperation(value = "获取客户标签列表", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result listLabel(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result listLabel(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 LabelService 的 listLabel 方法，执行获取客户标签列表的操作，并返回结果
return labelService.listLabel();
}
+ /**
+ * 新增标签分类的方法。
+ *
+ * @param operateLabelTypeQuery 新增标签分类的请求实体，包含要新增的标签分类的详细信息，如分类名称、描述等。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含新增标签分类操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 使用 Spring MVC 的 @PostMapping 注解，处理 HTTP POST 请求，路径为 /label/addLabelType
@PostMapping("/addLabelType")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“新增标签分类”，并添加备注信息
@ApiOperation(value = "新增标签分类", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result addLabelType(@ApiParam(value = "新增标签分类请求实体", required = true) @RequestBody OperateLabelTypeQuery operateLabelTypeQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result addLabelType(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“新增标签分类请求实体”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+ @ApiParam(value = "新增标签分类请求实体", required = true) @RequestBody
+ OperateLabelTypeQuery operateLabelTypeQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 LabelService 的 addLabelType 方法，传入新增标签分类请求实体，执行新增操作，并返回结果
return labelService.addLabelType(operateLabelTypeQuery);
}
+ /**
+ * 根据编号获取标签分类信息的方法。
+ *
+ * @param typeId 要获取信息的标签分类的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含根据编号获取标签分类信息操作结果的 Result 对象，封装了操作是否成功以及获取到的标签分类详细信息等。
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，处理 HTTP GET 请求，路径为 /label/getLabelTypeById
@GetMapping("/getLabelTypeById")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“根据编号获取标签分类信息”，并添加备注信息
@ApiOperation(value = "根据编号获取标签分类信息", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result getLabelTypeById(@ApiParam(value = "根据编号获取标签分类信息请求参数", required = true) @RequestParam Long typeId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result getLabelTypeById(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“根据编号获取标签分类信息请求参数”，并标记为必需参数，同时使用 @RequestParam 注解从请求参数中获取该参数值
+ @ApiParam(value = "根据编号获取标签分类信息请求参数", required = true) @RequestParam
+ Long typeId,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 LabelService 的 getLabelTypeById 方法，传入标签分类编号，执行查询操作，并返回结果
return labelService.getLabelTypeById(typeId);
}
+ /**
+ * 编辑标签分类的方法。
+ *
+ * @param operateLabelTypeQuery 编辑标签分类的请求实体，包含要修改的标签分类的详细信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含编辑标签分类操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 使用 Spring MVC 的 @PutMapping 注解，处理 HTTP PUT 请求，路径为 /label/editLabelType
@PutMapping("/editLabelType")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“编辑标签分类”，并添加备注信息
@ApiOperation(value = "编辑标签分类", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result editLabelType(@ApiParam(value = "编辑标签分类请求实体", required = true) @RequestBody OperateLabelTypeQuery operateLabelTypeQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result editLabelType(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“编辑标签分类请求实体”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+ @ApiParam(value = "编辑标签分类请求实体", required = true) @RequestBody
+ OperateLabelTypeQuery operateLabelTypeQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 LabelService 的 editLabelType 方法，传入编辑标签分类请求实体，执行编辑操作，并返回结果
return labelService.editLabelType(operateLabelTypeQuery);
}
+ /**
+ * 删除标签分类的方法。
+ *
+ * @param typeId 要删除的标签分类的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含删除标签分类操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 使用 Spring MVC 的 @DeleteMapping 注解，处理 HTTP DELETE 请求，路径为 /label/deleteLabelType
@DeleteMapping("/deleteLabelType")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“删除标签分类”，并添加备注信息
@ApiOperation(value = "删除标签分类", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result deleteLabelType(@ApiParam(value = "删除标签分类请求参数", required = true) @RequestParam Long typeId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result deleteLabelType(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“删除标签分类请求参数”，并标记为必需参数，同时使用 @RequestParam 注解从请求参数中获取该参数值
+ @ApiParam(value = "删除标签分类请求参数", required = true) @RequestParam
+ Long typeId,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 LabelService 的 deleteLabelType 方法，传入标签分类编号，执行删除操作，并返回结果
return labelService.deleteLabelType(typeId);
}
+ /**
+ * 新增标签的方法。
+ *
+ * @param operateLabelQuery 新增标签的请求实体，包含要新增的标签的详细信息，如标签名称、所属分类等。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含新增标签操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 使用 Spring MVC 的 @PostMapping 注解，处理 HTTP POST 请求，路径为 /label/addLabel
@PostMapping("/addLabel")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“新增标签”，并添加备注信息
@ApiOperation(value = "新增标签", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result addLabel(@ApiParam(value = "新增标签请求实体", required = true) @RequestBody OperateLabelQuery operateLabelQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result addLabel(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“新增标签请求实体”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+ @ApiParam(value = "新增标签请求实体", required = true) @RequestBody
+ OperateLabelQuery operateLabelQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 LabelService 的 addLabel 方法，传入新增标签请求实体，执行新增操作，并返回结果
return labelService.addLabel(operateLabelQuery);
}
+ /**
+ * 根据编号获取标签信息的方法。
+ *
+ * @param labelId 要获取信息的标签的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含根据编号获取标签信息操作结果的 Result 对象，封装了操作是否成功以及获取到的标签详细信息等。
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，处理 HTTP GET 请求，路径为 /label/getLabelById
@GetMapping("/getLabelById")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“根据编号获取标签信息”，并添加备注信息
@ApiOperation(value = "根据编号获取标签信息", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result getLabelById(@ApiParam(value = "根据编号获取标签信息请求参数", required = true) @RequestParam Long labelId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result getLabelById(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“根据编号获取标签信息请求参数”，并标记为必需参数，同时使用 @RequestParam 注解从请求参数中获取该参数值
+ @ApiParam(value = "根据编号获取标签信息请求参数", required = true) @RequestParam
+ Long labelId,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 LabelService 的 getLabelById 方法，传入标签编号，执行查询操作，并返回结果
return labelService.getLabelById(labelId);
}
+ /**
+ * 编辑标签的方法。
+ *
+ * @param operateLabelQuery 编辑标签的请求实体，包含要修改的标签的详细信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含编辑标签操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 使用 Spring MVC 的 @PutMapping 注解，处理 HTTP PUT 请求，路径为 /label/editLabel
@PutMapping("/editLabel")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“编辑标签”，并添加备注信息
@ApiOperation(value = "编辑标签", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result editLabel(@ApiParam(value = "编辑标签请求实体", required = true) @RequestBody OperateLabelQuery operateLabelQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result editLabel(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“编辑标签请求实体”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+ @ApiParam(value = "编辑标签请求实体", required = true) @RequestBody
+ OperateLabelQuery operateLabelQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 LabelService 的 editLabel 方法，传入编辑标签请求实体，执行编辑操作，并返回结果
return labelService.editLabel(operateLabelQuery);
}
+ /**
+ * 删除标签的方法。
+ *
+ * @param labelId 要删除的标签的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含删除标签操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 使用 Spring MVC 的 @DeleteMapping 注解，处理 HTTP DELETE 请求，路径为 /label/deleteLabel
@DeleteMapping("/deleteLabel")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“删除标签”，并添加备注信息
@ApiOperation(value = "删除标签", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result deleteLabel(@ApiParam(value = "删除标签请求参数", required = true) @RequestParam Long labelId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result deleteLabel(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“删除标签请求参数”，并标记为必需参数，同时使用 @RequestParam 注解从请求参数中获取该参数值
+ @ApiParam(value = "删除标签请求参数", required = true) @RequestParam
+ Long labelId,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 LabelService 的 deleteLabel 方法，传入标签编号，执行删除操作，并返回结果
return labelService.deleteLabel(labelId);
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/controller/MaterialController.java b/server/src/main/java/com/ew/gerocomium/controller/MaterialController.java
index 128515f..d388d92 100644
--- a/server/src/main/java/com/ew/gerocomium/controller/MaterialController.java
+++ b/server/src/main/java/com/ew/gerocomium/controller/MaterialController.java
@@ -12,14 +12,27 @@ import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
-@Api(tags = "物资信息")
-@RestController
-@RequestMapping("/material")
-@PreAuthorize("@AuthorityAssert.hasAuthority('/resource/info')")
+/**
+ * 物资信息控制器类，用于处理与物资信息相关的各种操作请求，
+ * 包括物资分类的管理（增删改查）以及物资的管理（增删改查）和分页查询等功能。
+ */
+@Api(tags = "物资信息") // 使用 Swagger 注解，标记该控制器的标签为“物资信息”，方便在生成 API 文档时进行分类展示
+@RestController // 标记该类为 RESTful 风格的控制器，用于处理 HTTP 请求并返回 JSON 等格式的响应
+@RequestMapping("/material") // 定义该控制器的基础请求路径为 /material，该控制器下的所有请求都以此为前缀
+@PreAuthorize("@AuthorityAssert.hasAuthority('/resource/info')") // 权限控制注解，只有拥有指定权限的用户才能访问该控制器的方法
public class MaterialController {
+
+ // 注入物资相关的业务逻辑服务类，通过依赖注入的方式获取 MaterialService 的实例
@Resource
private MaterialService materialService;
+ /**
+ * 获取物资分类的方法。
+ *
+ * @param materialTypeName 可选的物资分类名称参数，用于筛选特定名称的物资分类，若为 null 则获取所有分类。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含获取物资分类操作结果的 Result 对象，封装了操作是否成功以及获取到的物资分类数据列表等信息。
+ */
@GetMapping("/getMaterialType")
@ApiOperation(value = "获取物资分类", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
public Result getMaterialType(@ApiParam(value = "获取物资分类请求参数", required = false) String materialTypeName,
@@ -27,6 +40,13 @@ public class MaterialController {
return materialService.getMaterialType(materialTypeName);
}
+ /**
+ * 分页查询物资信息的方法。
+ *
+ * @param pageMaterialByKeyQuery 分页查询物资的请求实体，包含查询条件（如物资名称、规格等）和分页信息（如页码、每页数量等）。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含分页查询物资操作结果的 Result 对象，封装了操作是否成功以及查询到的物资数据列表等信息。
+ */
@GetMapping("/pageMaterialByKey")
@ApiOperation(value = "分页查询物资", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
public Result pageMaterialByKey(@ApiParam(value = "分页查询物资请求实体", required = true) PageMaterialByKeyQuery pageMaterialByKeyQuery,
@@ -34,6 +54,13 @@ public class MaterialController {
return materialService.pageMaterialByKey(pageMaterialByKeyQuery);
}
+ /**
+ * 新增物资分类的方法。
+ *
+ * @param operateMaterialTypeQuery 新增物资分类的请求实体，包含要新增的物资分类的详细信息，如分类名称、描述等。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含新增物资分类操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
@PostMapping("/addMaterialType")
@ApiOperation(value = "新增物资分类", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
public Result addMaterialType(@ApiParam(value = "新增物资分类请求实体", required = true) @RequestBody OperateMaterialTypeQuery operateMaterialTypeQuery,
@@ -41,6 +68,13 @@ public class MaterialController {
return materialService.addMaterialType(operateMaterialTypeQuery);
}
+ /**
+ * 根据编号查询物资分类信息的方法。
+ *
+ * @param materialTypeId 要查询的物资分类的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含根据编号查询物资分类操作结果的 Result 对象，封装了操作是否成功以及获取到的物资分类详细信息等。
+ */
@GetMapping("/getMaterialTypeById")
@ApiOperation(value = "根据编号查询物资分类", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
public Result getMaterialTypeById(@ApiParam(value = "根据编号查询物资分类请求参数", required = true) @RequestParam Long materialTypeId,
@@ -48,6 +82,13 @@ public class MaterialController {
return materialService.getMaterialTypeById(materialTypeId);
}
+ /**
+ * 编辑物资分类信息的方法。
+ *
+ * @param operateMaterialTypeQuery 编辑物资分类的请求实体，包含要修改的物资分类的详细信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含编辑物资分类操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
@PutMapping("/editMaterialType")
@ApiOperation(value = "编辑物资分类", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
public Result editMaterialType(@ApiParam(value = "编辑物资分类请求实体", required = true) @RequestBody OperateMaterialTypeQuery operateMaterialTypeQuery,
@@ -55,6 +96,13 @@ public class MaterialController {
return materialService.editMaterialType(operateMaterialTypeQuery);
}
+ /**
+ * 删除物资分类的方法。
+ *
+ * @param materialTypeId 要删除的物资分类的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含删除物资分类操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
@DeleteMapping("/deleteMaterialType")
@ApiOperation(value = "删除物资分类", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
public Result deleteMaterialType(@ApiParam(value = "删除物资分类请求参数", required = true) @RequestParam Long materialTypeId,
@@ -62,6 +110,13 @@ public class MaterialController {
return materialService.deleteMaterialType(materialTypeId);
}
+ /**
+ * 新增物资的方法。
+ *
+ * @param operateMaterialQuery 新增物资的请求实体，包含要新增的物资的详细信息，如物资名称、规格、所属分类等。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含新增物资操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
@PostMapping("/addMaterial")
@ApiOperation(value = "新增物资", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
public Result addMaterial(@ApiParam(value = "新增物资请求实体", required = true) @RequestBody OperateMaterialQuery operateMaterialQuery,
@@ -69,6 +124,13 @@ public class MaterialController {
return materialService.addMaterial(operateMaterialQuery);
}
+ /**
+ * 根据编号查询物资信息的方法。
+ *
+ * @param materialId 要查询的物资的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含根据编号查询物资操作结果的 Result 对象，封装了操作是否成功以及获取到的物资详细信息等。
+ */
@GetMapping("/getMaterialById")
@ApiOperation(value = "根据编号查询物资", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
public Result getMaterialById(@ApiParam(value = "根据编号查询物资请求参数", required = true) @RequestParam Long materialId,
@@ -76,6 +138,13 @@ public class MaterialController {
return materialService.getMaterialById(materialId);
}
+ /**
+ * 编辑物资信息的方法。
+ *
+ * @param operateMaterialQuery 编辑物资的请求实体，包含要修改的物资的详细信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含编辑物资操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
@PutMapping("/editMaterial")
@ApiOperation(value = "编辑物资", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
public Result editMaterial(@ApiParam(value = "编辑物资请求实体", required = true) @RequestBody OperateMaterialQuery operateMaterialQuery,
@@ -83,10 +152,17 @@ public class MaterialController {
return materialService.editMaterial(operateMaterialQuery);
}
+ /**
+ * 删除物资的方法。
+ *
+ * @param materialId 要删除的物资的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含删除物资操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
@DeleteMapping("/deleteMaterial")
@ApiOperation(value = "删除物资", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
public Result deleteMaterial(@ApiParam(value = "删除物资请求参数", required = true) @RequestParam Long materialId,
@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
return materialService.deleteMaterial(materialId);
}
-}
+}
\ 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/OrderController.java b/server/src/main/java/com/ew/gerocomium/controller/OrderController.java
index cd6fcce..2e4f7d0 100644
--- a/server/src/main/java/com/ew/gerocomium/controller/OrderController.java
+++ b/server/src/main/java/com/ew/gerocomium/controller/OrderController.java
@@ -1,86 +1,225 @@
+// 声明该类所属的包，方便代码的组织和管理
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.DishesService;
+// 导入护理预定服务类，用于处理与护理预定相关的业务逻辑
import com.ew.gerocomium.service.NurseReserveService;
+// 导入订单服务类，用于处理与订单相关的业务逻辑
import com.ew.gerocomium.service.OrderService;
+// 导入 Swagger 注解，用于在生成 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 请求
import org.springframework.web.bind.annotation.*;
-
+// 导入 Spring 注解，用于实现依赖注入
import javax.annotation.Resource;
+/**
+ * 点餐控制器类，用于处理与点餐相关的各种操作请求，
+ * 包括分页查询点餐记录、搜索老人、菜品分类和菜品的查询、新增点餐、根据编号获取点餐信息、
+ * 获取护理人员列表以及送餐等功能。
+ */
+// 使用 Swagger 的 @Api 注解，标记该控制器的标签为“点餐”，方便在 API 文档中分类展示
@Api(tags = "点餐")
+// 使用 Spring MVC 的 @RestController 注解，将该类标记为 RESTful 风格的控制器，处理 HTTP 请求并返回 JSON 格式的响应
@RestController
+// 使用 Spring MVC 的 @RequestMapping 注解，定义该控制器的基础请求路径为 /order
@RequestMapping("/order")
+// 使用 Spring Security 的 @PreAuthorize 注解，进行权限控制，只有拥有 '/food/order' 权限的用户才能访问该控制器的方法
@PreAuthorize("@AuthorityAssert.hasAuthority('/food/order')")
public class OrderController {
+
+ // 使用 @Resource 注解，将 OrderService 实例注入到当前类中，用于处理订单相关的业务逻辑
@Resource
private OrderService orderService;
+
+ // 使用 @Resource 注解，将 DepositRechargeService 实例注入到当前类中，用于处理押金充值相关的业务逻辑
@Resource
private DepositRechargeService depositRechargeService;
+
+ // 使用 @Resource 注解，将 DishesService 实例注入到当前类中，用于处理菜品相关的业务逻辑
@Resource
private DishesService dishesService;
+
+ // 使用 @Resource 注解，将 NurseReserveService 实例注入到当前类中，用于处理护理预定相关的业务逻辑
@Resource
private NurseReserveService nurseReserveService;
+ /**
+ * 分页查询点餐记录的方法。
+ *
+ * @param pageOrderByKeyQuery 分页查询点餐的请求实体，包含查询条件（如点餐时间、点餐人等）和分页信息（如页码、每页数量等）。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含分页查询点餐操作结果的 Result 对象，封装了操作是否成功以及查询到的点餐数据列表等信息。
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，处理 HTTP GET 请求，路径为 /order/pageOrderByKey
@GetMapping("/pageOrderByKey")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称和备注信息
@ApiOperation(value = "分页查询点餐", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result pageOrderByKey(@ApiParam(value = "分页查询点餐请求实体", required = true) PageOrderByKeyQuery pageOrderByKeyQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result pageOrderByKey(
+ // 使用 Swagger 的 @ApiParam 注解，描述参数的作用和是否必填
+ @ApiParam(value = "分页查询点餐请求实体", required = true)
+ PageOrderByKeyQuery pageOrderByKeyQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述参数的作用和是否必填，并使用 @RequestHeader 注解从请求头中获取参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 OrderService 的 pageOrderByKey 方法进行分页查询，并返回结果
return orderService.pageOrderByKey(pageOrderByKeyQuery);
}
+ /**
+ * 分页搜索老人信息的方法。
+ *
+ * @param pageSearchElderByKeyQuery 分页搜索老人的请求实体，包含搜索条件（如老人姓名、身份证号等）和分页信息（如页码、每页数量等）。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含分页搜索老人操作结果的 Result 对象，封装了操作是否成功以及搜索到的老人数据列表等信息。
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，处理 HTTP GET 请求，路径为 /order/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 dishesTypeName 可选的菜品分类名称参数，用于筛选特定名称的菜品分类，若为 null 则获取所有分类。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含获取菜品分类操作结果的 Result 对象，封装了操作是否成功以及获取到的菜品分类数据列表等信息。
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，处理 HTTP GET 请求，路径为 /order/listDishesType
@GetMapping("/listDishesType")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称和备注信息
@ApiOperation(value = "获取菜品分类", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result listDishesType(@ApiParam(value = "获取菜品分类请求参数", required = false) String dishesTypeName,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result listDishesType(
+ // 使用 Swagger 的 @ApiParam 注解，描述参数的作用和是否必填
+ @ApiParam(value = "获取菜品分类请求参数", required = false)
+ String dishesTypeName,
+ // 使用 Swagger 的 @ApiParam 注解，描述参数的作用和是否必填，并使用 @RequestHeader 注解从请求头中获取参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 DishesService 的 listDishesType 方法获取菜品分类列表，并返回结果
return dishesService.listDishesType(dishesTypeName);
}
+ /**
+ * 分页查询菜品信息的方法。
+ *
+ * @param pageDishesByKeyQuery 分页查询菜品的请求实体，包含查询条件（如菜品名称、价格范围等）和分页信息（如页码、每页数量等）。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含分页查询菜品操作结果的 Result 对象，封装了操作是否成功以及查询到的菜品数据列表等信息。
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，处理 HTTP GET 请求，路径为 /order/pageDishesByKey
@GetMapping("/pageDishesByKey")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称和备注信息
@ApiOperation(value = "分页查询菜品", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result pageDishesByKey(@ApiParam(value = "分页查询菜品请求实体", required = true) PageDishesByKeyQuery pageDishesByKeyQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result pageDishesByKey(
+ // 使用 Swagger 的 @ApiParam 注解，描述参数的作用和是否必填
+ @ApiParam(value = "分页查询菜品请求实体", required = true)
+ PageDishesByKeyQuery pageDishesByKeyQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述参数的作用和是否必填，并使用 @RequestHeader 注解从请求头中获取参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 DishesService 的 pageDishesByKey 方法进行分页查询，并返回结果
return dishesService.pageDishesByKey(pageDishesByKeyQuery);
}
+ /**
+ * 新增点餐记录的方法。
+ *
+ * @param addOrderQuery 新增点餐的请求实体，包含要新增的点餐的详细信息，如点餐人、点餐菜品、数量等。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含新增点餐操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 使用 Spring MVC 的 @PostMapping 注解，处理 HTTP POST 请求，路径为 /order/addOrder
@PostMapping("/addOrder")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称和备注信息
@ApiOperation(value = "新增点餐", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result addOrder(@ApiParam(value = "新增点餐请求实体", required = true) @RequestBody AddOrderQuery addOrderQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result addOrder(
+ // 使用 Swagger 的 @ApiParam 注解，描述参数的作用和是否必填，并使用 @RequestBody 注解从请求体中获取参数值
+ @ApiParam(value = "新增点餐请求实体", required = true) @RequestBody
+ AddOrderQuery addOrderQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述参数的作用和是否必填，并使用 @RequestHeader 注解从请求头中获取参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 OrderService 的 addOrder 方法新增点餐记录，并返回结果
return orderService.addOrder(addOrderQuery);
}
+ /**
+ * 根据编号获取点餐记录信息的方法。
+ *
+ * @param orderId 要获取信息的点餐记录的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含根据编号获取点餐记录操作结果的 Result 对象，封装了操作是否成功以及获取到的点餐记录详细信息等。
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，处理 HTTP GET 请求，路径为 /order/getOrderById
@GetMapping("/getOrderById")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称和备注信息
@ApiOperation(value = "根据编号获取点餐", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result getOrderById(@ApiParam(value = "根据编号获取点餐请求参数", required = true) @RequestParam Long orderId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result getOrderById(
+ // 使用 Swagger 的 @ApiParam 注解，描述参数的作用和是否必填，并使用 @RequestParam 注解从请求参数中获取参数值
+ @ApiParam(value = "根据编号获取点餐请求参数", required = true) @RequestParam
+ Long orderId,
+ // 使用 Swagger 的 @ApiParam 注解，描述参数的作用和是否必填，并使用 @RequestHeader 注解从请求头中获取参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 OrderService 的 getOrderById 方法获取点餐记录信息，并返回结果
return orderService.getOrderById(orderId);
}
+ /**
+ * 获取护理人员列表的方法。
+ *
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含获取护理人员列表操作结果的 Result 对象，封装了操作是否成功以及获取到的护理人员数据列表等信息。
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，处理 HTTP GET 请求，路径为 /order/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 sendOrderQuery 送餐的请求实体，包含送餐的详细信息，如订单编号、送餐地址、送餐时间等。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含送餐操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 使用 Spring MVC 的 @PutMapping 注解，处理 HTTP PUT 请求，路径为 /order/sendOrder
@PutMapping("/sendOrder")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称和备注信息
@ApiOperation(value = "送餐", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result sendOrder(@ApiParam(value = "送餐请求实体", required = true) @RequestBody SendOrderQuery sendOrderQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result sendOrder(
+ // 使用 Swagger 的 @ApiParam 注解，描述参数的作用和是否必填，并使用 @RequestBody 注解从请求体中获取参数值
+ @ApiParam(value = "送餐请求实体", required = true) @RequestBody
+ SendOrderQuery sendOrderQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述参数的作用和是否必填，并使用 @RequestHeader 注解从请求头中获取参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用 OrderService 的 sendOrder 方法进行送餐操作，并返回结果
return orderService.sendOrder(sendOrderQuery);
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/controller/OutboundRecordController.java b/server/src/main/java/com/ew/gerocomium/controller/OutboundRecordController.java
index b36f1ed..6e1f806 100644
--- a/server/src/main/java/com/ew/gerocomium/controller/OutboundRecordController.java
+++ b/server/src/main/java/com/ew/gerocomium/controller/OutboundRecordController.java
@@ -1,99 +1,259 @@
+// 声明该类所在的包，用于组织代码结构
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.OutboundRecordService;
+// 导入仓库记录服务类，处理与仓库记录相关的业务逻辑
import com.ew.gerocomium.service.WarehouseRecordService;
+// 导入仓库服务类，处理与仓库相关的业务逻辑
import com.ew.gerocomium.service.WarehouseService;
+// 导入 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 注解，指定该控制器处理的请求的基础路径为 "/outboundRecord"
@RequestMapping("/outboundRecord")
+// 使用 Spring Security 的 @PreAuthorize 注解，进行权限验证，只有拥有 '/resource/leave' 权限的用户才能访问该控制器的方法
@PreAuthorize("@AuthorityAssert.hasAuthority('/resource/leave')")
public class OutboundRecordController {
+
+ // 使用 @Resource 注解，将 OutboundRecordService 类型的实例注入到当前类中，以便调用其方法处理出库记录相关业务逻辑
@Resource
private OutboundRecordService outboundRecordService;
+
+ // 使用 @Resource 注解，将 DepositRechargeService 类型的实例注入到当前类中，以便调用其方法处理押金充值相关业务逻辑
@Resource
private DepositRechargeService depositRechargeService;
+
+ // 使用 @Resource 注解，将 WarehouseService 类型的实例注入到当前类中，以便调用其方法处理仓库相关业务逻辑
@Resource
private WarehouseService warehouseService;
+
+ // 使用 @Resource 注解，将 WarehouseRecordService 类型的实例注入到当前类中，以便调用其方法处理仓库记录相关业务逻辑
@Resource
private WarehouseRecordService warehouseRecordService;
+ /**
+ * 分页查询出库记录信息的方法。
+ *
+ * @param pageOutboundRecordByKeyQuery 分页查询出库记录的请求实体，包含查询条件（如出库时间、出库物资等）和分页信息（如页码、每页数量等）。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含分页查询出库记录操作结果的 Result 对象，封装了操作是否成功以及查询到的出库记录数据列表等信息。
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/outboundRecord/pageOutboundRecordByKey"
@GetMapping("/pageOutboundRecordByKey")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“分页查询出库记录”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "分页查询出库记录", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result pageOutboundRecordByKey(@ApiParam(value = "分页查询出库记录请求实体", required = true) PageOutboundRecordByKeyQuery pageOutboundRecordByKeyQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result pageOutboundRecordByKey(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“分页查询出库记录请求实体”，并标记为必需参数
+ @ApiParam(value = "分页查询出库记录请求实体", required = true)
+ PageOutboundRecordByKeyQuery pageOutboundRecordByKeyQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用出库记录服务类的 pageOutboundRecordByKey 方法，传入分页查询请求实体，获取分页查询结果并以 Result 对象形式返回
return outboundRecordService.pageOutboundRecordByKey(pageOutboundRecordByKeyQuery);
}
+ /**
+ * 分页搜索老人信息的方法。
+ *
+ * @param pageSearchElderByKeyQuery 分页搜索老人的请求实体，包含搜索条件（如老人姓名、身份证号等）和分页信息（如页码、每页数量等）。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含分页搜索老人操作结果的 Result 对象，封装了操作是否成功以及搜索到的老人数据列表等信息。
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/outboundRecord/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 depositRechargeService.pageSearchElderByKey(pageSearchElderByKeyQuery);
}
+ /**
+ * 分页搜索员工信息的方法。
+ *
+ * @param pageSearchStaffByKeyQuery 分页搜索员工的请求实体，包含搜索条件（如员工姓名、工号等）和分页信息（如页码、每页数量等）。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含分页搜索员工操作结果的 Result 对象，封装了操作是否成功以及搜索到的员工数据列表等信息。
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/outboundRecord/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 outboundRecordService.pageSearchStaffByKey(pageSearchStaffByKeyQuery);
}
+ /**
+ * 获取仓库列表的方法。
+ *
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含获取仓库列表操作结果的 Result 对象，封装了操作是否成功以及获取到的仓库数据列表等信息。
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/outboundRecord/listWarehouse"
@GetMapping("/listWarehouse")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“获取仓库列表”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "获取仓库列表", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result listWarehouse(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result listWarehouse(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用仓库记录服务类的 listWarehouse 方法获取仓库列表，并以 Result 对象形式返回结果
return warehouseRecordService.listWarehouse();
}
+ /**
+ * 获取登记人的方法。
+ *
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含获取登记人操作结果的 Result 对象，封装了操作是否成功以及获取到的登记人数据列表等信息。
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/outboundRecord/listWarehouseStaff"
@GetMapping("/listWarehouseStaff")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“获取登记人”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "获取登记人", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result listWarehouseStaff(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result listWarehouseStaff(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用仓库服务类的 listWarehouseStaff 方法获取登记人列表，并以 Result 对象形式返回结果
return warehouseService.listWarehouseStaff();
}
+ /**
+ * 分页查询仓库物资信息的方法。
+ *
+ * @param pageWarehouseMaterialByKeyQuery 分页查询仓库物资的请求实体，包含查询条件（如物资名称、库存数量等）和分页信息（如页码、每页数量等）。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含分页查询仓库物资操作结果的 Result 对象，封装了操作是否成功以及查询到的仓库物资数据列表等信息。
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/outboundRecord/pageWarehouseMaterialByKey"
@GetMapping("/pageWarehouseMaterialByKey")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“分页查询仓库物资”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "分页查询仓库物资", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result pageWarehouseMaterialByKey(@ApiParam(value = "分页查询仓库物资请求实体", required = true) PageWarehouseMaterialByKeyQuery pageWarehouseMaterialByKeyQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result pageWarehouseMaterialByKey(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“分页查询仓库物资请求实体”，并标记为必需参数
+ @ApiParam(value = "分页查询仓库物资请求实体", required = true)
+ PageWarehouseMaterialByKeyQuery pageWarehouseMaterialByKeyQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用出库记录服务类的 pageWarehouseMaterialByKey 方法，传入分页查询请求实体，获取分页查询结果并以 Result 对象形式返回
return outboundRecordService.pageWarehouseMaterialByKey(pageWarehouseMaterialByKeyQuery);
}
+ /**
+ * 新增出库记录的方法。
+ *
+ * @param addOutboundRecordQuery 新增出库记录的请求实体，包含要新增的出库记录的详细信息，如出库物资、数量、出库人等。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含新增出库记录操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 使用 Spring MVC 的 @PostMapping 注解，指定该方法处理 HTTP POST 请求，路径为 "/outboundRecord/addOutboundRecord"
@PostMapping("/addOutboundRecord")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“新增出库记录”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "新增出库记录", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result addOutboundRecord(@ApiParam(value = "新增出库记录请求实体", required = true) @RequestBody AddOutboundRecordQuery addOutboundRecordQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result addOutboundRecord(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“新增出库记录请求实体”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+ @ApiParam(value = "新增出库记录请求实体", required = true) @RequestBody AddOutboundRecordQuery addOutboundRecordQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用出库记录服务类的 addOutboundRecord 方法，传入新增出库记录请求实体，执行新增操作并以 Result 对象形式返回
return outboundRecordService.addOutboundRecord(addOutboundRecordQuery);
}
+ /**
+ * 根据编号查询出库记录信息的方法。
+ *
+ * @param outboundRecordId 要获取信息的出库记录的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含根据编号查询出库记录操作结果的 Result 对象，封装了操作是否成功以及获取到的出库记录详细信息等。
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/outboundRecord/getOutboundRecordById"
@GetMapping("/getOutboundRecordById")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“根据编号查询出库记录”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "根据编号查询出库记录", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result getOutboundRecordById(@ApiParam(value = "根据编号查询出库记录请求参数", required = true) @RequestParam Long outboundRecordId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result getOutboundRecordById(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“根据编号查询出库记录请求参数”，并标记为必需参数，同时使用 @RequestParam 注解从请求参数中获取该参数值
+ @ApiParam(value = "根据编号查询出库记录请求参数", required = true) @RequestParam Long outboundRecordId,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用出库记录服务类的 getOutboundRecordById 方法，传入出库记录编号，获取出库记录信息并以 Result 对象形式返回
return outboundRecordService.getOutboundRecordById(outboundRecordId);
}
+ /**
+ * 审核出库记录的方法。
+ *
+ * @param auditOutboundRecordQuery 审核出库记录的请求实体，包含审核所需的详细信息，如审核结果、审核意见等。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含审核出库记录操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 使用 Spring MVC 的 @PutMapping 注解，指定该方法处理 HTTP PUT 请求，路径为 "/outboundRecord/auditOutboundRecord"
@PutMapping("/auditOutboundRecord")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“审核出库记录”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "审核出库记录", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result auditOutboundRecord(@ApiParam(value = "审核出库记录请求实体", required = true) @RequestBody AuditOutboundRecordQuery auditOutboundRecordQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result auditOutboundRecord(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“审核出库记录请求实体”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+ @ApiParam(value = "审核出库记录请求实体", required = true) @RequestBody AuditOutboundRecordQuery auditOutboundRecordQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用出库记录服务类的 auditOutboundRecord 方法，传入审核请求实体，执行审核操作并以 Result 对象形式返回
return outboundRecordService.auditOutboundRecord(auditOutboundRecordQuery);
}
+ /**
+ * 删除出库记录的方法。
+ *
+ * @param outboundRecordId 要删除的出库记录的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含删除出库记录操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 使用 Spring MVC 的 @DeleteMapping 注解，指定该方法处理 HTTP DELETE 请求，路径为 "/outboundRecord/deleteOutboundRecord"
@DeleteMapping("/deleteOutboundRecord")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“删除出库记录”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "删除出库记录", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result deleteOutboundRecord(@ApiParam(value = "删除出库记录请求参数", required = true) @RequestParam Long outboundRecordId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result deleteOutboundRecord(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“删除出库记录请求参数”，并标记为必需参数，同时使用 @RequestParam 注解从请求参数中获取该参数值
+ @ApiParam(value = "删除出库记录请求参数", required = true) @RequestParam Long outboundRecordId,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用出库记录服务类的 deleteOutboundRecord 方法，传入出库记录编号，执行删除操作并以 Result 对象形式返回
return outboundRecordService.deleteOutboundRecord(outboundRecordId);
}
-}
+}
\ 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/RetreatAuditController.java b/server/src/main/java/com/ew/gerocomium/controller/RetreatAuditController.java
index cb7a45c..c5c2058 100644
--- a/server/src/main/java/com/ew/gerocomium/controller/RetreatAuditController.java
+++ b/server/src/main/java/com/ew/gerocomium/controller/RetreatAuditController.java
@@ -1,44 +1,103 @@
+// 声明该类所在的包，用于组织和管理项目中的类，这里表明是与退住费用审核相关的控制器类所在的包
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.AuditElderFeeQuery;
+// 导入分页查询退住审核的查询实体类，用于封装分页查询退住审核信息时的条件和分页信息
import com.ew.gerocomium.dao.query.PageRetreatAuditQuery;
+// 导入退住审核服务类，该类包含处理退住费用审核相关业务逻辑的方法
import com.ew.gerocomium.service.RetreatAuditService;
+// 导入 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 注解，指定该控制器处理的请求的基础路径为 "/retreatAudit"
@RequestMapping("/retreatAudit")
+// 使用 Spring Security 的 @PreAuthorize 注解，进行权限验证，只有拥有 '/fee/audit' 权限的用户才能访问该控制器的方法
@PreAuthorize("@AuthorityAssert.hasAuthority('/fee/audit')")
public class RetreatAuditController {
+ // 使用 @Resource 注解，将 RetreatAuditService 类型的实例注入到当前类中，以便调用其方法处理业务逻辑
@Resource
private RetreatAuditService retreatAuditService;
+ /**
+ * 分页查询退住审核信息。
+ *
+ * @param pageRetreatAuditQuery 分页查询退住审核的请求实体，包含查询条件和分页信息
+ * @param token 接口访问请求头中的令牌，用于身份验证
+ * @return 包含分页查询结果的 Result 对象
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/retreatAudit/pageRetreatAuditByKey"
@GetMapping("/pageRetreatAuditByKey")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“分页查询退住审核”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "分页查询退住审核", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result pageRetreatAuditByKey(@ApiParam(value = "分页查询退住审核请求实体", required = true) PageRetreatAuditQuery pageRetreatAuditQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result pageRetreatAuditByKey(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“分页查询退住审核请求实体”，并标记为必需参数
+ @ApiParam(value = "分页查询退住审核请求实体", required = true)
+ PageRetreatAuditQuery pageRetreatAuditQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用退住审核服务类的 pageRetreatAuditByKey 方法，传入分页查询请求实体，获取分页查询结果并以 Result 对象形式返回
return retreatAuditService.pageRetreatAuditByKey(pageRetreatAuditQuery);
}
+ /**
+ * 根据老人编号获取老人费用详情。
+ *
+ * @param elderId 老人的编号，用于指定要查询的老人
+ * @param token 接口访问请求头中的令牌，用于身份验证
+ * @return 包含老人费用详情的 Result 对象
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/retreatAudit/getElderFeeById"
@GetMapping("/getElderFeeById")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“根据编号获取老人费用详情”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "根据编号获取老人费用详情", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result getElderFeeById(@ApiParam(value = "根据获取老人费用详情请求参数", required = true) @RequestParam Long elderId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result getElderFeeById(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“根据获取老人费用详情请求参数”，并标记为必需参数，同时使用 @RequestParam 注解从请求参数中获取该参数值
+ @ApiParam(value = "根据获取老人费用详情请求参数", required = true) @RequestParam Long elderId,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用退住审核服务类的 getElderFeeById 方法，传入老人编号，获取老人费用详情并以 Result 对象形式返回
return retreatAuditService.getElderFeeById(elderId);
}
+ /**
+ * 审核老人费用详情。
+ *
+ * @param auditElderFeeQuery 审核老人费用详情的请求实体，包含审核所需的信息
+ * @param token 接口访问请求头中的令牌，用于身份验证
+ * @return 包含审核结果的 Result 对象
+ */
+ // 使用 Spring MVC 的 @PutMapping 注解，指定该方法处理 HTTP PUT 请求，路径为 "/retreatAudit/auditElderFee"
@PutMapping("/auditElderFee")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“审核老人费用详情”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "审核老人费用详情", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result auditElderFee(@ApiParam(value = "审核老人费用详情请求实体", required = true) @RequestBody AuditElderFeeQuery auditElderFeeQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result auditElderFee(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“审核老人费用详情请求实体”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+ @ApiParam(value = "审核老人费用详情请求实体", required = true) @RequestBody AuditElderFeeQuery auditElderFeeQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用退住审核服务类的 auditElderFee 方法，传入审核请求实体，执行审核操作并将结果以 Result 对象形式返回
return retreatAuditService.auditElderFee(auditElderFeeQuery);
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/controller/RoomTypeController.java b/server/src/main/java/com/ew/gerocomium/controller/RoomTypeController.java
index 4b32439..2fabdc7 100644
--- a/server/src/main/java/com/ew/gerocomium/controller/RoomTypeController.java
+++ b/server/src/main/java/com/ew/gerocomium/controller/RoomTypeController.java
@@ -1,58 +1,145 @@
+// 声明该类所在的包，通常用于将相关的类组织在一起，这里表示这是控制器层的类
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.OperateRoomTypeQuery;
+// 导入分页查询房间类型的查询实体类，用于封装分页查询时的条件和分页信息
import com.ew.gerocomium.dao.query.PageRoomTypeByKeyQuery;
+// 导入房间类型的服务类，该类包含了处理房间类型相关业务逻辑的方法
import com.ew.gerocomium.service.RoomTypeService;
+// 导入 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 注解，指定该控制器处理的请求的基础路径为 "/roomType"
@RequestMapping("/roomType")
+// 使用 Spring Security 的 @PreAuthorize 注解，进行权限验证，只有拥有 '/base/check - in/room' 权限的用户才能访问该控制器的方法
@PreAuthorize("@AuthorityAssert.hasAuthority('/base/check-in/room')")
public class RoomTypeController {
+
+ // 使用 @Resource 注解，将 RoomTypeService 类型的实例注入到当前类中，以便调用其方法处理业务逻辑
@Resource
private RoomTypeService roomTypeService;
+ /**
+ * 分页查询房间类型信息的方法。
+ *
+ * @param pageRoomTypeByKeyQuery 分页查询房间类型的请求实体，包含查询条件（如房间类型名称、价格范围等）和分页信息（如页码、每页数量等）。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含分页查询房间类型操作结果的 Result 对象，封装了操作是否成功以及查询到的房间类型数据列表等信息。
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/roomType/pageRoomTypeByKey"
@GetMapping("/pageRoomTypeByKey")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“分页查询房间类型”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "分页查询房间类型", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result pageRoomTypeByKey(@ApiParam(value = "分页查询房间类型请求实体", required = true) PageRoomTypeByKeyQuery pageRoomTypeByKeyQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result pageRoomTypeByKey(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“分页查询房间类型请求实体”，并标记为必需参数
+ @ApiParam(value = "分页查询房间类型请求实体", required = true)
+ PageRoomTypeByKeyQuery pageRoomTypeByKeyQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用房间类型服务类的 pageRoomTypeByKey 方法，传入分页查询请求实体，获取分页查询结果并以 Result 对象形式返回
return roomTypeService.pageRoomTypeByKey(pageRoomTypeByKeyQuery);
}
+ /**
+ * 新增房间类型的方法。
+ *
+ * @param operateRoomTypeQuery 新增房间类型的请求实体，包含要新增的房间类型的详细信息，如房间类型名称、房间面积、可容纳人数等。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含新增房间类型操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 使用 Spring MVC 的 @PostMapping 注解，指定该方法处理 HTTP POST 请求，路径为 "/roomType/addRoomType"
@PostMapping("/addRoomType")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“新增房间类型”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "新增房间类型", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result addRoomType(@ApiParam(value = "新增房间类型请求实体", required = true) @RequestBody OperateRoomTypeQuery operateRoomTypeQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result addRoomType(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“新增房间类型请求实体”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+ @ApiParam(value = "新增房间类型请求实体", required = true) @RequestBody OperateRoomTypeQuery operateRoomTypeQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用房间类型服务类的 addRoomType 方法，传入新增房间类型请求实体，执行新增操作并将结果以 Result 对象形式返回
return roomTypeService.addRoomType(operateRoomTypeQuery);
}
+ /**
+ * 根据编号获取房间类型信息的方法。
+ *
+ * @param roomTypeId 要获取信息的房间类型的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含根据编号获取房间类型操作结果的 Result 对象，封装了操作是否成功以及获取到的房间类型详细信息等。
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/roomType/getRoomTypeById"
@GetMapping("/getRoomTypeById")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“根据编号获取房间类型”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "根据编号获取房间类型", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result getRoomTypeById(@ApiParam(value = "根据编号获取房间类型请求参数", required = true) @RequestParam Long roomTypeId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result getRoomTypeById(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“根据编号获取房间类型请求参数”，并标记为必需参数，同时使用 @RequestParam 注解从请求参数中获取该参数值
+ @ApiParam(value = "根据编号获取房间类型请求参数", required = true) @RequestParam Long roomTypeId,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用房间类型服务类的 getRoomTypeById 方法，传入房间类型编号，获取指定编号的房间类型详细信息并以 Result 对象形式返回
return roomTypeService.getRoomTypeById(roomTypeId);
}
+ /**
+ * 编辑房间类型信息的方法。
+ *
+ * @param operateRoomTypeQuery 编辑房间类型的请求实体，包含要修改的房间类型的详细信息。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含编辑房间类型操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 使用 Spring MVC 的 @PutMapping 注解，指定该方法处理 HTTP PUT 请求，路径为 "/roomType/editRoomType"
@PutMapping("/editRoomType")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“编辑房间类型”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "编辑房间类型", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result editRoomType(@ApiParam(value = "编辑房间类型请求实体", required = true) @RequestBody OperateRoomTypeQuery operateRoomTypeQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result editRoomType(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“编辑房间类型请求实体”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+ @ApiParam(value = "编辑房间类型请求实体", required = true) @RequestBody OperateRoomTypeQuery operateRoomTypeQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用房间类型服务类的 editRoomType 方法，传入编辑房间类型请求实体，执行编辑操作并将结果以 Result 对象形式返回
return roomTypeService.editRoomType(operateRoomTypeQuery);
}
+ /**
+ * 删除房间类型的方法。
+ *
+ * @param roomTypeId 要删除的房间类型的编号。
+ * @param token 接口访问请求头中的令牌，用于身份验证，确保只有合法用户才能访问该接口。
+ * @return 包含删除房间类型操作结果的 Result 对象，封装了操作是否成功以及可能的错误信息等。
+ */
+ // 使用 Spring MVC 的 @DeleteMapping 注解，指定该方法处理 HTTP DELETE 请求，路径为 "/roomType/deleteRoomType"
@DeleteMapping("/deleteRoomType")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“删除房间类型”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "删除房间类型", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result deleteRoomType(@ApiParam(value = "删除房间类型请求参数", required = true) @RequestParam Long roomTypeId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result deleteRoomType(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“删除房间类型请求参数”，并标记为必需参数，同时使用 @RequestParam 注解从请求参数中获取该参数值
+ @ApiParam(value = "删除房间类型请求参数", required = true) @RequestParam Long roomTypeId,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用房间类型服务类的 deleteRoomType 方法，传入房间类型编号，执行删除操作并将结果以 Result 对象形式返回
return roomTypeService.deleteRoomType(roomTypeId);
}
-}
+}
\ 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/SourceController.java b/server/src/main/java/com/ew/gerocomium/controller/SourceController.java
index de64f72..f81ce29 100644
--- a/server/src/main/java/com/ew/gerocomium/controller/SourceController.java
+++ b/server/src/main/java/com/ew/gerocomium/controller/SourceController.java
@@ -1,58 +1,144 @@
+// 声明该类所在的包，用于组织和管理代码结构，表明这是一个控制器类所在的包
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.OperateSourceQuery;
+// 导入分页查询来源渠道的查询实体类，用于封装分页查询时的条件和分页信息
import com.ew.gerocomium.dao.query.PageSourceByKeyQuery;
+// 导入来源渠道服务类，该类包含处理来源渠道相关业务逻辑的方法
import com.ew.gerocomium.service.SourceService;
+// 导入 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 注解，指定该控制器处理的请求的基础路径为 "/source"
@RequestMapping("/source")
+// 使用 Spring Security 的 @PreAuthorize 注解，进行权限验证，只有拥有 '/base/marketing/origin' 权限的用户才能访问该控制器的方法
@PreAuthorize("@AuthorityAssert.hasAuthority('/base/marketing/origin')")
public class SourceController {
+ // 使用 @Resource 注解，将 SourceService 类型的实例注入到当前类中，以便调用其方法处理业务逻辑
@Resource
private SourceService sourceService;
+ /**
+ * 分页查询来源渠道信息。
+ *
+ * @param pageSourceByKeyQuery 分页查询来源渠道的请求实体，包含查询条件和分页信息
+ * @param token 接口访问请求头中的令牌，用于身份验证
+ * @return 包含分页查询结果的 Result 对象
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/source/pageSourceByKey"
@GetMapping("/pageSourceByKey")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“分页查询来源渠道”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "分页查询来源渠道", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result pageSourceByKey(@ApiParam(value = "分页查询来源渠道请求实体", required = true) PageSourceByKeyQuery pageSourceByKeyQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result pageSourceByKey(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“分页查询来源渠道请求实体”，并标记为必需参数
+ @ApiParam(value = "分页查询来源渠道请求实体", required = true)
+ PageSourceByKeyQuery pageSourceByKeyQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用来源渠道服务类的 pageSourceByKey 方法，传入分页查询请求实体，获取分页查询结果并以 Result 对象形式返回
return sourceService.pageSourceByKey(pageSourceByKeyQuery);
}
+ /**
+ * 新增来源渠道。
+ *
+ * @param operateSourceQuery 新增来源渠道的请求实体，包含要新增的来源渠道的相关信息
+ * @param token 接口访问请求头中的令牌，用于身份验证
+ * @return 包含新增操作结果的 Result 对象
+ */
+ // 使用 Spring MVC 的 @PostMapping 注解，指定该方法处理 HTTP POST 请求，路径为 "/source/addSource"
@PostMapping("/addSource")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“新增来源渠道”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "新增来源渠道", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result addSource(@ApiParam(value = "新增来源渠道请求参数", required = true) @RequestBody OperateSourceQuery operateSourceQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result addSource(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“新增来源渠道请求参数”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+ @ApiParam(value = "新增来源渠道请求参数", required = true) @RequestBody OperateSourceQuery operateSourceQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 从请求实体中获取来源渠道名称，并调用来源渠道服务类的 addSource 方法进行新增操作，将操作结果以 Result 对象形式返回
return sourceService.addSource(operateSourceQuery.getName());
}
+ /**
+ * 根据编号获取来源渠道信息。
+ *
+ * @param sourceId 要获取的来源渠道的编号
+ * @param token 接口访问请求头中的令牌，用于身份验证
+ * @return 包含来源渠道详细信息的 Result 对象
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 "/source/getSourceById"
@GetMapping("/getSourceById")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“根据编号获取来源渠道”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "根据编号获取来源渠道", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result getSourceById(@ApiParam(value = "根据编号获取来源渠道请求参数", required = true) @RequestParam Long sourceId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result getSourceById(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“根据编号获取来源渠道请求参数”，并标记为必需参数，同时使用 @RequestParam 注解从请求参数中获取该参数值
+ @ApiParam(value = "根据编号获取来源渠道请求参数", required = true) @RequestParam Long sourceId,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用来源渠道服务类的 getSourceById 方法，传入来源渠道编号，获取指定编号的来源渠道信息，并以 Result 对象形式返回
return sourceService.getSourceById(sourceId);
}
+ /**
+ * 编辑来源渠道信息。
+ *
+ * @param operateSourceQuery 编辑来源渠道的请求实体，包含要更新的来源渠道的相关信息
+ * @param token 接口访问请求头中的令牌，用于身份验证
+ * @return 包含编辑操作结果的 Result 对象
+ */
+ // 使用 Spring MVC 的 @PutMapping 注解，指定该方法处理 HTTP PUT 请求，路径为 "/source/editSource"
@PutMapping("/editSource")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“编辑来源渠道”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "编辑来源渠道", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result editSource(@ApiParam(value = "编辑来源渠道请求实体", required = true) @RequestBody OperateSourceQuery operateSourceQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result editSource(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“编辑来源渠道请求实体”，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数值
+ @ApiParam(value = "编辑来源渠道请求实体", required = true) @RequestBody OperateSourceQuery operateSourceQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用来源渠道服务类的 editSource 方法，传入编辑请求实体，执行编辑操作，并将操作结果以 Result 对象形式返回
return sourceService.editSource(operateSourceQuery);
}
+ /**
+ * 删除来源渠道。
+ *
+ * @param sourceId 要删除的来源渠道的编号
+ * @param token 接口访问请求头中的令牌，用于身份验证
+ * @return 包含删除操作结果的 Result 对象
+ */
+ // 使用 Spring MVC 的 @DeleteMapping 注解，指定该方法处理 HTTP DELETE 请求，路径为 "/source/deleteSource"
@DeleteMapping("/deleteSource")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称为“删除来源渠道”，并添加备注信息（包含开发者信息）
@ApiOperation(value = "删除来源渠道", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result deleteSource(@ApiParam(value = "删除来源渠道请求参数", required = true) @RequestParam Long sourceId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result deleteSource(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“删除来源渠道请求参数”，并标记为必需参数，同时使用 @RequestParam 注解从请求参数中获取该参数值
+ @ApiParam(value = "删除来源渠道请求参数", required = true) @RequestParam Long sourceId,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用为“接口访问请求头”，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用来源渠道服务类的 deleteSource 方法，传入来源渠道编号，执行删除操作，并将操作结果以 Result 对象形式返回
return sourceService.deleteSource(sourceId);
}
-}
+}
\ 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);
}
}
diff --git a/server/src/main/java/com/ew/gerocomium/controller/WarehouseController.java b/server/src/main/java/com/ew/gerocomium/controller/WarehouseController.java
index 901f882..d7cfb32 100644
--- a/server/src/main/java/com/ew/gerocomium/controller/WarehouseController.java
+++ b/server/src/main/java/com/ew/gerocomium/controller/WarehouseController.java
@@ -1,64 +1,161 @@
+// 声明该类所属的包，表明这是控制器层的类
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.OperateWarehouseQuery;
+// 导入按关键字分页查询仓库的查询实体类，用于传递分页和查询条件信息
import com.ew.gerocomium.dao.query.PageWarehouseByKeyQuery;
+// 导入仓库服务类，用于处理仓库相关的业务逻辑
import com.ew.gerocomium.service.WarehouseService;
+// 导入 Swagger 注解，用于标记 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 请求映射
import org.springframework.web.bind.annotation.*;
-
+// 导入 Spring 注解，用于依赖注入
import javax.annotation.Resource;
+/**
+ * 仓库设置相关的控制器类，处理与仓库管理相关的 HTTP 请求。
+ * 只有拥有 '/resource/set' 权限的用户才能访问该控制器中的接口。
+ */
+// 使用 Swagger 的 @Api 注解，标记该控制器的 API 分组为“仓库设置”
@Api(tags = "仓库设置")
+// 使用 Spring MVC 的 @RestController 注解，将该类标记为 RESTful 风格的控制器
@RestController
+// 使用 Spring MVC 的 @RequestMapping 注解，指定该控制器处理的请求路径前缀
@RequestMapping("/warehouse")
+// 使用 Spring Security 的 @PreAuthorize 注解，限制只有拥有 '/resource/set' 权限的用户才能访问该控制器的接口
@PreAuthorize("@AuthorityAssert.hasAuthority('/resource/set')")
public class WarehouseController {
+ // 使用 @Resource 注解，将 WarehouseService 类型的 Bean 注入到当前类中
@Resource
private WarehouseService warehouseService;
+ /**
+ * 分页查询仓库信息的接口
+ *
+ * @param pageWarehouseByKeyQuery 分页查询仓库的请求实体，包含分页参数和查询条件等信息
+ * @param token 接口访问请求头，用于身份验证等
+ * @return 返回包含分页查询仓库结果的 Result 对象
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 '/warehouse/pageWarehouseByKey'
@GetMapping("/pageWarehouseByKey")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称和备注信息
@ApiOperation(value = "分页查询仓库", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result pageWarehouseByKey(@ApiParam(value = "分页查询仓库请求实体", required = true) PageWarehouseByKeyQuery pageWarehouseByKeyQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result pageWarehouseByKey(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用，并标记为必需参数
+ @ApiParam(value = "分页查询仓库请求实体", required = true)
+ PageWarehouseByKeyQuery pageWarehouseByKeyQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用仓库服务类的分页查询仓库方法，并将结果返回
return warehouseService.pageWarehouseByKey(pageWarehouseByKeyQuery);
}
+ /**
+ * 获取仓库管理员列表的接口
+ *
+ * @param token 接口访问请求头，用于身份验证等
+ * @return 返回包含仓库管理员列表的 Result 对象
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 '/warehouse/listWarehouseStaff'
@GetMapping("/listWarehouseStaff")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称和备注信息
@ApiOperation(value = "仓库管理员", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result listWarehouseStaff(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result listWarehouseStaff(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用仓库服务类的获取仓库管理员列表方法，并将结果返回
return warehouseService.listWarehouseStaff();
}
+ /**
+ * 新增仓库的接口
+ *
+ * @param operateWarehouseQuery 新增仓库的请求实体，包含仓库的相关信息
+ * @param token 接口访问请求头，用于身份验证等
+ * @return 返回包含新增仓库操作结果的 Result 对象
+ */
+ // 使用 Spring MVC 的 @PostMapping 注解，指定该方法处理 HTTP POST 请求，路径为 '/warehouse/addWarehouse'
@PostMapping("/addWarehouse")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称和备注信息
@ApiOperation(value = "新增仓库", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result addWarehouse(@ApiParam(value = "新增仓库请求实体", required = true) @RequestBody OperateWarehouseQuery operateWarehouseQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result addWarehouse(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数
+ @ApiParam(value = "新增仓库请求实体", required = true) @RequestBody OperateWarehouseQuery operateWarehouseQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用仓库服务类的新增仓库方法，并将结果返回
return warehouseService.addWarehouse(operateWarehouseQuery);
}
+ /**
+ * 根据编号查询仓库信息的接口
+ *
+ * @param warehouseId 仓库编号，用于指定要查询的仓库
+ * @param token 接口访问请求头，用于身份验证等
+ * @return 返回包含指定编号仓库信息的 Result 对象
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，路径为 '/warehouse/getWarehouseById'
@GetMapping("/getWarehouseById")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称和备注信息
@ApiOperation(value = "根据编号查询仓库", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result getWarehouseById(@ApiParam(value = "根据编号查询仓库请求参数", required = true) @RequestParam Long warehouseId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result getWarehouseById(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用，并标记为必需参数，同时使用 @RequestParam 注解从请求参数中获取该参数
+ @ApiParam(value = "根据编号查询仓库请求参数", required = true) @RequestParam Long warehouseId,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用仓库服务类的根据编号查询仓库方法，并将结果返回
return warehouseService.getWarehouseById(warehouseId);
}
+ /**
+ * 编辑仓库信息的接口
+ *
+ * @param operateWarehouseQuery 编辑仓库的请求实体，包含要修改的仓库信息
+ * @param token 接口访问请求头，用于身份验证等
+ * @return 返回包含编辑仓库操作结果的 Result 对象
+ */
+ // 使用 Spring MVC 的 @PutMapping 注解，指定该方法处理 HTTP PUT 请求，路径为 '/warehouse/editWarehouse'
@PutMapping("/editWarehouse")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称和备注信息
@ApiOperation(value = "编辑仓库", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result editWarehouse(@ApiParam(value = "编辑仓库请求实体", required = true) @RequestBody OperateWarehouseQuery operateWarehouseQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result editWarehouse(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用，并标记为必需参数，同时使用 @RequestBody 注解从请求体中获取该参数
+ @ApiParam(value = "编辑仓库请求实体", required = true) @RequestBody OperateWarehouseQuery operateWarehouseQuery,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用仓库服务类的编辑仓库方法，并将结果返回
return warehouseService.editWarehouse(operateWarehouseQuery);
}
+ /**
+ * 删除仓库的接口
+ *
+ * @param warehouseId 要删除的仓库编号
+ * @param token 接口访问请求头，用于身份验证等
+ * @return 返回包含删除仓库操作结果的 Result 对象
+ */
+ // 使用 Spring MVC 的 @DeleteMapping 注解，指定该方法处理 HTTP DELETE 请求，路径为 '/warehouse/deleteWarehouse'
@DeleteMapping("/deleteWarehouse")
+ // 使用 Swagger 的 @ApiOperation 注解，描述该 API 操作的名称和备注信息
@ApiOperation(value = "删除仓库", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result deleteWarehouse(@ApiParam(value = "删除仓库请求参数", required = true) @RequestParam Long warehouseId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result deleteWarehouse(
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用，并标记为必需参数，同时使用 @RequestParam 注解从请求参数中获取该参数
+ @ApiParam(value = "删除仓库请求参数", required = true) @RequestParam Long warehouseId,
+ // 使用 Swagger 的 @ApiParam 注解，描述该参数的作用，并标记为必需参数，同时使用 @RequestHeader 注解从请求头中获取该参数
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用仓库服务类的删除仓库方法，并将结果返回
return warehouseService.deleteWarehouse(warehouseId);
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/controller/WarehouseRecordController.java b/server/src/main/java/com/ew/gerocomium/controller/WarehouseRecordController.java
index 9a227ed..e00cae5 100644
--- a/server/src/main/java/com/ew/gerocomium/controller/WarehouseRecordController.java
+++ b/server/src/main/java/com/ew/gerocomium/controller/WarehouseRecordController.java
@@ -1,82 +1,207 @@
+// 声明当前类所在的包名，该包名为控制器相关的包
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.MaterialService;
+// 导入仓库记录服务类，用于处理仓库记录相关的业务逻辑
import com.ew.gerocomium.service.WarehouseRecordService;
+// 导入仓库服务类，用于处理仓库相关的业务逻辑
import com.ew.gerocomium.service.WarehouseService;
+// 导入 Swagger 注解，用于生成 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 注解，将该类标记为 RESTful 风格的控制器
import org.springframework.web.bind.annotation.*;
-
+// 导入 Spring 注解，用于依赖注入，将所需的 Bean 注入到当前类中
import javax.annotation.Resource;
+/**
+ * 入库管理相关的控制器类，负责处理与入库管理业务相关的 HTTP 请求。
+ * 该控制器需要用户具有 '/resource/enter' 权限才能访问其接口。
+ */
+// 使用 Swagger 的 @Api 注解，标记该控制器属于“入库管理”这个 API 分组
@Api(tags = "入库管理")
+// 使用 Spring MVC 的 @RestController 注解，将该类标记为 RESTful 风格的控制器，返回的结果会自动进行 JSON 序列化
@RestController
+// 使用 Spring MVC 的 @RequestMapping 注解，指定该控制器处理的请求路径前缀
@RequestMapping("/warehouseRecord")
+// 使用 Spring Security 的 @PreAuthorize 注解，要求访问该控制器的接口需要具有 '/resource/enter' 权限
@PreAuthorize("@AuthorityAssert.hasAuthority('/resource/enter')")
public class WarehouseRecordController {
+ // 使用 @Resource 注解，将 WarehouseRecordService 类型的 Bean 注入到当前类中，用于处理入库记录的核心业务逻辑
@Resource
private WarehouseRecordService warehouseRecordService;
+ // 使用 @Resource 注解，将 WarehouseService 类型的 Bean 注入到当前类中，用于处理仓库相关的业务逻辑
@Resource
private WarehouseService warehouseService;
+ // 使用 @Resource 注解，将 MaterialService 类型的 Bean 注入到当前类中，用于处理物资相关的业务逻辑
@Resource
private MaterialService materialService;
+ /**
+ * 分页查询入库记录信息
+ *
+ * @param pageWarehouseRecordByKeyQuery 分页查询入库记录的请求实体，包含分页和查询条件等信息
+ * @param token 接口访问请求头，用于身份验证等操作
+ * @return 返回包含分页查询结果的 Result 对象
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，请求路径为 '/warehouseRecord/pageWarehouseRecordByKey'
@GetMapping("/pageWarehouseRecordByKey")
+ // 使用 Swagger 的 @ApiOperation 注解，标注该接口的操作信息，包含接口描述和开发者信息
@ApiOperation(value = "分页查询入库记录", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result pageWarehouseRecordByKey(@ApiParam(value = "分页查询入库记录请求实体", required = true) PageWarehouseRecordByKeyQuery pageWarehouseRecordByKeyQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result pageWarehouseRecordByKey(
+ // 使用 Swagger 的 @ApiParam 注解，标注该参数的信息，要求该参数为必需参数
+ @ApiParam(value = "分页查询入库记录请求实体", required = true)
+ PageWarehouseRecordByKeyQuery pageWarehouseRecordByKeyQuery,
+ // 使用 Swagger 的 @ApiParam 注解，标注该参数的信息，要求该参数为必需参数，同时使用 @RequestHeader 注解获取请求头中的 token 值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用入库记录服务类的分页查询方法，传入请求实体，获取分页查询结果
return warehouseRecordService.pageWarehouseRecordByKey(pageWarehouseRecordByKeyQuery);
}
+ /**
+ * 获取仓库列表信息
+ *
+ * @param token 接口访问请求头，用于身份验证等操作
+ * @return 返回包含仓库列表的 Result 对象
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，请求路径为 '/warehouseRecord/listWarehouse'
@GetMapping("/listWarehouse")
+ // 使用 Swagger 的 @ApiOperation 注解，标注该接口的操作信息，包含接口描述和开发者信息
@ApiOperation(value = "获取仓库列表", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result listWarehouse(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result listWarehouse(
+ // 使用 Swagger 的 @ApiParam 注解，标注该参数的信息，要求该参数为必需参数，同时使用 @RequestHeader 注解获取请求头中的 token 值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用入库记录服务类的获取仓库列表方法，获取仓库列表结果
return warehouseRecordService.listWarehouse();
}
+ /**
+ * 获取入库经办人员列表信息
+ *
+ * @param token 接口访问请求头，用于身份验证等操作
+ * @return 返回包含经办人列表的 Result 对象
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，请求路径为 '/warehouseRecord/listWarehouseStaff'
@GetMapping("/listWarehouseStaff")
+ // 使用 Swagger 的 @ApiOperation 注解，标注该接口的操作信息，包含接口描述和开发者信息
@ApiOperation(value = "获取经办人", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result listWarehouseStaff(@ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result listWarehouseStaff(
+ // 使用 Swagger 的 @ApiParam 注解，标注该参数的信息，要求该参数为必需参数，同时使用 @RequestHeader 注解获取请求头中的 token 值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用仓库服务类的获取仓库经办人列表方法，获取经办人列表结果
return warehouseService.listWarehouseStaff();
}
+ /**
+ * 分页查询物资信息
+ *
+ * @param pageMaterialByKeyQuery 分页查询物资的请求实体，包含分页和查询条件等信息
+ * @param token 接口访问请求头，用于身份验证等操作
+ * @return 返回包含分页查询物资结果的 Result 对象
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，请求路径为 '/warehouseRecord/pageMaterialByKey'
@GetMapping("/pageMaterialByKey")
+ // 使用 Swagger 的 @ApiOperation 注解，标注该接口的操作信息，包含接口描述和开发者信息
@ApiOperation(value = "分页查询物资", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result pageMaterialByKey(@ApiParam(value = "分页查询物资请求实体", required = true) PageMaterialByKeyQuery pageMaterialByKeyQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result pageMaterialByKey(
+ // 使用 Swagger 的 @ApiParam 注解，标注该参数的信息，要求该参数为必需参数
+ @ApiParam(value = "分页查询物资请求实体", required = true)
+ PageMaterialByKeyQuery pageMaterialByKeyQuery,
+ // 使用 Swagger 的 @ApiParam 注解，标注该参数的信息，要求该参数为必需参数，同时使用 @RequestHeader 注解获取请求头中的 token 值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用物资服务类的分页查询物资方法，传入请求实体，获取分页查询物资结果
return materialService.pageMaterialByKey(pageMaterialByKeyQuery);
}
+ /**
+ * 新增入库记录信息
+ *
+ * @param addWarehouseRecordQuery 新增入库记录的请求实体，包含入库记录的详细信息
+ * @param token 接口访问请求头，用于身份验证等操作
+ * @return 返回包含新增操作结果的 Result 对象
+ */
+ // 使用 Spring MVC 的 @PostMapping 注解，指定该方法处理 HTTP POST 请求，请求路径为 '/warehouseRecord/addWarehouseRecord'
@PostMapping("/addWarehouseRecord")
+ // 使用 Swagger 的 @ApiOperation 注解，标注该接口的操作信息，包含接口描述和开发者信息
@ApiOperation(value = "新增入库记录", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result addWarehouseRecord(@ApiParam(value = "新增入库记录请求实体", required = true) @RequestBody AddWarehouseRecordQuery addWarehouseRecordQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result addWarehouseRecord(
+ // 使用 Swagger 的 @ApiParam 注解，标注该参数的信息，要求该参数为必需参数，同时使用 @RequestBody 注解将请求体中的 JSON 数据映射到请求实体对象
+ @ApiParam(value = "新增入库记录请求实体", required = true) @RequestBody AddWarehouseRecordQuery addWarehouseRecordQuery,
+ // 使用 Swagger 的 @ApiParam 注解，标注该参数的信息，要求该参数为必需参数，同时使用 @RequestHeader 注解获取请求头中的 token 值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用入库记录服务类的新增入库记录方法，传入请求实体，获取新增操作结果
return warehouseRecordService.addWarehouseRecord(addWarehouseRecordQuery);
}
+ /**
+ * 根据编号获取入库记录信息
+ *
+ * @param warehouseRecordId 入库记录的编号，用于唯一标识一条入库记录
+ * @param token 接口访问请求头，用于身份验证等操作
+ * @return 返回包含指定编号入库记录信息的 Result 对象
+ */
+ // 使用 Spring MVC 的 @GetMapping 注解，指定该方法处理 HTTP GET 请求，请求路径为 '/warehouseRecord/getWarehouseRecordById'
@GetMapping("/getWarehouseRecordById")
+ // 使用 Swagger 的 @ApiOperation 注解，标注该接口的操作信息，包含接口描述和开发者信息
@ApiOperation(value = "根据编号查询入库记录", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result getWarehouseRecordById(@ApiParam(value = "根据编号查询入库记录请求参数", required = true) @RequestParam Long warehouseRecordId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result getWarehouseRecordById(
+ // 使用 Swagger 的 @ApiParam 注解，标注该参数的信息，要求该参数为必需参数，同时使用 @RequestParam 注解获取请求参数中的入库记录编号
+ @ApiParam(value = "根据编号查询入库记录请求参数", required = true) @RequestParam Long warehouseRecordId,
+ // 使用 Swagger 的 @ApiParam 注解，标注该参数的信息，要求该参数为必需参数，同时使用 @RequestHeader 注解获取请求头中的 token 值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用入库记录服务类的根据编号获取入库记录方法，传入入库记录编号，获取指定编号的入库记录信息
return warehouseRecordService.getWarehouseRecordById(warehouseRecordId);
}
+ /**
+ * 审核入库记录信息
+ *
+ * @param auditWarehouseRecordQuery 审核入库记录的请求实体，包含审核相关信息
+ * @param token 接口访问请求头，用于身份验证等操作
+ * @return 返回包含审核操作结果的 Result 对象
+ */
+ // 使用 Spring MVC 的 @PutMapping 注解，指定该方法处理 HTTP PUT 请求，请求路径为 '/warehouseRecord/auditWarehouseRecord'
@PutMapping("/auditWarehouseRecord")
+ // 使用 Swagger 的 @ApiOperation 注解，标注该接口的操作信息，包含接口描述和开发者信息
@ApiOperation(value = "审核入库记录", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result auditWarehouseRecord(@ApiParam(value = "审核入库记录请求实体", required = true) @RequestBody AuditWarehouseRecordQuery auditWarehouseRecordQuery,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result auditWarehouseRecord(
+ // 使用 Swagger 的 @ApiParam 注解，标注该参数的信息，要求该参数为必需参数，同时使用 @RequestBody 注解将请求体中的 JSON 数据映射到请求实体对象
+ @ApiParam(value = "审核入库记录请求实体", required = true) @RequestBody AuditWarehouseRecordQuery auditWarehouseRecordQuery,
+ // 使用 Swagger 的 @ApiParam 注解，标注该参数的信息，要求该参数为必需参数，同时使用 @RequestHeader 注解获取请求头中的 token 值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用入库记录服务类的审核入库记录方法，传入请求实体，获取审核操作结果
return warehouseRecordService.auditWarehouseRecord(auditWarehouseRecordQuery);
}
+ /**
+ * 删除入库记录信息
+ *
+ * @param warehouseRecordId 要删除的入库记录的编号
+ * @param token 接口访问请求头，用于身份验证等操作
+ * @return 返回包含删除操作结果的 Result 对象
+ */
+ // 使用 Spring MVC 的 @DeleteMapping 注解，指定该方法处理 HTTP DELETE 请求，请求路径为 '/warehouseRecord/deleteWarehouseRecord'
@DeleteMapping("/deleteWarehouseRecord")
+ // 使用 Swagger 的 @ApiOperation 注解，标注该接口的操作信息，包含接口描述和开发者信息
@ApiOperation(value = "删除入库记录", notes = Constant.DEVELOPER + Constant.EMPEROR_WEN)
- public Result deleteWarehouseRecord(@ApiParam(value = "删除入库记录请求参数", required = true) @RequestParam Long warehouseRecordId,
- @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ public Result deleteWarehouseRecord(
+ // 使用 Swagger 的 @ApiParam 注解，标注该参数的信息，要求该参数为必需参数，同时使用 @RequestParam 注解获取请求参数中的入库记录编号
+ @ApiParam(value = "删除入库记录请求参数", required = true) @RequestParam Long warehouseRecordId,
+ // 使用 Swagger 的 @ApiParam 注解，标注该参数的信息，要求该参数为必需参数，同时使用 @RequestHeader 注解获取请求头中的 token 值
+ @ApiParam(value = "接口访问请求头", required = true) @RequestHeader String token) {
+ // 调用入库记录服务类的删除入库记录方法，传入入库记录编号，获取删除操作结果
return warehouseRecordService.deleteWarehouseRecord(warehouseRecordId);
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/dao/base/BaseEntity.java b/server/src/main/java/com/ew/gerocomium/dao/base/BaseEntity.java
index a5590b3..c13f2c7 100644
--- a/server/src/main/java/com/ew/gerocomium/dao/base/BaseEntity.java
+++ b/server/src/main/java/com/ew/gerocomium/dao/base/BaseEntity.java
@@ -1,42 +1,61 @@
+// 声明该类所在的包路径，用于组织和管理 Java 类
package com.ew.gerocomium.dao.base;
+// 导入 MyBatis-Plus 框架中用于配置字段填充策略的注解
import com.baomidou.mybatisplus.annotation.FieldFill;
+// 导入 MyBatis-Plus 框架中用于配置主键生成策略的注解
import com.baomidou.mybatisplus.annotation.IdType;
+// 导入 MyBatis-Plus 框架中用于标识数据库表字段的注解
import com.baomidou.mybatisplus.annotation.TableField;
+// 导入 MyBatis-Plus 框架中用于标识数据库表主键的注解
import com.baomidou.mybatisplus.annotation.TableId;
+// 导入 Lombok 框架的注解，用于自动生成该类的 get、set、equals、hashCode、toString 等方法
import lombok.Data;
+// 导入 Java 标准库中的日期类，用于表示时间信息
import java.util.Date;
+// 使用 Lombok 的 @Data 注解，自动为该类生成常用方法，简化代码编写
@Data
+// 定义一个名为 BaseEntity 的基础实体类，作为其他实体类的基类，封装一些通用的属性
public class BaseEntity {
/**
* ID
*/
+ // 使用 MyBatis-Plus 的 @TableId 注解，指定该属性为数据库表的主键，主键生成策略为自动增长
@TableId(type = IdType.AUTO)
+ // 定义一个 Long 类型的属性 id，用于表示实体的唯一标识
private Long id;
/**
* 创建人ID
*/
+ // 使用 MyBatis-Plus 的 @TableField 注解，指定该属性对应数据库表中的字段，并且在插入数据时自动填充
@TableField(fill = FieldFill.INSERT)
+ // 定义一个 Long 类型的属性 createId，用于记录创建该实体的用户的 ID
private Long createId;
/**
* 创建时间
*/
+ // 使用 MyBatis-Plus 的 @TableField 注解，指定该属性对应数据库表中的字段，并且在插入数据时自动填充
@TableField(fill = FieldFill.INSERT)
+ // 定义一个 Date 类型的属性 createTime，用于记录该实体的创建时间
private Date createTime;
/**
* 修改人ID
*/
+ // 使用 MyBatis-Plus 的 @TableField 注解，指定该属性对应数据库表中的字段，并且在插入和更新数据时自动填充
@TableField(fill = FieldFill.INSERT_UPDATE)
+ // 定义一个 Long 类型的属性 updateId，用于记录最后修改该实体的用户的 ID
private Long updateId;
/**
* 修改时间
*/
+ // 使用 MyBatis-Plus 的 @TableField 注解，指定该属性对应数据库表中的字段，并且在插入和更新数据时自动填充
@TableField(fill = FieldFill.INSERT_UPDATE)
+ // 定义一个 Date 类型的属性 updateTime，用于记录该实体的最后修改时间
private Date updateTime;
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/dao/base/BuildingVo.java b/server/src/main/java/com/ew/gerocomium/dao/base/BuildingVo.java
index 677a540..eec104a 100644
--- a/server/src/main/java/com/ew/gerocomium/dao/base/BuildingVo.java
+++ b/server/src/main/java/com/ew/gerocomium/dao/base/BuildingVo.java
@@ -1,63 +1,114 @@
+// 声明该类所属的包，用于组织和管理 Java 类，这里表明该类位于 com.ew.gerocomium.dao.base 包下
package com.ew.gerocomium.dao.base;
+// 导入 Swagger 注解，用于生成 API 文档，便于接口的可视化和文档化
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
+// 导入 Lombok 注解，用于自动生成 getter、setter、toString 等方法，简化代码
import lombok.Data;
-
+// 导入 Java 标准库中的 List 接口，用于存储数据集合
import java.util.List;
+// 使用 Lombok 的 @Data 注解，自动生成类的 getter、setter、equals、hashCode 和 toString 方法
@Data
+// 使用 Swagger 的 @ApiModel 注解，为该类添加描述信息，用于在 API 文档中展示该类的用途
@ApiModel(value = "获取楼栋列表响应实体")
+// 定义一个名为 BuildingVo 的类，用于封装获取楼栋列表的响应数据
public class BuildingVo {
+ // 使用 Swagger 的 @ApiModelProperty 注解，为属性添加描述信息和示例值，方便在 API 文档中查看
@ApiModelProperty(value = "楼栋编号", example = "1")
+ // 定义一个 Long 类型的属性 id，用于存储楼栋的编号
private Long id;
+ // 使用 Swagger 的 @ApiModelProperty 注解，为属性添加描述信息和示例值
@ApiModelProperty(value = "楼栋名称", example = "爱心楼")
+ // 定义一个 String 类型的属性 name，用于存储楼栋的名称
private String name;
+ // 使用 Swagger 的 @ApiModelProperty 注解，为属性添加描述信息和示例值
@ApiModelProperty(value = "楼层数量", example = "5")
+ // 定义一个 Integer 类型的属性 floorNum，用于存储该楼栋的楼层数量
private Integer floorNum;
+ // 使用 Swagger 的 @ApiModelProperty 注解，为属性添加描述信息和示例值
@ApiModelProperty(value = "楼层列表", example = "{}")
+ // 定义一个 List 类型的属性 floorList，用于存储该楼栋下的楼层信息，元素类型为 BuildingItem
private List floorList;
+ // 使用 Lombok 的 @Data 注解，自动生成类的 getter、setter、equals、hashCode 和 toString 方法
@Data
+ // 使用 Swagger 的 @ApiModel 注解，为该类添加描述信息，用于在 API 文档中展示该类的用途
@ApiModel(value = "获取楼层列表响应实体")
+ // 定义一个静态内部类 BuildingItem，用于封装楼层的相关信息
public static class BuildingItem {
+ // 使用 Swagger 的 @ApiModelProperty 注解，为属性添加描述信息和示例值
@ApiModelProperty(value = "楼层编号", example = "1")
+ // 定义一个 Long 类型的属性 id，用于存储楼层的编号
private Long id;
+ // 使用 Swagger 的 @ApiModelProperty 注解，为属性添加描述信息和示例值
@ApiModelProperty(value = "楼层名称", example = "爱心楼-1层")
+ // 定义一个 String 类型的属性 name，用于存储楼层的名称
private String name;
+ // 使用 Swagger 的 @ApiModelProperty 注解，为属性添加描述信息和示例值
@ApiModelProperty(value = "房间数量", example = "5")
+ // 定义一个 Integer 类型的属性 roomNum，用于存储该楼层的房间数量
private Integer roomNum;
+ // 使用 Swagger 的 @ApiModelProperty 注解，为属性添加描述信息和示例值
@ApiModelProperty(value = "房间列表", example = "{}")
+ // 定义一个 List 类型的属性 roomList，用于存储该楼层下的房间信息，元素类型为 FloorItem
private List roomList;
+ // 使用 Lombok 的 @Data 注解，自动生成类的 getter、setter、equals、hashCode 和 toString 方法
@Data
+ // 使用 Swagger 的 @ApiModel 注解，为该类添加描述信息，用于在 API 文档中展示该类的用途
@ApiModel(value = "获取房间列表响应实体")
+ // 定义一个静态内部类 FloorItem，用于封装房间的相关信息
public static class FloorItem {
+ // 使用 Swagger 的 @ApiModelProperty 注解，为属性添加描述信息和示例值
@ApiModelProperty(value = "房间编号", example = "1")
+ // 定义一个 Long 类型的属性 id，用于存储房间的编号
private Long id;
+ // 使用 Swagger 的 @ApiModelProperty 注解，为属性添加描述信息和示例值
@ApiModelProperty(value = "房间名称", example = "爱心楼-1层-1房")
+ // 定义一个 String 类型的属性 name，用于存储房间的名称
private String name;
+ // 使用 Swagger 的 @ApiModelProperty 注解，为属性添加描述信息和示例值
@ApiModelProperty(value = "床位数量", example = "5")
+ // 定义一个 Integer 类型的属性 bedNum，用于存储该房间的床位数量
private Integer bedNum;
+ // 使用 Swagger 的 @ApiModelProperty 注解，为属性添加描述信息和示例值
@ApiModelProperty(value = "床位列表", example = "{}")
+ // 定义一个 List 类型的属性 bedList，用于存储该房间下的床位信息，元素类型为 RoomItem
private List bedList;
+ // 使用 Lombok 的 @Data 注解，自动生成类的 getter、setter、equals、hashCode 和 toString 方法
@Data
+ // 使用 Swagger 的 @ApiModel 注解，为该类添加描述信息，用于在 API 文档中展示该类的用途
@ApiModel(value = "获取床位列表响应实体")
+ // 定义一个静态内部类 RoomItem，用于封装床位的相关信息
public static class RoomItem {
+ // 使用 Swagger 的 @ApiModelProperty 注解，为属性添加描述信息和示例值
@ApiModelProperty(value = "床位编号", example = "1")
+ // 定义一个 Long 类型的属性 id，用于存储床位的编号
private Long id;
+ // 使用 Swagger 的 @ApiModelProperty 注解，为属性添加描述信息和示例值
@ApiModelProperty(value = "床位名称", example = "爱心楼-1层-1房-1床")
+ // 定义一个 String 类型的属性 name，用于存储床位的名称
private String name;
+ // 使用 Swagger 的 @ApiModelProperty 注解，为属性添加描述信息和示例值
@ApiModelProperty(value = "床位状态", example = "空闲")
+ // 定义一个 String 类型的属性 bedFlag，用于存储床位的状态，如空闲、已占用等
private String bedFlag;
+ // 使用 Swagger 的 @ApiModelProperty 注解，为属性添加描述信息和示例值
@ApiModelProperty(value = "所住老人", example = "张三")
+ // 定义一个 String 类型的属性 elderName，用于存储该床位所住老人的姓名
private String elderName;
+ // 使用 Swagger 的 @ApiModelProperty 注解，为属性添加描述信息和示例值
@ApiModelProperty(value = "老人性别", example = "男")
+ // 定义一个 String 类型的属性 sex，用于存储该床位所住老人的性别
private String sex;
+ // 使用 Swagger 的 @ApiModelProperty 注解，为属性添加描述信息和示例值
@ApiModelProperty(value = "老人年龄", example = "70")
+ // 定义一个 Integer 类型的属性 age，用于存储该床位所住老人的年龄
private Integer age;
}
}
}
-}
+}
\ No newline at end of file
diff --git a/server/src/test/java/com/ew/gerocomium/GerocomiumApplicationTests.java b/server/src/test/java/com/ew/gerocomium/GerocomiumApplicationTests.java
index 75da199..4cd7473 100644
--- a/server/src/test/java/com/ew/gerocomium/GerocomiumApplicationTests.java
+++ b/server/src/test/java/com/ew/gerocomium/GerocomiumApplicationTests.java
@@ -1,12 +1,22 @@
+// 声明该类所属的包，此包名为 com.ew.gerocomium，用于组织和管理 Java 类
package com.ew.gerocomium;
+// 导入 JUnit 5 框架中的 Test 注解，该注解用于标记测试方法
import org.junit.jupiter.api.Test;
+// 导入 Spring Boot 提供的测试注解，用于在 Spring Boot 应用环境下进行测试
import org.springframework.boot.test.context.SpringBootTest;
+// 使用 SpringBootTest 注解，表明这是一个 Spring Boot 应用的测试类
+// 该注解会启动 Spring 应用上下文，使得测试可以在完整的 Spring 环境中运行
@SpringBootTest
+// 定义一个测试类，类名为 GerocomiumApplicationTests，用于对 Gerocomium 应用进行测试
class GerocomiumApplicationTests {
+ // 使用 Test 注解标记该方法为一个测试方法，JUnit 框架会自动识别并执行该方法
@Test
+ // 定义一个名为 contextLoads 的测试方法，用于测试 Spring 应用上下文是否能够正常加载
+ // 该方法为空，只是通过执行来验证上下文加载过程中是否会抛出异常
void contextLoads() {
+ // 方法体为空，仅用于验证 Spring 应用上下文的加载情况
}
-}
+}
\ No newline at end of file
diff --git a/server/target/classes/application-dev.yml b/server/target/classes/application-dev.yml
index 2a23c00..fd6ee1f 100644
--- a/server/target/classes/application-dev.yml
+++ b/server/target/classes/application-dev.yml
@@ -19,7 +19,7 @@ spring:
type: com.alibaba.druid.pool.DruidDataSource
druid:
driver-class-name: com.mysql.cj.jdbc.Driver
- url: jdbc:mysql://127.0.0.1:3306/db_gerocomium?useSSL=false&useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&serverTimezone=Asia/Shanghai
+ url: jdbc:mysql://localhost:3306/db_gerocomium?useSSL=false&useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&serverTimezone=Asia/Shanghai
username: root
password: 123456
# 初始连接数
@@ -59,8 +59,8 @@ spring:
redis:
host: 127.0.0.1
port: 6379
-# password: 123456
- timeout: 10000
+ password: 123456
+ timeout: 10
database: 1
jedis:
pool:
diff --git a/server/target/classes/com/ew/gerocomium/common/config/exception/BusinessRuntimeException.class b/server/target/classes/com/ew/gerocomium/common/config/exception/BusinessRuntimeException.class
index d19d6ed670d667763bb25819ab3c301663925715..09e73db1ca5287bf1bf6d9a6439e904b5943f7b0 100644
GIT binary patch
delta 55
zcmcb~d6RR)CT3m<237_s1}+8}27U(F$@`hJSe1Y*<;i+1fsBHa8(3@@g@L3fyAlHf
I0~3QX06|I#;Q#;t
delta 55
zcmcb~d6RR)CT3nf237`s1}+8xASpO`KXVqV2#_T@S&t=M1A}Nw0DH3@}5;rL6ip65ETg7Csn=FPK
zP0Gh`J=_rv7^kM3J0p3
zRC%V(g$6g8+-dQk&65sqx;XUs(C4deKZfFBB!0#cU?L$+i3o-im`Rhlj4)-2B}*3e
M*7p(#9|!)>9}Q<8&;S4c
diff --git a/server/target/classes/com/ew/gerocomium/common/config/file/FileTempPath.class b/server/target/classes/com/ew/gerocomium/common/config/file/FileTempPath.class
index 491c1ae4cd5f31d05aadf28ac674b31d900566ad..cc44bc67c79a04762dc8be12b77d41126815f36f 100644
GIT binary patch
delta 180
zcmeyO_Csw04=-c>WL{nuem(|f1_lO81~~?61|tT`$uYe7jBb<9@J2BPOjhTMVvL&H
z1SC@?-{mV2&12wTC}7}cC}I$2C$XHa9P*__7D$Ee!PAi&VWAjHtmpwBRo!I@z)
zLo&luhI)qS46O_^8G0FJF-&0Sm^@Qp1M6}IPKG6u{REp?*8+`OHTjxgzu*oAR)$>+
f>3=MGA-l)
diff --git a/server/target/classes/com/ew/gerocomium/common/config/file/FileUploadConfigPropertity.class b/server/target/classes/com/ew/gerocomium/common/config/file/FileUploadConfigPropertity.class
index f821a405a69de8d2c5dba88b8d9b1f0241ad3ff7..44fc2a271fc968b215224856a42c469728706685 100644
GIT binary patch
delta 136
zcmdley-|7tAKT;(HnGVnZ0d~SlO5PaCno|~l3><6AWIs|x(#H>f>{#m>WuP0mMtUy
zA<
E0EP@DZ2$lO
delta 138
zcmdley-|7t9~&drWCwQ9$trB>jC^2LBAfc;3+!x@UD*XD&jX4IfJJWuS%P4e1iLz;
z5RhdH)OnFzeDYLwYcMMa%D3i#@Wm(h!C0Fga_}%Ra&3Oc$p)k*f91LkHx
evdO2p`ot9&m>8@X7=WY=gA9;nV_*c@$p8Qb_8IvA
delta 137
zcmew$_CajJS`J3h$?G_7TdFZ|FlaDHGiWlXF=#VrG3YQ@GUzk7G8i!gFc>q$Gng`D
zF_<&tF<3CvGFUToGT1RpVX$Xd%-}fr5a$a;H=u40pl(l~Zf~G&AE0i3pza``?qHzq
e(8;H{`ox79n1Fg2fTRtB43K7HU}UgmU;qF{AQw^q
diff --git a/server/target/classes/com/ew/gerocomium/common/config/quartz/QuartzConfig.class b/server/target/classes/com/ew/gerocomium/common/config/quartz/QuartzConfig.class
index fe4aff824e296a58a9d1f1980487f63a546f38d5..94e38059084b095c5329ef3df89d4e963894848a 100644
GIT binary patch
delta 165
zcmaDM{y}_$5htU>WMfVTUO5J31_lNm21X#sIr$=|=;W!K`i!cRk8=9(>R`wjbLlf0
z1Lfp-nHcmK^ck2L6oL9WC--ydDJwB>0NGYRlWZ7R8SH>&Ixq+`I5LPaI5S8xxG=~t
tSWUje6~kCG*^*mbT8e=UsM?Exg~11?&kv|NkU@wch(VOWb8d2T=e3
diff --git a/server/target/classes/com/ew/gerocomium/common/config/redis/FastJsonRedisSerializer.class b/server/target/classes/com/ew/gerocomium/common/config/redis/FastJsonRedisSerializer.class
index 765dd3c7df5fa29c2b5542d31b57620387810147..bedc850e99d378e4c3da4b6ec70a268a556987b9 100644
GIT binary patch
delta 87
zcmcaEc3o`40}f7I1{MZA22KY3$uBv2Ijw*^YX%Mm`^oj3i+R0);yw)A4E_w_41tsN
jxq29*C-32Ekd_6iP-Wm}P-9?XkYHc{lGY41VA>V{IS>yM
delta 87
zcmcaEc3o`40}f7U1{MYx22KXq$uBv2ITe9CB?b-#mC5y-i+MGH;#v&c3_1+r40@CG
hxq29lC-32EkQM@}5NF_LkYHc}Vg?{-&0qtjZ2|TN4YvRQ
diff --git a/server/target/classes/com/ew/gerocomium/common/config/redis/RedisConfig.class b/server/target/classes/com/ew/gerocomium/common/config/redis/RedisConfig.class
index 7290774938888e821dbf94c7de53d875c3eb1aa9..6c3adab817fe262e9bcdd8a9ae8cb0c715761392 100644
GIT binary patch
delta 51
zcmbQsKbL>Q1U5$D$rIU16y+E=7!(+I8I&2s8Ppk+7&L*T4ucVc9)mf9A%iu8@nkjj
Fasc^)2r&Qv
delta 51
zcmbQsKbL>Q1U5#l$rIU16!{o982A}@83Y-`8AKSA7(^M=86+5t7$h0Y8KfDk8Du7_
Hv6lk?>Q@JN
diff --git a/server/target/classes/com/ew/gerocomium/common/config/security/config/SecurityConfig.class b/server/target/classes/com/ew/gerocomium/common/config/security/config/SecurityConfig.class
index 79f42404bc4cf603f7426bebce01454e9c775695..95956136c013adcf84e71472f0294b1c3a01e10f 100644
GIT binary patch
delta 95
zcmcbncTI0YfGDHhFNo
y3|0*O3^oi=40a4j3=RyL3{DKW49=7F#nM?l7z7wRC(jm(X7mS|COnx-+y?+F$Pp0$
diff --git a/server/target/classes/com/ew/gerocomium/common/config/security/entity/LoginUserDetails.class b/server/target/classes/com/ew/gerocomium/common/config/security/entity/LoginUserDetails.class
index d93305cafde1bfa98fee0e8945eec5c360568543..daca63ae87778afe7fcef96daffbb6ec48eae11d 100644
GIT binary patch
delta 115
zcmca8a#3W%WY)={Y$B7FvzjoPOuoZv&uBeahRu@EY4QX%(aG6tDvX{$mL+2Vn13J0
z4+pa(+0_|kCp)s+GKx;FXYU7+{2X0Cau!E6kYwYW1tb@8+AxX()re01%&EgDIaz_r
F5CDn0A1VL<
delta 111
zcmca8a#3W%WL8GG$x~R}8I>pBVYO$}m@LC)Ie9Xx$mC2mHAbV!6WA;n&4HxoK1pE-3H`6erH
G83F*)Q5{DB
diff --git a/server/target/classes/com/ew/gerocomium/common/config/security/filter/JwtAuthenticationTokenFilter.class b/server/target/classes/com/ew/gerocomium/common/config/security/filter/JwtAuthenticationTokenFilter.class
index 747f2ff0eae734b2d5cc3d8bb07ffbae8f6175d0..05f32440c9fdd9a21aa0fd9a14345c88d1dd5200 100644
GIT binary patch
delta 153
zcmWN}y$V5L9DwoXzbonFU6h6S%*VhYgM>s8We^ETB;=!`T!Mv?MV)~~ovW}}Y+Qkp
zas%>?PyKov(=o4aL*lMy)WuE{AVY{O5%O3RNKw>PB1f446~=H!>?b8s(TAYMa=C-*?-z(Am;!8
diff --git a/server/target/classes/com/ew/gerocomium/common/config/security/handler/AccessDeniedHandlerImpl.class b/server/target/classes/com/ew/gerocomium/common/config/security/handler/AccessDeniedHandlerImpl.class
index 546c346b91da3e03e0b833d265954529b5d39c07..03a7060b301da7db9fefb90b0a729f304ba338c6 100644
GIT binary patch
delta 23
fcmaFQ^`2|PQ5HtI$;VjiSydR=8B`~8v8Dn5Vg&|+
delta 23
fcmaFQ^`2|PQ5Hs_$;VjiSw$Jx8N?=Yv8Dn5V1EW#
diff --git a/server/target/classes/com/ew/gerocomium/common/config/security/handler/AuthenticationEntryPointImpl.class b/server/target/classes/com/ew/gerocomium/common/config/security/handler/AuthenticationEntryPointImpl.class
index fcbd4a9dad72c63f730d9389facdf3afdfab5a37..9cdc4c208cdbccc005990a9632e8e033880ad1a8 100644
GIT binary patch
delta 23
fcmbQtJ(+vMOBP1C$*)-KSydR=8B{0hv8Dn5S0@HJ
delta 23
fcmbQtJ(+vMOBP0<$*)-KSw$Jx8N?>*v8Dn5RiOqC
diff --git a/server/target/classes/com/ew/gerocomium/common/config/security/handler/AuthorityAssert.class b/server/target/classes/com/ew/gerocomium/common/config/security/handler/AuthorityAssert.class
index 46fea2182d8cc379bec898b063294c3dc86152b6..2663e194d75c8a25e4d563243fe45f698e4021e6 100644
GIT binary patch
delta 59
zcmbO#FjHW|JT^w@$@AId8S5wSXR{R+VqjrlV323vWKd*KW>8_!W>B2W%^t(3H93Rb
Pi`9UEgTZL>cJ?>`fp81P
delta 57
zcmbO!FjZi~JT^wb$@AId8LKDnXS3z!V_;@rU=U&8WDsRgW)Ppu&mJ>*9vjc(a&~)G
N1qKcVrOCV5;{bZ23_}0_
diff --git a/server/target/classes/com/ew/gerocomium/common/config/security/handler/PasswordEncoderImpl.class b/server/target/classes/com/ew/gerocomium/common/config/security/handler/PasswordEncoderImpl.class
index 38d815590b5ff7971a972c1802bc7cf6e0279d0a..3645216df53b3bb06ce8048993fa19092b863547 100644
GIT binary patch
delta 25
hcmX@hd6sj-6J|!i$xoRb8O0~7vqUkzCwHhBNwC2WG1cyx)uza4Au++47Lms40a5P3=Rz53{DK;3@!{Q46Y364DJj?
S44w=XK+$>z-^uT}b^-u))eM0E
delta 63
zcmZ1>zCwHhBNwCOWG1cyx=IY33@Qu)3~CG#4C)Mu3>pmH44Mq#3|b5+4B8Co47v|
z?HSA%oEUT_ujdM3%$dx>Z7nayzz)=51Jq~7z{lXgAPkgOW^iFpV{l{8WU!eW#jOJX
DVoeVT
delta 97
zcmeAZZxi1j&c!G+S%OQRartBmt`KD<1`Y-W22loaAe3j2V9;WaWH4lqVlZKlX0T+C
xVX$YAoxGVVgfU|>2e-Af6ayPjwITy2gAxNDgEE6Kg9?yTWl&>Ko1Db00|32U488yW
diff --git a/server/target/classes/com/ew/gerocomium/common/config/web/IgnoreConfig.class b/server/target/classes/com/ew/gerocomium/common/config/web/IgnoreConfig.class
index 668639b380781cfcfa5f07f866c9700e8eddaa9f..cb9c212c4bdced79429ae66ddaf064f18ee93ec5 100644
GIT binary patch
delta 69
zcmZ1_yh?aOHY+3lA850;x
qCNJflC~3vO&tStK%wWf$$Kb$V#oz=aU4YPavOiB4qsZiCJhlKO&=EKQ
delta 89
zcmaDX`B-v84Y#HcgA{`>g9(EOgCBz^Lk5EwLlc8I!yE=lhO(RAS&~Pywn}W6)#JV6bA)VsK#4VQ^v4o$SvO#>hQ+8ILUh=sFL*
diff --git a/server/target/classes/com/ew/gerocomium/common/constant/AuditEnum.class b/server/target/classes/com/ew/gerocomium/common/constant/AuditEnum.class
index b54efab47283116ec5413e40c535ca15ccc0862e..41d93333c393d67ab487696320add2b9de56679c 100644
GIT binary patch
delta 71
zcmX@dbB<@jToy*5$@5tBf#f+BcShaGVyw=LB9o(7&#Fr@@H5CV$T27~=rX7>*f3}^
VcryqwFfkZ2FaSw&1`9B42>?dl3(o)m
delta 71
zcmX@dbB<@jToy*Q$@5tBf#f+BcSionVyw=L?31Hd&#H4W@H22R$T4s;=rZsy*f8)i
Vcr&muFfkZ2FaSw&1`9B42>>fT3labT
diff --git a/server/target/classes/com/ew/gerocomium/common/constant/BedEnum.class b/server/target/classes/com/ew/gerocomium/common/constant/BedEnum.class
index 5575afb6b1f3f6a90b394694e17d27d95f47a9be..76ea9727844046372b0f6392d4796152a705ae50 100644
GIT binary patch
delta 67
zcmey!{gHb^BnzX^Alb#@&Zs&05{omV$Ye3r9mAlb#@&d4|U5{ok<`(!cJ9m<>x{0v+Satz!Ix(qxFHVkYG
RObq%A3_#MD!30d30s!+b3V#3q
diff --git a/server/target/classes/com/ew/gerocomium/common/constant/ChargeEnum.class b/server/target/classes/com/ew/gerocomium/common/constant/ChargeEnum.class
index 4f2e9fce06daf21c59afda6944db5b6e640dfd94..85b3c3b5594b23cdf4e9a1f7282eb73462c98e39 100644
GIT binary patch
delta 63
zcmdnWy_I`|84IJ(WOEjMAeqkM&Zs(hJ&QA=$mGu~i{&L5_!(pw9Gf
N7=WZcg8`T}1OU4?3TFTS
delta 63
zcmdnWy_I`|84DxZWOEjMAeqkM&d57?J&Q9V`{d6oi{&{P_!+nu9Gf
N7=WZcg8`T}1OTa@3FQC)
diff --git a/server/target/classes/com/ew/gerocomium/common/constant/CheckEnum.class b/server/target/classes/com/ew/gerocomium/common/constant/CheckEnum.class
index e3ef52d68de5f80245a973145b48e5c3cdd93ab0..2c2b139243d2c5565b0d5ff6e9463f042ddb88b0 100644
GIT binary patch
delta 79
zcmcc5d!Kj1PZma@$-h|ifut6zJEQ63B35Tck;&Uwf9Xpy@H5CV$T27~=rX7>*f3}^
ccmr8c42BF@3_=V{4Au+`K+>MU0Zcmr00MCiKL7v#
delta 79
zcmcc5d!Kj1PZmbD$-h|ifut6zJEP#_B35Tc_Q~5=f9Z2F@H22R$T4s;=rZsy*f8)i
ccr)-ZL;*#!7}yw?7_1o>fTTTx1DJLM0NI2MI{*Lx
diff --git a/server/target/classes/com/ew/gerocomium/common/constant/CodeEnum.class b/server/target/classes/com/ew/gerocomium/common/constant/CodeEnum.class
index e38cb9c9f31933a676f7a4fbd459db064cc3169a..d9197c08a9abf53f12957ea61d0f562140ffaea5 100644
GIT binary patch
delta 69
zcmeyz^N(l4ZWczt$$MDzf#e$&cSe=Tg{;Dp-B~pm)qpHdM&Zf3SyxC)F^DoKFlaFd
SGB7ddGB5y1Lk1%-Z43aN;0`kY
delta 69
zcmeyz^N(l4ZWczi$$MDzf#e$&cSfGcg{;Dp-B~pmd4ViXM)t|OSyxDNGKey8F=#Qc
SF)%UcGB5y1Lk1%-Z43a4TMe!N
diff --git a/server/target/classes/com/ew/gerocomium/common/constant/ConsumeEnum.class b/server/target/classes/com/ew/gerocomium/common/constant/ConsumeEnum.class
index cb496fc4c192130caa1f686c0e62d2a4455b5037..84ff433375193d69ffe9a6534deaa1791980e022 100644
GIT binary patch
delta 59
zcmeyx^^0qR2n(aoWKkAFPF#OxTyJwt|Kz%^
zFkudI!?cnxev&3k%EXy88Kz8;TV{pZW{tEN|47DsW!mg8WB!u0HQcoh_iQ&g8zgUs
td0=lcYxB(6B_7&WJhE>o*e?|AcNXj~9@{;h)YMf!DoI1tX_?t?_CM*_6Rnt7(R@jnx{28+V(Vz#
zn$RV?RmTi3R=4z)9kW~OXx*w~6B=DU4?HEe~q^kW9~8gaeOu-;-s?=q@?a8;MM
zW_(;XjU-HnG2=3B#<*eTxoIA8%dB$Sye4VJ-!o}GGi|zR#f3ZNearQCG)?F{{WAuPRRfO
diff --git a/server/target/classes/com/ew/gerocomium/common/constant/MarkEnum.class b/server/target/classes/com/ew/gerocomium/common/constant/MarkEnum.class
index 692506ed762483bcae93196b497a9fdb2982a958..49e1f07ad82b3d72299b4e0c27e6456d2b789004 100644
GIT binary patch
delta 63
zcmZ3%y@Gp#CJUp`WGxnbAQ{Et&ZseY5sNdU$mC}%i{+&l_!;CG9Gf
N7=WZcg8`T}1OTce3KakV
delta 63
zcmZ3%y@Gp#CJQ6mWGxnbAQ{Et&d57?5sNb;`{ZXVi{&{P_!+nu9Gf
N7=WZcg8`T}1OS(D35oy!
diff --git a/server/target/classes/com/ew/gerocomium/common/constant/RecipientEnum.class b/server/target/classes/com/ew/gerocomium/common/constant/RecipientEnum.class
index 21dc079679cfeac9f52a2b878f3323852b44c5bb..5b7cf1d106b9076af61bfbd6d31c25940975e327 100644
GIT binary patch
delta 59
zcmZqYZs*>h$igTzS&2m-NCvUEGb&G>#p28;GWi}$pR^PMKZ87j9D@)86N5Sf1CZ2a
I&;irB0A;%gEC2ui
delta 59
zcmZqYZs*>h$im1rS&2m-NCvUEGxAKH#p2A!KKUL?pEM@}KLZzo90MBz6N5Sf1CZ2a
I&;irB09Shmz5oCK
diff --git a/server/target/classes/com/ew/gerocomium/common/constant/VisitEnum.class b/server/target/classes/com/ew/gerocomium/common/constant/VisitEnum.class
index 4fc829599fcc86173d59492b0f5506726d730016..d432d6a6c3c464776147a2a8a235fc2df2c1507d 100644
GIT binary patch
delta 59
zcmZqTZsOh`!@?*uS(Zf~Ncyt4Gb&G>%Hqr@GWjM;pR^PMKZ87j9D@)86N5Sf1CZ2a
I&;irB0AEQ72><{9
delta 59
zcmZqTZsOh`!@|fmS(Zf~Ncyt4GxAKH%Hqt(KKUj~pEM@}KLZzo90MBz6N5Sf1CZ2a
I&;irB08t4Dn*aa+
diff --git a/server/target/classes/com/ew/gerocomium/common/constant/YesNoEnum.class b/server/target/classes/com/ew/gerocomium/common/constant/YesNoEnum.class
index 1660144a0818aca743b7a2238a3bd79f2f3e3ccd..1dc3996ad08b633fe561cb9f04d2a38b3252b4cf 100644
GIT binary patch
delta 69
zcmZqXY3AAB!NSNn*^@;dNLI4AGfGW9$YR4N10;nf3$mIqa!>YPT_7#UAjlxbpv1t*
Rz{H@Y)fU3M0Y#F>6>==B3GX9fgIeHjlCa>af1OP=`5Yzww
delta 95
zcmaDY_*!s78ylm*yTgIZQd5fg-Iyk#?X+5&#V}8+!l%
delta 145
zcmdljv|DHc7b`0t0}BKHWPVmxP9Y#mn1Po;baE_fA*Te8Ckf<919^^yTgIZQcifFia)5qqFW5&$r97gGQL
diff --git a/server/target/classes/com/ew/gerocomium/common/util/ClassJavaToTSUtil.class b/server/target/classes/com/ew/gerocomium/common/util/ClassJavaToTSUtil.class
index 25f9670876aed7350b68a9e8f44bb5194b19e702..9e0b61992b81a0ec35f03d6e92c744609fb7133b 100644
GIT binary patch
delta 155
zcmWN`JqrN=9DwoX%GGgKiiqv<5=q_%FB#>f43|2ENV@rs!QwWXN&N?3!RRaa3_gX;
zV6(X88Gg?v^-VooO-YKUy*efu8KUIKlBYzGYS0m7)>Lq);Zo;FlQS(Y!MoDtMo;|k
zPaU8#6hHDzTXdPzXTgLOQ#Q=lV&jOdTgp!EdLteq1b7(iNpQf#lefN9Pl5O{HVS`L
CNFLe%
delta 151
zcmew&@j+rkJ_jTBggfSRR4&x4FjGw%M+lZf!fti7U!JL7I!2)Qu<>a^A(X6&Wp50_$9(4fT4;mi;
diff --git a/server/target/classes/com/ew/gerocomium/common/util/DateUtilWen.class b/server/target/classes/com/ew/gerocomium/common/util/DateUtilWen.class
index b48cf7f64ea6a3bd26f6e575b1eeb60a3643c1b7..0bdccced00b6553b607f7b9495f8daf0ffa87e90 100644
GIT binary patch
delta 472
zcmXZYUuey77{~GVC-dib&iS3+c6841JKJ$=$IcF-(OBnf{$-^#$C6ywY7HahN>Ib|Gkw(kuXC
zQnV2f+oPaYBlace_%BsL*3eAVa*4^XmnLci^pRn+-AEh{2R#|`q~Xc1Ws@_-5l=>0
z#25+2eda-OOi<(qD>-UUlGDW#-k9{pNpGC;#uRzZP~se2Oxxbn`S_AIF8kCgEafT%
zuF=kQs@$~isnhW-*W0dlT<_A#J<8noEg#rSI2Av0eeU{#EHC|6uUucVnm3kDpN-$T
z&bhvGeeYX+pp%cR<&({($AizVUtPahKI+k&?TYr4mb2I|^wZ^+%Wqnk_j~=NCfLfn
zJ&pdC!URslZ0H(yumlsKlT;7*m-8>U{j8xm$I0vrrpI
qsK?)KqO2Mf)mf!})@uuW+Qxvk)6f9>w3AT{aYzl0X}9gq%>D!E%2sUv
delta 464
zcmXYtOGs5=7)95K63=~jeUNgr>($JgsfmFRUY!+1T0u~fXlj@fwKQ<#s}e%cEa98k
z!^R~Ni1wZZQlNo}3PRC14a$^IEcc-4Ui<&q-?C_b^!ZiSajnUXIF)wC&G!4)1tbw5
z#U|ZjPL-{?`~Rnz1j({YUq`Tj-4x<-m}H7<)ORCTswAeQOi8(tG%NA9hEFOzMI5K`
zQ9+1GQaMAIvmD@@z4PA=Us9u5jT$v-)woO=bwsG=APrU%=<}M@XwlEDq;QRNu9Hn0
zd9>R`pxf&d?Go)4?ID9+a=1wWw`?%jY0!LY-oF$I4EG=Jj>{qVvZDK32*opC-J*-H@s^0$4*q=oC
g#Ua)>!f(l4=L8$l_lJvYO4>G!{FR=6)|5QH1Btt1LI3~&
diff --git a/server/target/classes/com/ew/gerocomium/common/util/EntityCodeGeneratorUtil.class b/server/target/classes/com/ew/gerocomium/common/util/EntityCodeGeneratorUtil.class
index 1cc7f4bc2243572c403b2dfd2ab5b63a1b9fe77e..dced4df2a8e7c1ad37c3fb786dfd8f77f82e0197 100644
GIT binary patch
delta 221
zcmWN`JxBrp0EXfB+Y}mFlvalzLc}YR=pu;l=L}IqR0J_1BT5L;evAVl4uW*k(YAw@
zg5YQg92y)Q+gh7jT>|A9AJ6cN_e4M;FB$k(cNHINEVE9KFp-5VqL^&3PmDBia%@v(
zhdR47*yCa`Z4R(W;ENgdjRGGO8B=0Hg(+3Osqw=RzZ~<&2{TS5&g9Q<
zt}sn)aw(H5S+rE9tp?X>aU+{sIozpFM?>y4!j?-{uRO@Z(I=1k;z<*FgQb<1IdU{H
ARR910
delta 221
zcmWN}y-NZC0LJ0pyBRoyaFUkU7iebTr4eKwisWY|2x^efRIwC!4Aq?)6Sh1L_*mkV{iz9`wVbCbZwY8y`yrd@5)F
diff --git a/server/target/classes/com/ew/gerocomium/common/util/ExcelUtil$Test.class b/server/target/classes/com/ew/gerocomium/common/util/ExcelUtil$Test.class
index ef2ac2a0abd08b1a89ec9f114657b06e2221c982..0e6551b5d42711df697d254454a1b1b638ed5c8b 100644
GIT binary patch
delta 74
zcmdlax=D0{7c1kF$=<9sj4vj40LeF#kFwe_-kZ$K76c^2z~oA{n?QCm`w1ZF!?BR@
V-sX24Qj9c^791;Kk
delta 74
zcmdlax=D0{7c1lP$=<9sjH@Si0Lk@}kFwe_E}YEF76c^2z~oA{n?QCm`w1ZF!?BQY
V;pTT7Qj9iuE8FK&t
diff --git a/server/target/classes/com/ew/gerocomium/common/util/ExcelUtil.class b/server/target/classes/com/ew/gerocomium/common/util/ExcelUtil.class
index 741f76d2fd217ca9e4b71c12a05cb66afd90b136..60b0d60c49c309b01dc6ef5f19e19c639c1d6f66 100644
GIT binary patch
delta 307
zcmWNNODMwu9LGPuABn<=!%CsVs9ltDQ8J0F$zvp?C7QPu2ON+jS!~QBlSe|zBQ;5+
zP!f{zxNJuUCFMX$N&c7b;rsa>zTa=y8n*7+O_CEVGu`N50g)79rU)A))Ee4=oes+B
zqmo%1EK$RTL3XL*hbVk6yug^x}}XC>106M
z42h3nSz$zW7?m@|>0BH3
bt#QB|rN*c#9_Z%@56{dPJV40*mGb%zU(r!&
delta 307
zcmWO1O(??w7=ZETeMuBf99AoonAHl&M_P^fSZz!~Az35C7*n)O;o_?uHk%2BlN+UW
zapdaa;ATe$CFMX$N&c7T@Vh-ZXU=)kZxVCXYkJU43;EPx!HNePqtxT4fkm2#(oBXH
z&S>M3cCN8=i-UVQc%+kOoV?S;2i;Oik5tnuwYbEJTWom5MW2k|l^_EWVobt}OOgq>
zU{bE|$sK-q8e~ddn3hjw=}pqG!oAyDq6*sppXMfNKr%D;6q~~gPS9U
TI3~skaZU|Q89h&bRlfcMfG0*D
diff --git a/server/target/classes/com/ew/gerocomium/common/util/JavaToTsConverter.class b/server/target/classes/com/ew/gerocomium/common/util/JavaToTsConverter.class
index 0cc37d5b082f25f8381a538afd85da2faa635ddf..c063c2ef57e179d8cdb2178fa73ac628bc89b654 100644
GIT binary patch
delta 145
zcmaDV@l;|%0tch$=0pxxMqhab4hAI#X$DmW1qO8nO9oAbI3S(Epv#cOpwH04V93zV
zV9c=^C=`A-;}82&KmGcqx_GjcL`ZT`&J!YCQaz{?QM
rAixj>G%67YQy5AZ(iqAavL;X9?&U27T3F7&&rr!A#!xj`i^m!OM%W!$
delta 145
zcmaDV@l;|%0tX}e=0pxxMqe%l4h9|uX$F1<1qJ~IO9nxPI3S(EAj*)%AjZ(bAkNUw
zAi=O0sA3g^48v9iS%zH<6JD5=Z9%b*7|
pL?39BDMKQI8AAz!IYT*v<>U$6y}Win3+;i{IRK4!oUFxT4FFTX86*Gz
diff --git a/server/target/classes/com/ew/gerocomium/common/util/JwtUtil.class b/server/target/classes/com/ew/gerocomium/common/util/JwtUtil.class
index bf908ef32b3bf6681c6b170563561f8cb8f0663b..83e3565556e9b55e3c5349b5ba903b44cd300c91 100644
GIT binary patch
delta 113
zcmaDN^hRjI8+JzV$#2=^881xc<)}3`W8h_AU{GM-U{GSO*!=e(v=eF
delta 105
zcmaDO^h9XG8+JzC$#2=^8P81S<)}3_V&Gw5U=U^CU=U;AXOI9wNd|caX$Cb0Sq2>-
z%ZNdd!G=MZ!H+?eA%a1jA&o(E@<9$0#?Z;%I1Ge^7+8S14S>208H9mqB^it-+j8my
E02!eX2LJ#7
diff --git a/server/target/classes/com/ew/gerocomium/common/util/PageUtil.class b/server/target/classes/com/ew/gerocomium/common/util/PageUtil.class
index 95f8cce6721868ec1df3d35e839a3e75baecfabd..80133be7486f240e049dd68507be5fae9cfed200 100644
GIT binary patch
delta 164
zcmcbleoKABJ3dC)$?y5(8K+F<=eHLYVqjrlU{GXWXHWt{6$V`f#m%w&Y>bLp43Z2w
zKp{N_8wPy_e;^&oV8oEYV8T$uV8+nMU@^HxU=L&GWJf_OaWMu~pdt1QJPeKu5)4iZ
zvJAlt8Vrt;`vj-+Ml!H5L^JR)#4?C6#7{O7dM@b(RPDha%HYLd#o)(a%izsm$KVUp
K6*$>QcmV*oZye45
delta 154
zcmWN{y$-=p06^i>h+6dCR#ntbs$Ggf#7{zl2IV(V2~IkH(~V%604^$dI1}+
zpwr2hoOk#N?_Z&r>L)zytfY*kAOqOsC=%d2wo=#p3NF=@H73+qr`_POqro1Z1A#i3
zPwl7@D^e?|8%^@GDAP{wvAS4SBSvSAU`dHYMTL*sAxjsB9uY&P^qDbW!AM2+?GKyR
B8m0gM
diff --git a/server/target/classes/com/ew/gerocomium/common/util/ResponseUtil.class b/server/target/classes/com/ew/gerocomium/common/util/ResponseUtil.class
index b445ef34b65f83cbacbe7f7577204e8e5102d902..3264650e94aa2f3aa22f594e3f470761781cbc8b 100644
GIT binary patch
delta 91
zcmca2ctvo-JvK&($@kfuI29RK8I&2g7*r-}v1f4VF>o*#Fz_-MPM*y^SJ9e*lfjlj
vkinion!$-dmBEEUo56!YkHM8epTV8MiotVoBu4?a7y~1N5d#AQ6N51TLa`3v
delta 91
zcmV~$xebFb06@|2NF3(20Er}=1r10bL6CXDe7@Gv2RBzVaWJsPUUcAX^Dd?#gC>g2v(CEcpT^GRwJedFPnGECr
diff --git a/server/target/classes/com/ew/gerocomium/common/util/SendEmailUtil.class b/server/target/classes/com/ew/gerocomium/common/util/SendEmailUtil.class
index 6556de545a6678c8dda66c0a9c1adf9758b8efd0..66ebd38defc735796c8574266fc53171f4d9f695 100644
GIT binary patch
delta 79
zcmZ3-zm9){G#jJfWEr+Cwo(jI46+Q$4Dt+G42lfKK$bOwDuWY)I)fL3CPN^DHbVr1
gE<-$nK0`WCHjBZ4A&0?;p^(9Zp@hM7GB5i=0Q-InYXATM
delta 79
zcmZ3-zm9){G#ew=WEr+Cwmb|{415gA3<3;V3_=XX3?dBH3}OsU3=#}pK$$=W8HNZ3
gIfi%!d4_ZbC59{p1%@03MTSD4juHly$-L|f0oZg4YXATM
diff --git a/server/target/classes/com/ew/gerocomium/controller/AccidentController.class b/server/target/classes/com/ew/gerocomium/controller/AccidentController.class
index 5d1da56100243c0f45ad4c4e1e317686425a9174..e74f1174a8e130a3d3b6c0d8020948969ea45e96 100644
GIT binary patch
delta 89
zcmeyN`$Knwsvx8CWHmu2M%T&bg~TT}2+n4V2D6NXW-}H7SsNLfCpQXDVVnsT)fJh~
axE{=U0%RQpvu2CVXS@v+Q=eQZRu2Hbpdt$Z
delta 89
zcmeyN`$Knwsvx8AWHmu2M#ahJg~TT}2+n5I0JDsRW;5yoSsNKmCpQXDVYC5@>Wa)~
ZbOy7Y09jsO)@;%FjDb)w^~sfD^#E2|A4UKG
diff --git a/server/target/classes/com/ew/gerocomium/controller/AccountController.class b/server/target/classes/com/ew/gerocomium/controller/AccountController.class
index 4c832640748f6c68f486e1c09ee4998f2bb95cd8..20272632f94641660aec82b1cb109f561a5ff927 100644
GIT binary patch
delta 43
zcmV+`0M!4v7`Yg*@(2MTlk*5d0XLI236udzlgkN^0bG+@3X}nJlkp0*0fv*O3zA%?
B5FG#j
delta 43
zcmV+`0M!4v7`Yg*@(2MGlk*5d0UMJx36udLlgkN^0Vk7O3X}mZlkp0*0W_1R3zAF*
B4*&oF
diff --git a/server/target/classes/com/ew/gerocomium/controller/ActiveController.class b/server/target/classes/com/ew/gerocomium/controller/ActiveController.class
index ad5929f7dd7ee99c227ec00c619d88f956230c87..d3e6a10e8cbf1d7cfa33868cb8f5befc774b18fb 100644
GIT binary patch
delta 79
zcmcbobWdr69S@_@WP2V*MvKXfJX09`CNC5apRCI}n=u8ejfgo>$8))1&*JOJeF1pqTI8^!
diff --git a/server/target/classes/com/ew/gerocomium/controller/ActiveTypeController.class b/server/target/classes/com/ew/gerocomium/controller/ActiveTypeController.class
index b6c1056dcdadd44f38bf542f1d9980aae981862a..953242943271296eda8dc71106254103bea2115e 100644
GIT binary patch
delta 59
zcmbO!H&bqd12?1cWJhi%Mw`j+c*G~q=AO+M3}*T9%xBC3vbHfcg86%R=QGX#vg{_$
H;;RP$V5}9@
delta 61
zcmbO!H&bqd12?0{WJhi%Mw!X)c*G~q=AJ#-ftzjeXC9%+emwITwSc1A7!AR4dwAzF
NS^!yglV|bO0|0F16-EF6
diff --git a/server/target/classes/com/ew/gerocomium/controller/BedPanoramaController.class b/server/target/classes/com/ew/gerocomium/controller/BedPanoramaController.class
index c20bb68e7030893ae62f1134af862c546071ceab..c47d05bf893eaa4c55971f07da72a2ba875b6959 100644
GIT binary patch
delta 35
qcmew^{9Sm%W_CuE$y?YR8LcLNW1qqpFxie%eDWfW*^FsG)=mKMrVOS4
delta 35
qcmew^{9Sm%W_CuA$y?YR8KozGW1qsPG}(?*eDWfW*^HV%)=mKEhztw>
diff --git a/server/target/classes/com/ew/gerocomium/controller/BuildController.class b/server/target/classes/com/ew/gerocomium/controller/BuildController.class
index c53902c99f0d81d60057090c9247e5c395a6e67f..a11de0a91c79f069c7d548f3575cc9bfbd484020 100644
GIT binary patch
delta 207
zcmeCS?Y7;JA;hROIaA1y(PFZVgw^DyLQ#wXlM_Y7Cx;8qX3PMx>?ZR|a!s}t$zyB)
ziysu3&o~3f+Qzs6%-0v2&v*jNdIn@YfQqS4o-fKZ`J8wz<7c3`lbIN~CtsA<%EYJw
zmY**Hss#Wq{0uP*I4{@v=ZYyP&e_
IlX>Lo0dk8%{r~^~
delta 207
zcmeCS?Y7;JA;c&=IaA1yQEIY{gw^DyLQ#y0lM_Y7Cx;8qX4C+(>?ZR|a!s}t$z#+9
ziysu3&u9i@ZDX_r^Yz8%GrE9T&wwm%sF?cX`J!Bt&xz+U1_I5U%)}5e`J%*DCWd&h
z{CvrIObls25j(K5cBxz@hFq`=ukPx#
diff --git a/server/target/classes/com/ew/gerocomium/controller/CateringSetController.class b/server/target/classes/com/ew/gerocomium/controller/CateringSetController.class
index 47d7cd7d9229298d92ecd558c8702799475e34d1..b02808098263265dc9218ceecbba02f4931886a4 100644
GIT binary patch
delta 83
zcmeyY`dM|u7G6e;$y<4y7~Lid3W!hU=bOzK2WA}tvdX}$QvTVDeL&VW#${mseS!Im
W`+zLF$$JGW7_ULa)F+n+)dK*BmK)Rn
delta 83
zcmeyY`dM|u7G6fN$y<4y7!@W93W!hU=bO!_4rUz!vh={LQvTVDra;yVxIHCFU_PdH|Vr
TlQkvFnHUqHqUw_$NY(=YK8`Ud
delta 143
zcmca_a^GY_oFJp{$@@5+7@a0Fa&2M^2a@8GPjk&?%mK6NxR(I{`|J!o
delta 39
rcmZ1?u|#6SUQR}_$@@5+80982a&2N%1(M>EPjk&?)B&^VxR(I{@CFN$
diff --git a/server/target/classes/com/ew/gerocomium/controller/DishesController.class b/server/target/classes/com/ew/gerocomium/controller/DishesController.class
index 872c2c2ca9e50a227a82ab01b936c355f1e54dae..2726bd323a3b8c309a9bee689ae7ef2c0060301b 100644
GIT binary patch
delta 129
zcmdn1wO4DyRbEE5$=7(DCNCD0m~6l|n=xW?gNXR#$3RvAm^F=mK4S-%+8=xccOMB3zT-2<9j0{l8c}$EF
HK;~Wm(jP6C
delta 129
zcmdn1wO4DyRbEEX$=7(D7-c6nh=@-%;G4~;0%ko1vb4dhY5emUjle8lf%%Ma*AXIJ{0K$tGaR2}S
delta 81
zcmdm{xJ_|`JrAS!WCtEcMy1J3Jo6YeCoA%9Vl)7f;*$jg)F;RDa!r=u%VRW05xEQ$
Qu>*@l^3P{VsVco_!ux|7FVo0Iqurvj6}9
delta 29
kcmaFK_mXeJHdaRd$=g|77{w?5Vco$f2P8cv|7FVo0ID<#UH||9
diff --git a/server/target/classes/com/ew/gerocomium/controller/HomeController.class b/server/target/classes/com/ew/gerocomium/controller/HomeController.class
index 2a8b47cfa2557f3a95d15e08ab52037b32875fa1..dbf5331da48915b3f4b58c3e4b98c9f3ea1a1b58 100644
GIT binary patch
delta 269
zcmZ23dP3CV)W2Q(7#J8#7y`K%xEP!{88{hSxEWj-+(3joi0}Xro*=>tM0m3^_^>nh
zZnUsrk&}D6Zqc)j?a$^eeYR`DvmFawHco!Ae*3eHO;6X&d$Mhx?I%a)W2Q(7#J8#7y`H$xEP!`88{i7xfxs-TtS2zh;RoH9w5RKM0l|?c(XJ3
zY_zap**ukni&5T}he3?NkB316L}-HuJrH5Y;LpQg&fvFsAFB}~qu}I^Y>tc)lizb#
zP0nSHWRwH57&#&tRluyNK$aGeHHFb|atmh$Q1mUQ45RsEeGZAqN?gJ~7EmXb1%n&|
z6N5}KgXQG;9E!S33|2s=Gci~*@B(Q$24)5u21W+kXa>e&20I3OpqK-YF9YT~0svTi
BEyDl+
diff --git a/server/target/classes/com/ew/gerocomium/controller/IntentionController.class b/server/target/classes/com/ew/gerocomium/controller/IntentionController.class
index 672cad7f2d18426cfefb1c55e77f41abb4c916f2..24e9f1a724e15e458df163822b0ebda7432c797c 100644
GIT binary patch
delta 193
zcmZqiZt>pWCdnv2*C!0#mW=sLHHcgIDmY94%R(SFu7akMRqbrzby;iIE4)d@4VSiBV;8
xqrz4uMjNn*zamgF1k7Yp0y1;J%)LrLbuD0Kfih5Z4w$K~0%UFhGw-P^0|4%TM7;n2
delta 192
zcmZqiZt>pWCdnu~*C!0#mX4C+(HZkgh`3GdxC+}C_ntVn&
zkI@V)!YOMwxmhNU(H6>^&*%bGIiJxRu408;9%B%grzby;i6Iiqd@4VSi6LQfqrz4u
uhIFuqzamgF56om!0y0a%%)LspCO1h-PA*Ue3N?d;)K!4YE->?+$}#|CNJ0q!
diff --git a/server/target/classes/com/ew/gerocomium/controller/InventoryController.class b/server/target/classes/com/ew/gerocomium/controller/InventoryController.class
index 1e42b5877026de4925aaf95e718ae186c7c2ed18..58fbdf79c3876657bf702689c8593bcb838357a2 100644
GIT binary patch
delta 25
hcmaDX_*ig55Idv#@>82qgdj
delta 25
hcmaDX_*ig55Idvz@$w2f_dV
diff --git a/server/target/classes/com/ew/gerocomium/controller/LabelController.class b/server/target/classes/com/ew/gerocomium/controller/LabelController.class
index b90fd7c058908da98680d05c62dc977423e9547b..eccea12047163834bb9e86b158b6cd6986755a1d 100644
GIT binary patch
delta 111
zcmbQBIze^AFK$Nl$-lWB8LcPV@=Re2nC!r3H(7wUf-x1y5}&+)cRphkkhP7mAIevs
sY|3B3xCG2Q%0HiRCzw?uFrV=pR7`zx9Us@^6u~^k$51)-$$~=l0R8tQQ2+n{
delta 111
zcmbQBIze^AFK$MW$-lWB8Ko!N@=Re=n(V-5H(7wUf>9I55}&+)cRr&5khP7`9LiUp
sY|3B3Xb0vU<)6>!3TD*^%xCn0im6Yo*v+
WSb)HM#vMS`HpUB3zWU^+g7pBPVIJB5
delta 79
zcmaE&@XlIjEjM?Qy6!E`3l0z02HMgi~s-t
delta 75
zcmX@6eoTGCNj^r=$*1_77!@ZU;1{2)!ati)1IXIQs5iMp$ZGN$fha~(u#BAGd`25E
U>#E>9Mkk=`6h==lUqN^o0NExPga7~l
diff --git a/server/target/classes/com/ew/gerocomium/controller/OrderController.class b/server/target/classes/com/ew/gerocomium/controller/OrderController.class
index e48bd46d0023149855bc022b448412bd85893652..c971f7d1b2d9d4ce45956e6dfe6ad484d756a236 100644
GIT binary patch
delta 85
zcmdn0vsGt9ngFBDEJLgJGT3e09q1+z*7XERm-S(_O9!Tei7vl*9wS-ryZ
Z8FzwNE+X?7PfdO-GKKLznBOnD3;>(99De`+
delta 85
zcmdn0vsGt9ngFBNy
YjP78Ti^x1i-^q_frZ9$p`Te5H063T#hX4Qo
diff --git a/server/target/classes/com/ew/gerocomium/controller/OutboundRecordController.class b/server/target/classes/com/ew/gerocomium/controller/OutboundRecordController.class
index 1e45cef89e255741b4ce399b8d2f43cdb756d7e3..17c2e94294c4820b0a6b8a10d2fb3f0770e71518 100644
GIT binary patch
delta 106
zcmaE3`o?s_C1FOL$(Mzl7y~9Bln|e+D>9og70h}7WL1G#lSOASc2Cw5o6I-|NLo$)
rBNoND5iFA@KAZ69o=8_aqDWEp{3lSOAST1?gxo6KkjB&{a@
q5sPAU1%KObm%YrrqRRsd@nTNF|v7
diff --git a/server/target/classes/com/ew/gerocomium/controller/OutwardController.class b/server/target/classes/com/ew/gerocomium/controller/OutwardController.class
index 3011b4e8ec03b8751ed3911e7bf57bdbcef7460e..6dbddc85eb99dfede97a126d3f92f2a450e1b088 100644
GIT binary patch
delta 120
zcmeA-?Kj;pTZmD8@*E*2M*GS4g*GvU07>!5D}`q>W`bEUBC{B)CVv;1!q^YyFBYB6
zxOlR?*fz%PU_P(-e8$sY)=NqC$rpsVCVv&rW4sR*sg{_}_!-PHlAOoH$PQJu3;_Do
BF9!es
delta 120
zcmeA-?Kj;pTZmC)@*E*2Mw!X?g*GuN14;48D}`q>YJpiXBC{9`CVv;1!e|cWFBYB6
zXgAqjY#XC1n9nOdpV0@*dMT+s`GPRl)?EHsj5Rm}fTZ|jEADxW8Ix~v?*#z1bPELl
delta 35
qcmbOxIZbkd4i}^7WL+*NM%l>)T$>nGfTZ|jEADxW+LLc`?*#y@s0w2M
diff --git a/server/target/classes/com/ew/gerocomium/controller/RetreatAuditController.class b/server/target/classes/com/ew/gerocomium/controller/RetreatAuditController.class
index c2d77000183ab4e182477b3444dbd162f6668f4c..6b4cf83ed1cddf9b21a7a633728a1e4e4f397d2c 100644
GIT binary patch
delta 31
ncmca9ep7ry9w(#Pri1zRJo6c=fh@bpvb+_H{ZKLW
I$ya#m0j7);*Z=?k
delta 63
zcmcaCb6I9X6&It(YJvIoJo6b1fh@bpvb+_H7Em$u
I$ya#m0fB}SlmGw#
diff --git a/server/target/classes/com/ew/gerocomium/controller/ServiceProjectController.class b/server/target/classes/com/ew/gerocomium/controller/ServiceProjectController.class
index f854d65db1e4551188f444284c7d6afa203a0c6b..74bbc3038fa92d4c96d4e4b104ef5bb36a0232c6 100644
GIT binary patch
delta 123
zcmZ3kya?m>kAEi_w4bNA4+%$&>B5#V60@na@}bW`*$1XY7WG
TsZTcIt6-cD6<449lCK^BBTO1W
delta 71
zcmaDM_d;&NZ!SiW$$z+<7-c5gb8lo+n*5P_3Zo{FEk1cJ&wNG$Fe`+2KBGBQOntHu
TU&UlQZi&euyy}x*^3?+XZs8Y3
diff --git a/server/target/classes/com/ew/gerocomium/controller/WarehouseRecordController.class b/server/target/classes/com/ew/gerocomium/controller/WarehouseRecordController.class
index 0e129836a390bfb189f1a2e232b293e0f3c8d6d4..8067178c62a94d2253821c03834683644a5ebbfb 100644
GIT binary patch
delta 89
zcmZqFZq(jzmY-2`@;QDdMz_g=0vj2_Cx;7KP5vto$(R9TO<}ABii%HW7MjgC5zN{q
dG@o%Pn3XF$pK&Lcr6Mw)@hntKeKM11Jpc|58{7Z@
delta 89
zcmZqFZq(jzmY-2{@;QDdM#ag30vj3CCx;7KP5vto$*2otO<^TKR7B=820+EsCo_rG0|2Ly8A$*D
diff --git a/server/target/classes/com/ew/gerocomium/dao/base/BaseEntity.class b/server/target/classes/com/ew/gerocomium/dao/base/BaseEntity.class
index ef29f153a7b141528ce083983a46bb9527d9440e..9c6e040eac1673820cef4f3e91d585e8c4fbae5e 100644
GIT binary patch
delta 136
zcmbO&J6m=GFFT{~WP1+L$;#~Nj51(W0+6KwX3Yh%bik}zK$Z!ZCC;JFXai)~0`*$p<+_CqLp)XEX$}MK+=73E0FY_d3W+Hl`Zo
delta 99
zcmZ20zgB(&7bm0QWNuCyM%Bq4KvI2jE0ENjd3W+?Y9|s
diff --git a/server/target/classes/com/ew/gerocomium/dao/base/BuildingVo$BuildingItem.class b/server/target/classes/com/ew/gerocomium/dao/base/BuildingVo$BuildingItem.class
index a98a09e7bb96e536b6e4296f140b91625f8599e2..524e0b6f96bafc8aff430f4fd5d07b7572186dda 100644
GIT binary patch
delta 111
zcmZ1}w^D9H9|xn#!YCC91GXaZ(M16dZ6n>k&9D)YI-CqLk{
nhO&&gAgmw=fAdW)Mn)j>HurNNd6;Jpqsrz6-ei!_6Fye}^@AWJ
delta 111
zcmZ1}w^D9H9|xo8k&9D)YI-CqLk{
nhO&&gAgmw=fAdW)Mn)j>HurNNd6;Jpqv+-a-ei!_6Fye}#Wf#A
diff --git a/server/target/classes/com/ew/gerocomium/dao/base/BuildingVo.class b/server/target/classes/com/ew/gerocomium/dao/base/BuildingVo.class
index 334444b275e7e6bc473760228f08126fadaa55d6..f449d4a3bd900fed36adbcf70bbe35d3e0169865 100644
GIT binary patch
delta 119
zcmZ1?yF_+_Ajf1s4zbDV9O{gsll?ht7$t$E=;Vb!zATt^56DuS%*N>oRL3@X38&EH
yWKL@++ZQgz$z{#RJ9$2*_~sZcMn)hrj{7-S(wk>HBkyKr-eg7~muGSjpAi62iyt-s
delta 117
zcmZ1?yF_+_AO|DoWPc9P$?6>Hljm`=O%~@6n4H3)&d3iIT?k|ef?4-~EaAy)oUTCi
v^Et&QCv#eZSwT=fCl`b-zBz`Akr5~u$Nd~gy7BB`vH2W*
diff --git a/server/target/classes/com/ew/gerocomium/service/common/BedFunc.class b/server/target/classes/com/ew/gerocomium/service/common/BedFunc.class
index f7db6dabd403c672b535862af54f13d30988ce9a..d3f336f866f67f6738770d2fa82b1887ac2a87ac 100644
GIT binary patch
delta 72
zcmaEw{5E;RD<#If$*+}kg@qVc7#J858Mqme7z7xS8KfB!C#x&_0cFdSVX`?u*<7G(
Q9#A$1DC@HMoAP^J0IZ}DWdHyG
delta 64
zcmaEx{4{yPD<#IP$*+}k`S}=_85kH68Mqme7z7xSCu=MF0cEO`VKO;DnOvYu9#F<*
J^FQVHyZ}EG5L^HN
diff --git a/server/target/classes/com/ew/gerocomium/service/common/ConsultFunc.class b/server/target/classes/com/ew/gerocomium/service/common/ConsultFunc.class
index 90b439e22789b125a3ebf312fc56294c43ef6012..fee598715d2532126e21b83cce28af0e41c7eb2a 100644
GIT binary patch
delta 38
tcmZ2(y4rL@yeMPKVIc+<1_lOK23`g?1|bG_23ZEz&Fe*fumAwJ-UzM$
delta 34
qcmZ2&y4-X_fhc3cem(|f1_lOK23`g?1|bIb&6`DkumAv@?g&Ew
diff --git a/server/target/classes/com/ew/gerocomium/service/common/RoomFunc.class b/server/target/classes/com/ew/gerocomium/service/common/RoomFunc.class
index 9bd4be9cf38612cd3575571aa7ab840f13a0418f..0abd54f660a48ee6b0683efe1044ebcf31985c8f 100644
GIT binary patch
delta 38
ucmey9-H@|khX!NwpzVIc+<1_p)z2403h1|fzZ23dxH$=(tP+$jvv49pB}K)II5
zyb>^VaX@wPKy}GLb#Xv-S&U7Sw@K(iP045AW+-3~U?^meX2{?CN#Ya>W5wjXvL;aJ
Vcm_^}1O^d?L_)T&%nE?BJ8I}M5
delta 123
zcmZ4KIMZ=MvN&VI
-
-
+
+
diff --git a/server/src/main/java/com/ew/gerocomium/common/config/exception/BusinessRuntimeException.java b/server/src/main/java/com/ew/gerocomium/common/config/exception/BusinessRuntimeException.java
index 1d25322..979cee1 100644
--- a/server/src/main/java/com/ew/gerocomium/common/config/exception/BusinessRuntimeException.java
+++ b/server/src/main/java/com/ew/gerocomium/common/config/exception/BusinessRuntimeException.java
@@ -1,22 +1,36 @@
+// 声明该类所在的包路径，通常用于组织和管理代码结构
package com.ew.gerocomium.common.config.exception;
+// 导入自定义的异常枚举类，该类可能定义了各种异常类型的代码和消息
import com.ew.gerocomium.common.constant.ExceptionEnum;
+// 导入 Lombok 库的 @Getter 注解，用于自动生成类中属性的 getter 方法
import lombok.Getter;
+// 使用 @Getter 注解，让 Lombok 自动为类中的属性生成 getter 方法
@Getter
+// 定义一个自定义的运行时异常类，继承自 RuntimeException，用于处理业务逻辑中的异常情况
public class BusinessRuntimeException extends RuntimeException {
+ // 定义一个静态常量 serialVersionUID，用于序列化版本控制，确保在反序列化时版本的一致性
private static final long serialVersionUID = -7382189364622337034L;
+ // 定义一个私有成员变量 code，用于存储异常的错误码
private final Integer code;
+ // 定义一个私有成员变量 msg，用于存储异常的错误消息
private final String msg;
+ // 定义一个构造函数，接收错误码和错误消息作为参数
public BusinessRuntimeException(Integer code, String msg) {
+ // 调用父类 RuntimeException 的构造函数，将错误消息传递给父类
super(msg);
+ // 将传入的错误码赋值给当前类的 code 成员变量
this.code = code;
+ // 将传入的错误消息赋值给当前类的 msg 成员变量
this.msg = msg;
}
+ // 定义另一个构造函数，接收一个 ExceptionEnum 类型的参数
public BusinessRuntimeException(ExceptionEnum type) {
+ // 调用上面定义的构造函数，将 ExceptionEnum 类型参数的 code 和 msg 传递进去
this(type.getCode(), type.getMsg());
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/config/exception/BusinessRuntimeExceptionAdvice.java b/server/src/main/java/com/ew/gerocomium/common/config/exception/BusinessRuntimeExceptionAdvice.java
index 27995d0..9f31319 100644
--- a/server/src/main/java/com/ew/gerocomium/common/config/exception/BusinessRuntimeExceptionAdvice.java
+++ b/server/src/main/java/com/ew/gerocomium/common/config/exception/BusinessRuntimeExceptionAdvice.java
@@ -1,80 +1,143 @@
+// 声明该类所在的包，用于组织和管理代码结构
package com.ew.gerocomium.common.config.exception;
+// 导入自定义的代码枚举类，可能包含各种业务状态码
import com.ew.gerocomium.common.constant.CodeEnum;
+// 导入自定义的异常枚举类，包含不同类型异常的信息
import com.ew.gerocomium.common.constant.ExceptionEnum;
+// 导入自定义的响应工具类，用于构建响应结果
import com.ew.gerocomium.common.util.ResponseUtil;
+// 导入自定义的基础结果类，用于封装接口返回数据
import com.ew.gerocomium.dao.base.Result;
+// 导入 Lombok 提供的日志注解，可自动为类添加日志记录功能
import lombok.extern.slf4j.Slf4j;
+// 导入 Spring Security 框架中权限访问被拒绝的异常类
import org.springframework.security.access.AccessDeniedException;
+// 导入 Spring Security 框架中凭证错误的异常类
import org.springframework.security.authentication.BadCredentialsException;
+// 导入 Spring Security 框架中内部认证服务异常类
import org.springframework.security.authentication.InternalAuthenticationServiceException;
+// 导入 Spring Web 模块中 HTTP 请求方法不支持的异常类
import org.springframework.web.HttpRequestMethodNotSupportedException;
+// 导入 Spring Web 模块中缺少请求参数的异常类
import org.springframework.web.bind.MissingServletRequestParameterException;
+// 导入 Spring 框架的异常处理注解，用于捕获和处理控制器层抛出的异常
import org.springframework.web.bind.annotation.ExceptionHandler;
+// 导入 Spring 框架的全局异常处理注解，结合 @ExceptionHandler 捕获全局异常
import org.springframework.web.bind.annotation.RestControllerAdvice;
+// 导入 Spring Web 模块中方法参数类型不匹配的异常类
import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
+// 导入 Spring MVC 模块中未找到处理器的异常类
import org.springframework.web.servlet.NoHandlerFoundException;
-
+// 导入 JavaMail 中的消息传递异常类
import javax.mail.MessagingException;
+// 导入 JavaMail 中邮件发送失败的异常类
import javax.mail.SendFailedException;
+// 导入 Servlet 规范中的 HttpServletRequest 类，用于获取 HTTP 请求信息
import javax.servlet.http.HttpServletRequest;
+// 导入 Servlet 规范中的 HttpServletResponse 类，用于发送 HTTP 响应信息
import javax.servlet.http.HttpServletResponse;
+// 导入 Java 中的 Objects 工具类，提供一些对象操作方法
import java.util.Objects;
+// 使用 Lombok 的 Slf4j 注解，自动为该类添加日志记录功能
+
+// 标记为日志记录类，使用Slf4j日志框架
@Slf4j
+// 表示这是一个全局的异常处理类，用于处理控制器层抛出的异常
@RestControllerAdvice
public class BusinessRuntimeExceptionAdvice {
+ /**
+ * 异常处理方法，处理所有类型的异常
+ *
+ * @param ex 捕获到的异常对象
+ * @param response HTTP响应对象，用于返回结果
+ * @param request HTTP请求对象
+ */
@ExceptionHandler({Exception.class})
public void exceptionHandler(Exception ex, HttpServletResponse response, HttpServletRequest request) {
+ // 异常类型描述
String errorType;
+ // 异常对应的错误码
Integer errorCode;
+ // 异常对应的错误消息
String errorMsg;
+ // 判断是否为自定义的业务异常
if (ex instanceof BusinessRuntimeException) {
errorType = "业务异常";
- // AssertUtils断言抛出的自定义业务异常
+ // 获取自定义业务异常的错误码
errorCode = ((BusinessRuntimeException) ex).getCode();
+ // 获取自定义业务异常的错误消息
errorMsg = ((BusinessRuntimeException) ex).getMsg();
- } else if (ex instanceof NoHandlerFoundException) {
+ }
+ // 判断是否为请求的资源不存在的异常
+ else if (ex instanceof NoHandlerFoundException) {
errorType = "无访问资源";
+ // 获取资源不存在对应的错误码
errorCode = ExceptionEnum.NOT_EXIST.getCode();
+ // 获取资源不存在对应的错误消息
errorMsg = ExceptionEnum.NOT_EXIST.getMsg();
- } else if (ex instanceof HttpRequestMethodNotSupportedException) {
+ }
+ // 判断是否为请求方式不支持的异常
+ else if (ex instanceof HttpRequestMethodNotSupportedException) {
errorType = "请求方式错误";
+ // 获取请求方式错误对应的错误码
errorCode = ExceptionEnum.METHOD_ERROR.getCode();
+ // 获取请求方式错误对应的错误消息
errorMsg = ExceptionEnum.METHOD_ERROR.getMsg();
- // MissingServletRequestParameterException -> 未传必传参数
- // MethodArgumentTypeMismatchException -> 参数类型错误
- } else if (ex instanceof MissingServletRequestParameterException || ex instanceof MethodArgumentTypeMismatchException) {
+ }
+ // 判断是否为请求参数缺失或参数类型不匹配的异常
+ else if (ex instanceof MissingServletRequestParameterException || ex instanceof MethodArgumentTypeMismatchException) {
errorType = "请求参数异常";
+ // 获取请求参数异常对应的错误码
errorCode = ExceptionEnum.PARAM_ERROR.getCode();
+ // 获取请求参数异常对应的错误消息
errorMsg = ExceptionEnum.PARAM_ERROR.getMsg();
- // InternalAuthenticationServiceException -> 账号未注册
- // BadCredentialsException -> 密码错误
- } else if (ex instanceof InternalAuthenticationServiceException || ex instanceof BadCredentialsException) {
+ }
+ // 判断是否为认证失败的异常（账号未注册或密码错误）
+ else if (ex instanceof InternalAuthenticationServiceException || ex instanceof BadCredentialsException) {
errorType = "认证失败";
+ // 获取认证失败对应的错误码
errorCode = ExceptionEnum.CERTIFICATION_ERROR.getCode();
+ // 获取认证失败对应的错误消息
errorMsg = ExceptionEnum.CERTIFICATION_ERROR.getMsg();
- } else if (ex instanceof AccessDeniedException) {
+ }
+ // 判断是否为权限不足的异常
+ else if (ex instanceof AccessDeniedException) {
errorType = "权限不足";
+ // 获取权限不足对应的错误码
errorCode = ExceptionEnum.AUTH_ERROR.getCode();
+ // 获取权限不足对应的错误消息
errorMsg = ExceptionEnum.AUTH_ERROR.getMsg();
- } else {
+ }
+ // 其他类型的异常
+ else {
errorType = "其他异常";
+ // 获取通用错误码
errorCode = CodeEnum.ERROR.getCode();
+ // 获取异常的消息
String message = ex.getMessage();
+ // 标记是否匹配到自定义的异常消息
boolean checkMsg = false;
+ // 遍历所有自定义异常枚举
for (ExceptionEnum exceptionEnum : ExceptionEnum.values()) {
+ // 判断异常消息是否与自定义异常枚举中的消息匹配
if (Objects.equals(exceptionEnum.getMsg(), message)) {
checkMsg = true;
break;
}
}
+ // 如果匹配到自定义异常消息，则使用该消息，否则使用系统错误消息
errorMsg = checkMsg ? message : ExceptionEnum.SYS_ERROR.getMsg();
}
+ // 判断日志级别是否为INFO
if (log.isInfoEnabled()) {
+ // 记录异常类型
log.info(errorType);
+ // 打印异常堆栈信息
ex.printStackTrace();
}
+ // 使用工具类将错误结果输出到响应中
ResponseUtil.resultOut(response, Result.error(errorCode, errorMsg));
}
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/config/file/FileTempPath.java b/server/src/main/java/com/ew/gerocomium/common/config/file/FileTempPath.java
index 3ed73b8..e54630e 100644
--- a/server/src/main/java/com/ew/gerocomium/common/config/file/FileTempPath.java
+++ b/server/src/main/java/com/ew/gerocomium/common/config/file/FileTempPath.java
@@ -1,19 +1,35 @@
+// 声明该类所在的包，通常用于组织和管理代码结构
package com.ew.gerocomium.common.config.file;
+// 导入 Hutool 工具包中的日期格式常量类
import cn.hutool.core.date.DatePattern;
+// 导入 Hutool 工具包中的日期工具类
import cn.hutool.core.date.DateUtil;
+// 导入 Hutool 工具包中的文件操作工具类
import cn.hutool.core.io.FileUtil;
+// 导入 Hutool 工具包中的字符常量类
import cn.hutool.core.text.CharPool;
+// 导入 Hutool 工具包中的字符串常量类
import cn.hutool.core.text.StrPool;
+// 导入 Hutool 工具包中的 ID 生成工具类
import cn.hutool.core.util.IdUtil;
+// 导入 Hutool 工具包中的字符串操作工具类
import cn.hutool.core.util.StrUtil;
+// 导入 Hutool 工具包中的操作系统信息类
import cn.hutool.system.OsInfo;
+// 导入自定义的常量类
import com.ew.gerocomium.common.constant.Constant;
+// 导入自定义的异常枚举类
import com.ew.gerocomium.common.constant.ExceptionEnum;
+// 导入自定义的断言工具类
import com.ew.gerocomium.common.util.AssertUtil;
+// 导入 Lombok 提供的全参构造函数注解
import lombok.AllArgsConstructor;
+// 导入 Lombok 提供的自动处理异常注解
import lombok.SneakyThrows;
+// 导入 Spring 框架的配置类注解
import org.springframework.context.annotation.Configuration;
+// 导入 Spring 框架处理文件上传的类
import org.springframework.web.multipart.MultipartFile;
import java.io.File;
@@ -22,18 +38,22 @@ import java.time.LocalDateTime;
/**
* 文件信息
*/
+// 表明这是一个 Spring 配置类
@Configuration
+// 让 Lombok 自动生成全参构造函数
@AllArgsConstructor
public class FileTempPath {
+ // 注入文件上传配置属性类的实例
private final FileUploadConfigPropertity fileUploadConfigPropertity;
/**
- * 获取module存储路径
+ * 获取 module 存储路径
*
* @param module 模块名称
* @return 根路径/module/当天日期/
*/
public String uploadPath(String module) {
+ // 拼接上传路径，格式为根路径 + 模块名 + 当天日期
return getRootPath() + File.separator
+ module + File.separator
+ DateUtil.format(LocalDateTime.now(), DatePattern.PURE_DATE_PATTERN)
@@ -46,6 +66,7 @@ public class FileTempPath {
* @return 根路径/download/
*/
public String downloadPath() {
+ // 拼接下载路径，格式为根路径 + /download/
return getRootPath() + File.separator + Constant.STR_DOWNLOAD + File.separator;
}
@@ -55,6 +76,7 @@ public class FileTempPath {
* @return 根路径/upload/img/
*/
public String imgSrcPath() {
+ // 拼接图片存储路径，格式为根路径 + /upload/img/
return getRootPath() + File.separator + Constant.STR_UPLOAD_IMG + File.separator;
}
@@ -64,6 +86,7 @@ public class FileTempPath {
* @return 根路径/upload/video/
*/
public String videoSrcPath() {
+ // 拼接视频存储路径，格式为根路径 + /upload/video/
return getRootPath() + File.separator + Constant.STR_UPLOAD_VIDEO + File.separator;
}
@@ -73,6 +96,7 @@ public class FileTempPath {
* @return 根路径/upload/file/
*/
public String filePath() {
+ // 拼接附件存储路径，格式为根路径 + /upload/file/
return getRootPath() + File.separator + Constant.STR_UPLOAD_FILE + File.separator;
}
@@ -82,12 +106,21 @@ public class FileTempPath {
* @return 根路径
*/
public String getRootPath() {
+ // 创建操作系统信息对象
OsInfo osInfo = new OsInfo();
+ // 判断操作系统是否为 Windows
if (osInfo.isWindows()) {
+ // 如果是 Windows 系统，返回 Windows 对应的根路径
return fileUploadConfigPropertity.getWindows();
- } else if (osInfo.isMacOsX()) {
+ }
+ // 判断操作系统是否为 Mac OS X
+ else if (osInfo.isMacOsX()) {
+ // 如果是 Mac OS X 系统，返回 Mac OS X 对应的根路径
return fileUploadConfigPropertity.getMacos();
- } else {
+ }
+ // 其他操作系统，默认为 Linux
+ else {
+ // 返回 Linux 对应的根路径
return fileUploadConfigPropertity.getLinux();
}
}
@@ -95,63 +128,70 @@ public class FileTempPath {
/**
* 文件上传 保存
*
- * @param file
- * @param module
- * @param suff
- * @return
+ * @param file 上传的文件
+ * @param module 模块名称
+ * @param suff 允许的文件后缀数组
+ * @return 保存后的文件对象
*/
@SneakyThrows
public File saveFile(MultipartFile file, String module, String[] suff) {
+ // 检查文件是否为空或文件名是否为空
if (file == null || StrUtil.isBlank(file.getOriginalFilename())) {
return null;
}
+ // 获取文件后缀，格式为 .xxx
String suffix = StrPool.DOT + FileUtil.getSuffix(file.getOriginalFilename());
- // 文件后缀校验
+ // 校验文件后缀是否不在允许的后缀数组中，如果不在则抛出异常
AssertUtil.isTrue(!StrUtil.equalsAnyIgnoreCase(suffix, suff), ExceptionEnum.UPLOAD_SUFFIX_ERROR);
- // 文件转存
- // 模块路径/雪花算法ID_上传文件名称
+ // 生成新的文件名，格式为雪花算法 ID + _ + 原文件名
String fileName = IdUtil.getSnowflakeNextIdStr() + "_" + file.getOriginalFilename();
+ // 创建文件对象，路径为模块上传路径 + 新文件名
File files = FileUtil.file(uploadPath(module) + fileName);
+ // 创建文件的父目录
FileUtil.mkParentDirs(files);
-
+ // 将上传的文件转存到指定位置
file.transferTo(files);
return files;
}
-
/**
* 文件上传 备查信息
*
* @param file http MultipartFile 文件流
* @param suff 后缀 包含此类型的后缀不允许上传 如：.exe .sh
- * @return
+ * @return 保存后的文件对象
*/
@SneakyThrows
public File saveInformationFile(MultipartFile file, String[] suff) {
+ // 调用 saveFile 方法，指定模块名为 "information"
return saveFile(file, "information", suff);
}
@SneakyThrows
public File saveCommFile(MultipartFile file, String module) {
+ // 调用 saveFile 方法，不限制文件后缀
return saveFile(file, module, null);
}
/**
- * 下载路径处理 前提是放开uri
+ * 下载路径处理 前提是放开 uri
*
- * @param file
- * @return
+ * @param file 要下载的文件
+ * @return 处理后的下载 URL
*/
public String downloadUrl(File file) {
+ // 获取文件的绝对路径
String filePath = file.getAbsolutePath();
+ // 替换根路径为空字符串，并将反斜杠替换为正斜杠
String downloadUrl = filePath
.replace(getRootPath(), "")
.replace(StrPool.BACKSLASH, StrPool.SLASH);
+ // 在路径前添加斜杠
return CharPool.SLASH + downloadUrl;
}
public String downloadUrl(String path) {
+ // 调用 downloadUrl 方法，将文件路径转换为文件对象
return downloadUrl(FileUtil.file(path));
}
-
}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/config/file/FileUploadConfigPropertity.java b/server/src/main/java/com/ew/gerocomium/common/config/file/FileUploadConfigPropertity.java
index 61c9568..9eb680d 100644
--- a/server/src/main/java/com/ew/gerocomium/common/config/file/FileUploadConfigPropertity.java
+++ b/server/src/main/java/com/ew/gerocomium/common/config/file/FileUploadConfigPropertity.java
@@ -1,19 +1,32 @@
+// 声明该类所在的包，用于组织和管理代码结构
package com.ew.gerocomium.common.config.file;
+// 导入 Lombok 库的 @Data 注解，该注解会自动生成 getter、setter、toString、equals 和 hashCode 等方法
import lombok.Data;
+// 导入 Spring Boot 提供的 @ConfigurationProperties 注解，用于将配置文件中的属性映射到 Java 类中
import org.springframework.boot.context.properties.ConfigurationProperties;
+// 导入 Spring 框架的 @Configuration 注解，表明这是一个配置类，会被 Spring 容器管理
import org.springframework.context.annotation.Configuration;
/**
* 文件上传路径配置
*/
+// 使用 Lombok 的 @Data 注解，自动生成类的 getter、setter、toString 等方法
@Data
+// 使用 Spring 的 @Configuration 注解，将该类标记为配置类
@Configuration
+// 使用 @ConfigurationProperties 注解，指定从配置文件中读取以 "filesave" 为前缀的属性
@ConfigurationProperties(prefix = "filesave")
+// 定义一个配置属性类，用于存储文件上传路径的相关配置
public class FileUploadConfigPropertity {
+ // 定义一个字符串类型的属性，用于存储 Windows 系统下的文件上传路径
private String windows;
+ // 定义一个字符串类型的属性，用于存储 Mac OS 系统下的文件上传路径
private String macos;
+ // 定义一个字符串类型的属性，用于存储 Linux 系统下的文件上传路径
private String linux;
+ // 定义一个字符串类型的属性，用于存储上传文件的头部路径配置
private String uploadHead;
+ // 定义一个字符串类型的属性，用于存储本地文件的头部路径配置
private String localHead;
-}
+}
\ No newline at end of file
diff --git a/server/src/main/java/com/ew/gerocomium/common/config/mybatisplus/MetaObjectHandlerImpl.java b/server/src/main/java/com/ew/gerocomium/common/config/mybatisplus/MetaObjectHandlerImpl.java
index f211a64..95e2bbf 100644
--- a/server/src/main/java/com/ew/gerocomium/common/config/mybatisplus/MetaObjectHandlerImpl.java
+++ b/server/src/main/java/com/ew/gerocomium/common/config/mybatisplus/MetaObjectHandlerImpl.java
@@ -1,86 +1,119 @@
+// 声明该类所在的包，用于组织和管理代码结构
package com.ew.gerocomium.common.config.mybatisplus;
+// 导入 MyBatis-Plus 核心的元对象处理器接口
import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
+// 导入自定义的权限验证处理类
import com.ew.gerocomium.common.config.security.handler.AuthorityAssert;
+// 导入自定义的登录用户信息视图对象类
import com.ew.gerocomium.dao.vo.LoginUserVo;
+// 导入 Lombok 提供的日志注解，可自动为类添加日志记录功能
import lombok.extern.slf4j.Slf4j;
+// 导入 MyBatis 的元对象类，用于操作对象属性
import org.apache.ibatis.reflection.MetaObject;
+// 导入 Spring 框架的组件注解，将该类标记为 Spring 组件，以便 Spring 自动扫描和管理
import org.springframework.stereotype.Component;
+// 导入 Java 的资源注入注解
import javax.annotation.Resource;
-import java.util.Arrays;
+// 导入 Java 的日期类，用于表示时间
import java.util.Date;
+// 导入 Java 的数组工具类，用于处理数组操作
+import java.util.Arrays;
+// 导入 Java 的列表接口，用于存储元素
import java.util.List;
+// 导入 Java 的流处理工具类，用于集合元素的转换和处理
import java.util.stream.Collectors;
/**
* mybatis对象处理器
**/
+// 使用 Lombok 的 Slf4j 注解，自动为该类添加日志记录功能
@Slf4j
+// 使用 Spring 的 Component 注解，将该类标记为组件，让 Spring 框架管理
@Component
+// 定义一个元对象处理器实现类，实现 MyBatis-Plus 的 MetaObjectHandler 接口
public class MetaObjectHandlerImpl implements MetaObjectHandler {
+
+ // 使用 Spring 的 Resource 注解注入 AuthorityAssert 类的实例
@Resource
private AuthorityAssert authorityAssert;
+ // 定义常量，表示创建记录的用户 ID 字段名
private static final String CREATEID = "createId";
+ // 定义常量，表示创建记录的时间字段名
private static final String CREATETIME = "createTime";
+ // 定义常量，表示更新记录的用户 ID 字段名
private static final String UPDATEID = "updateId";
+ // 定义常量，表示更新记录的时间字段名
private static final String UPDATETIME = "updateTime";
/**
* 自动填充创建时间修改时间
*
- * @param metaObject
+ * @param metaObject 元对象，包含要操作的对象信息
*/
@Override
public void insertFill(MetaObject metaObject) {
- // 获取登录信息
+ // 调用 authorityAssert 的方法获取当前登录用户的信息
LoginUserVo loginUserInfo = authorityAssert.getLoginUserInfo();
- //获取所有的字段名称
+ // 获取元对象中所有可获取的字段名称，并存储在列表中
List
-
-
-
-
-
-
-
-
-
-
-
+
+
+ class="login-form"
+ ref="ruleFormRef"
+ :rules="rules"
+ label-width="120px"
+ >
+
+
+
+
+
+
+
-
-
-
+
+
+
+
+
+
+
+
+
+
+ pzem(|f1_p)z2403h1|f!^$;-sEfHHy-Fqt@@OgvB~87Py$ zoyrgmRPP4VQ8#&?gf3KfJ_9#H0fPWT;pTr5r&t(ECZCiwfl9?Qa55w?h%h8>7Lc3C F1OO1{7+C-S