mhx

dao/AttributeDAO.js

@@ -1,21 +1,29 @@
+// 引入 Node.js 的 path 模块，用于处理文件和目录路径
 var path = require("path");
+// 引入自定义的 DAO 模块，可能是数据访问对象模块，具体功能取决于其实现
 daoModule = require("./DAO");
+// 引入位于 modules/database 目录下的 database 模块，使用 process.cwd() 获取当前工作目录并拼接路径
 databaseModule = require(path.join(process.cwd(), "modules/database"));
 
 /**
  * 获取参数列表数据
  * 
- * @param  {[type]}   cat_id 分类ID
- * @param  {[type]}   sel    类型
- * @param  {Function} cb     回调函数
+ * @param  {[type]}   cat_id 分类 ID，可能是用于筛选的分类标识符
+ * @param  {[type]}   sel    类型，可能是属性的类型或筛选条件的一部分
+ * @param  {Function} cb     回调函数，用于处理获取数据后的操作，第一个参数为可能的错误信息，第二个参数为获取的数据
  */
 module.exports.list = function (cat_id, sel, cb) {
+    // 从 databaseModule 中获取数据库对象
     db = databaseModule.getDatabase();
+    // 定义 SQL 查询语句，从 sp_attribute 表中查询数据，根据 cat_id 和 attr_sel 进行筛选，并且 delete_time 为 NULL 的数据
     sql = "SELECT * FROM sp_attribute WHERE cat_id =? AND attr_sel =? AND delete_time is NULL";
+    // 使用数据库驱动执行查询操作，将 SQL 语句和参数 [cat_id, sel] 传递给 execQuery 方法
     database.driver.execQuery(
         sql
        , [cat_id, sel], function (err, attributes) {
+            // 如果执行查询出现错误，调用回调函数并传递错误信息
             if (err) return cb("查询执行出错");
+            // 如果查询成功，将结果传递给回调函数
             cb(null, attributes);
         });
 }

dao/DAO.js

@@ -1,86 +1,82 @@
 var path = require("path");
 
-// 获取数据库模型
+// 获取数据库模型，通过 path.join 拼接当前工作目录和相对路径来引入模块
 databaseModule = require(path.join(process.cwd(), "modules/database")); 
