m534ctfno
/
vue-shop-admin-work
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

dj

Browse Source
dj 8 months ago
parent 24f7febd2d
commit 00e94f2f45
14 changed files with 1126 additions and 790 deletions
Show Stats Download Patch File Download Diff File

28
.eslintrc.js
Unescape View File

@ -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'
}
}
}

2
README.md
Unescape View File

@ -1,4 +1,4 @@
注意：routes/services/test/config/dao/db/public2均为后端文件夹，仅是为了多注释放入的
### 大家有问题尽量在这里提： https://gitee.com/wBekvam/vue-shop-admin/issues

25
babel.config.js
Unescape View File

@ -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'
]
}
}

41
package.json
Unescape View File

@ -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"
}
}
}

472
routes/api/private/v1/categories.js
Unescape View File

@ -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;

348
routes/api/private/v1/goods.js
Unescape View File

@ -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;

31
routes/api/private/v1/menus.js
Unescape View File

@ -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;

190
routes/api/private/v1/orders.js
Unescape View File

@ -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;

49
routes/api/private/v1/reports.js
Unescape View File

@ -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;

55
routes/api/private/v1/rights.js
Unescape View File

@ -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;

274
routes/api/private/v1/roles.js
Unescape View File

@ -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;

42
routes/api/private/v1/upload.js
Unescape View File

@ -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;

307
routes/api/private/v1/users.js
Unescape View File

@ -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) {

52
vue.config.js
Unescape View File

@ -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 // 返回修改后的参数数组
})
})
}
}
}
Write Preview
Loading…
Cancel
Save