From 00e94f2f45b85391f8a621b44117dfcbc3202ef6 Mon Sep 17 00:00:00 2001 From: dj <2162570766@qq.com> Date: Mon, 16 Dec 2024 10:11:04 +0800 Subject: [PATCH] dj --- .eslintrc.js | 28 +- README.md | 2 +- babel.config.js | 25 +- package.json | 41 ++- routes/api/private/v1/categories.js | 472 +++++++++++++++------------- routes/api/private/v1/goods.js | 348 ++++++++++---------- routes/api/private/v1/menus.js | 31 +- routes/api/private/v1/orders.js | 190 ++++++----- routes/api/private/v1/reports.js | 49 +-- routes/api/private/v1/rights.js | 55 ++-- routes/api/private/v1/roles.js | 274 +++++++++------- routes/api/private/v1/upload.js | 42 ++- routes/api/private/v1/users.js | 307 ++++++++++-------- vue.config.js | 52 +-- 14 files changed, 1126 insertions(+), 790 deletions(-) diff --git a/.eslintrc.js b/.eslintrc.js index 98d0431..1c8ba40 100644 --- a/.eslintrc.js +++ b/.eslintrc.js @@ -1,17 +1,39 @@ +//这个配置文件主要做了以下几件事： + +//设置了ESLint的根配置，确保没有其他配置文件影响当前配置。 +//指定了脚本的运行环境为Node.js，这对于理解全局变量很重要。 +//继承了Vue.js官方推荐的eslint-plugin-vue的基础配置和Vue.js的标准配置。 +//自定义了两条规则，根据环境变量NODE_ENV的值（生产环境或开发环境）启用或禁用console和debugger语句。 +//指定了使用babel-eslint作为解析器，以支持ES6+语法和Babel特性。 +// 导出配置对象，使其可以被其他文件引入和使用 module.exports = { + // 设置ESLint的根配置，防止父级目录中的配置文件影响当前配置 root: true, + + // 指定脚本的运行环境，这里指定为Node.js环境 + // 这有助于ESLint理解全局变量，比如`module`, `require`等 env: { node: true }, + + // 继承（扩展）其他ESLint配置或插件配置 + // 这里继承了Vue.js官方推荐的eslint-plugin-vue的基础配置和Vue.js的标准配置 'extends': [ - 'plugin:vue/essential', - '@vue/standard' + 'plugin:vue/essential', // Vue.js官方推荐的eslint-plugin-vue的基础配置 + '@vue/standard' // Vue.js的标准配置，基于ESLint的标准规则集 ], + + // 自定义规则，覆盖继承的配置中的规则 rules: { + // 在生产环境中禁用console语句，在开发环境中允许使用 'no-console': process.env.NODE_ENV === 'production' ? 'error' : 'off', + // 在生产环境中禁用debugger语句，在开发环境中允许使用 'no-debugger': process.env.NODE_ENV === 'production' ? 'error' : 'off' }, + + // 解析器选项，用于指定ESLint使用的解析器 + // 这里指定使用babel-eslint解析器，它支持ES6+语法和Babel特性 parserOptions: { parser: 'babel-eslint' } -} +} \ No newline at end of file diff --git a/README.md b/README.md index 6755adc..07a07c5 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ - +注意：routes/services/test/config/dao/db/public2均为后端文件夹，仅是为了多注释放入的 ### 大家有问题尽量在这里提： https://gitee.com/wBekvam/vue-shop-admin/issues diff --git a/babel.config.js b/babel.config.js index b1e67b1..5756f22 100644 --- a/babel.config.js +++ b/babel.config.js @@ -1,23 +1,38 @@ -// 项目开发阶段用到的babel插件 +//这段代码展示了如何根据不同的环境（开发环境或生产环境）动态地配置Babel插件。在生产环境下，它 +//会移除所有的console语句以减少代码体积，并且使用了一些插件来优化Vue.js项目的打包结果和运行时性能。 +// 定义一个空数组，用于存放生产环境下需要用到的Babel插件 const prodPlugins = [] + +// 检查当前环境变量是否为生产环境（NODE_ENV === 'production'） if (process.env.NODE_ENV === 'production') { + // 如果是生产环境，则向prodPlugins数组中添加'transform-remove-console'插件 + // 这个插件的作用是在构建生产代码时移除所有的console.*调用，以减少打包后的文件大小和提高运行效率 prodPlugins.push('transform-remove-console') } +// 导出Babel配置对象 module.exports = { + // 预设（presets）数组，定义了Babel转译时使用的预设集 'presets': [ + // 使用Vue CLI提供的Babel预设集，适用于Vue.js项目 '@vue/cli-plugin-babel/preset' ], + // 插件（plugins）数组，定义了Babel转译时使用的插件 'plugins': [ + // 使用'component'插件，配合element-ui库使用 + // 该插件可以按需加载element-ui的组件和样式，减少打包后的文件大小 [ 'component', { - 'libraryName': 'element-ui', - 'styleLibraryName': 'theme-chalk' + 'libraryName': 'element-ui', // 指定按需加载的库名 + 'styleLibraryName': 'theme-chalk' // 指定样式库的名称 } ], - // 发布产品时候的插件数组 + // 使用展开运算符（...）将prodPlugins数组中的插件添加到这里 + // 这样，只有在生产环境下，'transform-remove-console'插件才会被包含在最终的插件列表中 ...prodPlugins, + // 添加'@babel/plugin-syntax-dynamic-import'插件 + // 该插件允许Babel解析动态import()语法，这对于代码分割和懒加载非常有用 '@babel/plugin-syntax-dynamic-import' ] -} +} \ No newline at end of file diff --git a/package.json b/package.json index 41138fd..85b7051 100644 --- a/package.json +++ b/package.json @@ -1,38 +1,77 @@ { +//请注意，vue-cli-plugin-element可能已经不是必需的，因为自从Vue CLI 3和Element UI 2.x版本以来， +//通常推荐使用babel-plugin-component来按需加载Element UI组件。此外，babel-eslint可能也需要更 +//新，因为ESLint现在原生支持Babel解析器（通过@babel/eslint-parser），但这取决于您的具体配置和需求。 +//另外，dependencies和devDependencies中的版本号前的^符号表示在安装依赖时，npm会安装与指定 +//版本兼容的最新版本（遵循语义化版本号）。这有助于确保您始终获得最新功能和安全修复，但也可能引 +//入不期望的更改。如果需要更严格的版本控制，可以考虑使用~（兼容补丁版本更新）或直接指定版本号（不自动更新）。 + // 项目名称 "name": "vue_shop_admin", + // 项目版本 "version": "0.1.0", + // 设置为私有项目，防止意外发布到npm "private": true, + // 定义npm脚本命令 "scripts": { + // 启动开发服务器，通常用于本地开发 "serve": "vue-cli-service serve", + // 构建生产环境的项目，生成dist目录 "build": "vue-cli-service build", + // 运行eslint检查代码质量 "lint": "vue-cli-service lint" }, + // 项目的依赖包，这些包会在项目安装时被安装到node_modules目录 "dependencies": { + // 用于发送HTTP请求的库 "axios": "^0.19.1", + // Babel插件，用于在生产环境中移除console语句 "babel-plugin-transform-remove-console": "^6.9.4", + // 包含新的JavaScript标准提案的polyfill，用于确保旧浏览器兼容 "core-js": "^3.4.4", + // 基于JavaScript的开源可视化图表库 "echarts": "^4.6.0", + // 基于Vue 2.0的桌面端组件库 "element-ui": "^2.4.5", + // JavaScript实用工具库 "lodash": "^4.17.15", + // 进度条组件库，用于显示页面加载进度 "nprogress": "^0.2.0", + // Vue.js框架 "vue": "^2.6.10", + // 富文本编辑器，基于Quill和Vue "vue-quill-editor": "^3.0.6", + // Vue.js的官方路由管理器 "vue-router": "^3.1.3", + // Vue表格组件，支持树形网格 "vue-table-with-tree-grid": "^0.2.4" }, + // 开发依赖包，仅在开发时使用，不会打包到最终项目中 "devDependencies": { + // Babel插件，支持动态import()语法 "@babel/plugin-syntax-dynamic-import": "^7.8.3", + // Vue CLI的Babel插件 "@vue/cli-plugin-babel": "^4.1.0", + // Vue CLI的ESLint插件 "@vue/cli-plugin-eslint": "^4.1.0", + // Vue CLI的服务工具，用于启动开发服务器和构建项目 "@vue/cli-service": "^4.1.0", + // Vue官方的ESLint配置 "@vue/eslint-config-standard": "^4.0.0", + // Babel和ESLint之间的桥梁，用于解析Babel代码 "babel-eslint": "^10.0.3", + // Babel插件，用于按需加载组件库（如element-ui） "babel-plugin-component": "^1.1.1", + // JavaScript的静态代码分析工具 "eslint": "^5.16.0", + // ESLint的Vue.js插件 "eslint-plugin-vue": "^5.0.0", + // CSS预处理器，LESS "less": "^3.10.3", + // webpack的loader，用于编译LESS文件 "less-loader": "^5.0.0", + // Vue CLI的element-ui插件（可能已经过时，因为可以直接通过babel-plugin-component配置） "vue-cli-plugin-element": "^1.0.1", + // Vue.js的模板编译器，用于将Vue模板预编译为渲染函数 "vue-template-compiler": "^2.6.10" } -} +} \ No newline at end of file diff --git a/routes/api/private/v1/categories.js b/routes/api/private/v1/categories.js index a23b4d2..9894eac 100644 --- a/routes/api/private/v1/categories.js +++ b/routes/api/private/v1/categories.js @@ -12,251 +12,293 @@ var catServ = authorization.getService("CategoryService"); var attrServ = authorization.getService("AttributeService"); // 获取分类列表 +// 引入Express框架的路由器对象（假设前面已经正确引入了Express） +const router = require('express').Router(); + +// 处理获取分类列表的GET请求，路径为根路径 "/" router.get("/", - function(req,res,next){ - // 参数验证 - // if(!req.query.pagenum || req.query.pagenum <= 0) return res.sendResult(null,400,"pagenum 参数错误"); - // if(!req.query.pagesize || req.query.pagesize <= 0) return res.sendResult(null,400,"pagesize 参数错误"); - next(); - }, - function(req,res,next){ - var conditions = null; - if(req.query.pagenum && req.query.pagesize) { - conditions = { - "pagenum" : req.query.pagenum, - "pagesize" : req.query.pagesize - }; - } - - catServ.getAllCategories(req.query.type,conditions,function(err,result){ - if(err) return res.sendResult(null,400,"获取分类列表失败"); - res.sendResult(result,200,"获取成功"); - })(req,res,next); -}); + // 第一个中间件函数，用于参数验证 + function (req, res, next) { + // 验证pagenum参数是否存在且大于0，如果不符合要求则返回错误响应，状态码400表示请求参数错误 + // 此处代码被注释掉了，若取消注释则会进行该参数验证逻辑 + // if (!req.query.pagenum || req.query.pagenum <= 0) return res.sendResult(null, 400, "pagenum 参数错误"); + // 验证pagesize参数是否存在且大于0，如果不符合要求则返回错误响应 + // 此处代码被注释掉了，若取消注释则会进行该参数验证逻辑 + // if (!req.query.pagesize || req.query.pagesize <= 0) return res.sendResult(null, 400, "pagesize 参数错误"); + // 如果参数验证通过，调用next()将控制权传递给下一个中间件或路由处理函数 + next(); + }, + // 第二个中间件函数，用于获取分类列表的业务逻辑处理 + function (req, res, next) { + var conditions = null; + // 如果pagenum和pagesize参数都存在，则构建包含这两个参数的查询条件对象 + if (req.query.pagenum && req.query.pagesize) { + conditions = { + "pagenum": req.query.pagenum, + "pagesize": req.query.pagesize + }; + } + + // 调用catServ服务（假设是自定义的分类相关服务模块）的getAllCategories方法，传入分类类型和查询条件等参数 + // 处理获取分类列表的异步操作，成功则返回结果，失败则返回错误信息 + catServ.getAllCategories(req.query.type, conditions, function (err, result) { + if (err) return res.sendResult(null, 400, "获取分类列表失败"); + res.sendResult(result, 200, "获取成功"); + })(req, res, next); + }); -// 创建分类 +// 处理创建分类的POST请求，路径为 "/" router.post("/", - // 参数验证 - function(req,res,next) { - if(!req.body.cat_name) { - return res.sendResult(null,400,"必须提供分类名称"); - } - next(); - }, - // 业务逻辑 - function(req,res,next) { - catServ.addCategory({ - "cat_pid":req.body.cat_pid, - "cat_name":req.body.cat_name, - "cat_level":req.body.cat_level - },function(err,result) { - if(err) return res.sendResult(null,400,err); - res.sendResult(result,201,"创建成功"); - })(req,res,next); - } + // 参数验证中间件，检查请求体中是否包含cat_name字段，如果没有则返回错误响应 + function (req, res, next) { + if (!req.body.cat_name) { + return res.sendResult(null, 400, "必须提供分类名称"); + } + // 参数验证通过，将控制权传递给下一个中间件 + next(); + }, + // 业务逻辑中间件，用于创建分类的具体操作 + function (req, res, next) { + // 调用catServ服务的addCategory方法，传入包含分类相关信息（父分类ID、分类名称、分类级别等）的对象 + // 处理创建分类的异步操作，成功则返回创建后的结果，失败则返回错误信息 + catServ.addCategory({ + "cat_pid": req.body.cat_pid, + "cat_name": req.body.cat_name, + "cat_level": req.body.cat_level + }, function (err, result) { + if (err) return res.sendResult(null, 400, err); + res.sendResult(result, 201, "创建成功"); + })(req, res, next); + } ); +// 处理根据分类ID获取分类详情的GET请求，路径中包含分类ID参数，如 "/:id" router.get("/:id", - // 参数验证 - function(req,res,next) { - if(!req.params.id) { - return res.sendResult(null,400,"分类ID不能为空"); - } - if(isNaN(parseInt(req.params.id))) return res.sendResult(null,400,"分类ID必须是数字"); - next(); - }, - // 正常业务逻辑 - function(req,res,next) { - catServ.getCategoryById(req.params.id,function(err,result){ - if(err) return res.sendResult(null,400,err); - res.sendResult(result,200,"获取成功"); - })(req,res,next); - } + // 参数验证中间件，检查分类ID参数是否存在以及是否为数字类型 + function (req, res, next) { + if (!req.params.id) { + return res.sendResult(null, 400, "分类ID不能为空"); + } + if (isNaN(parseInt(req.params.id))) return res.sendResult(null, 400, "分类ID必须是数字"); + // 参数验证通过，将控制权交给下一个中间件 + next(); + }, + // 正常业务逻辑中间件，用于根据分类ID获取分类详情的操作 + function (req, res, next) { + // 调用catServ服务的getCategoryById方法，传入分类ID参数 + // 处理获取分类详情的异步操作，成功则返回结果，失败则返回错误信息 + catServ.getCategoryById(req.params.id, function (err, result) { + if (err) return res.sendResult(null, 400, err); + res.sendResult(result, 200, "获取成功"); + })(req, res, next); + } ); - - - -// 删除分类 +// 处理删除分类的DELETE请求，路径中包含分类ID参数，如 "/:id" router.delete("/:id", - // 参数验证 - function(req,res,next) { - if(!req.params.id) { - return res.sendResult(null,400,"分类ID不能为空"); - } - if(isNaN(parseInt(req.params.id))) return res.sendResult(null,400,"分类ID必须是数字"); - next(); - }, - // 业务逻辑 - function(req,res,next) { - catServ.deleteCategory(req.params.id,function(msg) { - res.sendResult(null,200,msg); - })(req,res,next); - } + // 参数验证中间件，检查分类ID参数是否存在以及是否为数字类型 + function (req, res, next) { + if (!req.params.id) { + return res.sendResult(null, 400, "分类ID不能为空"); + } + if (isNaN(parseInt(req.params.id))) return res.sendResult(null, 400, "分类ID必须是数字"); + // 参数验证通过，将控制权交给下一个中间件 + next(); + }, + // 业务逻辑中间件，用于执行删除分类的操作 + function (req, res, next) { + // 调用catServ服务的deleteCategory方法，传入分类ID参数 + // 处理删除分类的异步操作，成功则返回提示信息，失败则返回错误信息 + catServ.deleteCategory(req.params.id, function (msg) { + res.sendResult(null, 200, msg); + })(req, res, next); + } ); -// 更新分类 +// 处理更新分类的PUT请求，路径中包含分类ID参数，如 "/:id" router.put("/:id", - // 参数验证 - function(req,res,next) { - if(!req.params.id) { - return res.sendResult(null,400,"分类ID不能为空"); - } - if(isNaN(parseInt(req.params.id))) return res.sendResult(null,400,"分类ID必须是数字"); - if(!req.body.cat_name || req.body.cat_name == "") return res.sendResult(null,400,"分类名称不能为空"); - next(); - }, - // 业务逻辑 - function(req,res,next) { - catServ.updateCategory(req.params.id,req.body.cat_name,function(err,result) { - if(err) return res.sendResult(null,400,err); - res.sendResult(result,200,"更新成功"); - })(req,res,next); - } + // 参数验证中间件，检查分类ID参数是否存在、是否为数字类型，以及分类名称是否为空 + function (req, res, next) { + if (!req.params.id) { + return res.sendResult(null, 400, "分类ID不能为空"); + } + if (isNaN(parseInt(req.params.id))) return res.sendResult(null, 400, "分类ID必须是数字"); + if (!req.body.cat_name || req.body.cat_name == "") return res.sendResult(null, 400, "分类名称不能为空"); + // 参数验证通过，将控制权交给下一个中间件 + next(); + }, + // 业务逻辑中间件，用于执行更新分类的操作 + function (req, res, next) { + // 调用catServ服务的updateCategory方法，传入分类ID和新的分类名称等参数 + // 处理更新分类的异步操作，成功则返回更新后的结果，失败则返回错误信息 + catServ.updateCategory(req.params.id, req.body.cat_name, function (err, result) { + if (err) return res.sendResult(null, 400, err); + res.sendResult(result, 200, "更新成功"); + })(req, res, next); + } ); -// 通过参数方式查询静态参数还是动态参数 +// 处理通过分类ID获取分类参数（attributes）的GET请求，路径为 "/:id/attributes" router.get("/:id/attributes", - // 验证参数 - function(req,res,next) { - if(!req.params.id) { - return res.sendResult(null,400,"分类ID不能为空"); - } - if(isNaN(parseInt(req.params.id))) return res.sendResult(null,400,"分类ID必须是数字"); - if(!req.query.sel || (req.query.sel != "only" && req.query.sel != "many")) { - return res.sendResult(null,400,"属性类型必须设置"); - } - next(); - }, - // 业务逻辑 - function(req,res,next) { - // attrServ - attrServ.getAttributes(req.params.id,req.query.sel,function(err,attributes){ - if(err) return res.sendResult(null,400,err); - res.sendResult(attributes,200,"获取成功"); - })(req,res,next); - } + // 参数验证中间件，检查分类ID参数是否存在、是否为数字类型，以及属性类型（sel）是否设置正确 + function (req, res, next) { + if (!req.params.id) { + return res.sendResult(null, 400, "分类ID不能为空"); + } + if (isNaN(parseInt(req.params.id))) return res.sendResult(null, 400, "分类ID必须是数字"); + if (!req.query.sel || (req.query.sel!= "only" && req.query.sel!= "many")) { + return res.sendResult(null, 400, "属性类型必须设置"); + } + // 参数验证通过，将控制权交给下一个中间件 + next(); + }, + // 业务逻辑中间件，用于获取分类参数的操作 + function (req, res, next) { + // 调用attrServ服务（假设是自定义的属性相关服务模块）的getAttributes方法，传入分类ID和属性类型等参数 + // 处理获取分类参数的异步操作，成功则返回获取到的属性列表，失败则返回错误信息 + attrServ.getAttributes(req.params.id, req.query.sel, function (err, attributes) { + if (err) return res.sendResult(null, 400, err); + res.sendResult(attributes, 200, "获取成功"); + })(req, res, next); + } ); -// 获取参数详情 +// 处理根据分类ID和参数ID获取参数详情的GET请求，路径为 "/:id/attributes/:attrId" router.get("/:id/attributes/:attrId", - // 验证参数 - function(req,res,next) { - if(!req.params.id) { - return res.sendResult(null,400,"分类ID不能为空"); - } - if(isNaN(parseInt(req.params.id))) return res.sendResult(null,400,"分类ID必须是数字"); - if(!req.params.attrId) { - return res.sendResult(null,400,"参数ID不能为空"); - } - if(isNaN(parseInt(req.params.attrId))) return res.sendResult(null,400,"参数ID必须是数字"); - next(); - }, - function(req,res,next) { - attrServ.attributeById(req.params.attrId,function(err,attr){ - if(err) return res.sendResult(null,400,err); - res.sendResult(attr,200,"获取成功"); - })(req,res,next); - } + // 参数验证中间件，检查分类ID和参数ID是否存在以及是否为数字类型 + function (req, res, next) { + if (!req.params.id) { + return res.sendResult(null, 400, "分类ID不能为空"); + } + if (isNaN(parseInt(req.params.id))) return res.sendResult(null, 400, "分类ID必须是数字"); + if (!req.params.attrId) { + return res.sendResult(null, 400, "参数ID不能为空"); + } + if (isNaN(parseInt(req.params.attrId))) return res.sendResult(null, 400, "参数ID必须是数字"); + // 参数验证通过，将控制权交给下一个中间件 + next(); + }, + function (req, res, next) { + // 调用attrServ服务的attributeById方法，传入参数ID参数 + // 处理获取参数详情的异步操作，成功则返回参数详情，失败则返回错误信息 + attrServ.attributeById(req.params.attrId, function (err, attr) { + if (err) return res.sendResult(null, 400, err); + res.sendResult(attr, 200, "获取成功"); + })(req, res, next); + } ); -// 创建参数 +// 处理创建分类参数的POST请求，路径为 "/:id/attributes" router.post("/:id/attributes", - // 验证参数 - function(req,res,next) { - if(!req.params.id) { - return res.sendResult(null,400,"分类ID不能为空"); - } - if(isNaN(parseInt(req.params.id))) return res.sendResult(null,400,"分类ID必须是数字"); - - if(!req.body.attr_name) return res.sendResult(null,400,"参数名称不能为空"); + // 参数验证中间件，检查分类ID是否存在、是否为数字类型，参数名称是否为空，以及参数的attr_sel类型是否正确等 + function (req, res, next) { + if (!req.params.id) { + return res.sendResult(null, 400, "分类ID不能为空"); + } + if (isNaN(parseInt(req.params.id))) return res.sendResult(null, 400, "分类ID必须是数字"); - if(!req.body.attr_sel || (req.body.attr_sel != "only" && req.body.attr_sel != "many")) { - return res.sendResult(null,400,"参数 attr_sel 类型必须为 only 或 many"); - } - /* - if(!req.body.attr_write || (req.body.attr_write != "manual" && req.body.attr_write != "list")) { - return res.sendResult(null,400,"参数的 attr_write 必须为 manual 或 list"); - }*/ - next(); - }, - // 业务逻辑 - function(req,res,next) { - attrServ.createAttribute( - { - "attr_name" : req.body.attr_name, - "cat_id" : req.params.id, - "attr_sel" : req.body.attr_sel, - "attr_write" : req.body.attr_sel == "many" ? "list" : "manual",//req.body.attr_write, - "attr_vals" : req.body.attr_vals ? req.body.attr_vals : "" - }, - function(err,attr) { - if(err) return res.sendResult(null,400,err); - res.sendResult(attr,201,"创建成功"); - })(req,res,next); - } -); + if (!req.body.attr_name) return res.sendResult(null, 400, "参数名称不能为空"); + if (!req.body.attr_sel || (req.body.attr_sel!= "only" && req.body.attr_sel!= "many")) { + return res.sendResult(null, 400, "参数 attr_sel 类型必须为 only 或 many"); + } + // 以下代码被注释掉了，原本可能是用于验证参数的attr_write字段是否符合要求 + /* + if (!req.body.attr_write || (req.body.attr_write!= "manual" && req.body.attr_write!= "list")) { + return res.sendResult(null, 400, "参数的 attr_write 必须为 manual 或 list"); + }*/ + // 参数验证通过，将控制权交给下一个中间件 + next(); + }, + // 业务逻辑中间件，用于创建分类参数的操作 + function (req, res, next) { + // 根据参数的attr_sel类型来确定attr_write的值，如果attr_sel为"many"则attr_write设为"list"，否则设为"manual" + const attr_write_value = req.body.attr_sel == "many"? "list" : "manual"; + // 调用attrServ服务的createAttribute方法，传入包含参数相关信息（名称、所属分类ID、选择类型、写入类型、参数值等）的对象 + // 处理创建分类参数的异步操作，成功则返回创建后的参数信息，失败则返回错误信息 + attrServ.createAttribute( + { + "attr_name": req.body.attr_name, + "cat_id": req.params.id, + "attr_sel": req.body.attr_sel, + "attr_write": attr_write_value, + "attr_vals": req.body.attr_vals? req.body.attr_vals : "" + }, + function (err, attr) { + if (err) return res.sendResult(null, 400, err); + res.sendResult(attr, 201, "创建成功"); + })(req, res, next); + } +); -// 更新参数 +// 处理更新分类参数的PUT请求，路径为 "/:id/attributes/:attrId" router.put("/:id/attributes/:attrId", - // 验证参数 - function(req,res,next) { - if(!req.params.id) { - return res.sendResult(null,400,"分类ID不能为空"); - } - if(isNaN(parseInt(req.params.id))) return res.sendResult(null,400,"分类ID必须是数字"); - if(!req.params.attrId) { - return res.sendResult(null,400,"参数ID不能为空"); - } - if(isNaN(parseInt(req.params.attrId))) return res.sendResult(null,400,"参数ID必须是数字"); - if(!req.body.attr_sel || (req.body.attr_sel != "only" && req.body.attr_sel != "many")) { - return res.sendResult(null,400,"参数 attr_sel 类型必须为 only 或 many"); - } + // 参数验证中间件，检查分类ID、参数ID是否存在、是否为数字类型，参数的attr_sel类型是否正确，以及参数名称是否为空等 + function (req, res, next) { + if (!req.params.id) { + return res.sendResult(null, 400, "分类ID不能为空"); + } + if (isNaN(parseInt(req.params.id))) return res.sendResult(null, 400, "分类ID必须是数字"); + if (!req.params.attrId) { + return res.sendResult(null, 400, "参数ID不能为空"); + } + if (isNaN(parseInt(req.params.attrId))) return res.sendResult(null, 400, "参数ID必须是数字"); + if (!req.body.attr_sel || (req.body.attr_sel!= "only" && req.body.attr_sel!= "many")) { + return res.sendResult(null, 400, "参数 attr_sel 类型必须为 only 或 many"); + } - if(!req.body.attr_name || req.body.attr_name == "") return res.sendResult(null,400,"参数名称不能为空"); + if (!req.body.attr_name || req.body.attr_name == "") return res.sendResult(null, 400, "参数名称不能为空"); - next(); - }, - // 业务逻辑 - function(req,res,next) { - attrServ.updateAttribute( - req.params.attrId, - { - "attr_name" : req.body.attr_name, - "cat_id" : req.params.id, - "attr_sel" : req.body.attr_sel, - "attr_write" : req.body.attr_sel == "many" ? "list" : "manual",//req.body.attr_write, - "attr_vals" : req.body.attr_vals ? req.body.attr_vals : "" - }, - function(err,newAttr) { - if(err) return res.sendResult(null,400,err); - res.sendResult(newAttr,200,"更新成功"); - })(req,res,next); - } + // 参数验证通过，将控制权交给下一个中间件 + next(); + }, + // 业务逻辑中间件，用于更新分类参数的操作 + function (req, res, next) { + // 根据参数的attr_sel类型来确定attr_write的值，如果attr_sel为"many"则attr_write设为"list"，否则设为"manual" + const attr_write_value = req.body.attr_sel == "many"? "list" : "manual"; + // 调用attrServ服务的updateAttribute方法，传入参数ID以及包含更新后的参数相关信息（名称、所属分类ID、选择类型、写入类型、参数值等）的对象 + // 处理更新分类参数的异步操作，成功则返回更新后的参数信息，失败则返回错误信息 + attrServ.updateAttribute( + req.params.attrId, + { + "attr_name": req.body.attr_name, + "cat_id": req.params.id, + "attr_sel": req.body.attr_sel, + "attr_write": attr_write_value, + "attr_vals": req.body.attr_vals? req.body.attr_vals : "" + }, + function (err, newAttr) { + if (err) return res.sendResult(null, 400, err); + res.sendResult(newAttr, 200, "更新成功"); + })(req, res, next); + } ); -// 删除参数 +// 处理删除分类参数的DELETE请求，路径为 "/:id/attributes/:attrId" router.delete("/:id/attributes/:attrId", - // 验证参数 - function(req,res,next) { - if(!req.params.id) { - return res.sendResult(null,400,"分类ID不能为空"); - } - if(isNaN(parseInt(req.params.id))) return res.sendResult(null,400,"分类ID必须是数字"); - if(!req.params.attrId) { - return res.sendResult(null,400,"参数ID不能为空"); - } - if(isNaN(parseInt(req.params.attrId))) return res.sendResult(null,400,"参数ID必须是数字"); - next(); - }, - // 业务逻辑 - function(req,res,next) { - attrServ.deleteAttribute(req.params.attrId,function(err,newAttr) { - if(err) return res.sendResult(null,400,err); - res.sendResult(null,200,"删除成功"); - })(req,res,next); - } + // 参数验证中间件，检查分类ID和参数ID是否存在以及是否为数字类型 + function (req, res, next) { + if (!req.params.id) { + return res.sendResult(null, 400, "分类ID不能为空"); + } + if (isNaN(parseInt(req.params.id))) return res.sendResult(null, 400, "分类ID必须是数字"); + if (!req.params.attrId) { + return res.sendResult(null, 400, "参数ID不能为空"); + } + if (isNaN(parseInt(req.params.attrId))) return res.sendResult(null, 400, "参数ID必须是数字"); + // 参数验证通过，将控制权交给下一个中间件 + next(); + }, + // 业务逻辑中间件，用于执行删除分类参数的操作 + function (req, res, next) { + // 调用attrServ服务的deleteAttribute方法，传入参数ID参数 + // 处理删除分类参数的异步操作，成功则返回提示信息，失败则返回错误信息 + attrServ.deleteAttribute(req.params.attrId, function (err, newAttr) { + if (err) return res.sendResult(null, 400, err); + res.sendResult(null, 200, "删除成功"); + })(req, res, next); + } ); +// 将配置好的路由器对象导出，以便在其他模块中使用 module.exports = router; \ No newline at end of file diff --git a/routes/api/private/v1/goods.js b/routes/api/private/v1/goods.js index a5d933e..6ade6b9 100644 --- a/routes/api/private/v1/goods.js +++ b/routes/api/private/v1/goods.js @@ -1,190 +1,222 @@ +// 引入Express框架的核心模块，用于创建Web应用和路由等功能 var express = require('express'); +// 创建一个Express路由器实例，用于定义一组相关的路由 var router = express.Router(); +// 引入Node.js的path模块，用于处理文件路径相关操作 var path = require("path"); -// 获取验证模块 -var authorization = require(path.join(process.cwd(),"/modules/authorization")); +// 获取自定义的验证模块，通过拼接当前工作目录和相对路径来指定模块位置 +// 这里假设验证模块（authorization）提供了一些权限验证以及获取相关服务的功能 +var authorization = require(path.join(process.cwd(), "/modules/authorization")); -// 通过验证模块获取分类管理 +// 通过验证模块获取名为"GoodService"的服务对象，用于后续对商品相关操作的调用 +// 这个服务对象应该封装了与商品数据交互的各种方法，比如增删改查等 var goodServ = authorization.getService("GoodService"); -// 商品列表 +// 定义处理获取商品列表的GET请求的路由，路径为根路径 "/" router.get("/", - // 验证参数 - function(req,res,next) { - // 参数验证 - if(!req.query.pagenum || req.query.pagenum <= 0) return res.sendResult(null,400,"pagenum 参数错误"); - if(!req.query.pagesize || req.query.pagesize <= 0) return res.sendResult(null,400,"pagesize 参数错误"); - next(); - }, - // 业务逻辑 - function(req,res,next) { - var conditions = { - "pagenum" : req.query.pagenum, - "pagesize" : req.query.pagesize - }; + // 第一个中间件函数，用于验证请求参数的合法性 + function (req, res, next) { + // 验证pagenum参数是否存在且大于0，如果不符合要求则返回错误响应，状态码400表示请求参数错误 + if (!req.query.pagenum || req.query.pagenum <= 0) return res.sendResult(null, 400, "pagenum 参数错误"); + // 验证pagesize参数是否存在且大于0，如果不符合要求则返回错误响应 + if (!req.query.pagesize || req.query.pagesize <= 0) return res.sendResult(null, 400, "pagesize 参数错误"); + // 参数验证通过，调用next()将控制权传递给下一个中间件或路由处理函数 + next(); + }, + // 第二个中间件函数，用于处理获取商品列表的业务逻辑 + function (req, res, next) { + var conditions = { + // 将请求中的pagenum参数添加到查询条件对象中，用于分页查询等操作 + "pagenum": req.query.pagenum, + // 将请求中的pagesize参数添加到查询条件对象中 + "pagesize": req.query.pagesize + }; - if(req.query.query) { - conditions["query"] = req.query.query; - } - goodServ.getAllGoods( - conditions, - function(err,result){ - if(err) return res.sendResult(null,400,err); - res.sendResult(result,200,"获取成功"); - } - )(req,res,next); - } + // 如果请求中包含query参数，则将其也添加到查询条件对象中，可能用于模糊查询等功能 + if (req.query.query) { + conditions["query"] = req.query.query; + } + + // 调用goodServ服务对象的getAllGoods方法，传入查询条件对象，用于获取商品列表 + // 处理获取商品列表的异步操作，若出现错误则返回错误信息，成功则返回查询到的商品列表数据 + goodServ.getAllGoods( + conditions, + function (err, result) { + if (err) return res.sendResult(null, 400, err); + res.sendResult(result, 200, "获取成功"); + } + )(req, res, next); + } ); -// 添加商品 +// 定义处理添加商品的POST请求的路由，路径为 "/" router.post("/", - // 参数验证 - function(req,res,next) { - next(); - }, - // 业务逻辑 - function(req,res,next) { - var params = req.body; - goodServ.createGood(params,function(err,newGood){ - if(err) return res.sendResult(null,400,err); - res.sendResult(newGood,201,"创建商品成功"); - })(req,res,next); - } + // 参数验证中间件，这里暂时直接调用next()，可能后续需要补充具体的参数验证逻辑 + function (req, res, next) { + next(); + }, + // 业务逻辑中间件，用于处理添加商品的具体操作 + function (req, res, next) { + // 获取请求体中的参数，假设这些参数包含了创建商品所需的各种信息，如商品名称、价格、描述等 + var params = req.body; + // 调用goodServ服务对象的createGood方法，传入商品参数，用于创建新商品 + // 处理创建商品的异步操作，若出现错误则返回错误信息，成功则返回创建后的商品信息 + goodServ.createGood(params, function (err, newGood) { + if (err) return res.sendResult(null, 400, err); + res.sendResult(newGood, 201, "创建商品成功"); + })(req, res, next); + } ); -// 更新商品 +// 定义处理更新商品信息的PUT请求的路由，路径中包含商品ID参数，如 "/:id" router.put("/:id", - // 参数验证 - function(req,res,next) { - if(!req.params.id) { - return res.sendResult(null,400,"商品ID不能为空"); - } - if(isNaN(parseInt(req.params.id))) return res.sendResult(null,400,"商品ID必须是数字"); - next(); - }, - // 业务逻辑 - function(req,res,next) { - var params = req.body; - goodServ.updateGood(req.params.id,params,function(err,newGood){ - if(err) return res.sendResult(null,400,err); - res.sendResult(newGood,200,"创建商品成功"); - })(req,res,next); - } + // 参数验证中间件，检查商品ID参数是否存在以及是否为数字类型 + function (req, res, next) { + if (!req.params.id) { + return res.sendResult(null, 400, "商品ID不能为空"); + } + if (isNaN(parseInt(req.params.id))) return res.sendResult(null, 400, "商品ID必须是数字"); + // 参数验证通过，将控制权交给下一个中间件 + next(); + }, + // 业务逻辑中间件，用于处理更新商品信息的具体操作 + function (req, res, next) { + var params = req.body; + // 调用goodServ服务对象的updateGood方法，传入商品ID和更新的参数，用于更新指定商品的信息 + // 处理更新商品信息的异步操作，若出现错误则返回错误信息，成功则返回更新后的商品信息 + // 这里返回的提示信息文本 "创建商品成功" 可能有误，应该是 "更新商品成功"，后续可根据实际情况修改 + goodServ.updateGood(req.params.id, params, function (err, newGood) { + if (err) return res.sendResult(null, 400, err); + res.sendResult(newGood, 200, "创建商品成功"); + })(req, res, next); + } ); -// 获取商品详情 +// 定义处理获取商品详情的GET请求的路由，路径中包含商品ID参数，如 "/:id" router.get("/:id", - // 参数验证 - function(req,res,next) { - if(!req.params.id) { - return res.sendResult(null,400,"商品ID不能为空"); - } - if(isNaN(parseInt(req.params.id))) return res.sendResult(null,400,"商品ID必须是数字"); - next(); - }, - // 业务逻辑 - function(req,res,next) { - goodServ.getGoodById(req.params.id,function(err,good){ - if(err) return res.sendResult(null,400,err); - return res.sendResult(good,200,"获取成功"); - })(req,res,next); - } + // 参数验证中间件，检查商品ID参数是否存在以及是否为数字类型 + function (req, res, next) { + if (!req.params.id) { + return res.sendResult(null, 400, "商品ID不能为空"); + } + if (isNaN(parseInt(req.params.id))) return res.sendResult(null, 400, "商品ID必须是数字"); + // 参数验证通过，将控制权交给下一个中间件 + next(); + }, + // 业务逻辑中间件，用于处理获取商品详情的具体操作 + function (req, res, next) { + // 调用goodServ服务对象的getGoodById方法，传入商品ID参数，用于获取指定商品的详细信息 + // 处理获取商品详情的异步操作，若出现错误则返回错误信息，成功则返回商品详细信息 + goodServ.getGoodById(req.params.id, function (err, good) { + if (err) return res.sendResult(null, 400, err); + return res.sendResult(good, 200, "获取成功"); + })(req, res, next); + } ); - - -// 删除商品 +// 定义处理删除商品的DELETE请求的路由，路径中包含商品ID参数，如 "/:id" router.delete("/:id", - // 参数验证 - function(req,res,next) { - if(!req.params.id) { - return res.sendResult(null,400,"商品ID不能为空"); - } - if(isNaN(parseInt(req.params.id))) return res.sendResult(null,400,"商品ID必须是数字"); - next(); - }, - // 业务逻辑 - function(req,res,next) { - goodServ.deleteGood(req.params.id,function(err){ - if(err) - return res.sendResult(null,400,"删除失败"); - else - return res.sendResult(null,200,"删除成功"); - })(req,res,next); - } + // 参数验证中间件，检查商品ID参数是否存在以及是否为数字类型 + function (req, res, next) { + if (!req.params.id) { + return res.sendResult(null, 400, "商品ID不能为空"); + } + if (isNaN(parseInt(req.params.id))) return res.sendResult(null, 400, "商品ID必须是数字"); + // 参数验证通过，将控制权交给下一个中间件 + next(); + }, + // 业务逻辑中间件，用于处理删除商品的具体操作 + function (req, res, next) { + // 调用goodServ服务对象的deleteGood方法，传入商品ID参数，用于删除指定商品 + // 处理删除商品的异步操作，若出现错误则返回错误信息，成功则返回相应提示信息 + goodServ.deleteGood(req.params.id, function (err) { + if (err) + return res.sendResult(null, 400, "删除失败"); + else + return res.sendResult(null, 200, "删除成功"); + })(req, res, next); + } ); -// 更新商品的图片 +// 定义处理更新商品图片的PUT请求的路由，路径为 "/:id/pics"，其中包含商品ID参数 router.put("/:id/pics", - // 参数验证 - function(req,res,next) { - if(!req.params.id) { - return res.sendResult(null,400,"商品ID不能为空"); - } - if(isNaN(parseInt(req.params.id))) return res.sendResult(null,400,"商品ID必须是数字"); - next(); - }, - // 业务逻辑 - function(req,res,next) { - - goodServ.updateGoodPics( - req.params.id, - req.body, - function(err,good){ - if(err) return res.sendResult(null,400,err); - res.sendResult(good,200,"更新成功"); - } - )(req,res,next); - } + // 参数验证中间件，检查商品ID参数是否存在以及是否为数字类型 + function (req, res, next) { + if (!req.params.id) { + return res.sendResult(null, 400, "商品ID不能为空"); + } + if (isNaN(parseInt(req.params.id))) return res.sendResult(null, 400, "商品ID必须是数字"); + // 参数验证通过，将控制权交给下一个中间件 + next(); + }, + // 业务逻辑中间件，用于处理更新商品图片的具体操作 + function (req, res, next) { + // 调用goodServ服务对象的updateGoodPics方法，传入商品ID和请求体中的相关参数（可能包含新的图片信息等） + // 处理更新商品图片的异步操作，若出现错误则返回错误信息，成功则返回更新后的商品信息 + goodServ.updateGoodPics( + req.params.id, + req.body, + function (err, good) { + if (err) return res.sendResult(null, 400, err); + res.sendResult(good, 200, "更新成功"); + } + )(req, res, next); + } ); -// 更新商品的属性 +// 定义处理更新商品属性的PUT请求的路由，路径为 "/:id/attributes"，包含商品ID参数 router.put("/:id/attributes", - // 参数验证 - function(req,res,next) { - if(!req.params.id) { - return res.sendResult(null,400,"商品ID不能为空"); - } - if(isNaN(parseInt(req.params.id))) return res.sendResult(null,400,"商品ID必须是数字"); - next(); - }, - // 业务逻辑 - function(req,res,next) { - - goodServ.updateGoodAttributes ( - req.params.id, - req.body, - function(err,good){ - if(err) return res.sendResult(null,400,err); - res.sendResult(good,200,"更新成功"); - } - )(req,res,next); - } + // 参数验证中间件，检查商品ID参数是否存在以及是否为数字类型 + function (req, res, next) { + if (!req.params.id) { + return res.sendResult(null, 400, "商品ID不能为空"); + } + if (isNaN(parseInt(req.params.id))) return res.sendResult(null, 400, "商品ID必须是数字"); + // 参数验证通过，将控制权交给下一个中间件 + next(); + }, + // 业务逻辑中间件，用于处理更新商品属性的具体操作 + function (req, res, next) { + // 调用goodServ服务对象的updateGoodAttributes方法，传入商品ID和请求体中的相关参数（包含要更新的属性信息等） + // 处理更新商品属性的异步操作，若出现错误则返回错误信息，成功则返回更新后的商品信息 + goodServ.updateGoodAttributes( + req.params.id, + req.body, + function (err, good) { + if (err) return res.sendResult(null, 400, err); + res.sendResult(good, 200, "更新成功"); + } + )(req, res, next); + } ); -// 更新商品状态 +// 定义处理更新商品状态的PUT请求的路由，路径为 "/:id/state/:state"，包含商品ID和状态值两个参数 router.put("/:id/state/:state", - // 参数验证 - function(req,res,next) { - if(!req.params.id) { - return res.sendResult(null,400,"商品ID不能为空"); - } - if(isNaN(parseInt(req.params.id))) return res.sendResult(null,400,"商品ID必须是数字"); - if(!req.params.state) { - return res.sendResult(null,400,"状态值不能为空"); - } - if(req.params.state != 0 && req.params.state != 1 && req.params.state != 2) { - return res.sendResult(null,400,"状态值只能为 0 ，1 或 2"); - } - next(); - }, - function(req,res,next) { - goodServ.updateGoodsState(req.params.id,req.params.state,function(err,good){ - if(err) return res.sendResult(null,400,err); - res.sendResult(good,200,"更新成功"); - })(req,res,next); -} + // 参数验证中间件，检查商品ID参数是否存在、是否为数字类型，以及状态值参数是否符合要求 + function (req, res, next) { + if (!req.params.id) { + return res.sendResult(null, 400, "商品ID不能为空"); + } + if (isNaN(parseInt(req.params.id))) return res.sendResult(null, 400, "商品ID必须是数字"); + if (!req.params.state) { + return res.sendResult(null, 400, "状态值不能为空"); + } + if (req.params.state!= 0 && req.params.state!= 1 && req.params.state!= 2) { + return res.sendResult(null, 400, "状态值只能为 0 ，1 或 2"); + } + // 参数验证通过，将控制权交给下一个中间件 + next(); + }, + function (req, res, next) { + // 调用goodServ服务对象的updateGoodsState方法，传入商品ID和状态值参数，用于更新商品的状态 + // 处理更新商品状态的异步操作，若出现错误则返回错误信息，成功则返回更新后的商品信息 + goodServ.updateGoodsState(req.params.id, req.params.state, function (err, good) { + if (err) return res.sendResult(null, 400, err); + res.sendResult(good, 200, "更新成功"); + })(req, res, next); + } ); -module.exports = router; +// 将配置好的路由器对象导出，以便在主应用模块中使用，挂载到对应的路径上 +module.exports = router; \ No newline at end of file diff --git a/routes/api/private/v1/menus.js b/routes/api/private/v1/menus.js index 4198ccd..a8bd238 100644 --- a/routes/api/private/v1/menus.js +++ b/routes/api/private/v1/menus.js @@ -1,20 +1,31 @@ +// 引入Express框架的核心模块，通过它可以创建路由等功能 var express = require('express'); +// 创建一个Express路由器实例，用于定义一组相关的路由，方便在应用中进行模块化的路由管理 var router = express.Router(); +// 引入Node.js的path模块，主要用于处理文件路径相关的操作，例如拼接、解析路径等 var path = require("path"); -// 获取验证模块 -var authorization = require(path.join(process.cwd(),"/modules/authorization")); +// 获取自定义的验证模块，通过path.join方法将当前工作目录（process.cwd()）和相对路径（"/modules/authorization"）拼接起来，指定了验证模块的准确位置，然后使用require进行引入 +// 这个验证模块通常会用于验证用户的权限等相关操作，确保后续的操作是合法且符合权限要求的 +var authorization = require(path.join(process.cwd(), "/modules/authorization")); -// 通过验证模块获取菜单服务模块 -var menuService = require(path.join(process.cwd(),"/services/MenuService")); +// 通过验证模块获取名为"MenuService"的菜单服务模块，同样使用path.join拼接当前工作目录和服务模块所在的相对路径（"/services/MenuService"）来准确引入该模块 +// 这个菜单服务模块应该封装了与菜单相关的各种业务逻辑，比如获取菜单数据、操作菜单等功能 +var menuService = require(path.join(process.cwd(), "/services/MenuService")); +// 定义一个处理GET请求的路由，路径为根路径 "/"，用于获取菜单列表 router.get("/", - function(req,res,next) { - menuService.getLeftMenus(req.userInfo,function(err,result) { - if(err) return res.sendResult(null,400,err); - res.sendResult(result,200,"获取菜单列表成功"); - }); - } + // 路由处理函数，在这个函数中调用了menuService的getLeftMenus方法来获取左侧菜单列表 + // 传入的参数req.userInfo可能是包含了当前用户相关信息的对象，例如用户的角色、权限等信息，以便菜单服务模块根据用户信息来生成对应的菜单列表 + function (req, res, next) { + menuService.getLeftMenus(req.userInfo, function (err, result) { + // 如果获取菜单列表的操作出现错误（err不为null），则使用res.sendResult方法返回一个带有错误信息的响应，状态码为400，表示请求出现错误，错误信息具体由err传递过来 + if (err) return res.sendResult(null, 400, err); + // 如果获取菜单列表成功，则使用res.sendResult方法返回成功的响应，将获取到的菜单列表数据（result）传递回去，状态码为200，表示请求成功，同时附带一个提示信息"获取菜单列表成功" + res.sendResult(result, 200, "获取菜单列表成功"); + }); + } ); +// 将配置好的路由器对象导出，以便在主应用中可以引入并挂载到对应的路径上，从而使得这些定义的路由能够正常工作并响应客户端的请求 module.exports = router; \ No newline at end of file diff --git a/routes/api/private/v1/orders.js b/routes/api/private/v1/orders.js index a620241..e54e7da 100644 --- a/routes/api/private/v1/orders.js +++ b/routes/api/private/v1/orders.js @@ -1,101 +1,129 @@ +// 引入Express框架的核心模块，用于创建Web应用以及进行路由相关操作 var express = require('express'); +// 创建一个Express路由器实例，方便后续在应用中进行模块化的路由定义与管理 var router = express.Router(); +// 引入Node.js的path模块，主要用于处理文件路径相关的操作，例如拼接文件或模块的路径等 var path = require("path"); -// 获取验证模块 -var authorization = require(path.join(process.cwd(),"/modules/authorization")); +// 获取自定义的验证模块，通过path.join方法将当前工作目录（process.cwd()）与相对路径（"/modules/authorization"）拼接起来，准确地找到并引入该验证模块 +// 这个验证模块通常会负责诸如用户权限验证等相关功能，确保后续操作的合法性和安全性 +var authorization = require(path.join(process.cwd(), "/modules/authorization")); -// 通过验证模块获取分类管理 +// 通过验证模块获取名为"OrderService"的服务对象，该服务对象应该封装了与订单相关的各种业务操作方法，例如订单的增删改查等功能 var orderServ = authorization.getService("OrderService"); -// 订单列表 +// 定义处理获取订单列表的GET请求的路由，路径为根路径 "/" router.get("/", - // 参数验证 - function(req,res,next) { - // 参数验证 - if(!req.query.pagenum || req.query.pagenum <= 0) return res.sendResult(null,400,"pagenum 参数错误"); - if(!req.query.pagesize || req.query.pagesize <= 0) return res.sendResult(null,400,"pagesize 参数错误"); - next(); - }, - // 业务逻辑 - function(req,res,next) { - var conditions = { - "pagenum" : req.query.pagenum, - "pagesize" : req.query.pagesize - }; + // 第一个中间件函数，用于对请求参数进行验证 + function (req, res, next) { + // 验证pagenum参数是否存在且大于0，如果该参数不存在或者小于等于0，则返回错误响应，状态码400表示请求参数有误 + if (!req.query.pagenum || req.query.pagenum <= 0) return res.sendResult(null, 400, "pagenum 参数错误"); + // 验证pagesize参数是否存在且大于0，如果该参数不存在或者小于等于0，则返回错误响应 + if (!req.query.pagesize || req.query.pagesize <= 0) return res.sendResult(null, 400, "pagesize 参数错误"); + // 参数验证通过后，调用next()将控制权传递给下一个中间件或路由处理函数 + next(); + }, + // 第二个中间件函数，用于处理获取订单列表的业务逻辑 + function (req, res, next) { + var conditions = { + // 将请求中的pagenum参数添加到查询条件对象中，该参数常用于分页查询操作，指定要获取的页码 + "pagenum": req.query.pagenum, + // 将请求中的pagesize参数添加到查询条件对象中，用于指定每页显示的订单数量 + "pagesize": req.query.pagesize + }; - if(req.query.user_id) { - conditions["user_id"] = req.query.user_id; - } - if(req.query.pay_status) { - conditions["pay_status"] = req.query.pay_status; - } - if(req.query.is_send) { - conditions["is_send"] = req.query.is_send; - } - if(req.query.order_fapiao_title) { - conditions["order_fapiao_title"] = req.query.order_fapiao_title; - } - if(req.query.order_fapiao_company) { - conditions["order_fapiao_company"] = req.query.order_fapiao_company; - } - if(req.query.order_fapiao_content) { - conditions["order_fapiao_content"] = req.query.order_fapiao_content; - } - if(req.query.consignee_addr) { - conditions["consignee_addr"] = req.query.consignee_addr; - } + // 如果请求中包含user_id参数，则将其添加到查询条件对象中，可用于根据用户ID筛选订单 + if (req.query.user_id) { + conditions["user_id"] = req.query.user_id; + } + // 如果请求中包含pay_status参数，则将其添加到查询条件对象中，可能用于根据支付状态筛选订单 + if (req.query.pay_status) { + conditions["pay_status"] = req.query.pay_status; + } + // 如果请求中包含is_send参数，则将其添加到查询条件对象中，也许用于根据订单是否已发送来筛选订单 + if (req.query.is_send) { + conditions["is_send"] = req.query.is_send; + } + // 如果请求中包含order_fapiao_title参数，则将其添加到查询条件对象中，可能是用于根据发票抬头筛选订单之类的业务需求 + if (req.query.order_fapiao_title) { + conditions["order_fapiao_title"] = req.query.order_fapiao_title; + } + // 如果请求中包含order_fapiao_company参数，则将其添加到查询条件对象中，也许是根据发票所属公司来筛选订单 + if (req.query.order_fapiao_company) { + conditions["order_fapiao_company"] = req.query.order_fapiao_company; + } + // 如果请求中包含order_fapiao_content参数，则将其添加到查询条件对象中，可能用于根据发票内容筛选订单 + if (req.query.order_fapiao_content) { + conditions["order_fapiao_content"] = req.query.order_fapiao_content; + } + // 如果请求中包含consignee_addr参数，则将其添加到查询条件对象中，可用于根据收件人地址筛选订单 + if (req.query.consignee_addr) { + conditions["consignee_addr"] = req.query.consignee_addr; + } - orderServ.getAllOrders( - conditions, - function(err,result){ - if(err) return res.sendResult(null,400,err); - res.sendResult(result,200,"获取成功"); - } - )(req,res,next); - } + // 调用orderServ服务对象的getAllOrders方法，传入构建好的查询条件对象，用于获取符合条件的订单列表 + // 处理获取订单列表的异步操作，若出现错误（err不为null），则返回包含错误信息的响应，状态码为400 + // 若获取成功，则返回包含订单列表数据（result）的响应，状态码为200，并附带提示信息"获取成功" + orderServ.getAllOrders( + conditions, + function (err, result) { + if (err) return res.sendResult(null, 400, err); + res.sendResult(result, 200, "获取成功"); + } + )(req, res, next); + } ); -// 添加订单 +// 定义处理添加订单的POST请求的路由，路径为 "/" router.post("/", - // 参数验证 - function(req,res,next) { - next(); - }, - // 业务逻辑 - function(req,res,next) { - var params = req.body; - orderServ.createOrder(params,function(err,newOrder){ - if(err) return res.sendResult(null,400,err); - return res.sendResult(newOrder,201,"创建订单成功"); - })(req,res,next); - - } + // 参数验证中间件，当前这里直接调用next()，意味着暂时没有进行额外的参数验证逻辑，可能后续需要补充相关验证代码 + function (req, res, next) { + next(); + }, + // 业务逻辑中间件，用于处理添加订单的具体操作 + function (req, res, next) { + // 获取请求体中的参数，这些参数（params）应该包含了创建订单所需的各种信息，例如商品信息、用户信息、收货地址等 + var params = req.body; + // 调用orderServ服务对象的createOrder方法，传入订单参数，用于创建新的订单 + // 处理创建订单的异步操作，若出现错误（err不为null），则返回包含错误信息的响应，状态码为400 + // 若创建成功，则返回包含新创建订单信息（newOrder）的响应，状态码为201，并附带提示信息"创建订单成功" + orderServ.createOrder(params, function (err, newOrder) { + if (err) return res.sendResult(null, 400, err); + return res.sendResult(newOrder, 201, "创建订单成功"); + })(req, res, next); + + } ); -// 更新订单发送状态 +// 定义处理更新订单的PUT请求的路由，路径中包含订单ID参数，格式为 "/:id"，这里用于更新订单的发送状态（从代码上下文推测） router.put("/:id", - // 参数验证 - function(req,res,next) { - next(); - }, - // 业务逻辑 - function(req,res,next) { - var params = req.body; - orderServ.updateOrder(req.params.id,params,function(err,newOrder){ - if(err) return res.sendResult(null,400,err); - return res.sendResult(newOrder,201,"更新订单成功"); - })(req,res,next); - } + // 参数验证中间件，当前这里直接调用next()，暂时没有进行参数验证相关逻辑，也许后续需要添加如验证订单ID合法性等代码 + function (req, res, next) { + next(); + }, + // 业务逻辑中间件，用于处理更新订单的具体操作 + function (req, res, next) { + var params = req.body; + // 调用orderServ服务对象的updateOrder方法，传入订单ID（req.params.id）和更新的参数（params），用于更新指定订单的相关信息 + // 处理更新订单的异步操作，若出现错误（err不为null），则返回包含错误信息的响应，状态码为400 + // 若更新成功，则返回包含更新后订单信息（newOrder）的响应，状态码为201，并附带提示信息"更新订单成功" + orderServ.updateOrder(req.params.id, params, function (err, newOrder) { + if (err) return res.sendResult(null, 400, err); + return res.sendResult(newOrder, 201, "更新订单成功"); + })(req, res, next); + } ); -router.get("/:id",function(req,res,next){ - orderServ.getOrder(req.params.id,function(err,result){ - if(err) return res.sendResult(null,400,err); - return res.sendResult(result,200,"获取成功"); - })(req,res,next); +// 定义处理获取指定订单详情的GET请求的路由，路径中包含订单ID参数，格式为 "/:id" +router.get("/:id", function (req, res, next) { + // 调用orderServ服务对象的getOrder方法，传入订单ID（req.params.id），用于获取指定订单的详细信息 + // 处理获取订单详情的异步操作，若出现错误（err不为null），则返回包含错误信息的响应，状态码为400 + // 若获取成功，则返回包含订单详细信息（result）的响应，状态码为200，并附带提示信息"获取成功" + orderServ.getOrder(req.params.id, function (err, result) { + if (err) return res.sendResult(null, 400, err); + return res.sendResult(result, 200, "获取成功"); + })(req, res, next); }); - - -module.exports = router; +// 将配置好的路由器对象导出，以便在主应用中引入并挂载到对应的路径上，使这些路由能够响应客户端相应的HTTP请求 +module.exports = router; \ No newline at end of file diff --git a/routes/api/private/v1/reports.js b/routes/api/private/v1/reports.js index 1990982..1cf1d64 100644 --- a/routes/api/private/v1/reports.js +++ b/routes/api/private/v1/reports.js @@ -1,30 +1,41 @@ +// 引入Express框架的核心模块，Express是一个基于Node.js的Web应用框架，用于创建服务器端应用和处理HTTP请求等相关操作 var express = require('express'); +// 创建一个Express路由器实例，通过这个实例可以定义一组相关的路由，方便在整个Web应用中进行模块化的路由管理 var router = express.Router(); +// 引入Node.js的path模块，主要用于处理文件路径相关的操作，例如拼接、解析文件路径等，在这里用于准确找到其他模块的位置 var path = require("path"); +// 获取自定义的验证模块，通过path.join方法将当前工作目录（process.cwd()）与相对路径（"/modules/authorization"）拼接起来，以此来准确引入验证模块 +// 这个验证模块通常会承担诸如验证用户权限、合法性等功能，确保后续的操作符合相关安全和业务规则 +var authorization = require(path.join(process.cwd(), "/modules/authorization")); -// 获取验证模块 -var authorization = require(path.join(process.cwd(),"/modules/authorization")); - -// 通过验证模块获取用户管理服务 +// 通过验证模块获取名为"ReportsService"的用户管理服务对象，该服务对象应该封装了与报表相关的各种业务操作方法，比如获取不同类型报表等功能 var reportsServ = authorization.getService("ReportsService"); +// 定义处理获取特定类型报表的GET请求的路由，路径格式为 "/type/:typeid"，其中":typeid"是一个路由参数，表示报表的类型ID router.get("/type/:typeid", - // 参数验证 - function(req,res,next){ - if(!req.params.typeid) { - return res.sendResult(null,400,"报表类型不能为空"); - } - if(isNaN(parseInt(req.params.typeid))) return res.sendResult(null,400,"报表类型必须是数字"); - next(); - }, - // 业务逻辑 - function(req,res,next) { - reportsServ.reports(req.params.typeid,function(err,result){ - if(err) return res.sendResult(null,400,err); - res.sendResult(result,200,"获取报表成功"); - })(req,res,next); - } + // 第一个中间件函数，用于对路由参数进行验证，确保传入的报表类型ID参数是合法有效的 + function (req, res, next) { + // 检查请求参数中的typeid是否存在，如果不存在则返回错误响应，状态码400表示请求参数有误，并附带相应的错误提示信息 + if (!req.params.typeid) { + return res.sendResult(null, 400, "报表类型不能为空"); + } + // 进一步验证typeid参数是否可以转换为数字类型，如果不能转换成功（即不是有效的数字），则返回错误响应，同样状态码为400，并给出相应错误提示 + if (isNaN(parseInt(req.params.typeid))) return res.sendResult(null, 400, "报表类型必须是数字"); + // 如果参数验证通过，调用next()将控制权传递给下一个中间件或者路由处理函数，继续后续的业务逻辑处理 + next(); + }, + // 第二个中间件函数，用于处理获取报表的业务逻辑 + function (req, res, next) { + // 调用reportsServ服务对象的reports方法，传入经过验证的报表类型ID（req.params.typeid），用于获取相应类型的报表数据 + // 处理获取报表数据的异步操作，若出现错误（err不为null），则返回包含错误信息的响应，状态码为400 + // 若获取报表数据成功，则返回包含报表数据（result）的响应，状态码为200，并附带提示信息"获取报表成功" + reportsServ.reports(req.params.typeid, function (err, result) { + if (err) return res.sendResult(null, 400, err); + res.sendResult(result, 200, "获取报表成功"); + })(req, res, next); + } ); +// 将配置好的路由器对象导出，以便在主应用中引入并挂载到对应的路径上，使得这个路由能够正确响应客户端发送的相应HTTP请求，实现获取报表的功能 module.exports = router; \ No newline at end of file diff --git a/routes/api/private/v1/rights.js b/routes/api/private/v1/rights.js index 1a41661..d52a22c 100644 --- a/routes/api/private/v1/rights.js +++ b/routes/api/private/v1/rights.js @@ -1,30 +1,45 @@ +// 引入Express框架的核心模块，Express是用于构建Node.js网络应用程序的常用框架，通过它可以方便地处理HTTP请求、定义路由等操作 var express = require('express'); +// 创建一个Express路由器实例，利用这个实例能够以模块化的方式定义一组相关的路由，便于在整个Web应用中进行有条理的路由管理 var router = express.Router(); +// 引入Node.js的path模块，该模块主要用于处理文件路径相关的操作，像拼接、解析路径等，此处用于准确地定位其他模块所在的文件位置 var path = require("path"); -// 获取验证模块 -var authorization = require(path.join(process.cwd(),"/modules/authorization")); +// 获取自定义的验证模块，通过path.join函数把当前工作目录（process.cwd()）与相对路径（"/modules/authorization"）进行拼接，以此精确地引入验证模块。 +// 这个验证模块通常负责对用户的身份、权限等方面进行验证，保障后续操作的合法性与安全性，比如判断用户是否有权限访问某些特定资源等 +var authorization = require(path.join(process.cwd(), "/modules/authorization")); -// 通过验证模块构建权限服务模块 +// 通过上述验证模块获取名为"RightService"的权限服务模块，这个服务模块应该封装了一系列与权限相关的业务操作方法，例如获取不同类型的权限列表等功能 var rightService = authorization.getService("RightService"); + +// 定义一个处理GET请求的路由，路径格式为 "/:type"，其中":type"是一个路由参数，用于指定权限列表的显示类型 router.get("/:type", - // 参数验证 - function(req,res,next) { - if(!req.params.type) { - return res.sendResult(null,400,"显示类型未定义"); - } - if(req.params.type != "list" && req.params.type != "tree") { - return res.sendResult(null,400,"显示类型参数错误"); - } - next(); - }, - // 业务逻辑 - function(req,res,next) { - rightService.getAllRights(req.params.type,function(err,rights){ - if(err) return res.sendResult(null,400,err); - res.sendResult(rights,200,"获取权限列表成功"); - })(req,res,next); - } + // 第一个中间件函数，主要用于对路由参数进行验证，确保传入的参数符合业务要求，保证后续业务逻辑能正确执行 + function (req, res, next) { + // 首先检查请求参数中的type是否存在，如果不存在（即为空），则返回错误响应给客户端。 + // 这里使用res.sendResult函数返回响应，状态码设置为400，表示请求出现了参数错误，同时附带具体的错误提示信息"显示类型未定义" + if (!req.params.type) { + return res.sendResult(null, 400, "显示类型未定义"); + } + // 接着进一步验证type参数的值是否符合预定义的合法值，即判断是否等于"list"或者"tree"，如果不符合，则同样返回错误响应。 + // 状态码依旧为400，附带错误提示信息"显示类型参数错误"，告知客户端传入的显示类型参数不符合要求 + if (req.params.type!= "list" && req.params.type!= "tree") { + return res.sendResult(null, 400, "显示类型参数错误"); + } + // 如果参数验证通过，就调用next()函数，将控制权传递给下一个中间件或者路由处理函数，以便继续执行后续的业务逻辑 + next(); + }, + // 第二个中间件函数，用于处理获取权限列表的实际业务逻辑，依赖于前面验证通过的参数进行相应操作 + function (req, res, next) { + // 调用rightService权限服务模块的getAllRights方法，传入经过验证的显示类型参数（req.params.type），用于获取相应类型的权限列表数据。 + // 这个方法执行的是异步操作，在操作过程中如果出现错误（err不为null），就通过res.sendResult返回包含错误信息的响应，状态码设置为400，表示请求处理出现错误。 + // 如果获取权限列表操作成功，就使用res.sendResult返回包含权限列表数据（rights）的响应，状态码为200，表示请求成功，同时附带提示信息"获取权限列表成功"，告知客户端操作顺利完成 + rightService.getAllRights(req.params.type, function (err, rights) { + if (err) return res.sendResult(null, 400, err); + res.sendResult(rights, 200, "获取权限列表成功"); + })(req, res, next); + } ); +// 将配置好的路由器对象导出，这样在主应用程序中就可以引入这个路由器模块，并将其挂载到对应的路径上，使得这个定义好的路由能够正确响应客户端发送的相应HTTP请求，实现获取权限列表的功能 module.exports = router; \ No newline at end of file diff --git a/routes/api/private/v1/roles.js b/routes/api/private/v1/roles.js index 2a700e6..fca5090 100644 --- a/routes/api/private/v1/roles.js +++ b/routes/api/private/v1/roles.js @@ -1,142 +1,190 @@ +// 引入Express框架的核心模块，用于创建Web应用、定义路由以及处理HTTP请求等相关操作 var express = require('express'); +// 创建一个Express路由器实例，方便以模块化的方式来定义一组相关的路由，便于在整个应用中进行有条理的路由管理 var router = express.Router(); +// 引入Node.js的path模块，主要用于处理文件路径相关的操作，比如拼接模块的路径，以便准确地引入其他模块 var path = require("path"); -// 获取验证模块 -var authorization = require(path.join(process.cwd(),"/modules/authorization")); +// 获取自定义的验证模块，通过path.join方法将当前工作目录（process.cwd()）与相对路径（"/modules/authorization"）拼接起来，准确地引入该验证模块 +// 这个验证模块通常用于验证用户的权限等情况，确保后续操作符合相应的安全和业务规则 +var authorization = require(path.join(process.cwd(), "/modules/authorization")); -// 角色管理模块 +// 通过验证模块获取名为"RoleService"的角色管理模块，该模块应该封装了与角色相关的各种业务操作方法，例如角色的增删改查以及权限管理等功能 var roleServ = authorization.getService("RoleService"); -// 获取角色列表 +// 定义处理获取角色列表的GET请求的路由，路径为根路径 "/" router.get("/", - // 参数验证 - function(req,res,next){ - next(); - }, - // 处理业务逻辑 - function(req,res,next) { - roleServ.getAllRoles(function(err,result) { - if(err) return res.sendResult(null,400,err); - res.sendResult(result,200,"获取成功"); - })(req,res,next); - } + // 参数验证中间件，当前这里直接调用next()，意味着暂时没有进行额外的参数验证逻辑，不过一般情况下可根据实际需求添加相关验证，比如分页参数等验证 + function (req, res, next) { + next(); + }, + // 处理业务逻辑的中间件，用于获取所有角色的信息 + function (req, res, next) { + // 调用roleServ角色管理模块的getAllRoles方法，该方法用于获取所有角色的相关数据，是一个异步操作 + // 如果在获取角色列表的过程中出现错误（err不为null），则通过res.sendResult返回包含错误信息的响应，状态码为400，表示请求出现错误 + // 如果获取成功，则返回包含角色列表数据（result）的响应，状态码为200，并附带提示信息"获取成功" + roleServ.getAllRoles(function (err, result) { + if (err) return res.sendResult(null, 400, err); + res.sendResult(result, 200, "获取成功"); + })(req, res, next); + } ); -// 创建角色 +// 定义处理创建角色的POST请求的路由，路径为 "/" router.post("/", - // 参数验证 - function(req,res,next) { - if(!req.body.roleName) return res.sendResult(null,400,"角色名称不能为空"); - next(); - }, - // 处理业务逻辑 - function(req,res,next) { - roleServ.createRole({ - "roleName":req.body.roleName, - "roleDesc":req.body.roleDesc - },function(err,role){ - if(err) return res.sendResult(null,400,err); - res.sendResult(role,201,"创建成功"); - })(req,res,next); - } + // 参数验证中间件，用于验证创建角色时请求体中必要参数是否存在 + function (req, res, next) { + // 检查请求体中是否包含roleName字段，如果不存在则返回错误响应，状态码400表示请求参数有误，同时附带提示信息"角色名称不能为空" + if (!req.body.roleName) return res.sendResult(null, 400, "角色名称不能为空"); + // 参数验证通过后，将控制权传递给下一个中间件，继续后续的业务逻辑处理 + next(); + }, + // 处理业务逻辑的中间件，用于创建新的角色 + function (req, res, next) { + // 构建一个包含角色名称（roleName）和角色描述（roleDesc）的对象，从请求体中获取相应的值 + roleServ.createRole({ + "roleName": req.body.roleName, + "roleDesc": req.body.roleDesc + }, function (err, role) { + // 如果创建角色的操作出现错误（err不为null），则通过res.sendResult返回包含错误信息的响应，状态码为400，表示请求出现错误 + if (err) return res.sendResult(null, 400, err); + // 如果创建成功，则返回包含新创建角色信息（role）的响应，状态码为201，表示资源创建成功，并附带提示信息"创建成功" + res.sendResult(role, 201, "创建成功"); + })(req, res, next); + } ); -// 获取角色详情 +// 定义处理获取角色详情的GET请求的路由，路径中包含角色ID参数，格式为 "/:id" router.get("/:id", - // 参数验证 - function(req,res,next) { - if(!req.params.id) return res.sendResult(null,400,"角色ID不能为空"); - if(isNaN(parseInt(req.params.id))) res.sendResult(null,400,"角色ID必须为数字"); - next(); - }, - // 处理业务逻辑 - function(req,res,next) { - roleServ.getRoleById( - req.params.id, - function(err,result){ - if(err) return res.sendResult(null,400,err); - res.sendResult(result,200,"获取成功"); - })(req,res,next); - } + // 参数验证中间件，用于验证角色ID参数的合法性 + function (req, res, next) { + // 检查请求参数中的角色ID（req.params.id）是否存在，如果不存在则返回错误响应，状态码400表示请求参数有误，同时附带提示信息"角色ID不能为空" + if (!req.params.id) return res.sendResult(null, 400, "角色ID不能为空"); + // 进一步验证角色ID是否可以转换为数字类型，如果不能转换成功（即不是有效的数字），则返回错误响应，状态码同样为400，并附带提示信息"角色ID必须为数字" + if (isNaN(parseInt(req.params.id))) res.sendResult(null, 400, "角色ID必须为数字"); + // 参数验证通过后，将控制权传递给下一个中间件，继续后续的业务逻辑处理 + next(); + }, + // 处理业务逻辑的中间件，用于获取指定角色的详细信息 + function (req, res, next) { + // 调用roleServ角色管理模块的getRoleById方法，传入经过验证的角色ID（req.params.id），用于获取该角色的详细信息，这是一个异步操作 + // 如果在获取角色详情的过程中出现错误（err不为null），则通过res.sendResult返回包含错误信息的响应，状态码为400，表示请求出现错误 + // 如果获取成功，则返回包含角色详细信息（result）的响应，状态码为200，并附带提示信息"获取成功" + roleServ.getRoleById( + req.params.id, + function (err, result) { + if (err) return res.sendResult(null, 400, err); + res.sendResult(result, 200, "获取成功"); + } + )(req, res, next); + } ); -// 更新角色信息 +// 定义处理更新角色信息的PUT请求的路由，路径中包含角色ID参数，格式为 "/:id" router.put("/:id", - // 参数验证 - function(req,res,next) { - if(!req.params.id) return res.sendResult(null,400,"角色ID不能为空"); - if(isNaN(parseInt(req.params.id))) return res.sendResult(null,400,"角色ID必须为数字"); - if(!req.body.roleName) return res.sendResult(null,400,"角色名称不能为空"); - next(); - }, - // 处理业务逻辑 - function(req,res,next) { - roleServ.updateRole( - { - "id":req.params.id, - "roleName":req.body.roleName, - "roleDesc":req.body.roleDesc - }, - function(err,result){ - if(err) return res.sendResult(null,400,err); - res.sendResult(result,200,"获取成功"); - })(req,res,next); - } + // 参数验证中间件，用于验证更新角色信息时必要参数的合法性 + function (req, res, next) { + // 检查请求参数中的角色ID（req.params.id）是否存在，如果不存在则返回错误响应，状态码400表示请求参数有误，同时附带提示信息"角色ID不能为空" + if (!req.params.id) return res.sendResult(null, 400, "角色ID不能为空"); + // 验证角色ID是否可以转换为数字类型，如果不能转换成功（即不是有效的数字），则返回错误响应，状态码为400，并附带提示信息"角色ID必须为数字" + if (isNaN(parseInt(req.params.id))) return res.sendResult(null, 400, "角色ID必须为数字"); + // 检查请求体中是否包含roleName字段，如果不存在则返回错误响应，状态码400表示请求参数有误，同时附带提示信息"角色名称不能为空" + if (!req.body.roleName) return res.sendResult(null, 400, "角色名称不能为空"); + // 参数验证通过后，将控制权传递给下一个中间件，继续后续的业务逻辑处理 + next(); + }, + // 处理业务逻辑的中间件，用于更新指定角色的信息 + function (req, res, next) { + // 构建一个包含角色ID（id）、角色名称（roleName）和角色描述（roleDesc）的对象，用于传递给更新角色信息的方法 + roleServ.updateRole( + { + "id": req.params.id, + "roleName": req.body.roleName, + "roleDesc": req.body.roleDesc + }, + function (err, result) { + // 如果更新角色信息的操作出现错误（err不为null），则通过res.sendResult返回包含错误信息的响应，状态码为400，表示请求出现错误 + if (err) return res.sendResult(null, 400, err); + // 如果更新成功，则返回包含更新后角色信息（result）的响应，状态码为200，并附带提示信息"获取成功"（此处提示信息可能更改为"更新成功"更合适，可根据实际情况调整） + res.sendResult(result, 200, "获取成功"); + } + )(req, res, next); + } ); -// 删除角色 +// 定义处理删除角色的DELETE请求的路由，路径中包含角色ID参数，格式为 "/:id" router.delete("/:id", - // 参数验证 - function(req,res,next) { - if(!req.params.id) return res.sendResult(null,400,"角色ID不能为空"); - if(isNaN(parseInt(req.params.id))) return res.sendResult(null,400,"角色ID必须为数字"); - next(); - }, - // 处理业务逻辑 - function(req,res,next) { - roleServ.deleteRole( - req.params.id, - function(err,success){ - if(err) return res.sendResult(null,400,err); - res.sendResult(null,200,"删除成功"); - })(req,res,next); - } + // 参数验证中间件，用于验证角色ID参数的合法性 + function (req, res, next) { + // 检查请求参数中的角色ID（req.params.id）是否存在，如果不存在则返回错误响应，状态码400表示请求参数有误，同时附带提示信息"角色ID不能为空" + if (!req.params.id) return res.sendResult(null, 400, "角色ID不能为空"); + // 验证角色ID是否可以转换为数字类型，如果不能转换成功（即不是有效的数字），则返回错误响应，状态码为400，并附带提示信息"角色ID必须为数字" + if (isNaN(parseInt(req.params.id))) return res.sendResult(null, 400, "角色ID必须为数字"); + // 参数验证通过后，将控制权传递给下一个中间件，继续后续的业务逻辑处理 + next(); + }, + // 处理业务逻辑的中间件，用于执行删除指定角色的操作 + function (req, res, next) { + // 调用roleServ角色管理模块的deleteRole方法，传入经过验证的角色ID（req.params.id），用于删除该角色，这是一个异步操作 + // 如果在删除角色的过程中出现错误（err不为null），则通过res.sendResult返回包含错误信息的响应，状态码为400，表示请求出现错误 + // 如果删除成功，则返回一个空数据的响应（因为角色已被删除），状态码为200，并附带提示信息"删除成功" + roleServ.deleteRole( + req.params.id, + function (err, success) { + if (err) return res.sendResult(null, 400, err); + res.sendResult(null, 200, "删除成功"); + } + )(req, res, next); + } ); -// 为角色授权 +// 定义处理为角色授权的POST请求的路由，路径中包含角色ID参数，格式为 "/:id/rights" router.post("/:id/rights", - // 参数校验 - function(req,res,next) { - if(!req.params.id) return res.sendResult(null,400,"角色ID不能为空"); - if(isNaN(parseInt(req.params.id))) res.sendResult(null,400,"角色ID必须为数字"); - next(); - }, - // 业务逻辑 - function(req,res,next) { - roleServ.updateRoleRight(req.params.id,req.body.rids,function(err,newRole){ - if(err) return res.sendResult(null,400,err); - res.sendResult(null,200,"更新成功"); - })(req,res,next); - } + // 参数校验中间件，用于验证角色ID参数的合法性 + function (req, res, next) { + // 检查请求参数中的角色ID（req.params.id）是否存在，如果不存在则返回错误响应，状态码400表示请求参数有误，同时附带提示信息"角色ID不能为空" + if (!req.params.id) return res.sendResult(null, 400, "角色ID不能为空"); + // 验证角色ID是否可以转换为数字类型，如果不能转换成功（即不是有效的数字），则返回错误响应，状态码为400，并附带提示信息"角色ID必须为数字" + if (isNaN(parseInt(req.params.id))) res.sendResult(null, 400, "角色ID必须为数字"); + // 参数验证通过后，将控制权传递给下一个中间件，继续后续的业务逻辑处理 + next(); + }, + // 业务逻辑中间件，用于为指定角色更新权限 + function (req, res, next) { + // 调用roleServ角色管理模块的updateRoleRight方法，传入角色ID（req.params.id）和权限ID列表（req.body.rids），用于更新角色的权限信息，这是一个异步操作 + // 如果在更新角色权限的过程中出现错误（err不为null），则通过res.sendResult返回包含错误信息的响应，状态码为400，表示请求出现错误 + // 如果更新成功，则返回一个空数据的响应（重点在于权限更新成功的提示），状态码为200，并附带提示信息"更新成功" + roleServ.updateRoleRight(req.params.id, req.body.rids, function (err, newRole) { + if (err) return res.sendResult(null, 400, err); + res.sendResult(null, 200, "更新成功"); + })(req, res, next); + } ); -// 删除角色权限 +// 定义处理删除角色权限的DELETE请求的路由，路径中包含角色ID和权限ID两个参数，格式为 "/:id/rights/:rightId" router.delete("/:id/rights/:rightId", - // 参数验证 - function(req,res,next) { - if(!req.params.id) return res.sendResult(null,400,"角色ID不能为空"); - if(isNaN(parseInt(req.params.id))) res.sendResult(null,400,"角色ID必须为数字"); - if(isNaN(parseInt(req.params.rightId))) res.sendResult(null,400,"权限ID必须为数字"); - next(); - }, - // 业务逻辑 - function(req,res,next) { - roleServ.deleteRoleRight(req.params.id,req.params.rightId,function(err,result){ - if(err) return res.sendResult(null,400,err); - res.sendResult(result,200,"取消权限成功"); - })(req,res,next); - } + // 参数验证中间件，用于验证角色ID和权限ID参数的合法性 + function (req, res, next) { + // 检查请求参数中的角色ID（req.params.id）是否存在，如果不存在则返回错误响应，状态码400表示请求参数有误，同时附带提示信息"角色ID不能为空" + if (!req.params.id) return res.sendResult(null, 400, "角色ID不能为空"); + // 验证角色ID是否可以转换为数字类型，如果不能转换成功（即不是有效的数字），则返回错误响应，状态码为400，并附带提示信息"角色ID必须为数字" + if (isNaN(parseInt(req.params.id))) res.sendResult(null, 400, "角色ID必须为数字"); + // 检查请求参数中的权限ID（req.params.rightId）是否存在，如果不存在则返回错误响应，状态码400表示请求参数有误，同时附带提示信息"权限ID必须为数字" + if (isNaN(parseInt(req.params.rightId))) res.sendResult(null, 400, "权限ID必须为数字"); + // 参数验证通过后，将控制权传递给下一个中间件，继续后续的业务逻辑处理 + next(); + }, + // 业务逻辑中间件，用于执行删除指定角色的指定权限的操作 + function (req, res, next) { + // 调用roleServ角色管理模块的deleteRoleRight方法，传入角色ID（req.params.id）和权限ID（req.params.rightId），用于删除该角色的指定权限，这是一个异步操作 + // 如果在删除角色权限的过程中出现错误（err不为null），则通过res.sendResult返回包含错误信息的响应，状态码为400，表示请求出现错误 + // 如果删除成功，则返回一个空数据的响应（重点在于提示取消权限成功），状态码为200，并附带提示信息"取消权限成功" + roleServ.deleteRoleRight(req.params.id, req.params.rightId, function (err, result) { + if (err) return res.sendResult(null, 400, err); + res.sendResult(result, 200, "取消权限成功"); + })(req, res, next); + } ); +// 将配置好的路由器对象导出，以便在主应用中引入并挂载到对应的路径上，使这些路由能够正确响应客户端发送的相应HTTP请求，实现角色管理相关的各种功能 module.exports = router; \ No newline at end of file diff --git a/routes/api/private/v1/upload.js b/routes/api/private/v1/upload.js index e742c85..d9d675c 100644 --- a/routes/api/private/v1/upload.js +++ b/routes/api/private/v1/upload.js @@ -1,27 +1,45 @@ +// 引入Express框架的核心模块，用于创建Web应用、定义路由以及处理HTTP请求等相关操作 var express = require('express'); +// 创建一个Express路由器实例，方便以模块化的方式来定义一组相关的路由，便于在整个应用中进行有条理的路由管理 var router = express.Router(); +// 引入Node.js的path模块，主要用于处理文件路径相关的操作，例如拼接、解析文件路径等 var path = require("path"); +// 引入Node.js的文件系统模块（fs），用于对文件进行读写、重命名等操作 var fs = require('fs'); +// 引入Node.js的操作系统模块（os），通常可以获取操作系统相关的信息等，不过在这段代码里暂未体现其具体使用 var os = require('os'); +// 引入multer模块，它是一个用于处理文件上传的中间件，能够方便地解析上传的文件数据 var multer = require('multer'); -// 临时上传目录 +// 创建一个multer实例，配置文件上传的临时存储目录为'tmp_uploads/'，意味着上传的文件会先临时存放在这个目录下 var upload = multer({ dest: 'tmp_uploads/' }); +// 引入自定义的配置文件（config），并获取其中名为"upload_config"的配置项，这里的配置项可能包含了与文件上传相关的一些配置信息，比如文件访问的基础URL等 var upload_config = require('config').get("upload_config"); -// 提供文件上传服务 -router.post("/",upload.single('file'),function(req,res,next) { - var fileExtArray = req.file.originalname.split("."); - var ext = fileExtArray[fileExtArray.length - 1]; - var targetPath = req.file.path + "." + ext; - fs.rename(path.join(process.cwd(),"/" + req.file.path),path.join(process.cwd(),targetPath),function(err){ - if(err) { - return res.sendResult(null,400,"上传文件失败"); - } - res.sendResult({"tmp_path":targetPath,"url":upload_config.get("baseURL") + "/" + targetPath},200,"上传成功"); - }) +// 定义一个处理POST请求的路由，路径为根路径 "/"，该路由用于处理文件上传的业务逻辑 +// 这里使用了upload.single('file')中间件，意味着它期望接收一个名为'file'的文件上传字段 +router.post("/", upload.single('file'), function (req, res, next) { + // 从上传的文件信息（req.file）中获取原始文件名，通过split方法以'.'为分隔符将文件名拆分成数组 + var fileExtArray = req.file.originalname.split("."); + // 获取文件扩展名，即数组中的最后一个元素，例如对于文件名'test.txt'，获取到的ext就是'txt' + var ext = fileExtArray[fileExtArray.length - 1]; + // 构建目标文件路径，先获取上传文件的临时存储路径（req.file.path），然后拼接上文件扩展名，形成最终带有正确扩展名的完整路径 + var targetPath = req.file.path + "." + ext; + + // 使用fs模块的rename方法对文件进行重命名操作，将临时存储的文件重命名为带有正确扩展名的目标文件路径 + // path.join方法用于拼接当前工作目录（process.cwd()）、文件路径相关部分，确保路径的准确性 + fs.rename(path.join(process.cwd(), "/" + req.file.path), path.join(process.cwd(), targetPath), function (err) { + // 如果重命名文件的操作出现错误（err不为null），则返回包含错误信息的响应给客户端，状态码为400，表示请求出现错误，同时附带提示信息"上传文件失败" + if (err) { + return res.sendResult(null, 400, "上传文件失败"); + } + // 如果文件重命名成功，即文件上传操作顺利完成，则返回包含相关信息的成功响应给客户端 + // 返回的数据包含了文件的临时路径（tmp_path）以及完整的访问URL（通过配置项中的基础URL和目标文件路径拼接而成），状态码为200，表示请求成功，同时附带提示信息"上传成功" + res.sendResult({"tmp_path": targetPath, "url": upload_config.get("baseURL") + "/" + targetPath}, 200, "上传成功"); + }); }); +// 将配置好的路由器对象导出，以便在主应用中可以引入并挂载到对应的路径上，使得这个文件上传的路由能够正确响应客户端发送的相应HTTP请求 module.exports = router; \ No newline at end of file diff --git a/routes/api/private/v1/users.js b/routes/api/private/v1/users.js index fbb49fd..b3e141a 100644 --- a/routes/api/private/v1/users.js +++ b/routes/api/private/v1/users.js @@ -1,161 +1,204 @@ +// 引入Express框架的核心模块，用于创建Web应用、定义路由以及处理HTTP请求等相关操作 var express = require('express'); +// 创建一个Express路由器实例，方便以模块化的方式来定义一组相关的路由，便于在整个应用中进行有条理的路由管理 var router = express.Router(); +// 引入Node.js的path模块，主要用于处理文件路径相关的操作，例如拼接、解析文件路径等，以便准确地引入其他模块 var path = require("path"); -// 获取验证模块 -var authorization = require(path.join(process.cwd(),"/modules/authorization")); +// 获取自定义的验证模块，通过path.join方法将当前工作目录（process.cwd()）与相对路径（"/modules/authorization"）拼接起来，准确地引入该验证模块 +// 这个验证模块通常用于验证用户的权限等情况，确保后续操作符合相应的安全和业务规则 +var authorization = require(path.join(process.cwd(), "/modules/authorization")); -// 通过验证模块获取用户管理服务 +// 通过验证模块获取名为"ManagerService"的用户管理服务对象，该模块应该封装了与用户相关的各种业务操作方法，例如用户的增删改查、角色分配以及状态更新等功能 var mgrServ = authorization.getService("ManagerService"); - -// 查询用户列表 +// 定义处理查询用户列表的GET请求的路由，路径为根路径 "/" router.get("/", - // 验证参数 - function(req,res,next) { - // 参数验证 - if(!req.query.pagenum || req.query.pagenum <= 0) return res.sendResult(null,400,"pagenum 参数错误"); - if(!req.query.pagesize || req.query.pagesize <= 0) return res.sendResult(null,400,"pagesize 参数错误"); - next(); - }, - // 处理业务逻辑 - function(req,res,next) { - mgrServ.getAllManagers( - { - "query":req.query.query, - "pagenum":req.query.pagenum, - "pagesize":req.query.pagesize - }, - function(err,result){ - if(err) return res.sendResult(null,400,err); - res.sendResult(result,200,"获取管理员列表成功"); - } - )(req,res,next); - - } + // 第一个中间件函数，用于对请求中的查询参数进行验证，确保传入的参数符合业务要求，保证后续业务逻辑能正确执行 + function (req, res, next) { + // 验证pagenum参数是否存在且大于0，如果该参数不存在或者小于等于0，则返回错误响应，状态码400表示请求参数有误，并附带相应的错误提示信息"pagenum 参数错误" + if (!req.query.pagenum || req.query.pagenum <= 0) return res.sendResult(null, 400, "pagenum 参数错误"); + // 验证pagesize参数是否存在且大于0，如果该参数不存在或者小于等于0，则返回错误响应，状态码400表示请求参数有误，并附带相应的错误提示信息"pagesize 参数错误" + if (!req.query.pagesize || req.query.pagesize <= 0) return res.sendResult(null, 400, "pagesize 参数错误"); + // 参数验证通过后，调用next()函数将控制权传递给下一个中间件或者路由处理函数，以便继续执行后续的业务逻辑 + next(); + }, + // 第二个中间件函数，用于处理查询用户列表的实际业务逻辑，依赖于前面验证通过的参数进行相应操作 + function (req, res, next) { + // 调用mgrServ用户管理服务对象的getAllManagers方法，传入一个包含查询条件的对象，其中包括模糊查询的内容（query）以及分页相关的参数（pagenum和pagesize），用于获取符合条件的用户列表数据。 + // 这个方法执行的是异步操作，在操作过程中如果出现错误（err不为null），就通过res.sendResult返回包含错误信息的响应，状态码设置为400，表示请求处理出现错误。 + // 如果获取用户列表操作成功，就使用res.sendResult返回包含用户列表数据（result）的响应，状态码为200，表示请求成功，同时附带提示信息"获取管理员列表成功"，告知客户端操作顺利完成 + mgrServ.getAllManagers( + { + "query": req.query.query, + "pagenum": req.query.pagenum, + "pagesize": req.query.pagesize + }, + function (err, result) { + if (err) return res.sendResult(null, 400, err); + res.sendResult(result, 200, "获取管理员列表成功"); + } + )(req, res, next); + + } ); -// 获取用户信息 +// 定义处理获取用户信息的GET请求的路由，路径中包含用户ID参数，格式为 "/:id" router.get("/:id", - // 参数验证 - function(req,res,next) { - if(!req.params.id) { - return res.sendResult(null,400,"用户ID不能为空"); - } - if(isNaN(parseInt(req.params.id))) return res.sendResult(null,400,"用户ID必须是数字"); - next(); - }, - function(req,res,next) { - mgrServ.getManager(req.params.id,function(err,manager){ - if(err) return res.sendResult(null,400,err); - res.sendResult(manager,200,"获取成功"); - })(req,res,next); - } + // 第一个中间件函数，主要用于对路由参数进行验证，确保传入的用户ID参数符合业务要求，保证后续业务逻辑能正确执行 + function (req, res, next) { + // 检查请求参数中的用户ID（req.params.id）是否存在，如果不存在则返回错误响应，状态码400表示请求参数有误，同时附带提示信息"用户ID不能为空" + if (!req.params.id) { + return res.sendResult(null, 400, "用户ID不能为空"); + } + // 进一步验证用户ID是否可以转换为数字类型，如果不能转换成功（即不是有效的数字），则返回错误响应，状态码同样为400，并附带提示信息"用户ID必须是数字" + if (isNaN(parseInt(req.params.id))) return res.sendResult(null, 400, "用户ID必须是数字"); + // 如果参数验证通过，就调用next()函数，将控制权传递给下一个中间件或者路由处理函数，以便继续执行后续的业务逻辑 + next(); + }, + // 第二个中间件函数，用于处理获取指定用户信息的实际业务逻辑，依赖于前面验证通过的用户ID参数进行相应操作 + function (req, res, next) { + // 调用mgrServ用户管理服务对象的getManager方法，传入经过验证的用户ID（req.params.id），用于获取该用户的详细信息。 + // 这个方法执行的是异步操作，在操作过程中如果出现错误（err不为null），就通过res.sendResult返回包含错误信息的响应，状态码设置为400，表示请求处理出现错误。 + // 如果获取用户信息操作成功，就使用res.sendResult返回包含用户详细信息（manager）的响应，状态码为200，表示请求成功，同时附带提示信息"获取成功"，告知客户端操作顺利完成 + mgrServ.getManager(req.params.id, function (err, manager) { + if (err) return res.sendResult(null, 400, err); + res.sendResult(manager, 200, "获取成功"); + })(req, res, next); + } ); -// 创建用户 +// 定义处理创建用户的POST请求的路由，路径为 "/" router.post("/", - // 验证参数 - function(req,res,next) { - if(!req.body.username){ - return res.sendResult(null,400,"用户名不能为空"); - } - if(!req.body.password) { - return res.sendResult(null,400,"密码不能为空"); - } - if(!req.body.rid) { - req.body.rid = -1; - //return res.sendResult(null,200,"角色ID不能为空"); - } - if(isNaN(parseInt(req.body.rid))) req.body.rid = -1;//return res.sendResult(null,200,"角色ID必须是数字"); - next(); - }, - // 处理业务逻辑 - function(req,res,next) { - params = { - "username":req.body.username, - "password":req.body.password, - "mobile":req.body.mobile, - "email":req.body.email, - "rid":req.body.rid - } - mgrServ.createManager(params,function(err,manager){ - if(err) return res.sendResult(null,400,err); - res.sendResult(manager,201,"创建成功"); - })(req,res,next); - } + // 第一个中间件函数，用于对创建用户时请求体中的必要参数进行验证，确保传入的参数符合业务要求，保证后续业务逻辑能正确执行 + function (req, res, next) { + // 检查请求体中是否包含username字段，如果不存在则返回错误响应，状态码400表示请求参数有误，同时附带提示信息"用户名不能为空" + if (!req.body.username) { + return res.sendResult(null, 400, "用户名不能为空"); + } + // 检查请求体中是否包含password字段，如果不存在则返回错误响应，状态码400表示请求参数有误，同时附带提示信息"密码不能为空" + if (!req.body.password) { + return res.sendResult(null, 400, "密码不能为空"); + } + // 检查请求体中是否包含rid字段，如果不存在则将其默认设置为 -1，此处原代码有部分注释掉的返回错误逻辑，可能根据实际情况调整过，目前是默认赋值 + if (!req.body.rid) { + req.body.rid = -1; + // return res.sendResult(null, 200, "角色ID不能为空"); + } + // 进一步验证rid字段是否可以转换为数字类型，如果不能转换成功（即不是有效的数字），则将其默认设置为 -1，此处原代码也有部分注释掉的返回错误逻辑，目前是默认赋值处理 + if (isNaN(parseInt(req.body.rid))) req.body.rid = -1; // return res.sendResult(null, 200, "角色ID必须是数字"); + // 参数验证通过后，调用next()函数将控制权传递给下一个中间件或者路由处理函数，以便继续执行后续的业务逻辑 + next(); + }, + // 第二个中间件函数，用于处理创建用户的实际业务逻辑，依赖于前面验证通过的请求体参数进行相应操作 + function (req, res, next) { + // 构建一个包含创建用户所需信息的对象，从请求体中获取相应的值，如用户名（username）、密码（password）、手机号（mobile）、邮箱（email）以及角色ID（rid）等信息 + params = { + "username": req.body.username, + "password": req.body.password, + "mobile": req.body.mobile, + "email": req.body.email, + "rid": req.body.rid + } + // 调用mgrServ用户管理服务对象的createManager方法，传入构建好的用户信息对象，用于创建新的用户。 + // 这个方法执行的是异步操作，在操作过程中如果出现错误（err不为null），就通过res.sendResult返回包含错误信息的响应，状态码设置为400，表示请求处理出现错误。 + // 如果创建用户操作成功，就使用res.sendResult返回包含新创建用户信息（manager）的响应，状态码为201，表示资源创建成功，同时附带提示信息"创建成功"，告知客户端操作顺利完成 + mgrServ.createManager(params, function (err, manager) { + if (err) return res.sendResult(null, 400, err); + res.sendResult(manager, 201, "创建成功"); + })(req, res, next); + } ); - -// 修改用户信息 +// 定义处理修改用户信息的PUT请求的路由，路径中包含用户ID参数，格式为 "/:id" router.put("/:id", - // 参数验证 - function(req,res,next) { - if(!req.params.id) { - return res.sendResult(null,400,"用户ID不能为空"); - } - if(isNaN(parseInt(req.params.id))) return res.sendResult(null,400,"用户ID必须是数字"); - next(); - }, - // 处理业务逻辑 - function(req,res,next) { - mgrServ.updateManager( - { - "id":req.params.id, - "mobile":req.body.mobile, - "email":req.body.email - }, - function(err,manager) { - if(err) return res.sendResult(null,400,err); - res.sendResult(manager,200,"更新成功"); - } - )(req,res,next); - } + // 第一个中间件函数，用于对修改用户信息时请求中的必要参数进行验证，确保传入的用户ID参数符合业务要求，保证后续业务逻辑能正确执行 + function (req, res, next) { + // 检查请求参数中的用户ID（req.params.id）是否存在，如果不存在则返回错误响应，状态码400表示请求参数有误，同时附带提示信息"用户ID不能为空" + if (!req.params.id) { + return res.sendResult(null, 400, "用户ID不能为空"); + } + // 进一步验证用户ID是否可以转换为数字类型，如果不能转换成功（即不是有效的数字），则返回错误响应，状态码同样为400，并附带提示信息"用户ID必须是数字" + if (isNaN(parseInt(req.params.id))) return res.sendResult(null, 400, "用户ID必须是数字"); + // 参数验证通过后，调用next()函数将控制权传递给下一个中间件或者路由处理函数，以便继续执行后续的业务逻辑 + next(); + }, + // 第二个中间件函数，用于处理修改用户信息的实际业务逻辑，依赖于前面验证通过的用户ID参数以及请求体中的其他信息进行相应操作 + function (req, res, next) { + // 构建一个包含要修改的用户信息的对象，包括用户ID（id）以及要更新的手机号（mobile）和邮箱（email）等信息，从请求体和请求参数中获取相应的值 + mgrServ.updateManager( + { + "id": req.params.id, + "mobile": req.body.mobile, + "email": req.body.email + }, + function (err, manager) { + // 这个方法执行的是异步操作，在操作过程中如果出现错误（err不为null），就通过res.sendResult返回包含错误信息的响应，状态码设置为400，表示请求处理出现错误。 + // 如果修改用户信息操作成功，就使用res.sendResult返回包含修改后用户信息（manager）的响应，状态码为200，表示请求成功，同时附带提示信息"更新成功"，告知客户端操作顺利完成 + if (err) return res.sendResult(null, 400, err); + res.sendResult(manager, 200, "更新成功"); + } + )(req, res, next); + } ); -// 删除用户信息 +// 定义处理删除用户信息的DELETE请求的路由，路径中包含用户ID参数，格式为 "/:id" router.delete("/:id", - // 验证参数 - function(req,res,next){ - if(!req.params.id) return res.sendResult(null,400,"用户ID不能为空"); - if(isNaN(parseInt(req.params.id))) return res.sendResult(null,400,"ID必须是数字"); - if(req.params.id == 500) return res.sendResult(null,400,"不允许删除admin账户"); - next(); - }, - // 处理业务逻辑 - function(req,res,next){ - mgrServ.deleteManager(req.params.id,function(err){ - if(err) return res.sendResult(null,400,err); - return res.sendResult(null,200,"删除成功"); - })(req,res,next); - } + // 第一个中间件函数，用于对删除用户信息时请求中的必要参数进行验证，确保传入的用户ID参数符合业务要求，保证后续业务逻辑能正确执行 + function (req, res, next) { + // 检查请求参数中的用户ID（req.params.id）是否存在，如果不存在则返回错误响应，状态码400表示请求参数有误，同时附带提示信息"用户ID不能为空" + if (!req.params.id) return res.sendResult(null, 400, "用户ID不能为空"); + // 进一步验证用户ID是否可以转换为数字类型，如果不能转换成功（即不是有效的数字），则返回错误响应，状态码同样为400，并附带提示信息"ID必须是数字" + if (isNaN(parseInt(req.params.id))) return res.sendResult(null, 400, "ID必须是数字"); + // 特别地，对于用户ID为500的情况（可能是特殊的admin账户），不允许删除，直接返回错误响应，状态码为400，并附带提示信息"不允许删除admin账户" + if (req.params.id == 500) return res.sendResult(null, 400, "不允许删除admin账户"); + // 参数验证通过后，调用next()函数将控制权传递给下一个中间件或者路由处理函数，以便继续执行后续的业务逻辑 + next(); + }, + // 第二个中间件函数，用于处理删除用户信息的实际业务逻辑，依赖于前面验证通过的用户ID参数进行相应操作 + function (req, res, next) { + // 调用mgrServ用户管理服务对象的deleteManager方法，传入经过验证的用户ID（req.params.id），用于删除该用户的信息。 + // 这个方法执行的是异步操作，在操作过程中如果出现错误（err不为null），就通过res.sendResult返回包含错误信息的响应，状态码设置为400，表示请求处理出现错误。 + // 如果删除用户信息操作成功，就使用res.sendResult返回一个空数据的响应（因为用户信息已被删除），状态码为200，表示请求成功，同时附带提示信息"删除成功"，告知客户端操作顺利完成 + mgrServ.deleteManager(req.params.id, function (err) { + if (err) return res.sendResult(null, 400, err); + return res.sendResult(null, 200, "删除成功"); + })(req, res, next); + } ); -// 分配用户角色 +// 定义处理分配用户角色的PUT请求的路由，路径中包含用户ID和角色相关的路径参数，格式为 "/:id/role" router.put("/:id/role", - // 参数验证 - function(req,res,next) { - if(!req.params.id) { - return res.sendResult(null,400,"用户ID不能为空"); - } - if(isNaN(parseInt(req.params.id))) return res.sendResult(null,400,"用户ID必须是数字"); - - if(req.params.id == 500) return res.sendResult(null,400,"不允许修改admin账户"); - - if(!req.body.rid) res.sendResult(null,400,"权限ID不能为空"); - next(); - }, - // 处理业务逻辑 - function(req,res,next) { - mgrServ.setRole(req.params.id,req.body.rid,function(err,manager){ - if(err) return res.sendResult(null,400,err); - res.sendResult(manager,200,"设置角色成功"); - })(req,res,next); - } + // 第一个中间件函数，用于对分配用户角色时请求中的必要参数进行验证，确保传入的参数符合业务要求，保证后续业务逻辑能正确执行 + function (req, res, next) { + // 检查请求参数中的用户ID（req.params.id）是否存在，如果不存在则返回错误响应，状态码400表示请求参数有误，同时附带提示信息"用户ID不能为空" + if (!req.params.id) { + return res.sendResult(null, 400, "用户ID不能为空"); + } + // 进一步验证用户ID是否可以转换为数字类型，如果不能转换成功（即不是有效的数字），则返回错误响应，状态码同样为400，并附带提示信息"用户ID必须是数字" + if (isNaN(parseInt(req.params.id))) return res.sendResult(null, 400, "用户ID必须是数字"); + // 对于用户ID为500的情况（可能是特殊的admin账户），不允许修改角色，直接返回错误响应，状态码为400，并附带提示信息"不允许修改admin账户" + if (req.params.id == 500) return res.sendResult(null, 400, "不允许修改admin账户"); + // 检查请求体中是否包含rid字段，如果不存在则返回错误响应，状态码400，表示请求参数有误，同时附带提示信息"权限ID不能为空" + if (!req.body.rid) res.sendResult(null, 400, "权限ID不能为空"); + // 参数验证通过后，调用next()函数将控制权传递给下一个中间件或者路由处理函数，以便继续执行后续的业务逻辑 + next(); + }, + // 第二个中间件函数，用于处理分配用户角色的实际业务逻辑，依赖于前面验证通过的用户ID和请求体中的角色ID参数进行相应操作 + function (req, res, next) { + // 调用mgrServ用户管理服务对象的setRole方法，传入经过验证的用户ID（req.params.id）和角色ID（req.body.rid），用于为用户设置相应的角色。 + // 这个方法执行的是异步操作，在操作过程中如果出现错误（err不为null），就通过res.sendResult返回包含错误信息的响应，状态码设置为400，表示请求处理出现错误。 + // 如果分配用户角色操作成功，就使用res.sendResult返回包含更新后用户信息（manager）的响应，状态码为200，表示请求成功，同时附带提示信息"设置角色成功"，告知客户端操作顺利完成 + mgrServ.setRole(req.params.id, req.body.rid, function (err, manager) { + if (err) return res.sendResult(null, 400, err); + res.sendResult(manager, 200, "设置角色成功"); + })(req, res, next); + } ); - +// 定义处理更新用户状态的PUT请求的路由，路径中包含用户ID和状态相关的路径参数，格式为 "/:id/state/:state" router.put("/:id/state/:state", + // 第一个中间件函数，用于对更新用户状态时请求中的必要参数进行验证，确保传入的参数符合业务要求，保证后续业务逻辑能正确 // 参数验证 function(req,res,next) { if(!req.params.id) { diff --git a/vue.config.js b/vue.config.js index 5a6a16a..0731956 100644 --- a/vue.config.js +++ b/vue.config.js @@ -1,39 +1,51 @@ +//这段代码主要用于根据不同的环境（生产环境或开发环境）来配置webpack的入口文件和外部依赖 +//（externals）。在生产环境中，通过externals配置来告诉webpack不要将这些指定的库打包到最终的 +//bundle中，因为它们将在运行时通过全局变量来访问。同时，它还修改了html-webpack-plugin插件的 +//配置，通过添加一个isProd标志来区分当前是生产环境还是开发环境，这可以在生成的HTML文件中被用 +//来进行条件渲染或其他逻辑处理。 +// 导出webpack配置修改函数 module.exports = { + // 使用chainWebpack来自定义webpack配置 chainWebpack: config => { - // 发布模式 + // 判断当前是否为生产环境 config.when(process.env.NODE_ENV === 'production', config => { + // 修改入口文件为src/main-prod.js（用于生产环境） config - .entry('app') - .clear() - .add('./src/main-prod.js') + .entry('app') // 获取名为'app'的入口配置 + .clear() // 清除原有的入口文件 + .add('./src/main-prod.js') // 添加新的入口文件 + // 设置externals，这些库在打包时将不会被包含，而是作为外部依赖在运行时引入 config.set('externals', { - vue: 'Vue', - 'vue-router': 'VueRouter', - axios: 'axios', - lodash: '_', - echarts: 'echarts', - nprogress: 'NProgress', - 'vue-quill-editor': 'VueQuillEditor' + vue: 'Vue', // Vue库在运行时通过全局变量Vue访问 + 'vue-router': 'VueRouter', // vue-router库在运行时通过全局变量VueRouter访问 + axios: 'axios', // axios库在运行时通过全局变量axios访问 + lodash: '_', // lodash库在运行时通过全局变量_访问 + echarts: 'echarts', // echarts库在运行时通过全局变量echarts访问 + nprogress: 'NProgress', // nprogress库在运行时通过全局变量NProgress访问 + 'vue-quill-editor': 'VueQuillEditor' // vue-quill-editor库在运行时通过全局变量VueQuillEditor访问 }) + // 修改html-webpack-plugin插件的配置，设置isProd标志为true config.plugin('html').tap(args => { - args[0].isProd = true - return args + args[0].isProd = true // 修改html-webpack-plugin的第一个参数对象，添加isProd属性并设为true + return args // 返回修改后的参数数组 }) }) - // 开发模式 + // 判断当前是否为开发环境 config.when(process.env.NODE_ENV === 'development', config => { + // 修改入口文件为src/main-dev.js（用于开发环境） config - .entry('app') - .clear() - .add('./src/main-dev.js') + .entry('app') // 获取名为'app'的入口配置 + .clear() // 清除原有的入口文件 + .add('./src/main-dev.js') // 添加新的入口文件 + // 修改html-webpack-plugin插件的配置，设置isProd标志为false config.plugin('html').tap(args => { - args[0].isProd = false - return args + args[0].isProd = false // 修改html-webpack-plugin的第一个参数对象，添加isProd属性并设为false + return args // 返回修改后的参数数组 }) }) } -} +} \ No newline at end of file