+// 引入自定义的 logger 模块，并调用 logger 函数获取日志记录器
 var logger = require('../modules/logger').logger();
 
 /**
  * 创建对象数据
  * 
- * @param  {[type]}   modelName 模型名称
- * @param  {[type]}   obj       模型对象
- * @param  {Function} cb        回调函数
+ * @param  {[type]}   modelName 模型名称，用于标识要创建数据的具体模型
+ * @param  {[type]}   obj       要创建的模型对象，包含具体的数据内容
+ * @param  {Function} cb        回调函数，用于处理创建操作的结果，第一个参数可能为错误信息，第二个参数为创建成功后的返回结果（如果有）
  */
 module.exports.create = function (modelName, obj, cb) {
+    // 从 databaseModule 中获取数据库对象
     var db = databaseModule.getDatabase();
+    // 根据模型名称获取相应的模型
     var Model = db.models[modelName];
+    // 调用模型的 create 方法创建对象，将结果传递给回调函数
     Model.create(obj, cb);
 }
 
 /**
  * 获取所有数据
  * 
- * @param  {[type]}   conditions 查询条件
+ * @param  {[type]}   conditions 查询条件，用于筛选数据，包含多种可能的条件设置
  * 查询条件统一规范
  * conditions
     {
         "columns" : {
-			字段条件
+            字段条件，存储具体字段和其对应的值
             "字段名" : "条件值"
         },
-		"offset" : "偏移",
-		"omit" : ["字段"],
-		"only" : ["需要字段"],
-		"limit" : "",
+        "offset" : "偏移",  // 用于分页，表示从第几条数据开始查询
+        "omit" : ["字段"],  // 表示要排除的字段列表
+        "only" : ["需要字段"],  // 表示只查询的字段列表
+        "limit" : "",  // 表示查询的数量限制，用于分页
         "order" :[ 
-			"字段" , A | Z,
+            "字段", A | Z,  // 表示排序的字段和排序方向（升序或降序）
            ...
         ]
     }
- * @param  {Function} cb         回调函数
+ * @param  {Function} cb         回调函数，用于处理查询结果，第一个参数可能为错误信息，第二个参数为查询到的数据
  */
 module.exports.list = function (modelName, conditions, cb) {
+    // 从 databaseModule 中获取数据库对象
     var db = databaseModule.getDatabase();
-
+    // 根据模型名称获取相应的模型
     var model = db.models[modelName];
-
+    // 如果模型不存在，调用回调函数并传递错误信息
     if (!model) return cb("模型不存在", null);
-
-
-
+    // 根据不同的条件进行相应的查询操作
     if (conditions) {
         if (conditions["columns"]) {
             model = model.find(conditions["columns"]);
         } else {
             model = model.find();
         }
-
         if (conditions["offset"]) {
             model = model.offset(parseInt(conditions["offset"]));
         }
-
         if (conditions["limit"]) {
             model = model.limit(parseInt(conditions["limit"]));
         }
-
         if (conditions["only"]) {
             model = model.only(conditions["only"]);
         }
-
         if (conditions["omit"]) {
             model = model.omit(conditions["omit"]);
         }
-
         if (conditions["order"]) {
             model = model.order(conditions["order"]);
         }
-
     } else {
         model = model.find();
     }
-
+    // 执行查询操作并处理结果，将结果传递给回调函数
     model.run(function (err, models) {
-		
         if (err) {
             console.log(err);
             return cb("查询失败", null);
@@ -90,47 +86,47 @@ module.exports.list = function(modelName,conditions,cb) {
 };
 
 module.exports.countByConditions = function (modelName, conditions, cb) {
+    // 从 databaseModule 中获取数据库对象
     var db = databaseModule.getDatabase();
-
+    // 根据模型名称获取相应的模型
     var model = db.models[modelName];
-
+    // 如果模型不存在，调用回调函数并传递错误信息
     if (!model) return cb("模型不存在", null);
-
+    // 定义回调函数用于处理计数结果
     var resultCB = function (err, count) {
         if (err) {
             return cb("查询失败", null);
         }
         cb(null, count);
     }
-
+    // 根据不同的条件进行相应的计数操作
     if (conditions) {
         if (conditions["columns"]) {
             model = model.count(conditions["columns"], resultCB);
         } else {
             model = model.count(resultCB);
         }
-
     } else {
         model = model.count(resultCB);
     }
-
 };
 
 /**
  * 获取一条数据
- * @param  {[type]}   modelName  模型名称
- * @param  {[数组]}   conditions  条件集合
- * @param  {Function} cb         回调函数
+ * @param  {[type]}   modelName  模型名称，用于指定要查找的模型
+ * @param  {[数组]}   conditions  条件集合，包含查找该条数据的具体条件
+ * @param  {Function} cb         回调函数，用于处理查找结果，第一个参数可能为错误信息，第二个参数为找到的数据
  */
 module.exports.findOne = function (modelName, conditions, cb) {
+    // 从 databaseModule 中获取数据库对象
     var db = databaseModule.getDatabase();
-
+    // 根据模型名称获取相应的模型
     var Model = db.models[modelName];
-
+    // 如果模型不存在，调用回调函数并传递错误信息
     if (!Model) return cb("模型不存在", null);
-
+    // 如果条件为空，调用回调函数并传递错误信息
     if (!conditions) return cb("条件为空", null);
-
+    // 调用模型的 one 方法查找一条数据，使用日志记录器记录错误，并将结果传递给回调函数
     Model.one(conditions, function (err, obj) {
         logger.debug(err);
         if (err) {
@@ -143,14 +139,17 @@ module.exports.findOne = function(modelName,conditions,cb) {
 /**
  * 更新对象数据
  * 
- * @param  {[type]}   modelName 模型名称
- * @param  {[type]}   id        数据关键ID
- * @param  {[type]}   updateObj 更新对象数据
- * @param  {Function} cb        回调函数
+ * @param  {[type]}   modelName 模型名称，用于指定要更新的模型
+ * @param  {[type]}   id        数据关键 ID，用于确定要更新的具体数据记录
+ * @param  {[type]}   updateObj 更新对象数据，包含要更新的具体数据内容
+ * @param  {Function} cb        回调函数，用于处理更新操作的结果，第一个参数可能为错误信息，第二个参数为更新成功后的返回结果（如果有）
  */
 module.exports.update = function (modelName, id, updateObj, cb) {
+    // 从 databaseModule 中获取数据库对象
     var db = databaseModule.getDatabase();
+    // 根据模型名称获取相应的模型
     var Model = db.models[modelName];
+    // 通过 ID 获取要更新的对象，处理获取过程中的错误，并调用对象的 save 方法更新数据
     Model.get(id, function (err, obj) {
         if (err) return cb("更新失败", null);
         obj.save(updateObj, cb);
@@ -159,13 +158,16 @@ module.exports.update = function(modelName,id,updateObj,cb) {
 
 /**
  * 通过主键 ID 获取对象
- * @param  {[type]}   modelName 模型名称
- * @param  {[type]}   id        主键ID
- * @param  {Function} cb        回调函数
+ * @param  {[type]}   modelName 模型名称，用于指定要查找的模型
+ * @param  {[type]}   id        主键 ID，用于确定要查找的具体数据记录
+ * @param  {Function} cb        回调函数，用于处理查找结果，第一个参数可能为错误信息，第二个参数为找到的数据
  */
 module.exports.show = function (modelName, id, cb) {
+    // 从 databaseModule 中获取数据库对象
     var db = databaseModule.getDatabase();
+    // 根据模型名称获取相应的模型
     var Model = db.models[modelName];
+    // 通过 ID 获取对象，将结果传递给回调函数
     Model.get(id, function (err, obj) {
         cb(err, obj);
     });
@@ -174,13 +176,16 @@ module.exports.show = function(modelName,id,cb) {
 /**
  * 通过主键 ID 删除对象
  * 
- * @param  {[type]}   modelName 模型名称
- * @param  {[type]}   id        主键ID
- * @param  {Function} cb        回调函数
+ * @param  {[type]}   modelName 模型名称，用于指定要删除的模型
+ * @param  {[type]}   id        主键 ID，用于确定要删除的具体数据记录
+ * @param  {Function} cb        回调函数，用于处理删除操作的结果，第一个参数可能为错误信息，第二个参数为删除成功后的返回结果（如果有）
  */
 module.exports.destroy = function (modelName, id, cb) {
+    // 从 databaseModule 中获取数据库对象
     var db = databaseModule.getDatabase();
+    // 根据模型名称获取相应的模型
     var Model = db.models[modelName];
+    // 通过 ID 获取要删除的对象，处理获取过程中的错误，并调用对象的 remove 方法删除数据
     Model.get(id, function (err, obj) {
         if (err) return cb("无模型 ID");
         obj.remove(function (err) {
@@ -193,25 +198,31 @@ module.exports.destroy = function(modelName,id,cb) {
 /**
  * 通过模型名称获取数据库数量
  * 
- * @param  {[type]}   modelName 模型名称
- * @param  {Function} cb        回调函数
+ * @param  {[type]}   modelName 模型名称，用于指定要统计数量的模型
+ * @param  {Function} cb        回调函数，用于处理统计结果，第一个参数可能为错误信息，第二个参数为统计得到的数量
  */
 module.exports.count = function (modelName, cb) {
+    // 从 databaseModule 中获取数据库对象
     var db = databaseModule.getDatabase();
+    // 根据模型名称获取相应的模型
     var Model = db.models[modelName];
+    // 调用模型的 count 方法统计数量，将结果传递给回调函数
     Model.count(cb);
 }
 
 /**
  * 通过条件判断数据是否存在
  * 
- * @param  {[type]}   modelName  模块名
- * @param  {[type]}   conditions 条件
- * @param  {Function} cb         回调函数
+ * @param  {[type]}   modelName  模块名，用于指定要检查是否存在数据的模型
+ * @param  {[type]}   conditions 条件，用于判断数据是否存在的条件集合
+ * @param  {Function} cb         回调函数，用于处理检查结果，第一个参数可能为错误信息，第二个参数为数据是否存在的布尔值
  */
 module.exports.exists = function (modelName, conditions, cb) {
+    // 从 databaseModule 中获取数据库对象
     var db = databaseModule.getDatabase();
+    // 根据模型名称获取相应的模型
     var Model = db.models[modelName];
+    // 调用模型的 exists 方法检查数据是否存在，将结果传递给回调函数
     Model.exists(conditions, function (err, isExists) {
         if (err) return cb("查询失败");
         cb(null, isExists);
@@ -219,6 +230,8 @@ module.exports.exists = function(modelName,conditions,cb) {
 }
 
 module.exports.getModel = function (modelName) {
+    // 从 databaseModule 中获取数据库对象
     var db = databaseModule.getDatabase();
+    // 根据模型名称获取相应的模型
     return db.models[modelName];
 }

dao/GoodAttributeDAO.js

@@ -1,26 +1,54 @@
 var path = require("path");
+// 引入自定义的 DAO 模块，可能用于数据访问操作，具体功能取决于其内部实现
 daoModule = require("./DAO");
+// 引入位于 modules/database 目录下的数据库模块，使用 path.join 拼接当前工作目录与相对路径
 databaseModule = require(path.join(process.cwd(), "modules/database"));
 
 
+/**
+ * 清除商品属性
+ * 
+ * @param {[type]} goods_id 商品的唯一标识符，用于确定要清除属性的商品
+ * @param {Function} cb 回调函数，用于处理清除操作的结果
+ * 当操作完成时，将调用此函数。若操作出现错误，第一个参数将包含错误信息；若操作成功，第一个参数为 null
+ */
 module.exports.clearGoodAttributes = function (goods_id, cb) {
+    // 从数据库模块中获取数据库对象
     db = databaseModule.getDatabase();
+    // 定义 SQL 语句，用于删除 sp_goods_attr 表中 goods_id 匹配的记录
     sql = "DELETE FROM sp_goods_attr WHERE goods_id =?";
+    // 执行 SQL 查询操作，将 goods_id 作为参数传递给 SQL 语句
     database.driver.execQuery(
         sql
       , [goods_id], function (err) {
+            // 如果执行查询时出现错误，调用回调函数并传递错误信息
             if (err) return cb("删除出错");
+            // 若操作成功，调用回调函数，将第一个参数设为 null
             cb(null);
         });
 }
 
+/**
+ * 查询商品属性列表
+ * 
+ * @param {[type]} goods_id 商品的唯一标识符，用于确定要查询属性的商品
+ * @param {Function} cb 回调函数，用于处理查询操作的结果
+ * 当操作完成时，将调用此函数。若操作出现错误，第一个参数将包含错误信息；若操作成功，第一个参数为 null，第二个参数为查询结果
+ */
 module.exports.list = function (goods_id, cb) {
+    // 从数据库模块中获取数据库对象
     db = databaseModule.getDatabase();
+    // 定义 SQL 语句，使用 LEFT JOIN 连接 sp_goods_attr 和 sp_attribute 表进行查询
+    // 查询内容包括多个属性，从 sp_goods_attr 表中查询一些属性，从 sp_attribute 表中查询一些属性
+    // 并根据 good_attr.goods_id 进行筛选
     sql = "SELECT good_attr.goods_id,good_attr.attr_id,good_attr.attr_value,good_attr.add_price,attr.attr_name,attr.attr_sel,attr.attr_write,attr.attr_vals FROM sp_goods_attr as good_attr LEFT JOIN sp_attribute as attr ON attr.attr_id = good_attr.attr_id WHERE good_attr.goods_id =?";
+    // 执行 SQL 查询操作，将 goods_id 作为参数传递给 SQL 语句
     database.driver.execQuery(
         sql
       , [goods_id], function (err, attrs) {
+            // 如果执行查询时出现错误，调用回调函数并传递错误信息
             if (err) return cb("删除出错");
+            // 若操作成功，调用回调函数，将第一个参数设为 null，第二个参数为查询结果
             cb(null, attrs);
         });
 }

dao/ManagerDAO.js

@@ -1,24 +1,30 @@
 var path = require("path");
+// 引入自定义的 DAO 模块，可能包含了对数据库操作的封装
 daoModule = require("./DAO");
+// 引入位于 modules/database 目录下的数据库模块，使用 path.join 拼接当前工作目录和相对路径
 databaseModule = require(path.join(process.cwd(), "modules/database"));
 
 /**
  * 创建管理员
  * 
- * @param  {[type]}   obj 管理员信息
- * @param  {Function} cb  回调函数
+ * @param {[type]} obj 管理员信息，包含创建管理员所需的信息，如用户名、密码等，具体结构取决于数据库表的设计
+ * @param {Function} cb 回调函数，用于处理创建操作的结果
+ * 当创建操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null
  */
 module.exports.create = function (obj, cb) {
+    // 调用 daoModule 的 create 方法，创建 ManagerModel 类型的对象，传入管理员信息和回调函数
     daoModule.create("ManagerModel", obj, cb);
 }
 
 /**
  * 获取管理员列表
  * 
- * @param  {[type]}   conditions 查询条件
- * @param  {Function} cb         回调函数
+ * @param {[type]} conditions 查询条件，用于筛选管理员列表，具体内容根据业务需求而定
+ * @param {Function} cb 回调函数，用于处理查询结果
+ * 当查询操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null，第二个参数为查询到的管理员列表
  */
 module.exports.list = function (conditions, cb) {
+    // 调用 daoModule 的 list 方法，查询 ManagerModel 类型的对象，传入查询条件和自定义的回调函数
     daoModule.list("ManagerModel", conditions, function (err, models) {
         if (err) return cb(err, null);
         cb(null, models);
@@ -28,26 +34,32 @@ module.exports.list = function(conditions,cb) {
 /**
  * 通过查询条件获取管理员对象
  * 
- * @param  {[type]}   conditions 条件
- * @param  {Function} cb         回调函数
+ * @param {[type]} conditions 条件，用于筛选单个管理员，具体内容根据业务需求而定
+ * @param {Function} cb 回调函数，用于处理查询结果
+ * 当查询操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null，第二个参数为查询到的管理员对象
  */
 module.exports.findOne = function (conditions, cb) {
+    // 调用 daoModule 的 findOne 方法，根据条件查询 ManagerModel 类型的对象，传入条件和回调函数
     daoModule.findOne("ManagerModel", conditions, cb);
 }
 
 /**
  * 通过关键词查询用户
  * 
- * @param  {[type]}   key    关键词
- * @param  {[type]}   offset 
- * @param  {[type]}   limit  
- * @param  {Function} cb     回调函数
+ * @param {[type]} key 关键词，用于筛选用户，可能是用户名的一部分等
+ * @param {[type]} offset 分页偏移量，用于分页查询，从第几行开始查询
+ * @param {[type]} limit 分页限制，每页显示的数量
+ * @param {Function} cb 回调函数，用于处理查询结果
+ * 当查询操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null，第二个参数为查询到的管理员列表
  */
 module.exports.findByKey = function (key, offset, limit, cb) {
+    // 从数据库模块中获取数据库对象
     db = databaseModule.getDatabase();
+    // 定义基本的 SQL 查询语句，使用 LEFT JOIN 连接 sp_manager 和 sp_role 表
     sql = "SELECT * FROM sp_manager as mgr LEFT JOIN sp_role as role ON mgr.role_id = role.role_id";
-
+    // 根据是否有关键词进行不同的 SQL 拼接和查询操作
     if (key) {
+        // 拼接 LIKE 子句，进行模糊查询，并添加 LIMIT 子句进行分页
         sql += " WHERE mg_name LIKE? LIMIT?,?";
         database.driver.execQuery(
             sql
@@ -56,6 +68,7 @@ module.exports.findByKey = function(key,offset,limit,cb) {
                 cb(null, managers);
             });
     } else {
+        // 仅添加 LIMIT 子句进行分页
         sql += " LIMIT?,? ";
         database.driver.execQuery(sql, [offset, limit], function (err, managers) {
             if (err) return cb("查询执行出错");
@@ -67,13 +80,16 @@ module.exports.findByKey = function(key,offset,limit,cb) {
 /**
  * 判断是否存在管理员
  * 
- * @param  {[type]}   username 用户名
- * @param  {Function} cb       回调函数
- * 
+ * @param {[type]} username 用户名，用于判断该用户名对应的管理员是否存在
+ * @param {Function} cb 回调函数，用于处理查询结果
+ * 当查询操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null，第二个参数为布尔值表示是否存在
  */
 module.exports.exists = function (username, cb) {
+    // 从数据库模块中获取数据库对象
     var db = databaseModule.getDatabase();
+    // 获取 ManagerModel 模型
     var Model = db.models.ManagerModel;
+    // 调用 Model 的 exists 方法，传入用户名作为条件，查询是否存在
     Model.exists({"mg_name": username}, function (err, isExists) {
         if (err) return cb("查询失败");
         cb(null, isExists);
@@ -83,56 +99,68 @@ module.exports.exists = function(username,cb) {
 /**
  * 模糊查询用户数量
  * 
- * @param  {[type]}   key 关键词
- * @param  {Function} cb  回调函数
+ * @param {[type]} key 关键词，用于模糊查询用户数量，可能是用户名的一部分等
+ * @param {Function} cb 回调函数，用于处理查询结果
+ * 当查询操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null，第二个参数为查询到的用户数量
  */
 module.exports.countByKey = function (key, cb) {
+    // 从数据库模块中获取数据库对象
     db = databaseModule.getDatabase();
+    // 定义基本的 SQL 查询语句，统计 sp_manager 表中的记录数
     sql = "SELECT count(*) as count FROM sp_manager";
+    // 根据是否有关键词进行不同的 SQL 拼接和查询操作
     if (key) {
+        // 拼接 LIKE 子句，进行模糊查询
         sql += " WHERE mg_name LIKE?";
         database.driver.execQuery(
             sql
          , ["%" + key + "%"], function (err, result) {
                 if (err) return cb("查询执行出错");
+                // 从查询结果中获取数量
                 cb(null, result[0]["count"]);
             });
     } else {
         database.driver.execQuery(sql, function (err, result) {
             if (err) return cb("查询执行出错");
+            // 从查询结果中获取数量
             cb(null, result[0]["count"]);
         });
     }
-	
 }
 
 /**
  * 通过 ID 获取管理员对象数据
  * 
- * @param  {[type]}   id 管理员主键ID
- * @param  {Function} cb 回调函数
+ * @param {[type]} id 管理员主键 ID，用于唯一标识管理员
+ * @param {Function} cb 回调函数，用于处理查询结果
+ * 当查询操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null，第二个参数为查询到的管理员对象
  */
 module.exports.show = function (id, cb) {
+    // 调用 daoModule 的 show 方法，根据 ID 查询 ManagerModel 类型的对象，传入 ID 和回调函数
     daoModule.show("ManagerModel", id, cb);
 }
 
 /**
  * 更新管理员信息
  * 
- * @param  {[type]}   obj 管理员对象
- * @param  {Function} cb  回调函数
+ * @param {[type]} obj 管理员对象，包含更新后的管理员信息，具体结构取决于数据库表的设计
+ * @param {Function} cb 回调函数，用于处理更新操作的结果
+ * 当更新操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null
  */
 module.exports.update = function (obj, cb) {
+    // 调用 daoModule 的 update 方法，更新 ManagerModel 类型的对象，传入对象的 mg_id 作为主键和对象信息及回调函数
     daoModule.update("ManagerModel", obj.mg_id, obj, cb);
 }
 
 /**
  * 删除管理员对象数据
  * 
- * @param  {[type]}   id 主键ID
- * @param  {Function} cb 回调函数
+ * @param {[type]} id 主键 ID，用于唯一标识要删除的管理员
+ * @param {Function} cb 回调函数，用于处理删除操作的结果
+ * 当删除操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null
  */
 module.exports.destroy = function (id, cb) {
+    // 调用 daoModule 的 destroy 方法，根据 ID 删除 ManagerModel 类型的对象，传入 ID 和自定义的回调函数
     daoModule.destroy("ManagerModel", id, function (err) {
         if (err) return cb(err);
         return cb(null);
@@ -142,14 +170,18 @@ module.exports.destroy = function(id,cb) {
 /**
  * 保存管理员信息
  * 
- * @param  {[type]}   obj 管理员对象
- * @param  {Function} cb  回调函数
+ * @param {[type]} obj 管理员对象，包含管理员信息，具体结构取决于数据库表的设计
+ * @param {Function} cb 回调函数，用于处理保存操作的结果
+ * 当保存操作完成时调用此函数，根据管理员对象是否有 mg_id 决定是创建新的管理员还是更新现有管理员
  */
 module.exports.save = function (obj, cb) {
+    // 调用 daoModule 的 show 方法，根据管理员对象的 mg_id 进行查询
     daoModule.show(obj.mg_id, function (err, oldObj) {
         if (err) {
+            // 若查询出错，可能是不存在该管理员，调用 create 方法创建新的管理员
             daoModule.create("ManagerModel", obj, cb);
         } else {
+            // 若查询成功，调用 update 方法更新现有管理员
             daoModule.update("ManagerModel", obj.mg_id, obj, cb);
         }
     })
@@ -158,8 +190,10 @@ module.exports.save = function(obj,cb) {
 /**
  * 获取管理员数量
  * 
- * @param  {Function} cb 回调函数
+ * @param {Function} cb 回调函数，用于处理查询结果
+ * 当查询操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null，第二个参数为管理员数量
  */
 module.exports.count = function (cb) {
+    // 调用 daoModule 进行查询，传入 ManagerModel 类型和回调函数，但这里可能存在错误，因为调用方式不完整，应该是调用 daoModule 的某个方法
     daoModule("ManagerModel", cb);
 }

dao/PermissionAPIDAO.js

@@ -1,15 +1,22 @@
 var path = require("path");
+// 引入自定义的 DAO 模块，可能包含了对数据库操作的相关函数
 daoModule = require("./DAO");
+// 引入位于 modules/database 目录下的数据库模块，使用 path.join 拼接当前工作目录和相对路径
 databaseModule = require(path.join(process.cwd(), "modules/database"));
 
 /**
  * 获取权限列表
  * 
- * @param  {Function} cb 回调函数
+ * @param  {Function} cb 回调函数，用于处理获取权限列表的结果
+ * 当获取权限列表操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null，第二个参数为权限列表结果
  */
 module.exports.list = function (cb) {
+    // 从数据库模块中获取数据库对象
     db = databaseModule.getDatabase();
+    // 定义 SQL 查询语句，使用 LEFT JOIN 连接 sp_permission_api 和 sp_permission 表
+    // 筛选出 sp_permission 表的 ps_id 不为空的记录
     sql = "SELECT * FROM sp_permission_api as api LEFT JOIN sp_permission as main ON main.ps_id = api.ps_id WHERE main.ps_id is not null";
+    // 执行 SQL 查询操作
     database.driver.execQuery(sql, function (err, result) {
         if (err) return cb("获取权限列表失败", null);
         cb(null, result);
@@ -19,31 +26,38 @@ module.exports.list = function(cb) {
 /**
  * 权限验证
  * 
- * @param  {[type]}   rid         角色ID
- * @param  {[type]}   serviceName 服务名
- * @param  {[type]}   actionName  动作名
- * @param  {Function} cb          回调函数
+ * @param  {[type]}   rid         角色 ID，用于标识用户的角色，可能是数字类型，不同角色拥有不同的权限
+ * @param  {[type]}   serviceName 服务名，可能是要访问的服务的名称，例如 API 服务的名称
+ * @param  {[type]}   actionName  动作名，可能是对服务的具体操作名称，例如 GET、POST 等操作
+ * @param  {Function} cb          回调函数，用于处理权限验证的结果
+ * 当权限验证操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若验证通过，第一个参数为 null，第二个参数为 true；若验证不通过，第一个参数包含相应的错误信息，第二个参数为 false
  */
 module.exports.authRight = function (rid, serviceName, actionName, cb) {
-	
-	// 超级管理员
+    // 超级管理员权限验证，若角色 ID 为 0，则直接认为有权限
     if (rid == 0) return cb(null, true);
-
-	// 权限验证
+    // 权限验证过程
+    // 使用 daoModule 的 findOne 方法查找 PermissionAPIModel 类型的对象
     daoModule.findOne("PermissionAPIModel", {"ps_api_service": serviceName, "ps_api_action": actionName}, function (err, permissionAPI) {
+        // 打印当前角色 ID、服务名和动作名，方便调试
         console.log("rid => %s,serviceName => %s,actionName => %s", rid, serviceName, actionName);
+        // 若出现错误或未找到权限 API 对象，认为无权限
         if (err ||!permissionAPI) return cb("无权限访问", false);
-		
+        // 查找 RoleModel 类型的对象，获取角色信息
         daoModule.findOne("RoleModel", {"role_id": rid}, function (err, role) {
             console.log(role);
+            // 若出现错误或未找到角色对象，认为获取角色信息失败
             if (err ||!role) return cb("获取角色信息失败", false);
+            // 将角色的 ps_ids 以逗号分隔存储在数组中
             ps_ids = role.ps_ids.split(",");
+            // 遍历 ps_ids 数组
             for (idx in ps_ids) {
                 ps_id = ps_ids[idx];
+                // 若权限 API 的 ps_id 与角色的某个 ps_id 相等，认为有权限
                 if (parseInt(permissionAPI.ps_id) == parseInt(ps_id)) {
                     return cb(null, true);
                 }
             }
+            // 若遍历完都不满足条件，认为无权限
             return cb("无权限访问", false);
         });
     });

models/AttributeModel.js

@@ -1,15 +1,22 @@
+// 导出一个函数，这个函数接受数据库对象db和一个回调函数callback作为参数
 module.exports = function(db,callback){
     // 用户模型
+    // 使用db.define方法定义一个模型，模型名为AttributeModel
     db.define("AttributeModel",{
-		attr_id : {type: 'serial', key: true},
-		attr_name : String,
-		cat_id : Number,
-		attr_sel : ["only", "many"],	// only:输入框(唯一)  many:后台下拉列表/前台单选框
-		attr_write: ["manual","list"],	// manual:手工录入  list:从列表选择
-		attr_vals: String,
-		delete_time : Number
+        // 定义模型的属性
+        attr_id : {type: 'serial', key: true}, // 自增主键
+        attr_name : String, // 属性名称，类型为字符串
+        cat_id : Number, // 分类ID，类型为数字
+        attr_sel : ["only", "many"], // 属性选择类型，可以是"only"或"many"
+        // "only":输入框(唯一) "many":后台下拉列表/前台单选框
+        attr_write: ["manual","list"], // 属性写入方式，可以是"manual"或"list"
+        // "manual":手工录入 "list":从列表选择
+        attr_vals: String, // 属性值，类型为字符串
+        delete_time : Number // 删除时间，类型为数字
     },{
-		table : "sp_attribute"
+        // 定义模型的选项
+        table : "sp_attribute" // 指定模型对应的数据库表名为sp_attribute
     });
+    // 调用回调函数，传入无参数
     return callback();
 }

models/CategoryModel.js

@@ -1,13 +1,18 @@
+// 导出一个函数，这个函数接受数据库对象db和一个回调函数callback作为参数
 module.exports = function(db,callback){
     // 用户模型
+    // 使用db.define方法定义一个模型，模型名为CategoryModel
     db.define("CategoryModel",{
-		cat_id : {type: 'serial', key: true},
-		cat_name : String,
-		cat_pid : Number,
-		cat_level : Number,
-		cat_deleted: Boolean
+        // 定义模型的属性
+        cat_id : {type: 'serial', key: true}, // 分类ID，自增主键
+        cat_name : String, // 分类名称，类型为字符串
+        cat_pid : Number, // 父分类ID，类型为数字
+        cat_level : Number, // 分类级别，类型为数字
+        cat_deleted: Boolean // 是否已删除，类型为布尔值
     },{
-		table : "sp_category"
+        // 定义模型的选项
+        table : "sp_category" // 指定模型对应的数据库表名为sp_category
     });
+    // 调用回调函数，传入无参数
     return callback();
 }

models/GoodAttributeModel.js

@@ -1,13 +1,18 @@
+// 导出一个函数，这个函数接受数据库对象db和一个回调函数callback作为参数
 module.exports = function(db, callback) {
     // 用户模型
+    // 使用db.define方法定义一个模型，模型名为GoodAttributeModel
     db.define("GoodAttributeModel", {
-		id : {type: 'serial', key: true},
-		goods_id : Number,
-		attr_id : Number,
-		attr_value : String,
-		add_price : Number
+        // 定义模型的属性
+        id: {type: 'serial', key: true}, // 主键ID，自增序列
+        goods_id: Number, // 商品ID，类型为数字
+        attr_id: Number, // 属性ID，类型为数字
+        attr_value: String, // 属性值，类型为字符串
+        add_price: Number // 附加价格，类型为数字
     }, {
-		table : "sp_goods_attr"
+        // 定义模型的选项
+        table: "sp_goods_attr" // 指定模型对应的数据库表名为sp_goods_attr
     });
+    // 调用回调函数，传入无参数
     return callback();
 }

models/GoodModel.js

@@ -1,33 +1,38 @@
+// 导出一个函数，这个函数接受数据库对象db和一个回调函数callback作为参数
 module.exports = function(db, callback) {
     // 用户模型
+    // 使用db.define方法定义一个模型，模型名为GoodModel
     db.define("GoodModel", {
-		goods_id : {type: 'serial', key: true},
-		cat_id : Number,
-		goods_name : String,
-		goods_price : Number,
-		goods_number : Number,
-		goods_weight : Number,
-		goods_introduce : String,
-		goods_big_logo : String,
-		goods_small_logo : String,
-		goods_state : Number,	// 0：未审核 1: 审核中 2: 已审核
-		is_del : ['0','1'],	// 0: 正常 , 1: 删除
-		add_time : Number,
-		upd_time : Number,
-		delete_time : Number,
-		hot_mumber : Number,
-		is_promote : Boolean,
-		cat_one_id : Number,
-		cat_two_id : Number,
-		cat_three_id : Number
-
+        // 定义模型的属性
+        goods_id: {type: 'serial', key: true}, // 商品ID，自增主键
+        cat_id: Number, // 分类ID，类型为数字
+        goods_name: String, // 商品名称，类型为字符串
+        goods_price: Number, // 商品价格，类型为数字
+        goods_number: Number, // 商品数量，类型为数字
+        goods_weight: Number, // 商品重量，类型为数字
+        goods_introduce: String, // 商品介绍，类型为字符串
+        goods_big_logo: String, // 商品大图，类型为字符串
+        goods_small_logo: String, // 商品小图，类型为字符串
+        goods_state: Number, // 商品状态，0：未审核 1: 审核中 2: 已审核
+        is_del: ['0', '1'], // 是否删除，0: 正常 , 1: 删除
+        add_time: Number, // 添加时间，类型为数字
+        upd_time: Number, // 更新时间，类型为数字
+        delete_time: Number, // 删除时间，类型为数字
+        hot_mumber: Number, // 热门数量，类型为数字
+        is_promote: Boolean, // 是否促销，类型为布尔值
+        cat_one_id: Number, // 一级分类ID，类型为数字
+        cat_two_id: Number, // 二级分类ID，类型为数字
+        cat_three_id: Number // 三级分类ID，类型为数字
     }, {
-		table : "sp_goods",
-		methods: {
+        // 定义模型的选项
+        table: "sp_goods", // 指定模型对应的数据库表名为sp_goods
+        methods: { // 定义模型的方法
             getGoodsCat: function() {
+                // 返回一个字符串，包含所有分类ID，用逗号分隔
                 return this.cat_one_id + ',' + this.cat_two_id + ',' + this.cat_three_id;
             }
         }
     });
+    // 调用回调函数，传入无参数
     return callback();
 }

models/GoodPicModel.js

@@ -1,13 +1,18 @@
+// 导出一个函数，这个函数接受数据库对象db和一个回调函数callback作为参数
 module.exports = function(db, callback) {
     // 用户模型
+    // 使用db.define方法定义一个模型，模型名为GoodPicModel
     db.define("GoodPicModel", {
-		pics_id : {type: 'serial', key: true},
-		goods_id : Number,
-		pics_big : String,
-		pics_mid : String,
-		pics_sma : String
+        // 定义模型的属性
+        pics_id: {type: 'serial', key: true}, // 图片ID，自增主键
+        goods_id: Number, // 商品ID，类型为数字
+        pics_big: String, // 商品大图地址，类型为字符串
+        pics_mid: String, // 商品中图地址，类型为字符串
+        pics_sma: String // 商品小图地址，类型为字符串
     }, {
-		table : "sp_goods_pics"
+        // 定义模型的选项
+        table: "sp_goods_pics" // 指定模型对应的数据库表名为sp_goods_pics
     });
+    // 调用回调函数，传入无参数
     return callback();
 }

models/ManagerModel.js

@@ -1,16 +1,21 @@
+// 导出一个函数，这个函数接受数据库对象db和一个回调函数callback作为参数
 module.exports = function(db, callback) {
     // 用户模型
+    // 使用db.define方法定义一个模型，模型名为ManagerModel
     db.define("ManagerModel", {
-		mg_id : {type: 'serial', key: true},
-		mg_name : String,
-		mg_pwd : String,
-		mg_time : Number,
-		role_id : Number,
-		mg_mobile : String,
-		mg_email : String,
-		mg_state : Number
+        // 定义模型的属性
+        mg_id: {type: 'serial', key: true}, // 管理ID，自增主键
+        mg_name: String, // 管理名称，类型为字符串
+        mg_pwd: String, // 管理密码，类型为字符串
+        mg_time: Number, // 管理时间，类型为数字（可能是注册时间或最后登录时间）
+        role_id: Number, // 角色ID，类型为数字
+        mg_mobile: String, // 管理手机号，类型为字符串
+        mg_email: String, // 管理邮箱，类型为字符串
+        mg_state: Number // 管理状态，类型为数字（可能表示是否激活、是否禁用等状态）
     }, {
-		table : "sp_manager"
+        // 定义模型的选项
+        table: "sp_manager" // 指定模型对应的数据库表名为sp_manager
     });
+    // 调用回调函数，传入无参数
     return callback();
 }

models/OrderGoodModel.js

@@ -1,14 +1,19 @@
+// 导出一个函数，这个函数接受数据库对象db和一个回调函数callback作为参数
 module.exports = function(db, callback) {
     // 用户模型
+    // 使用db.define方法定义一个模型，模型名为OrderGoodModel
     db.define("OrderGoodModel", {
-		id : {type: 'serial', key: true},
-		order_id : Number,
-		goods_id : Number,
-		goods_price : Number,
-		goods_number : Number,
-		goods_total_price : Number
+        // 定义模型的属性
+        id: {type: 'serial', key: true}, // 订单商品ID，自增主键
+        order_id: Number, // 订单ID，类型为数字
+        goods_id: Number, // 商品ID，类型为数字
+        goods_price: Number, // 商品价格，类型为数字
+        goods_number: Number, // 商品数量，类型为数字
+        goods_total_price: Number // 商品总价，类型为数字
     }, {
-		table : "sp_order_goods"
+        // 定义模型的选项
+        table: "sp_order_goods" // 指定模型对应的数据库表名为sp_order_goods
     });
+    // 调用回调函数，传入无参数
     return callback();
 }

models/OrderModel.js

@@ -1,22 +1,27 @@
+// 导出一个函数，这个函数接受数据库对象db和一个回调函数callback作为参数
 module.exports = function(db, callback) {
     // 用户模型
+    // 使用db.define方法定义一个模型，模型名为OrderModel
     db.define("OrderModel", {
-		order_id : {type: 'serial', key: true},
-		user_id : Number,
-		order_number : String,
-		order_price : Number,
-		order_pay : [1,2,3],
-		is_send : ["是","否"],
-		trade_no : String,
-		order_fapiao_title : ["个人","公司"],
-		order_fapiao_company : String,
-		order_fapiao_content : String,
-		consignee_addr : String,
-		pay_status : ['0','1'],
-		create_time : Number,
-		update_time : Number
+        // 定义模型的属性
+        order_id: {type: 'serial', key: true}, // 订单ID，自增主键
+        user_id: Number, // 用户ID，类型为数字
+        order_number: String, // 订单编号，类型为字符串
+        order_price: Number, // 订单总价，类型为数字
+        order_pay: [1,2,3], // 订单支付方式，类型为数字数组，具体值可能代表不同的支付方式
+        is_send: ["是","否"], // 是否发货，类型为字符串数组，可能代表“是”和“否”
+        trade_no: String, // 交易编号，类型为字符串
+        order_fapiao_title: ["个人","公司"], // 发票抬头，类型为字符串数组，可能代表“个人”和“公司”
+        order_fapiao_company: String, // 发票公司名称，类型为字符串
+        order_fapiao_content: String, // 发票内容，类型为字符串
+        consignee_addr: String, // 收货人地址，类型为字符串
+        pay_status: ['0','1'], // 支付状态，类型为字符串数组，可能代表不同的支付状态
+        create_time: Number, // 创建时间，类型为数字（可能是时间戳）
+        update_time: Number // 更新时间，类型为数字（可能是时间戳）
     }, {
-		table : "sp_order"
+        // 定义模型的选项
+        table: "sp_order" // 指定模型对应的数据库表名为sp_order
     });
+    // 调用回调函数，传入无参数
     return callback();
 }

models/PermissionAPIModel.js

@@ -1,14 +1,18 @@
+// 导出一个函数，这个函数接受数据库对象db和一个回调函数callback作为参数
 module.exports = function(db, callback) {
     // 用户模型
+    // 使用db.define方法定义一个模型，模型名为PermissionAPIModel
     db.define("PermissionAPIModel", {
-		id : {type: 'serial', key: true},
-		ps_id : Number,
-		ps_api_service : String,
-		ps_api_action : String,
-		ps_api_order : Number
-
+        // 定义模型的属性
+        id: {type: 'serial', key: true}, // 唯一标识ID，自增主键
+        ps_id: Number, // 权限ID，类型为数字
+        ps_api_service: String, // API服务名称，类型为字符串
+        ps_api_action: String, // API动作名称，类型为字符串
+        ps_api_order: Number // API顺序，类型为数字
     }, {
-		table : "sp_permission_api"
+        // 定义模型的选项
+        table: "sp_permission_api" // 指定模型对应的数据库表名为sp_permission_api
     });
+    // 调用回调函数，传入无参数
     return callback();
 }

models/PermissionModel.js

@@ -1,14 +1,19 @@
+// 导出一个函数，这个函数接受数据库对象db和一个回调函数callback作为参数
 module.exports = function(db, callback) {
     // 用户模型
+    // 使用db.define方法定义一个模型，模型名为PermissionModel
     db.define("PermissionModel", {
-		ps_id : {type: 'serial', key: true},
-		ps_name : String,
-		ps_pid : Number,
-		ps_c : String,
-		ps_a : String,
-		ps_level : String
+        // 定义模型的属性
+        ps_id: {type: 'serial', key: true}, // 权限ID，自增主键
+        ps_name: String, // 权限名称，类型为字符串
+        ps_pid: Number, // 父权限ID，类型为数字
+        ps_c: String, // 控制器名称，类型为字符串
+        ps_a: String, // 动作名称，类型为字符串
+        ps_level: String // 权限级别，类型为字符串
     }, {
-		table : "sp_permission"
+        // 定义模型的选项
+        table: "sp_permission" // 指定模型对应的数据库表名为sp_permission
     });
+    // 调用回调函数，传入无参数
     return callback();
 }

models/ReportOneModel.js

@@ -1,12 +1,17 @@
+// 导出一个函数，这个函数接受数据库对象db和一个回调函数callback作为参数
 module.exports = function(db, callback) {
     // 报表模型1
+    // 使用db.define方法定义一个模型，模型名为ReportOneModel
     db.define("ReportOneModel", {
-		id : {type: 'serial', key: true},
-		rp1_user_count : Number,
-		rp1_area : Number,
-		rp1_date : { type: "date", time: false }
+        // 定义模型的属性
+        id: {type: 'serial', key: true}, // 唯一标识ID，自增主键
+        rp1_user_count: Number, // 用户数量，类型为数字
+        rp1_area: Number, // 区域代码或标识，类型为数字
+        rp1_date: { type: "date", time: false } // 报表日期，类型为日期，不包含时间信息
     }, {
-		table : "sp_report_1"
+        // 定义模型的选项
+        table: "sp_report_1" // 指定模型对应的数据库表名为sp_report_1
     });
+    // 调用回调函数，传入无参数
     return callback();
 }

models/ReportTwoModel.js

@@ -1,12 +1,17 @@
+// 导出一个函数，这个函数接受数据库对象db和一个回调函数callback作为参数
 module.exports = function(db, callback) {
-	// 报表模型1
+    // 报表模型2
+    // 使用db.define方法定义一个模型，模型名为ReportTwoModel
     db.define("ReportTwoModel", {
-		id : {type: 'serial', key: true},
-		rp2_page : String,
-		rp2_count : Number,
-		rp2_date : { type: "date", time: false }
+        // 定义模型的属性
+        id: {type: 'serial', key: true}, // 唯一标识ID，自增主键
+        rp2_page: String, // 页面名称，类型为字符串
+        rp2_count: Number, // 计数，类型为数字（可能是页面访问次数或其他统计数据）
+        rp2_date: { type: "date", time: false } // 报表日期，类型为日期，不包含时间信息
     }, {
-		table : "sp_report_2"
+        // 定义模型的选项
+        table: "sp_report_2" // 指定模型对应的数据库表名为sp_report_2
     });
+    // 调用回调函数，传入无参数
     return callback();
 }

models/RoleModel.js

@@ -1,13 +1,18 @@
+// 导出一个函数，这个函数接受数据库对象db和一个回调函数callback作为参数
 module.exports = function(db, callback) {
     // 用户模型
+    // 使用db.define方法定义一个模型，模型名为RoleModel
     db.define("RoleModel", {
-		role_id : {type: 'serial', key: true},
-		role_name : String,
-		ps_ids : String,
-		ps_ca : String,
-		role_desc : String
+        // 定义模型的属性
+        role_id: {type: 'serial', key: true}, // 角色ID，自增主键
+        role_name: String, // 角色名称，类型为字符串
+        ps_ids: String, // 权限ID列表，类型为字符串，可能以某种方式（如逗号分隔）存储多个权限ID
+        ps_ca: String, // 权限字符串，类型为字符串，可能表示权限的字符串表示形式
+        role_desc: String // 角色描述，类型为字符串
     }, {
-		table : "sp_role"
+        // 定义模型的选项
+        table: "sp_role" // 指定模型对应的数据库表名为sp_role
     });
+    // 调用回调函数，传入无参数
     return callback();
 }

src/assets/css/global.css

@@ -1,4 +1,7 @@
-/* 全局样式 */
+/* 全局样式定义 */
+/* 请注意，直接覆盖第三方组件（如Element UI组件）的样式可能会导致在未来更新组件库时出现样式冲突或不一致的问题。更好的做法是使用组件库提供的自定义主题或样式修改接口（如果可用）。如果必须直接覆盖样式，请确保了解选择器特异性，并尽量使用更具体的选择器来避免不必要的全局影响。 */
+
+/* 设置html, body, 和#app元素的高度为100%，且没有边距和填充，最小宽度为1366px */
 html,
 body,
 #app {
@@ -8,37 +11,47 @@ body,
     min-width: 1366px;
 }
 
+/* 设置面包屑导航的底部外边距为15px，字体大小为12px */
 .el-breadcrumb {
     margin-bottom: 15px;
     font-size: 12px;
 }
 
+/* 为el-card组件添加盒子阴影效果，增加视觉层次感 */
 .el-card {
-    box-shadow: 0 1px 1px rgba(0, 0, 0, 0.15) !important;
+    box-shadow: 0 1px 1px rgba(0, 0, 0, 0.15) !important; /* !important用于确保该规则优先级最高 */
 }
 
+/* 设置el-table表格的顶部外边距为15px，字体大小为12px */
 .el-table {
     margin-top: 15px;
     font-size: 12px;
 }
 
+/* 设置el-pagination分页组件的顶部外边距为15px */
 .el-pagination {
     margin-top: 15px;
 }
 
-/* 解决级联选择框的问题 */
+/* 解决级联选择框内部滚动条包裹元素的高度问题 */
+/* 注意：这里的选择器可能存在特异性问题，通常不建议这样直接覆盖第三方组件的样式 */
 div .el-scrollbar__wrap {
-    height: 300px !important
+    height: 300px !important; /* 强制设置高度为300px */
 }
 
-/* 步骤条 */
+/* 步骤条样式 */
+/* 设置el-steps步骤条组件的外边距，上下各15px */
 .el-steps {
     margin: 15px 0;
 }
 
+/* 设置el-step步骤项标题的字体大小为13px */
 .el-step__title {
     font-size: 13px;
 }
+
+/* 富文本编辑器ql-editor的最小高度设置 */
+/* 这通常用于Quill富文本编辑器，确保编辑器区域有足够的高度进行内容编辑 */
 .ql-editor {
     min-height: 300px;
 }