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

dj1

Browse Source
dj 8 months ago
parent b80e9b1834
commit 4548f3c326
2 changed files with 208 additions and 195 deletions
Show Stats Download Patch File Download Diff File

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

@ -1,37 +1,53 @@
//这段代码整体是在处理删除分类参数相关的逻辑，先是对传入的参数（分类 ID 和参数 ID）进行严格的合
//法性验证，通过后再调用相应服务方法执行删除操作，并根据操作结果向客户端返回合适的响应信息，最
//后将路由器对象导出供外部使用。
// 引入Express框架，这是一个流行的Node.js web应用框架，用于创建服务器、处理HTTP请求以及定义路由等功能
var express = require('express');
// 创建一个Express的路由器对象，通过这个对象可以方便地定义一组相关的路由规则，用于处理不同路径和请求方法的逻辑
var router = express.Router();
// 引入Node.js的path模块，该模块提供了一系列用于处理文件路径的实用方法，比如拼接、解析路径等操作
var path = require("path");
// 获取验证模块
// 获取验证模块，通过process.cwd()获取当前工作目录，然后与"/modules/authorization"路径进行拼接，
// 最终引入对应的模块。这个模块大概率用于进行权限验证相关操作，或者提供获取其他服务的入口等功能
var authorization = require(path.join(process.cwd(),"/modules/authorization"));
// 通过验证模块获取分类管理
// 通过验证模块获取分类管理相关服务，"CategoryService"是在authorization模块内部定义好的一个服务标识，
// 借助这个标识可以调用一系列与分类管理相关的功能方法，例如获取分类列表、添加分类、删除分类等具体操作
var catServ = authorization.getService("CategoryService");
// 通过验证模块获取分类属性
// 通过验证模块获取分类属性相关服务，同理，"AttributeService"也是在authorization模块里定义的一个服务标识，
// 专门用于处理和分类属性相关的各类操作，比如获取属性、创建属性、更新属性以及删除属性等功能
var attrServ = authorization.getService("AttributeService");
// 获取分类列表
// 引入Express框架的路由器对象（假设前面已经正确引入了Express）
// 这里重新声明了一个名为router的变量，覆盖了之前定义的router，实际使用中可能需要注意避免这种重复定义导致的混淆，
// 不过从代码逻辑看可能是想重新明确这个路由器对象用于后续路由配置，建议可以使用不同的变量名更好区分
const router = require('express').Router();
// 处理获取分类列表的GET请求，路径为根路径 "/"
// 处理获取分类列表的GET请求，路径为根路径 "/"，意味着当客户端向服务器发送GET请求到根路径时，会进入这个路由的处理逻辑
router.get("/",
// 第一个中间件函数，用于参数验证
// 第一个中间件函数，用于参数验证，在Express框架中，中间件函数是一种可以对请求进行预处理的机制，比如检查请求参数是否合法等
function (req, res, next) {
// 验证pagenum参数是否存在且大于0，如果不符合要求则返回错误响应，状态码400表示请求参数错误
// 此处代码被注释掉了，若取消注释则会进行该参数验证逻辑
// 验证pagenum参数是否存在且大于0，如果不符合要求则返回错误响应，状态码400表示请求参数错误。
// 此处代码被注释掉了，若取消注释则会进行该参数验证逻辑，即检查请求中是否传递了合法的pagenum参数，
// 如果该参数不存在或者小于等于0，就会返回包含相应错误信息的响应给客户端
// if (!req.query.pagenum || req.query.pagenum <= 0) return res.sendResult(null, 400, "pagenum 参数错误");
// 验证pagesize参数是否存在且大于0，如果不符合要求则返回错误响应
// 此处代码被注释掉了，若取消注释则会进行该参数验证逻辑
// 验证pagesize参数是否存在且大于0，如果不符合要求则返回错误响应，
// 此处代码被注释掉了，若取消注释则会进行该参数验证逻辑，也就是检查请求中是否传递了合法的pagesize参数，
// 若该参数不存在或者小于等于0，同样会返回包含对应错误信息的响应给客户端
// if (!req.query.pagesize || req.query.pagesize <= 0) return res.sendResult(null, 400, "pagesize 参数错误");
// 如果参数验证通过，调用next()将控制权传递给下一个中间件或路由处理函数
// 如果参数验证通过，调用next()将控制权传递给下一个中间件或路由处理函数，这是Express中间件机制中用于流程控制的关键操作，
// 保证请求能按照顺序依次经过各个中间件进行相应处理
next();
},
// 第二个中间件函数，用于获取分类列表的业务逻辑处理
// 第二个中间件函数，用于获取分类列表的业务逻辑处理，在前面参数验证中间件通过后，会执行这个中间件里的具体业务逻辑，即获取分类列表的操作
function (req, res, next) {
var conditions = null;
// 如果pagenum和pagesize参数都存在，则构建包含这两个参数的查询条件对象
// 如果pagenum和pagesize参数都存在，则构建包含这两个参数的查询条件对象，用于后续向获取分类列表的服务方法传递相应的限制条件，
// 例如可以根据这两个参数来控制每页显示的分类数量以及获取第几页的分类数据等情况
if (req.query.pagenum && req.query.pagesize) {
conditions = {
"pagenum": req.query.pagenum,
@ -39,28 +55,31 @@ router.get("/",
};
}
// 调用catServ服务（假设是自定义的分类相关服务模块）的getAllCategories方法，传入分类类型和查询条件等参数
// 处理获取分类列表的异步操作，成功则返回结果，失败则返回错误信息
// 调用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请求，路径为 "/"
// 处理创建分类的POST请求，路径为 "/"，表示当客户端向服务器的根路径发起POST请求时，会进入此路由对应的处理逻辑，
// 通常这种请求用于向服务器提交创建新分类的数据信息
router.post("/",
// 参数验证中间件，检查请求体中是否包含cat_name字段，如果没有则返回错误响应
// 参数验证中间件，检查请求体中是否包含cat_name字段，如果没有则返回错误响应，因为分类名称在创建分类操作中一般是必不可少的信息，
// 所以要确保请求中包含这个字段才能进行后续的创建分类逻辑
function (req, res, next) {
if (!req.body.cat_name) {
return res.sendResult(null, 400, "必须提供分类名称");
}
// 参数验证通过，将控制权传递给下一个中间件
// 参数验证通过，将控制权传递给下一个中间件，继续后续创建分类的业务逻辑处理，遵循Express中间件按顺序执行的机制
next();
},
// 业务逻辑中间件，用于创建分类的具体操作
// 业务逻辑中间件，用于创建分类的具体操作，在前面参数验证中间件通过后，会执行这个中间件里的实际创建分类的业务逻辑
function (req, res, next) {
// 调用catServ服务的addCategory方法，传入包含分类相关信息（父分类ID、分类名称、分类级别等）的对象
// 处理创建分类的异步操作，成功则返回创建后的结果，失败则返回错误信息
// 调用catServ服务的addCategory方法，传入包含分类相关信息（父分类ID、分类名称、分类级别等）的对象，
// 通过这些信息向系统中添加新的分类，将客户端提交过来的分类相关数据传递给服务层进行相应的处理，这也是一个异步操作，
// 通过回调函数来处理操作完成后的结果情况，比如创建成功返回创建后的分类信息，失败则返回相应的错误信息
catServ.addCategory({
"cat_pid": req.body.cat_pid,
"cat_name": req.body.cat_name,
@ -72,21 +91,23 @@ router.post("/",
}
);
// 处理根据分类ID获取分类详情的GET请求，路径中包含分类ID参数，如 "/:id"
// 处理根据分类ID获取分类详情的GET请求，路径中包含分类ID参数，如 "/:id"，这里的":id"是路由参数的占位符，
// 在实际接收到请求时，会被替换为具体的分类ID值，然后根据这个ID去获取对应的分类详情信息
router.get("/:id",
// 参数验证中间件，检查分类ID参数是否存在以及是否为数字类型
// 参数验证中间件，检查分类ID参数是否存在以及是否为数字类型，保证获取详情的分类ID是合法有效的，
// 因为如果分类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必须是数字");
// 参数验证通过，将控制权交给下一个中间件
// 参数验证通过，将控制权交给下一个中间件，以便继续执行获取分类详情的业务逻辑，按照Express中间件的执行顺序推进处理流程
next();
},
// 正常业务逻辑中间件，用于根据分类ID获取分类详情的操作
// 正常业务逻辑中间件，用于根据分类ID获取分类详情的操作，在前面参数验证中间件通过后，会执行这个中间件里的具体获取分类详情的业务逻辑
function (req, res, next) {
// 调用catServ服务的getCategoryById方法，传入分类ID参数
// 处理获取分类详情的异步操作，成功则返回结果，失败则返回错误信息
// 调用catServ服务的getCategoryById方法，传入分类ID参数，通过该服务方法从数据存储（比如数据库）中获取对应分类的详细信息，
// 这同样是一个异步操作，依赖回调函数来处理获取详情后的结果情况，若成功获取到详情信息则返回给客户端，失败则返回相应的错误提示
catServ.getCategoryById(req.params.id, function (err, result) {
if (err) return res.sendResult(null, 400, err);
res.sendResult(result, 200, "获取成功");
@ -94,43 +115,47 @@ router.get("/:id",
}
);
// 处理删除分类的DELETE请求，路径中包含分类ID参数，如 "/:id"
// 处理删除分类的DELETE请求，路径中包含分类ID参数，如 "/:id"，意味着当客户端向服务器发起DELETE请求并且携带分类ID时，
// 会进入此路由对应的处理逻辑，用于执行删除指定分类的操作
router.delete("/:id",
// 参数验证中间件，检查分类ID参数是否存在以及是否为数字类型
// 参数验证中间件，检查分类ID参数是否存在以及是否为数字类型，确保要删除的分类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必须是数字");
// 参数验证通过，将控制权交给下一个中间件
// 参数验证通过，将控制权交给下一个中间件，进而执行删除分类的实际业务逻辑，遵循Express中间件按顺序执行的机制
next();
},
// 业务逻辑中间件，用于执行删除分类的操作
// 业务逻辑中间件，用于执行删除分类的操作，在前面参数验证中间件通过后，会执行这个中间件里的实际删除分类的业务逻辑
function (req, res, next) {
// 调用catServ服务的deleteCategory方法，传入分类ID参数
// 处理删除分类的异步操作，成功则返回提示信息，失败则返回错误信息
// 调用catServ服务的deleteCategory方法，传入分类ID参数，通过该服务方法从系统中删除指定的分类，
// 这是一个异步操作，通过回调函数来处理删除操作完成后的情况，若成功删除分类则返回相应的提示信息，失败则返回对应的错误信息
catServ.deleteCategory(req.params.id, function (msg) {
res.sendResult(null, 200, msg);
})(req, res, next);
}
);
// 处理更新分类的PUT请求，路径中包含分类ID参数，如 "/:id"
// 处理更新分类的PUT请求，路径中包含分类ID参数，如 "/:id"，表示当客户端向服务器发送PUT请求并携带分类ID时，
// 会进入此路由对应的处理逻辑，用于执行更新指定分类信息的操作
router.put("/:id",
// 参数验证中间件，检查分类ID参数是否存在、是否为数字类型，以及分类名称是否为空
// 参数验证中间件，检查分类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.body.cat_name || req.body.cat_name == "") return res.sendResult(null, 400, "分类名称不能为空");
// 参数验证通过，将控制权交给下一个中间件
// 参数验证通过，将控制权交给下一个中间件，以便继续执行更新分类的业务逻辑操作，按照Express中间件的执行顺序推进处理流程
next();
},
// 业务逻辑中间件，用于执行更新分类的操作
// 业务逻辑中间件，用于执行更新分类的操作，在前面参数验证中间件通过后，会执行这个中间件里的实际更新分类信息的业务逻辑
function (req, res, next) {
// 调用catServ服务的updateCategory方法，传入分类ID和新的分类名称等参数
// 处理更新分类的异步操作，成功则返回更新后的结果，失败则返回错误信息
// 调用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, "更新成功");
@ -138,9 +163,11 @@ router.put("/:id",
}
);
// 处理通过分类ID获取分类参数（attributes）的GET请求，路径为 "/:id/attributes"
// 处理通过分类ID获取分类参数（attributes）的GET请求，路径为 "/:id/attributes"，用于获取指定分类下的相关属性信息，
// 根据分类ID去查找对应的属性数据
router.get("/:id/attributes",
// 参数验证中间件，检查分类ID参数是否存在、是否为数字类型，以及属性类型（sel）是否设置正确
// 参数验证中间件，检查分类ID参数是否存在、是否为数字类型，以及属性类型（sel）是否设置正确，确保获取属性时的所有参数都是合法有效的，
// 只有这样才能准确地从数据存储中获取到期望的属性数据，避免因参数问题导致查询出错
function (req, res, next) {
if (!req.params.id) {
return res.sendResult(null, 400, "分类ID不能为空");
@ -149,13 +176,14 @@ router.get("/:id/attributes",
if (!req.query.sel || (req.query.sel!= "only" && req.query.sel!= "many")) {
return res.sendResult(null, 400, "属性类型必须设置");
}
// 参数验证通过，将控制权交给下一个中间件
// 参数验证通过，将控制权交给下一个中间件，继续执行获取分类参数的业务逻辑，遵循Express中间件按顺序执行的机制
next();
},
// 业务逻辑中间件，用于获取分类参数的操作
// 业务逻辑中间件，用于获取分类参数的操作，在前面参数验证中间件通过后，会执行这个中间件里的具体获取分类参数的业务逻辑
function (req, res, next) {
// 调用attrServ服务（假设是自定义的属性相关服务模块）的getAttributes方法，传入分类ID和属性类型等参数
// 处理获取分类参数的异步操作，成功则返回获取到的属性列表，失败则返回错误信息
// 调用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, "获取成功");
@ -163,24 +191,26 @@ router.get("/:id/attributes",
}
);
// 处理根据分类ID和参数ID获取参数详情的GET请求，路径为 "/:id/attributes/:attrId"
// 处理根据分类ID和参数ID获取参数详情的GET请求，路径为 "/:id/attributes/:attrId"，这里的":attrId"是参数ID的路由参数占位符，
// 在实际接收到请求时，会被替换为具体的参数ID值，然后根据分类ID和参数ID去获取对应的参数详情信息
router.get("/:id/attributes/:attrId",
// 参数验证中间件，检查分类ID和参数ID是否存在以及是否为数字类型
// 参数验证中间件，检查分类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();
return res.sendResult(null, 400, "参数ID不能为空");
}
if (isNaN(parseInt(req.params.attrId))) return res.sendResult(null, 400, "参数ID必须是数字");
// 参数验证通过，将控制权交给下一个中间件，以便继续执行获取参数详情的业务逻辑，按照Express中间件的执行顺序推进处理流程
next();
},
function (req, res, next) {
// 调用attrServ服务的attributeById方法，传入参数ID参数
// 处理获取参数详情的异步操作，成功则返回参数详情，失败则返回错误信息
// 调用attrServ服务的attributeById方法，传入参数ID参数，通过该服务方法从数据存储中获取对应参数的详细信息，
// 这是一个异步操作，通过回调函数来处理获取详情后的结果情况，若成功获取到参数详情则返回给客户端，失败则返回相应的错误提示
attrServ.attributeById(req.params.attrId, function (err, attr) {
if (err) return res.sendResult(null, 400, err);
res.sendResult(attr, 200, "获取成功");
@ -188,117 +218,44 @@ router.get("/:id/attributes/:attrId",
}
);
// 处理创建分类参数的POST请求，路径为 "/:id/attributes"
// 处理创建分类参数的POST请求，路径为 "/:id/attributes"，用于向指定分类下创建新的参数信息，根据分类ID来添加相应的参数数据
router.post("/:id/attributes",
// 参数验证中间件，检查分类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_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",
// 参数验证中间件，检查分类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, "参数名称不能为空");
// 参数验证通过，将控制权交给下一个中间件
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",
// 参数验证中间件，检查分类ID和参数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必须是数字");
// 参数验证通过，将控制权交给下一个中间件
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);
}
);
// 检查传入的 req.params.id 是否能成功转换为数字，如果不能（即不是数字格式），
// 则向客户端返回错误响应，状态码为400表示请求参数错误，同时给出相应的错误提示信息
if (isNaN(parseInt(req.params.id))) return res.sendResult(null, 400, "分类ID必须是数字");
// 检查 req.params.attrId 是否存在，如果不存在，说明参数缺失，不符合要求
if (!req.params.attrId) {
return res.sendResult(null, 400, "参数ID不能为空");
}
// 进一步检查 req.params.attrId 是否能成功转换为数字，若不能转换，同样不符合要求，
// 要向客户端返回错误响应，告知参数格式错误
if (isNaN(parseInt(req.params.attrId))) return res.sendResult(null, 400, "参数ID必须是数字");
// 参数验证通过，调用next()函数，按照Express中间件的机制，将控制权交给下一个中间件，
// 以便继续后续的业务逻辑处理流程
next();
},
// 业务逻辑中间件，用于执行删除分类参数的操作，在前面的参数验证中间件通过后，在此执行具体的删除操作逻辑
function (req, res, next) {
// 调用attrServ服务的deleteAttribute方法，传入参数ID参数（这里的参数ID即前面经过验证的req.params.attrId），
// 以此来触发删除分类参数的实际操作，该操作通常是与数据库等数据存储进行交互，执行删除对应记录的动作，这是一个异步操作
attrServ.deleteAttribute(req.params.attrId, function (err, newAttr) {
// 如果在执行删除操作过程中出现错误（err不为null），则向客户端返回包含错误信息的响应，
// 状态码400表示操作失败，同时将具体的错误信息传递过去
if (err) return res.sendResult(null, 400, err);
// 如果删除操作成功，向客户端返回成功提示信息，状态码200表示操作成功，
// 这里返回的提示信息只是简单的"删除成功"，实际应用中可根据需求返回更详细的内容
res.sendResult(null, 200, "删除成功");
})(req, res, next);
});
// 将配置好的路由器对象导出，以便在其他模块中使用
// 将配置好的路由器对象（包含了前面定义的一系列路由及对应的处理逻辑）导出，
// 这样其他的Node.js模块就可以通过引入这个模块来使用这个路由器，
// 进而处理相应的HTTP请求，实现对应的业务功能
module.exports = router;

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

@ -1,93 +1,143 @@
// 引入Express框架的核心模块，用于创建Web应用和路由等功能
//这段代码整体实现了一个用于获取商品列表的路由功能，先是对请求参数进行严格验证，确保参数符合分
//页查询及可能的模糊查询要求，然后基于验证通过的参数去调用相应服务方法获取商品列表数据，并根据
//操作结果向客户端返回合适的响应信息。
// 引入Express框架的核心模块，Express是一个广泛用于Node.js的Web应用框架，
// 通过它可以方便地创建Web应用、定义路由以及处理各种HTTP请求等功能
var express = require('express');
// 创建一个Express路由器实例，用于定义一组相关的路由
// 创建一个Express路由器实例，路由器（Router）在Express中用于将一组相关的路由进行集中管理，
// 可以让代码结构更加清晰，便于对不同路径和请求方法的请求进行分别处理
var router = express.Router();
// 引入Node.js的path模块，用于处理文件路径相关操作
// 引入Node.js的path模块，该模块提供了许多实用的函数用于处理文件路径相关操作，
// 例如拼接路径、解析路径、获取文件扩展名等，在这里主要用于拼接模块的正确引入路径
var path = require("path");
// 获取自定义的验证模块，通过拼接当前工作目录和相对路径来指定模块位置
// 这里假设验证模块（authorization）提供了一些权限验证以及获取相关服务的功能
// 获取自定义的验证模块，通过process.cwd()获取当前工作目录，并与"/modules/authorization"进行路径拼接，
// 以此来准确引入对应的模块。这里假设验证模块（authorization）具备权限验证功能，
// 同时还能提供获取其他相关服务的能力，是整个应用中权限管理及服务获取的关键部分
var authorization = require(path.join(process.cwd(), "/modules/authorization"));
// 通过验证模块获取名为"GoodService"的服务对象，用于后续对商品相关操作的调用
// 这个服务对象应该封装了与商品数据交互的各种方法，比如增删改查等
// 通过验证模块获取名为"GoodService"的服务对象，"GoodService"大概率是在authorization模块中定义的一个服务标识，
// 通过这个标识获取到的服务对象应该封装了一系列与商品数据交互的各种方法，例如对商品数据进行添加、删除、修改、查询等操作，
// 方便在后续的路由处理中调用相应功能来处理业务逻辑
var goodServ = authorization.getService("GoodService");
// 定义处理获取商品列表的GET请求的路由，路径为根路径 "/"
// 定义处理获取商品列表的GET请求的路由，路径为根路径 "/"，这意味着当客户端向服务器的根路径发送GET请求时，
// 将会进入这个路由对应的处理逻辑来获取商品列表信息
router.get("/",
// 第一个中间件函数，用于验证请求参数的合法性
// 第一个中间件函数，用于验证请求参数的合法性，在Express框架中，中间件函数可以对请求进行预处理，
// 在这里主要是检查请求中携带的参数是否符合要求，确保后续业务逻辑能基于正确的参数进行处理
function (req, res, next) {
// 验证pagenum参数是否存在且大于0，如果不符合要求则返回错误响应，状态码400表示请求参数错误
// 验证pagenum参数是否存在且大于0，如果不符合要求则返回错误响应，状态码400表示请求参数错误。
// pagenum参数通常用于分页查询，表示要获取的页码，若不存在或者小于等于0，则不符合正常的分页逻辑
if (!req.query.pagenum || req.query.pagenum <= 0) return res.sendResult(null, 400, "pagenum 参数错误");
// 验证pagesize参数是否存在且大于0，如果不符合要求则返回错误响应
// 验证pagesize参数是否存在且大于0，如果不符合要求则返回错误响应。
// pagesize参数同样常用于分页查询，表示每页显示的记录数量，若不存在或者小于等于0，也不符合分页的合理要求
if (!req.query.pagesize || req.query.pagesize <= 0) return res.sendResult(null, 400, "pagesize 参数错误");
// 参数验证通过，调用next()将控制权传递给下一个中间件或路由处理函数
// 参数验证通过，调用next()将控制权传递给下一个中间件或路由处理函数，这是Express中间件机制中很重要的一环，
// 通过调用next()来确保请求能按照顺序依次经过各个中间件进行相应的处理，若不调用则请求会被阻塞在此中间件处
next();
},
// 第二个中间件函数，用于处理获取商品列表的业务逻辑
// 第二个中间件函数，用于处理获取商品列表的业务逻辑，在前面的参数验证中间件通过后，
// 会进入这个中间件来执行具体的获取商品列表操作，比如从数据库等数据存储中查询符合条件的商品数据
function (req, res, next) {
var conditions = {
// 将请求中的pagenum参数添加到查询条件对象中，用于分页查询等操作
// 将请求中的pagenum参数添加到查询条件对象中，用于分页查询等操作，
// 后续在调用获取商品列表的方法时，可以根据这个参数来确定返回哪一页的数据
"pagenum": req.query.pagenum,
// 将请求中的pagesize参数添加到查询条件对象中
// 将请求中的pagesize参数添加到查询条件对象中，以便根据每页显示数量的设定来返回相应数量的商品记录
"pagesize": req.query.pagesize
};
// 如果请求中包含query参数，则将其也添加到查询条件对象中，可能用于模糊查询等功能
// 如果请求中包含query参数，则将其也添加到查询条件对象中，query参数可能用于模糊查询等功能，
// 例如根据商品名称、描述等字段进行模糊匹配查找符合条件的商品，丰富了查询的灵活性
if (req.query.query) {
conditions["query"] = req.query.query;
}
// 调用goodServ服务对象的getAllGoods方法，传入查询条件对象，用于获取商品列表
// 处理获取商品列表的异步操作，若出现错误则返回错误信息，成功则返回查询到的商品列表数据
// 调用goodServ服务对象的getAllGoods方法，传入查询条件对象，用于获取商品列表。
// getAllGoods方法应该是在GoodService中定义的用于从数据存储（如数据库）中查询所有符合条件商品的方法，
// 它是一个异步操作，通常会涉及到数据库连接、查询语句执行等操作，所以通过回调函数来处理操作完成后的结果情况
goodServ.getAllGoods(
conditions,
function (err, result) {
// 如果在执行获取商品列表的异步操作过程中出现错误（err不为null），
// 则向客户端返回包含错误信息的响应，状态码400表示请求出现错误，同时将具体的错误信息传递给客户端
if (err) return res.sendResult(null, 400, err);
// 如果获取商品列表操作成功，向客户端返回查询到的商品列表数据，状态码200表示请求成功，
// 并附带"获取成功"的提示信息告知客户端操作已顺利完成
res.sendResult(result, 200, "获取成功");
}
)(req, res, next);
}
);
// 定义处理添加商品的POST请求的路由，路径为 "/"
//这段代码分别实现了添加商品和更新商品信息的路由功能。添加商品的路由中参数验证部分有待完善，而
//更新商品信息的路由先对商品 ID 进行了严谨的参数验证，之后基于验证通过的参数去调用相应服务方法
//执行更新操作，并根据操作结果向客户端返回合适的响应信息，不过其中更新成功的提示文本可能需要修
//正。
// 定义处理添加商品的POST请求的路由，路径为 "/"，这意味着当客户端向服务器的根路径发送POST请求时，
// 将会进入这个路由对应的处理逻辑，通常POST请求用于向服务器提交数据以创建新的资源，在这里就是用于添加商品
router.post("/",
// 参数验证中间件，这里暂时直接调用next()，可能后续需要补充具体的参数验证逻辑
// 参数验证中间件，这里暂时直接调用next()，表示当前没有进行具体的参数验证操作，
// 可能后续需要补充具体的参数验证逻辑，比如验证请求体中是否包含创建商品必需的字段等内容，
// 按照正常的业务逻辑，添加商品时请求体应该携带如商品名称、价格、描述等必要信息，需要进行合法性检查
function (req, res, next) {
next();
},
// 业务逻辑中间件，用于处理添加商品的具体操作
// 业务逻辑中间件，用于处理添加商品的具体操作，在参数验证中间件（虽然当前为空验证）通过后，
// 会进入这个中间件来执行实际的添加商品操作，比如将商品数据插入到数据库等数据存储中
function (req, res, next) {
// 获取请求体中的参数，假设这些参数包含了创建商品所需的各种信息，如商品名称、价格、描述等
// 获取请求体中的参数，假设这些参数包含了创建商品所需的各种信息，如商品名称、价格、描述等，
// 在实际应用中，具体的参数结构和内容取决于前端传递的数据格式以及后端创建商品业务逻辑的要求
var params = req.body;
// 调用goodServ服务对象的createGood方法，传入商品参数，用于创建新商品
// 处理创建商品的异步操作，若出现错误则返回错误信息，成功则返回创建后的商品信息
// 调用goodServ服务对象的createGood方法，传入商品参数，用于创建新商品。
// createGood方法应该是在GoodService中定义的用于向数据存储（如数据库）中插入新商品记录的方法，
// 它是一个异步操作，会涉及到数据库连接、插入语句执行等操作，所以通过回调函数来处理操作完成后的结果情况
goodServ.createGood(params, function (err, newGood) {
// 如果在执行创建商品的异步操作过程中出现错误（err不为null），
// 则向客户端返回包含错误信息的响应，状态码400表示请求出现错误，同时将具体的错误信息传递给客户端
if (err) return res.sendResult(null, 400, err);
// 如果创建商品操作成功，向客户端返回创建后的商品信息，状态码201表示资源创建成功，
// 并附带"创建商品成功"的提示信息告知客户端操作已顺利完成
res.sendResult(newGood, 201, "创建商品成功");
})(req, res, next);
}
);
// 定义处理更新商品信息的PUT请求的路由，路径中包含商品ID参数，如 "/:id"
// 定义处理更新商品信息的PUT请求的路由，路径中包含商品ID参数，如 "/:id"，这表示当客户端向服务器发送PUT请求，
// 且路径中带有具体的商品ID值时，会进入这个路由对应的处理逻辑，PUT请求常用于更新指定资源的信息，此处就是更新商品信息
router.put("/:id",
// 参数验证中间件，检查商品ID参数是否存在以及是否为数字类型
// 参数验证中间件，检查商品ID参数是否存在以及是否为数字类型，因为要更新指定的商品，
// 必须先确保传入的商品ID是合法有效的，即不能为空且要是数字类型，这样才能准确找到对应的商品记录进行更新
function (req, res, next) {
// 检查商品ID参数是否存在，如果不存在，说明缺少关键的更新依据，不符合要求
if (!req.params.id) {
return res.sendResult(null, 400, "商品ID不能为空");
}
// 进一步检查商品ID参数是否能成功转换为数字，如果不能（即不是数字格式），同样不符合要求，
// 无法准确定位要更新的商品记录，所以要返回错误响应给客户端
if (isNaN(parseInt(req.params.id))) return res.sendResult(null, 400, "商品ID必须是数字");
// 参数验证通过，将控制权交给下一个中间件
// 参数验证通过，将控制权交给下一个中间件，以便继续执行更新商品信息的业务逻辑，按照Express中间件的执行顺序推进处理流程
next();
},
// 业务逻辑中间件，用于处理更新商品信息的具体操作
// 业务逻辑中间件，用于处理更新商品信息的具体操作，在前面的参数验证中间件通过后，
// 会进入这个中间件来执行实际的更新商品信息操作，比如修改数据库中对应商品记录的相关字段值
function (req, res, next) {
var params = req.body;
// 调用goodServ服务对象的updateGood方法，传入商品ID和更新的参数，用于更新指定商品的信息
// 处理更新商品信息的异步操作，若出现错误则返回错误信息，成功则返回更新后的商品信息
// 这里返回的提示信息文本 "创建商品成功" 可能有误，应该是 "更新商品成功"，后续可根据实际情况修改
// 调用goodServ服务对象的updateGood方法，传入商品ID和更新的参数，用于更新指定商品的信息。
// updateGood方法应该是在GoodService中定义的用于根据商品ID修改对应商品记录信息的方法，
// 它是一个异步操作，涉及到数据库连接、更新语句执行等操作，通过回调函数来处理操作完成后的结果情况
goodServ.updateGood(req.params.id, params, function (err, newGood) {
// 如果在执行更新商品信息的异步操作过程中出现错误（err不为null），
// 则向客户端返回包含错误信息的响应，状态码400表示请求出现错误，同时将具体的错误信息传递给客户端
if (err) return res.sendResult(null, 400, err);
// 如果更新商品信息操作成功，向客户端返回更新后的商品信息，状态码200表示请求成功，
// 当前这里返回的提示信息文本 "创建商品成功" 可能有误，应该是 "更新商品成功"，后续可根据实际情况修改，
// 用于告知客户端商品信息已成功更新
res.sendResult(newGood, 200, "创建商品成功");
})(req, res, next);
}
@ -184,7 +234,7 @@ router.put("/:id/attributes",
req.params.id,
req.body,
function (err, good) {
if (err) return res.sendResult(null, 400, err);
if (err) return res.sendResult(null, 400, "更新失败");
res.sendResult(good, 200, "更新成功");
}
)(req, res, next);
@ -218,5 +268,11 @@ router.put("/:id/state/:state",
}
);
// 将配置好的路由器对象导出，以便在主应用模块中使用，挂载到对应的路径上
module.exports = router;
// 将配置好的路由器对象导出，以便在主应用模块中使用，挂载到对应的路径上，
// 这样主应用就能通过引入这个模块来使用该路由器中定义的所有路由及相关处理逻辑，
// 从而处理各种与商品相关的HTTP请求
module.exports = router;
//这段代码整体围绕商品相关的各种操作定义了一系列的路由及其对应的处理逻辑。每个路由处理函数基本
//都遵循先进行参数验证（确保传入的参数符合业务要求），再执行相应的业务逻辑（如增删改查、更新图
//片、属性、状态等操作）的模式，并且根据操作结果向客户端返回合适的响应信息，最后通过导出路由器
//对象使得这些路由配置能在整个应用中生效。
Write Preview
Loading…
Cancel
Save